Loading...
1/*
2 * fs/cifs/inode.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2010
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21#include <linux/fs.h>
22#include <linux/stat.h>
23#include <linux/slab.h>
24#include <linux/pagemap.h>
25#include <linux/freezer.h>
26#include <linux/sched/signal.h>
27#include <linux/wait_bit.h>
28
29#include <asm/div64.h>
30#include "cifsfs.h"
31#include "cifspdu.h"
32#include "cifsglob.h"
33#include "cifsproto.h"
34#include "cifs_debug.h"
35#include "cifs_fs_sb.h"
36#include "cifs_unicode.h"
37#include "fscache.h"
38
39
40static void cifs_set_ops(struct inode *inode)
41{
42 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
43
44 switch (inode->i_mode & S_IFMT) {
45 case S_IFREG:
46 inode->i_op = &cifs_file_inode_ops;
47 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
48 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
49 inode->i_fop = &cifs_file_direct_nobrl_ops;
50 else
51 inode->i_fop = &cifs_file_direct_ops;
52 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
53 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
54 inode->i_fop = &cifs_file_strict_nobrl_ops;
55 else
56 inode->i_fop = &cifs_file_strict_ops;
57 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
58 inode->i_fop = &cifs_file_nobrl_ops;
59 else { /* not direct, send byte range locks */
60 inode->i_fop = &cifs_file_ops;
61 }
62
63 /* check if server can support readpages */
64 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
65 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
66 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
67 else
68 inode->i_data.a_ops = &cifs_addr_ops;
69 break;
70 case S_IFDIR:
71#ifdef CONFIG_CIFS_DFS_UPCALL
72 if (IS_AUTOMOUNT(inode)) {
73 inode->i_op = &cifs_dfs_referral_inode_operations;
74 } else {
75#else /* NO DFS support, treat as a directory */
76 {
77#endif
78 inode->i_op = &cifs_dir_inode_ops;
79 inode->i_fop = &cifs_dir_ops;
80 }
81 break;
82 case S_IFLNK:
83 inode->i_op = &cifs_symlink_inode_ops;
84 break;
85 default:
86 init_special_inode(inode, inode->i_mode, inode->i_rdev);
87 break;
88 }
89}
90
91/* check inode attributes against fattr. If they don't match, tag the
92 * inode for cache invalidation
93 */
94static void
95cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
96{
97 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
98
99 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
100 __func__, cifs_i->uniqueid);
101
102 if (inode->i_state & I_NEW) {
103 cifs_dbg(FYI, "%s: inode %llu is new\n",
104 __func__, cifs_i->uniqueid);
105 return;
106 }
107
108 /* don't bother with revalidation if we have an oplock */
109 if (CIFS_CACHE_READ(cifs_i)) {
110 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
111 __func__, cifs_i->uniqueid);
112 return;
113 }
114
115 /* revalidate if mtime or size have changed */
116 if (timespec64_equal(&inode->i_mtime, &fattr->cf_mtime) &&
117 cifs_i->server_eof == fattr->cf_eof) {
118 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
119 __func__, cifs_i->uniqueid);
120 return;
121 }
122
123 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
124 __func__, cifs_i->uniqueid);
125 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
126}
127
128/*
129 * copy nlink to the inode, unless it wasn't provided. Provide
130 * sane values if we don't have an existing one and none was provided
131 */
132static void
133cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
134{
135 /*
136 * if we're in a situation where we can't trust what we
137 * got from the server (readdir, some non-unix cases)
138 * fake reasonable values
139 */
140 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
141 /* only provide fake values on a new inode */
142 if (inode->i_state & I_NEW) {
143 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
144 set_nlink(inode, 2);
145 else
146 set_nlink(inode, 1);
147 }
148 return;
149 }
150
151 /* we trust the server, so update it */
152 set_nlink(inode, fattr->cf_nlink);
153}
154
155/* populate an inode with info from a cifs_fattr struct */
156void
157cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
158{
159 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
160 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
161
162 cifs_revalidate_cache(inode, fattr);
163
164 spin_lock(&inode->i_lock);
165 /* we do not want atime to be less than mtime, it broke some apps */
166 if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime))
167 inode->i_atime = fattr->cf_mtime;
168 else
169 inode->i_atime = fattr->cf_atime;
170 inode->i_mtime = fattr->cf_mtime;
171 inode->i_ctime = fattr->cf_ctime;
172 inode->i_rdev = fattr->cf_rdev;
173 cifs_nlink_fattr_to_inode(inode, fattr);
174 inode->i_uid = fattr->cf_uid;
175 inode->i_gid = fattr->cf_gid;
176
177 /* if dynperm is set, don't clobber existing mode */
178 if (inode->i_state & I_NEW ||
179 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
180 inode->i_mode = fattr->cf_mode;
181
182 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
183
184 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
185 cifs_i->time = 0;
186 else
187 cifs_i->time = jiffies;
188
189 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
190 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
191 else
192 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
193
194 cifs_i->server_eof = fattr->cf_eof;
195 /*
196 * Can't safely change the file size here if the client is writing to
197 * it due to potential races.
198 */
199 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
200 i_size_write(inode, fattr->cf_eof);
201
202 /*
203 * i_blocks is not related to (i_size / i_blksize),
204 * but instead 512 byte (2**9) size is required for
205 * calculating num blocks.
206 */
207 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
208 }
209 spin_unlock(&inode->i_lock);
210
211 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
212 inode->i_flags |= S_AUTOMOUNT;
213 if (inode->i_state & I_NEW)
214 cifs_set_ops(inode);
215}
216
217void
218cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
219{
220 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
221
222 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
223 return;
224
225 fattr->cf_uniqueid = iunique(sb, ROOT_I);
226}
227
228/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
229void
230cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
231 struct cifs_sb_info *cifs_sb)
232{
233 memset(fattr, 0, sizeof(*fattr));
234 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
235 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
236 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
237
238 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
239 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
240 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
241 /* old POSIX extensions don't get create time */
242
243 fattr->cf_mode = le64_to_cpu(info->Permissions);
244
245 /*
246 * Since we set the inode type below we need to mask off
247 * to avoid strange results if bits set above.
248 */
249 fattr->cf_mode &= ~S_IFMT;
250 switch (le32_to_cpu(info->Type)) {
251 case UNIX_FILE:
252 fattr->cf_mode |= S_IFREG;
253 fattr->cf_dtype = DT_REG;
254 break;
255 case UNIX_SYMLINK:
256 fattr->cf_mode |= S_IFLNK;
257 fattr->cf_dtype = DT_LNK;
258 break;
259 case UNIX_DIR:
260 fattr->cf_mode |= S_IFDIR;
261 fattr->cf_dtype = DT_DIR;
262 break;
263 case UNIX_CHARDEV:
264 fattr->cf_mode |= S_IFCHR;
265 fattr->cf_dtype = DT_CHR;
266 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
267 le64_to_cpu(info->DevMinor) & MINORMASK);
268 break;
269 case UNIX_BLOCKDEV:
270 fattr->cf_mode |= S_IFBLK;
271 fattr->cf_dtype = DT_BLK;
272 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
273 le64_to_cpu(info->DevMinor) & MINORMASK);
274 break;
275 case UNIX_FIFO:
276 fattr->cf_mode |= S_IFIFO;
277 fattr->cf_dtype = DT_FIFO;
278 break;
279 case UNIX_SOCKET:
280 fattr->cf_mode |= S_IFSOCK;
281 fattr->cf_dtype = DT_SOCK;
282 break;
283 default:
284 /* safest to call it a file if we do not know */
285 fattr->cf_mode |= S_IFREG;
286 fattr->cf_dtype = DT_REG;
287 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
288 break;
289 }
290
291 fattr->cf_uid = cifs_sb->mnt_uid;
292 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
293 u64 id = le64_to_cpu(info->Uid);
294 if (id < ((uid_t)-1)) {
295 kuid_t uid = make_kuid(&init_user_ns, id);
296 if (uid_valid(uid))
297 fattr->cf_uid = uid;
298 }
299 }
300
301 fattr->cf_gid = cifs_sb->mnt_gid;
302 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
303 u64 id = le64_to_cpu(info->Gid);
304 if (id < ((gid_t)-1)) {
305 kgid_t gid = make_kgid(&init_user_ns, id);
306 if (gid_valid(gid))
307 fattr->cf_gid = gid;
308 }
309 }
310
311 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
312}
313
314/*
315 * Fill a cifs_fattr struct with fake inode info.
316 *
317 * Needed to setup cifs_fattr data for the directory which is the
318 * junction to the new submount (ie to setup the fake directory
319 * which represents a DFS referral).
320 */
321static void
322cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
323{
324 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
325
326 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
327
328 memset(fattr, 0, sizeof(*fattr));
329 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
330 fattr->cf_uid = cifs_sb->mnt_uid;
331 fattr->cf_gid = cifs_sb->mnt_gid;
332 ktime_get_real_ts64(&fattr->cf_mtime);
333 fattr->cf_mtime = timespec64_trunc(fattr->cf_mtime, sb->s_time_gran);
334 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
335 fattr->cf_nlink = 2;
336 fattr->cf_flags = CIFS_FATTR_DFS_REFERRAL;
337}
338
339static int
340cifs_get_file_info_unix(struct file *filp)
341{
342 int rc;
343 unsigned int xid;
344 FILE_UNIX_BASIC_INFO find_data;
345 struct cifs_fattr fattr;
346 struct inode *inode = file_inode(filp);
347 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
348 struct cifsFileInfo *cfile = filp->private_data;
349 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
350
351 xid = get_xid();
352 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
353 if (!rc) {
354 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
355 } else if (rc == -EREMOTE) {
356 cifs_create_dfs_fattr(&fattr, inode->i_sb);
357 rc = 0;
358 }
359
360 cifs_fattr_to_inode(inode, &fattr);
361 free_xid(xid);
362 return rc;
363}
364
365int cifs_get_inode_info_unix(struct inode **pinode,
366 const unsigned char *full_path,
367 struct super_block *sb, unsigned int xid)
368{
369 int rc;
370 FILE_UNIX_BASIC_INFO find_data;
371 struct cifs_fattr fattr;
372 struct cifs_tcon *tcon;
373 struct tcon_link *tlink;
374 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
375
376 cifs_dbg(FYI, "Getting info on %s\n", full_path);
377
378 tlink = cifs_sb_tlink(cifs_sb);
379 if (IS_ERR(tlink))
380 return PTR_ERR(tlink);
381 tcon = tlink_tcon(tlink);
382
383 /* could have done a find first instead but this returns more info */
384 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
385 cifs_sb->local_nls, cifs_remap(cifs_sb));
386 cifs_put_tlink(tlink);
387
388 if (!rc) {
389 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
390 } else if (rc == -EREMOTE) {
391 cifs_create_dfs_fattr(&fattr, sb);
392 rc = 0;
393 } else {
394 return rc;
395 }
396
397 /* check for Minshall+French symlinks */
398 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
399 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
400 full_path);
401 if (tmprc)
402 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
403 }
404
405 if (*pinode == NULL) {
406 /* get new inode */
407 cifs_fill_uniqueid(sb, &fattr);
408 *pinode = cifs_iget(sb, &fattr);
409 if (!*pinode)
410 rc = -ENOMEM;
411 } else {
412 /* we already have inode, update it */
413
414 /* if uniqueid is different, return error */
415 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
416 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
417 CIFS_I(*pinode)->time = 0; /* force reval */
418 rc = -ESTALE;
419 goto cgiiu_exit;
420 }
421
422 /* if filetype is different, return error */
423 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
424 (fattr.cf_mode & S_IFMT))) {
425 CIFS_I(*pinode)->time = 0; /* force reval */
426 rc = -ESTALE;
427 goto cgiiu_exit;
428 }
429
430 cifs_fattr_to_inode(*pinode, &fattr);
431 }
432
433cgiiu_exit:
434 return rc;
435}
436
437static int
438cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
439 struct cifs_sb_info *cifs_sb, unsigned int xid)
440{
441 int rc;
442 __u32 oplock;
443 struct tcon_link *tlink;
444 struct cifs_tcon *tcon;
445 struct cifs_fid fid;
446 struct cifs_open_parms oparms;
447 struct cifs_io_parms io_parms;
448 char buf[24];
449 unsigned int bytes_read;
450 char *pbuf;
451 int buf_type = CIFS_NO_BUFFER;
452
453 pbuf = buf;
454
455 fattr->cf_mode &= ~S_IFMT;
456
457 if (fattr->cf_eof == 0) {
458 fattr->cf_mode |= S_IFIFO;
459 fattr->cf_dtype = DT_FIFO;
460 return 0;
461 } else if (fattr->cf_eof < 8) {
462 fattr->cf_mode |= S_IFREG;
463 fattr->cf_dtype = DT_REG;
464 return -EINVAL; /* EOPNOTSUPP? */
465 }
466
467 tlink = cifs_sb_tlink(cifs_sb);
468 if (IS_ERR(tlink))
469 return PTR_ERR(tlink);
470 tcon = tlink_tcon(tlink);
471
472 oparms.tcon = tcon;
473 oparms.cifs_sb = cifs_sb;
474 oparms.desired_access = GENERIC_READ;
475 oparms.create_options = CREATE_NOT_DIR;
476 if (backup_cred(cifs_sb))
477 oparms.create_options |= CREATE_OPEN_BACKUP_INTENT;
478 oparms.disposition = FILE_OPEN;
479 oparms.path = path;
480 oparms.fid = &fid;
481 oparms.reconnect = false;
482
483 if (tcon->ses->server->oplocks)
484 oplock = REQ_OPLOCK;
485 else
486 oplock = 0;
487 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
488 if (rc) {
489 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
490 cifs_put_tlink(tlink);
491 return rc;
492 }
493
494 /* Read header */
495 io_parms.netfid = fid.netfid;
496 io_parms.pid = current->tgid;
497 io_parms.tcon = tcon;
498 io_parms.offset = 0;
499 io_parms.length = 24;
500
501 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
502 &bytes_read, &pbuf, &buf_type);
503 if ((rc == 0) && (bytes_read >= 8)) {
504 if (memcmp("IntxBLK", pbuf, 8) == 0) {
505 cifs_dbg(FYI, "Block device\n");
506 fattr->cf_mode |= S_IFBLK;
507 fattr->cf_dtype = DT_BLK;
508 if (bytes_read == 24) {
509 /* we have enough to decode dev num */
510 __u64 mjr; /* major */
511 __u64 mnr; /* minor */
512 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
513 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
514 fattr->cf_rdev = MKDEV(mjr, mnr);
515 }
516 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
517 cifs_dbg(FYI, "Char device\n");
518 fattr->cf_mode |= S_IFCHR;
519 fattr->cf_dtype = DT_CHR;
520 if (bytes_read == 24) {
521 /* we have enough to decode dev num */
522 __u64 mjr; /* major */
523 __u64 mnr; /* minor */
524 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
525 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
526 fattr->cf_rdev = MKDEV(mjr, mnr);
527 }
528 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
529 cifs_dbg(FYI, "Symlink\n");
530 fattr->cf_mode |= S_IFLNK;
531 fattr->cf_dtype = DT_LNK;
532 } else {
533 fattr->cf_mode |= S_IFREG; /* file? */
534 fattr->cf_dtype = DT_REG;
535 rc = -EOPNOTSUPP;
536 }
537 } else {
538 fattr->cf_mode |= S_IFREG; /* then it is a file */
539 fattr->cf_dtype = DT_REG;
540 rc = -EOPNOTSUPP; /* or some unknown SFU type */
541 }
542
543 tcon->ses->server->ops->close(xid, tcon, &fid);
544 cifs_put_tlink(tlink);
545 return rc;
546}
547
548#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
549
550/*
551 * Fetch mode bits as provided by SFU.
552 *
553 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
554 */
555static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
556 struct cifs_sb_info *cifs_sb, unsigned int xid)
557{
558#ifdef CONFIG_CIFS_XATTR
559 ssize_t rc;
560 char ea_value[4];
561 __u32 mode;
562 struct tcon_link *tlink;
563 struct cifs_tcon *tcon;
564
565 tlink = cifs_sb_tlink(cifs_sb);
566 if (IS_ERR(tlink))
567 return PTR_ERR(tlink);
568 tcon = tlink_tcon(tlink);
569
570 if (tcon->ses->server->ops->query_all_EAs == NULL) {
571 cifs_put_tlink(tlink);
572 return -EOPNOTSUPP;
573 }
574
575 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
576 "SETFILEBITS", ea_value, 4 /* size of buf */,
577 cifs_sb);
578 cifs_put_tlink(tlink);
579 if (rc < 0)
580 return (int)rc;
581 else if (rc > 3) {
582 mode = le32_to_cpu(*((__le32 *)ea_value));
583 fattr->cf_mode &= ~SFBITS_MASK;
584 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
585 mode, fattr->cf_mode);
586 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
587 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
588 }
589
590 return 0;
591#else
592 return -EOPNOTSUPP;
593#endif
594}
595
596/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
597static void
598cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
599 struct super_block *sb, bool adjust_tz,
600 bool symlink)
601{
602 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
603 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
604
605 memset(fattr, 0, sizeof(*fattr));
606 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
607 if (info->DeletePending)
608 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
609
610 if (info->LastAccessTime)
611 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
612 else {
613 ktime_get_real_ts64(&fattr->cf_atime);
614 fattr->cf_atime = timespec64_trunc(fattr->cf_atime, sb->s_time_gran);
615 }
616
617 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
618 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
619
620 if (adjust_tz) {
621 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
622 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
623 }
624
625 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
626 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
627 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
628
629 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
630
631 if (symlink) {
632 fattr->cf_mode = S_IFLNK;
633 fattr->cf_dtype = DT_LNK;
634 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
635 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
636 fattr->cf_dtype = DT_DIR;
637 /*
638 * Server can return wrong NumberOfLinks value for directories
639 * when Unix extensions are disabled - fake it.
640 */
641 if (!tcon->unix_ext)
642 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
643 } else {
644 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
645 fattr->cf_dtype = DT_REG;
646
647 /* clear write bits if ATTR_READONLY is set */
648 if (fattr->cf_cifsattrs & ATTR_READONLY)
649 fattr->cf_mode &= ~(S_IWUGO);
650
651 /*
652 * Don't accept zero nlink from non-unix servers unless
653 * delete is pending. Instead mark it as unknown.
654 */
655 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
656 !info->DeletePending) {
657 cifs_dbg(1, "bogus file nlink value %u\n",
658 fattr->cf_nlink);
659 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
660 }
661 }
662
663 fattr->cf_uid = cifs_sb->mnt_uid;
664 fattr->cf_gid = cifs_sb->mnt_gid;
665}
666
667static int
668cifs_get_file_info(struct file *filp)
669{
670 int rc;
671 unsigned int xid;
672 FILE_ALL_INFO find_data;
673 struct cifs_fattr fattr;
674 struct inode *inode = file_inode(filp);
675 struct cifsFileInfo *cfile = filp->private_data;
676 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
677 struct TCP_Server_Info *server = tcon->ses->server;
678
679 if (!server->ops->query_file_info)
680 return -ENOSYS;
681
682 xid = get_xid();
683 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
684 switch (rc) {
685 case 0:
686 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
687 false);
688 break;
689 case -EREMOTE:
690 cifs_create_dfs_fattr(&fattr, inode->i_sb);
691 rc = 0;
692 break;
693 case -EOPNOTSUPP:
694 case -EINVAL:
695 /*
696 * FIXME: legacy server -- fall back to path-based call?
697 * for now, just skip revalidating and mark inode for
698 * immediate reval.
699 */
700 rc = 0;
701 CIFS_I(inode)->time = 0;
702 default:
703 goto cgfi_exit;
704 }
705
706 /*
707 * don't bother with SFU junk here -- just mark inode as needing
708 * revalidation.
709 */
710 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
711 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
712 cifs_fattr_to_inode(inode, &fattr);
713cgfi_exit:
714 free_xid(xid);
715 return rc;
716}
717
718/* Simple function to return a 64 bit hash of string. Rarely called */
719static __u64 simple_hashstr(const char *str)
720{
721 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
722 __u64 hash = 0;
723
724 while (*str)
725 hash = (hash + (__u64) *str++) * hash_mult;
726
727 return hash;
728}
729
730int
731cifs_get_inode_info(struct inode **inode, const char *full_path,
732 FILE_ALL_INFO *data, struct super_block *sb, int xid,
733 const struct cifs_fid *fid)
734{
735 __u16 srchflgs;
736 int rc = 0, tmprc = ENOSYS;
737 struct cifs_tcon *tcon;
738 struct TCP_Server_Info *server;
739 struct tcon_link *tlink;
740 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
741 char *buf = NULL;
742 bool adjust_tz = false;
743 struct cifs_fattr fattr;
744 struct cifs_search_info *srchinf = NULL;
745 bool symlink = false;
746
747 tlink = cifs_sb_tlink(cifs_sb);
748 if (IS_ERR(tlink))
749 return PTR_ERR(tlink);
750 tcon = tlink_tcon(tlink);
751 server = tcon->ses->server;
752
753 cifs_dbg(FYI, "Getting info on %s\n", full_path);
754
755 if ((data == NULL) && (*inode != NULL)) {
756 if (CIFS_CACHE_READ(CIFS_I(*inode)) &&
757 CIFS_I(*inode)->time != 0) {
758 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
759 goto cgii_exit;
760 }
761 }
762
763 /* if inode info is not passed, get it from server */
764 if (data == NULL) {
765 if (!server->ops->query_path_info) {
766 rc = -ENOSYS;
767 goto cgii_exit;
768 }
769 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
770 if (buf == NULL) {
771 rc = -ENOMEM;
772 goto cgii_exit;
773 }
774 data = (FILE_ALL_INFO *)buf;
775 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
776 data, &adjust_tz, &symlink);
777 }
778
779 if (!rc) {
780 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz,
781 symlink);
782 } else if (rc == -EREMOTE) {
783 cifs_create_dfs_fattr(&fattr, sb);
784 rc = 0;
785 } else if ((rc == -EACCES) && backup_cred(cifs_sb) &&
786 (strcmp(server->vals->version_string, SMB1_VERSION_STRING)
787 == 0)) {
788 /*
789 * For SMB2 and later the backup intent flag is already
790 * sent if needed on open and there is no path based
791 * FindFirst operation to use to retry with
792 */
793
794 srchinf = kzalloc(sizeof(struct cifs_search_info),
795 GFP_KERNEL);
796 if (srchinf == NULL) {
797 rc = -ENOMEM;
798 goto cgii_exit;
799 }
800
801 srchinf->endOfSearch = false;
802 if (tcon->unix_ext)
803 srchinf->info_level = SMB_FIND_FILE_UNIX;
804 else if ((tcon->ses->capabilities &
805 tcon->ses->server->vals->cap_nt_find) == 0)
806 srchinf->info_level = SMB_FIND_FILE_INFO_STANDARD;
807 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
808 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
809 else /* no srvino useful for fallback to some netapp */
810 srchinf->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
811
812 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
813 CIFS_SEARCH_CLOSE_AT_END |
814 CIFS_SEARCH_BACKUP_SEARCH;
815
816 rc = CIFSFindFirst(xid, tcon, full_path,
817 cifs_sb, NULL, srchflgs, srchinf, false);
818 if (!rc) {
819 data = (FILE_ALL_INFO *)srchinf->srch_entries_start;
820
821 cifs_dir_info_to_fattr(&fattr,
822 (FILE_DIRECTORY_INFO *)data, cifs_sb);
823 fattr.cf_uniqueid = le64_to_cpu(
824 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
825
826 cifs_buf_release(srchinf->ntwrk_buf_start);
827 }
828 kfree(srchinf);
829 if (rc)
830 goto cgii_exit;
831 } else
832 goto cgii_exit;
833
834 /*
835 * If an inode wasn't passed in, then get the inode number
836 *
837 * Is an i_ino of zero legal? Can we use that to check if the server
838 * supports returning inode numbers? Are there other sanity checks we
839 * can use to ensure that the server is really filling in that field?
840 */
841 if (*inode == NULL) {
842 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
843 if (server->ops->get_srv_inum)
844 tmprc = server->ops->get_srv_inum(xid,
845 tcon, cifs_sb, full_path,
846 &fattr.cf_uniqueid, data);
847 if (tmprc) {
848 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
849 tmprc);
850 fattr.cf_uniqueid = iunique(sb, ROOT_I);
851 cifs_autodisable_serverino(cifs_sb);
852 } else if ((fattr.cf_uniqueid == 0) &&
853 strlen(full_path) == 0) {
854 /* some servers ret bad root ino ie 0 */
855 cifs_dbg(FYI, "Invalid (0) inodenum\n");
856 fattr.cf_flags |=
857 CIFS_FATTR_FAKE_ROOT_INO;
858 fattr.cf_uniqueid =
859 simple_hashstr(tcon->treeName);
860 }
861 } else
862 fattr.cf_uniqueid = iunique(sb, ROOT_I);
863 } else {
864 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
865 && server->ops->get_srv_inum) {
866 /*
867 * Pass a NULL tcon to ensure we don't make a round
868 * trip to the server. This only works for SMB2+.
869 */
870 tmprc = server->ops->get_srv_inum(xid,
871 NULL, cifs_sb, full_path,
872 &fattr.cf_uniqueid, data);
873 if (tmprc)
874 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
875 else if ((fattr.cf_uniqueid == 0) &&
876 strlen(full_path) == 0) {
877 /*
878 * Reuse existing root inode num since
879 * inum zero for root causes ls of . and .. to
880 * not be returned
881 */
882 cifs_dbg(FYI, "Srv ret 0 inode num for root\n");
883 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
884 }
885 } else
886 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
887 }
888
889 /* query for SFU type info if supported and needed */
890 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
891 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
892 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
893 if (tmprc)
894 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
895 }
896
897 /* fill in 0777 bits from ACL */
898 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
899 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
900 full_path, fid);
901 if (rc) {
902 cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
903 __func__, rc);
904 goto cgii_exit;
905 }
906 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
907 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false,
908 full_path, fid);
909 if (rc) {
910 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
911 __func__, rc);
912 goto cgii_exit;
913 }
914 }
915
916 /* fill in remaining high mode bits e.g. SUID, VTX */
917 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
918 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
919
920 /* check for Minshall+French symlinks */
921 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
922 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
923 full_path);
924 if (tmprc)
925 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
926 }
927
928 if (!*inode) {
929 *inode = cifs_iget(sb, &fattr);
930 if (!*inode)
931 rc = -ENOMEM;
932 } else {
933 /* we already have inode, update it */
934
935 /* if uniqueid is different, return error */
936 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
937 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
938 CIFS_I(*inode)->time = 0; /* force reval */
939 rc = -ESTALE;
940 goto cgii_exit;
941 }
942
943 /* if filetype is different, return error */
944 if (unlikely(((*inode)->i_mode & S_IFMT) !=
945 (fattr.cf_mode & S_IFMT))) {
946 CIFS_I(*inode)->time = 0; /* force reval */
947 rc = -ESTALE;
948 goto cgii_exit;
949 }
950
951 cifs_fattr_to_inode(*inode, &fattr);
952 }
953
954cgii_exit:
955 if ((*inode) && ((*inode)->i_ino == 0))
956 cifs_dbg(FYI, "inode number of zero returned\n");
957
958 kfree(buf);
959 cifs_put_tlink(tlink);
960 return rc;
961}
962
963static const struct inode_operations cifs_ipc_inode_ops = {
964 .lookup = cifs_lookup,
965};
966
967static int
968cifs_find_inode(struct inode *inode, void *opaque)
969{
970 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
971
972 /* don't match inode with different uniqueid */
973 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
974 return 0;
975
976 /* use createtime like an i_generation field */
977 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
978 return 0;
979
980 /* don't match inode of different type */
981 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
982 return 0;
983
984 /* if it's not a directory or has no dentries, then flag it */
985 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
986 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
987
988 return 1;
989}
990
991static int
992cifs_init_inode(struct inode *inode, void *opaque)
993{
994 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
995
996 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
997 CIFS_I(inode)->createtime = fattr->cf_createtime;
998 return 0;
999}
1000
1001/*
1002 * walk dentry list for an inode and report whether it has aliases that
1003 * are hashed. We use this to determine if a directory inode can actually
1004 * be used.
1005 */
1006static bool
1007inode_has_hashed_dentries(struct inode *inode)
1008{
1009 struct dentry *dentry;
1010
1011 spin_lock(&inode->i_lock);
1012 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1013 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1014 spin_unlock(&inode->i_lock);
1015 return true;
1016 }
1017 }
1018 spin_unlock(&inode->i_lock);
1019 return false;
1020}
1021
1022/* Given fattrs, get a corresponding inode */
1023struct inode *
1024cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1025{
1026 unsigned long hash;
1027 struct inode *inode;
1028
1029retry_iget5_locked:
1030 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1031
1032 /* hash down to 32-bits on 32-bit arch */
1033 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1034
1035 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1036 if (inode) {
1037 /* was there a potentially problematic inode collision? */
1038 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1039 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1040
1041 if (inode_has_hashed_dentries(inode)) {
1042 cifs_autodisable_serverino(CIFS_SB(sb));
1043 iput(inode);
1044 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1045 goto retry_iget5_locked;
1046 }
1047 }
1048
1049 cifs_fattr_to_inode(inode, fattr);
1050 if (sb->s_flags & SB_NOATIME)
1051 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1052 if (inode->i_state & I_NEW) {
1053 inode->i_ino = hash;
1054#ifdef CONFIG_CIFS_FSCACHE
1055 /* initialize per-inode cache cookie pointer */
1056 CIFS_I(inode)->fscache = NULL;
1057#endif
1058 unlock_new_inode(inode);
1059 }
1060 }
1061
1062 return inode;
1063}
1064
1065/* gets root inode */
1066struct inode *cifs_root_iget(struct super_block *sb)
1067{
1068 unsigned int xid;
1069 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1070 struct inode *inode = NULL;
1071 long rc;
1072 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1073 char *path = NULL;
1074 int len;
1075
1076 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1077 && cifs_sb->prepath) {
1078 len = strlen(cifs_sb->prepath);
1079 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1080 if (path == NULL)
1081 return ERR_PTR(-ENOMEM);
1082 path[0] = '/';
1083 memcpy(path+1, cifs_sb->prepath, len);
1084 } else {
1085 path = kstrdup("", GFP_KERNEL);
1086 if (path == NULL)
1087 return ERR_PTR(-ENOMEM);
1088 }
1089
1090 xid = get_xid();
1091 if (tcon->unix_ext) {
1092 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1093 /* some servers mistakenly claim POSIX support */
1094 if (rc != -EOPNOTSUPP)
1095 goto iget_no_retry;
1096 cifs_dbg(VFS, "server does not support POSIX extensions");
1097 tcon->unix_ext = false;
1098 }
1099
1100 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1101 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1102
1103iget_no_retry:
1104 if (!inode) {
1105 inode = ERR_PTR(rc);
1106 goto out;
1107 }
1108
1109#ifdef CONFIG_CIFS_FSCACHE
1110 /* populate tcon->resource_id */
1111 tcon->resource_id = CIFS_I(inode)->uniqueid;
1112#endif
1113
1114 if (rc && tcon->pipe) {
1115 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1116 spin_lock(&inode->i_lock);
1117 inode->i_mode |= S_IFDIR;
1118 set_nlink(inode, 2);
1119 inode->i_op = &cifs_ipc_inode_ops;
1120 inode->i_fop = &simple_dir_operations;
1121 inode->i_uid = cifs_sb->mnt_uid;
1122 inode->i_gid = cifs_sb->mnt_gid;
1123 spin_unlock(&inode->i_lock);
1124 } else if (rc) {
1125 iget_failed(inode);
1126 inode = ERR_PTR(rc);
1127 }
1128
1129out:
1130 kfree(path);
1131 free_xid(xid);
1132 return inode;
1133}
1134
1135int
1136cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1137 char *full_path, __u32 dosattr)
1138{
1139 bool set_time = false;
1140 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1141 struct TCP_Server_Info *server;
1142 FILE_BASIC_INFO info_buf;
1143
1144 if (attrs == NULL)
1145 return -EINVAL;
1146
1147 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1148 if (!server->ops->set_file_info)
1149 return -ENOSYS;
1150
1151 info_buf.Pad = 0;
1152
1153 if (attrs->ia_valid & ATTR_ATIME) {
1154 set_time = true;
1155 info_buf.LastAccessTime =
1156 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1157 } else
1158 info_buf.LastAccessTime = 0;
1159
1160 if (attrs->ia_valid & ATTR_MTIME) {
1161 set_time = true;
1162 info_buf.LastWriteTime =
1163 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1164 } else
1165 info_buf.LastWriteTime = 0;
1166
1167 /*
1168 * Samba throws this field away, but windows may actually use it.
1169 * Do not set ctime unless other time stamps are changed explicitly
1170 * (i.e. by utimes()) since we would then have a mix of client and
1171 * server times.
1172 */
1173 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1174 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1175 info_buf.ChangeTime =
1176 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1177 } else
1178 info_buf.ChangeTime = 0;
1179
1180 info_buf.CreationTime = 0; /* don't change */
1181 info_buf.Attributes = cpu_to_le32(dosattr);
1182
1183 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1184}
1185
1186/*
1187 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1188 * and rename it to a random name that hopefully won't conflict with
1189 * anything else.
1190 */
1191int
1192cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1193 const unsigned int xid)
1194{
1195 int oplock = 0;
1196 int rc;
1197 struct cifs_fid fid;
1198 struct cifs_open_parms oparms;
1199 struct inode *inode = d_inode(dentry);
1200 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1201 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1202 struct tcon_link *tlink;
1203 struct cifs_tcon *tcon;
1204 __u32 dosattr, origattr;
1205 FILE_BASIC_INFO *info_buf = NULL;
1206
1207 tlink = cifs_sb_tlink(cifs_sb);
1208 if (IS_ERR(tlink))
1209 return PTR_ERR(tlink);
1210 tcon = tlink_tcon(tlink);
1211
1212 /*
1213 * We cannot rename the file if the server doesn't support
1214 * CAP_INFOLEVEL_PASSTHRU
1215 */
1216 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1217 rc = -EBUSY;
1218 goto out;
1219 }
1220
1221 oparms.tcon = tcon;
1222 oparms.cifs_sb = cifs_sb;
1223 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1224 oparms.create_options = CREATE_NOT_DIR;
1225 oparms.disposition = FILE_OPEN;
1226 oparms.path = full_path;
1227 oparms.fid = &fid;
1228 oparms.reconnect = false;
1229
1230 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1231 if (rc != 0)
1232 goto out;
1233
1234 origattr = cifsInode->cifsAttrs;
1235 if (origattr == 0)
1236 origattr |= ATTR_NORMAL;
1237
1238 dosattr = origattr & ~ATTR_READONLY;
1239 if (dosattr == 0)
1240 dosattr |= ATTR_NORMAL;
1241 dosattr |= ATTR_HIDDEN;
1242
1243 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1244 if (dosattr != origattr) {
1245 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1246 if (info_buf == NULL) {
1247 rc = -ENOMEM;
1248 goto out_close;
1249 }
1250 info_buf->Attributes = cpu_to_le32(dosattr);
1251 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1252 current->tgid);
1253 /* although we would like to mark the file hidden
1254 if that fails we will still try to rename it */
1255 if (!rc)
1256 cifsInode->cifsAttrs = dosattr;
1257 else
1258 dosattr = origattr; /* since not able to change them */
1259 }
1260
1261 /* rename the file */
1262 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1263 cifs_sb->local_nls,
1264 cifs_remap(cifs_sb));
1265 if (rc != 0) {
1266 rc = -EBUSY;
1267 goto undo_setattr;
1268 }
1269
1270 /* try to set DELETE_ON_CLOSE */
1271 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1272 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1273 current->tgid);
1274 /*
1275 * some samba versions return -ENOENT when we try to set the
1276 * file disposition here. Likely a samba bug, but work around
1277 * it for now. This means that some cifsXXX files may hang
1278 * around after they shouldn't.
1279 *
1280 * BB: remove this hack after more servers have the fix
1281 */
1282 if (rc == -ENOENT)
1283 rc = 0;
1284 else if (rc != 0) {
1285 rc = -EBUSY;
1286 goto undo_rename;
1287 }
1288 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1289 }
1290
1291out_close:
1292 CIFSSMBClose(xid, tcon, fid.netfid);
1293out:
1294 kfree(info_buf);
1295 cifs_put_tlink(tlink);
1296 return rc;
1297
1298 /*
1299 * reset everything back to the original state. Don't bother
1300 * dealing with errors here since we can't do anything about
1301 * them anyway.
1302 */
1303undo_rename:
1304 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1305 cifs_sb->local_nls, cifs_remap(cifs_sb));
1306undo_setattr:
1307 if (dosattr != origattr) {
1308 info_buf->Attributes = cpu_to_le32(origattr);
1309 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1310 current->tgid))
1311 cifsInode->cifsAttrs = origattr;
1312 }
1313
1314 goto out_close;
1315}
1316
1317/* copied from fs/nfs/dir.c with small changes */
1318static void
1319cifs_drop_nlink(struct inode *inode)
1320{
1321 spin_lock(&inode->i_lock);
1322 if (inode->i_nlink > 0)
1323 drop_nlink(inode);
1324 spin_unlock(&inode->i_lock);
1325}
1326
1327/*
1328 * If d_inode(dentry) is null (usually meaning the cached dentry
1329 * is a negative dentry) then we would attempt a standard SMB delete, but
1330 * if that fails we can not attempt the fall back mechanisms on EACCES
1331 * but will return the EACCES to the caller. Note that the VFS does not call
1332 * unlink on negative dentries currently.
1333 */
1334int cifs_unlink(struct inode *dir, struct dentry *dentry)
1335{
1336 int rc = 0;
1337 unsigned int xid;
1338 char *full_path = NULL;
1339 struct inode *inode = d_inode(dentry);
1340 struct cifsInodeInfo *cifs_inode;
1341 struct super_block *sb = dir->i_sb;
1342 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1343 struct tcon_link *tlink;
1344 struct cifs_tcon *tcon;
1345 struct TCP_Server_Info *server;
1346 struct iattr *attrs = NULL;
1347 __u32 dosattr = 0, origattr = 0;
1348
1349 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1350
1351 tlink = cifs_sb_tlink(cifs_sb);
1352 if (IS_ERR(tlink))
1353 return PTR_ERR(tlink);
1354 tcon = tlink_tcon(tlink);
1355 server = tcon->ses->server;
1356
1357 xid = get_xid();
1358
1359 /* Unlink can be called from rename so we can not take the
1360 * sb->s_vfs_rename_mutex here */
1361 full_path = build_path_from_dentry(dentry);
1362 if (full_path == NULL) {
1363 rc = -ENOMEM;
1364 goto unlink_out;
1365 }
1366
1367 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1368 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1369 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1370 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1371 cifs_remap(cifs_sb));
1372 cifs_dbg(FYI, "posix del rc %d\n", rc);
1373 if ((rc == 0) || (rc == -ENOENT))
1374 goto psx_del_no_retry;
1375 }
1376
1377retry_std_delete:
1378 if (!server->ops->unlink) {
1379 rc = -ENOSYS;
1380 goto psx_del_no_retry;
1381 }
1382
1383 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1384
1385psx_del_no_retry:
1386 if (!rc) {
1387 if (inode)
1388 cifs_drop_nlink(inode);
1389 } else if (rc == -ENOENT) {
1390 d_drop(dentry);
1391 } else if (rc == -EBUSY) {
1392 if (server->ops->rename_pending_delete) {
1393 rc = server->ops->rename_pending_delete(full_path,
1394 dentry, xid);
1395 if (rc == 0)
1396 cifs_drop_nlink(inode);
1397 }
1398 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1399 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1400 if (attrs == NULL) {
1401 rc = -ENOMEM;
1402 goto out_reval;
1403 }
1404
1405 /* try to reset dos attributes */
1406 cifs_inode = CIFS_I(inode);
1407 origattr = cifs_inode->cifsAttrs;
1408 if (origattr == 0)
1409 origattr |= ATTR_NORMAL;
1410 dosattr = origattr & ~ATTR_READONLY;
1411 if (dosattr == 0)
1412 dosattr |= ATTR_NORMAL;
1413 dosattr |= ATTR_HIDDEN;
1414
1415 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1416 if (rc != 0)
1417 goto out_reval;
1418
1419 goto retry_std_delete;
1420 }
1421
1422 /* undo the setattr if we errored out and it's needed */
1423 if (rc != 0 && dosattr != 0)
1424 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1425
1426out_reval:
1427 if (inode) {
1428 cifs_inode = CIFS_I(inode);
1429 cifs_inode->time = 0; /* will force revalidate to get info
1430 when needed */
1431 inode->i_ctime = current_time(inode);
1432 }
1433 dir->i_ctime = dir->i_mtime = current_time(dir);
1434 cifs_inode = CIFS_I(dir);
1435 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1436unlink_out:
1437 kfree(full_path);
1438 kfree(attrs);
1439 free_xid(xid);
1440 cifs_put_tlink(tlink);
1441 return rc;
1442}
1443
1444static int
1445cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1446 const char *full_path, struct cifs_sb_info *cifs_sb,
1447 struct cifs_tcon *tcon, const unsigned int xid)
1448{
1449 int rc = 0;
1450 struct inode *inode = NULL;
1451
1452 if (tcon->unix_ext)
1453 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1454 xid);
1455 else
1456 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1457 xid, NULL);
1458
1459 if (rc)
1460 return rc;
1461
1462 /*
1463 * setting nlink not necessary except in cases where we failed to get it
1464 * from the server or was set bogus. Also, since this is a brand new
1465 * inode, no need to grab the i_lock before setting the i_nlink.
1466 */
1467 if (inode->i_nlink < 2)
1468 set_nlink(inode, 2);
1469 mode &= ~current_umask();
1470 /* must turn on setgid bit if parent dir has it */
1471 if (parent->i_mode & S_ISGID)
1472 mode |= S_ISGID;
1473
1474 if (tcon->unix_ext) {
1475 struct cifs_unix_set_info_args args = {
1476 .mode = mode,
1477 .ctime = NO_CHANGE_64,
1478 .atime = NO_CHANGE_64,
1479 .mtime = NO_CHANGE_64,
1480 .device = 0,
1481 };
1482 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1483 args.uid = current_fsuid();
1484 if (parent->i_mode & S_ISGID)
1485 args.gid = parent->i_gid;
1486 else
1487 args.gid = current_fsgid();
1488 } else {
1489 args.uid = INVALID_UID; /* no change */
1490 args.gid = INVALID_GID; /* no change */
1491 }
1492 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1493 cifs_sb->local_nls,
1494 cifs_remap(cifs_sb));
1495 } else {
1496 struct TCP_Server_Info *server = tcon->ses->server;
1497 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1498 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1499 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1500 tcon, xid);
1501 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1502 inode->i_mode = (mode | S_IFDIR);
1503
1504 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1505 inode->i_uid = current_fsuid();
1506 if (inode->i_mode & S_ISGID)
1507 inode->i_gid = parent->i_gid;
1508 else
1509 inode->i_gid = current_fsgid();
1510 }
1511 }
1512 d_instantiate(dentry, inode);
1513 return rc;
1514}
1515
1516static int
1517cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1518 const char *full_path, struct cifs_sb_info *cifs_sb,
1519 struct cifs_tcon *tcon, const unsigned int xid)
1520{
1521 int rc = 0;
1522 u32 oplock = 0;
1523 FILE_UNIX_BASIC_INFO *info = NULL;
1524 struct inode *newinode = NULL;
1525 struct cifs_fattr fattr;
1526
1527 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1528 if (info == NULL) {
1529 rc = -ENOMEM;
1530 goto posix_mkdir_out;
1531 }
1532
1533 mode &= ~current_umask();
1534 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1535 NULL /* netfid */, info, &oplock, full_path,
1536 cifs_sb->local_nls, cifs_remap(cifs_sb));
1537 if (rc == -EOPNOTSUPP)
1538 goto posix_mkdir_out;
1539 else if (rc) {
1540 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1541 d_drop(dentry);
1542 goto posix_mkdir_out;
1543 }
1544
1545 if (info->Type == cpu_to_le32(-1))
1546 /* no return info, go query for it */
1547 goto posix_mkdir_get_info;
1548 /*
1549 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1550 * need to set uid/gid.
1551 */
1552
1553 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1554 cifs_fill_uniqueid(inode->i_sb, &fattr);
1555 newinode = cifs_iget(inode->i_sb, &fattr);
1556 if (!newinode)
1557 goto posix_mkdir_get_info;
1558
1559 d_instantiate(dentry, newinode);
1560
1561#ifdef CONFIG_CIFS_DEBUG2
1562 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1563 dentry, dentry, newinode);
1564
1565 if (newinode->i_nlink != 2)
1566 cifs_dbg(FYI, "unexpected number of links %d\n",
1567 newinode->i_nlink);
1568#endif
1569
1570posix_mkdir_out:
1571 kfree(info);
1572 return rc;
1573posix_mkdir_get_info:
1574 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1575 xid);
1576 goto posix_mkdir_out;
1577}
1578
1579int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1580{
1581 int rc = 0;
1582 unsigned int xid;
1583 struct cifs_sb_info *cifs_sb;
1584 struct tcon_link *tlink;
1585 struct cifs_tcon *tcon;
1586 struct TCP_Server_Info *server;
1587 char *full_path;
1588
1589 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1590 mode, inode);
1591
1592 cifs_sb = CIFS_SB(inode->i_sb);
1593 tlink = cifs_sb_tlink(cifs_sb);
1594 if (IS_ERR(tlink))
1595 return PTR_ERR(tlink);
1596 tcon = tlink_tcon(tlink);
1597
1598 xid = get_xid();
1599
1600 full_path = build_path_from_dentry(direntry);
1601 if (full_path == NULL) {
1602 rc = -ENOMEM;
1603 goto mkdir_out;
1604 }
1605
1606 server = tcon->ses->server;
1607
1608 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1609 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1610 cifs_sb);
1611 d_drop(direntry); /* for time being always refresh inode info */
1612 goto mkdir_out;
1613 }
1614
1615 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1616 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1617 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1618 tcon, xid);
1619 if (rc != -EOPNOTSUPP)
1620 goto mkdir_out;
1621 }
1622
1623 if (!server->ops->mkdir) {
1624 rc = -ENOSYS;
1625 goto mkdir_out;
1626 }
1627
1628 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1629 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1630 if (rc) {
1631 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1632 d_drop(direntry);
1633 goto mkdir_out;
1634 }
1635
1636 /* TODO: skip this for smb2/smb3 */
1637 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1638 xid);
1639mkdir_out:
1640 /*
1641 * Force revalidate to get parent dir info when needed since cached
1642 * attributes are invalid now.
1643 */
1644 CIFS_I(inode)->time = 0;
1645 kfree(full_path);
1646 free_xid(xid);
1647 cifs_put_tlink(tlink);
1648 return rc;
1649}
1650
1651int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1652{
1653 int rc = 0;
1654 unsigned int xid;
1655 struct cifs_sb_info *cifs_sb;
1656 struct tcon_link *tlink;
1657 struct cifs_tcon *tcon;
1658 struct TCP_Server_Info *server;
1659 char *full_path = NULL;
1660 struct cifsInodeInfo *cifsInode;
1661
1662 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1663
1664 xid = get_xid();
1665
1666 full_path = build_path_from_dentry(direntry);
1667 if (full_path == NULL) {
1668 rc = -ENOMEM;
1669 goto rmdir_exit;
1670 }
1671
1672 cifs_sb = CIFS_SB(inode->i_sb);
1673 tlink = cifs_sb_tlink(cifs_sb);
1674 if (IS_ERR(tlink)) {
1675 rc = PTR_ERR(tlink);
1676 goto rmdir_exit;
1677 }
1678 tcon = tlink_tcon(tlink);
1679 server = tcon->ses->server;
1680
1681 if (!server->ops->rmdir) {
1682 rc = -ENOSYS;
1683 cifs_put_tlink(tlink);
1684 goto rmdir_exit;
1685 }
1686
1687 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1688 cifs_put_tlink(tlink);
1689
1690 if (!rc) {
1691 spin_lock(&d_inode(direntry)->i_lock);
1692 i_size_write(d_inode(direntry), 0);
1693 clear_nlink(d_inode(direntry));
1694 spin_unlock(&d_inode(direntry)->i_lock);
1695 }
1696
1697 cifsInode = CIFS_I(d_inode(direntry));
1698 /* force revalidate to go get info when needed */
1699 cifsInode->time = 0;
1700
1701 cifsInode = CIFS_I(inode);
1702 /*
1703 * Force revalidate to get parent dir info when needed since cached
1704 * attributes are invalid now.
1705 */
1706 cifsInode->time = 0;
1707
1708 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1709 current_time(inode);
1710
1711rmdir_exit:
1712 kfree(full_path);
1713 free_xid(xid);
1714 return rc;
1715}
1716
1717static int
1718cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1719 const char *from_path, struct dentry *to_dentry,
1720 const char *to_path)
1721{
1722 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1723 struct tcon_link *tlink;
1724 struct cifs_tcon *tcon;
1725 struct TCP_Server_Info *server;
1726 struct cifs_fid fid;
1727 struct cifs_open_parms oparms;
1728 int oplock, rc;
1729
1730 tlink = cifs_sb_tlink(cifs_sb);
1731 if (IS_ERR(tlink))
1732 return PTR_ERR(tlink);
1733 tcon = tlink_tcon(tlink);
1734 server = tcon->ses->server;
1735
1736 if (!server->ops->rename)
1737 return -ENOSYS;
1738
1739 /* try path-based rename first */
1740 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1741
1742 /*
1743 * Don't bother with rename by filehandle unless file is busy and
1744 * source. Note that cross directory moves do not work with
1745 * rename by filehandle to various Windows servers.
1746 */
1747 if (rc == 0 || rc != -EBUSY)
1748 goto do_rename_exit;
1749
1750 /* Don't fall back to using SMB on SMB 2+ mount */
1751 if (server->vals->protocol_id != 0)
1752 goto do_rename_exit;
1753
1754 /* open-file renames don't work across directories */
1755 if (to_dentry->d_parent != from_dentry->d_parent)
1756 goto do_rename_exit;
1757
1758 oparms.tcon = tcon;
1759 oparms.cifs_sb = cifs_sb;
1760 /* open the file to be renamed -- we need DELETE perms */
1761 oparms.desired_access = DELETE;
1762 oparms.create_options = CREATE_NOT_DIR;
1763 oparms.disposition = FILE_OPEN;
1764 oparms.path = from_path;
1765 oparms.fid = &fid;
1766 oparms.reconnect = false;
1767
1768 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1769 if (rc == 0) {
1770 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1771 (const char *) to_dentry->d_name.name,
1772 cifs_sb->local_nls, cifs_remap(cifs_sb));
1773 CIFSSMBClose(xid, tcon, fid.netfid);
1774 }
1775do_rename_exit:
1776 cifs_put_tlink(tlink);
1777 return rc;
1778}
1779
1780int
1781cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1782 struct inode *target_dir, struct dentry *target_dentry,
1783 unsigned int flags)
1784{
1785 char *from_name = NULL;
1786 char *to_name = NULL;
1787 struct cifs_sb_info *cifs_sb;
1788 struct tcon_link *tlink;
1789 struct cifs_tcon *tcon;
1790 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1791 FILE_UNIX_BASIC_INFO *info_buf_target;
1792 unsigned int xid;
1793 int rc, tmprc;
1794
1795 if (flags & ~RENAME_NOREPLACE)
1796 return -EINVAL;
1797
1798 cifs_sb = CIFS_SB(source_dir->i_sb);
1799 tlink = cifs_sb_tlink(cifs_sb);
1800 if (IS_ERR(tlink))
1801 return PTR_ERR(tlink);
1802 tcon = tlink_tcon(tlink);
1803
1804 xid = get_xid();
1805
1806 /*
1807 * we already have the rename sem so we do not need to
1808 * grab it again here to protect the path integrity
1809 */
1810 from_name = build_path_from_dentry(source_dentry);
1811 if (from_name == NULL) {
1812 rc = -ENOMEM;
1813 goto cifs_rename_exit;
1814 }
1815
1816 to_name = build_path_from_dentry(target_dentry);
1817 if (to_name == NULL) {
1818 rc = -ENOMEM;
1819 goto cifs_rename_exit;
1820 }
1821
1822 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1823 to_name);
1824
1825 /*
1826 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1827 */
1828 if (flags & RENAME_NOREPLACE)
1829 goto cifs_rename_exit;
1830
1831 if (rc == -EEXIST && tcon->unix_ext) {
1832 /*
1833 * Are src and dst hardlinks of same inode? We can only tell
1834 * with unix extensions enabled.
1835 */
1836 info_buf_source =
1837 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
1838 GFP_KERNEL);
1839 if (info_buf_source == NULL) {
1840 rc = -ENOMEM;
1841 goto cifs_rename_exit;
1842 }
1843
1844 info_buf_target = info_buf_source + 1;
1845 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1846 info_buf_source,
1847 cifs_sb->local_nls,
1848 cifs_remap(cifs_sb));
1849 if (tmprc != 0)
1850 goto unlink_target;
1851
1852 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1853 info_buf_target,
1854 cifs_sb->local_nls,
1855 cifs_remap(cifs_sb));
1856
1857 if (tmprc == 0 && (info_buf_source->UniqueId ==
1858 info_buf_target->UniqueId)) {
1859 /* same file, POSIX says that this is a noop */
1860 rc = 0;
1861 goto cifs_rename_exit;
1862 }
1863 }
1864 /*
1865 * else ... BB we could add the same check for Windows by
1866 * checking the UniqueId via FILE_INTERNAL_INFO
1867 */
1868
1869unlink_target:
1870 /* Try unlinking the target dentry if it's not negative */
1871 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1872 if (d_is_dir(target_dentry))
1873 tmprc = cifs_rmdir(target_dir, target_dentry);
1874 else
1875 tmprc = cifs_unlink(target_dir, target_dentry);
1876 if (tmprc)
1877 goto cifs_rename_exit;
1878 rc = cifs_do_rename(xid, source_dentry, from_name,
1879 target_dentry, to_name);
1880 }
1881
1882 /* force revalidate to go get info when needed */
1883 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1884
1885 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1886 target_dir->i_mtime = current_time(source_dir);
1887
1888cifs_rename_exit:
1889 kfree(info_buf_source);
1890 kfree(from_name);
1891 kfree(to_name);
1892 free_xid(xid);
1893 cifs_put_tlink(tlink);
1894 return rc;
1895}
1896
1897static bool
1898cifs_inode_needs_reval(struct inode *inode)
1899{
1900 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1901 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1902
1903 if (cifs_i->time == 0)
1904 return true;
1905
1906 if (CIFS_CACHE_READ(cifs_i))
1907 return false;
1908
1909 if (!lookupCacheEnabled)
1910 return true;
1911
1912 if (!cifs_sb->actimeo)
1913 return true;
1914
1915 if (!time_in_range(jiffies, cifs_i->time,
1916 cifs_i->time + cifs_sb->actimeo))
1917 return true;
1918
1919 /* hardlinked files w/ noserverino get "special" treatment */
1920 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1921 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1922 return true;
1923
1924 return false;
1925}
1926
1927/*
1928 * Zap the cache. Called when invalid_mapping flag is set.
1929 */
1930int
1931cifs_invalidate_mapping(struct inode *inode)
1932{
1933 int rc = 0;
1934
1935 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1936 rc = invalidate_inode_pages2(inode->i_mapping);
1937 if (rc)
1938 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1939 __func__, inode);
1940 }
1941
1942 cifs_fscache_reset_inode_cookie(inode);
1943 return rc;
1944}
1945
1946/**
1947 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1948 * @word: long word containing the bit lock
1949 */
1950static int
1951cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
1952{
1953 freezable_schedule_unsafe();
1954 if (signal_pending_state(mode, current))
1955 return -ERESTARTSYS;
1956 return 0;
1957}
1958
1959int
1960cifs_revalidate_mapping(struct inode *inode)
1961{
1962 int rc;
1963 unsigned long *flags = &CIFS_I(inode)->flags;
1964
1965 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1966 TASK_KILLABLE);
1967 if (rc)
1968 return rc;
1969
1970 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1971 rc = cifs_invalidate_mapping(inode);
1972 if (rc)
1973 set_bit(CIFS_INO_INVALID_MAPPING, flags);
1974 }
1975
1976 clear_bit_unlock(CIFS_INO_LOCK, flags);
1977 smp_mb__after_atomic();
1978 wake_up_bit(flags, CIFS_INO_LOCK);
1979
1980 return rc;
1981}
1982
1983int
1984cifs_zap_mapping(struct inode *inode)
1985{
1986 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1987 return cifs_revalidate_mapping(inode);
1988}
1989
1990int cifs_revalidate_file_attr(struct file *filp)
1991{
1992 int rc = 0;
1993 struct inode *inode = file_inode(filp);
1994 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1995
1996 if (!cifs_inode_needs_reval(inode))
1997 return rc;
1998
1999 if (tlink_tcon(cfile->tlink)->unix_ext)
2000 rc = cifs_get_file_info_unix(filp);
2001 else
2002 rc = cifs_get_file_info(filp);
2003
2004 return rc;
2005}
2006
2007int cifs_revalidate_dentry_attr(struct dentry *dentry)
2008{
2009 unsigned int xid;
2010 int rc = 0;
2011 struct inode *inode = d_inode(dentry);
2012 struct super_block *sb = dentry->d_sb;
2013 char *full_path = NULL;
2014
2015 if (inode == NULL)
2016 return -ENOENT;
2017
2018 if (!cifs_inode_needs_reval(inode))
2019 return rc;
2020
2021 xid = get_xid();
2022
2023 /* can not safely grab the rename sem here if rename calls revalidate
2024 since that would deadlock */
2025 full_path = build_path_from_dentry(dentry);
2026 if (full_path == NULL) {
2027 rc = -ENOMEM;
2028 goto out;
2029 }
2030
2031 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2032 full_path, inode, inode->i_count.counter,
2033 dentry, cifs_get_time(dentry), jiffies);
2034
2035 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2036 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2037 else
2038 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2039 xid, NULL);
2040
2041out:
2042 kfree(full_path);
2043 free_xid(xid);
2044 return rc;
2045}
2046
2047int cifs_revalidate_file(struct file *filp)
2048{
2049 int rc;
2050 struct inode *inode = file_inode(filp);
2051
2052 rc = cifs_revalidate_file_attr(filp);
2053 if (rc)
2054 return rc;
2055
2056 return cifs_revalidate_mapping(inode);
2057}
2058
2059/* revalidate a dentry's inode attributes */
2060int cifs_revalidate_dentry(struct dentry *dentry)
2061{
2062 int rc;
2063 struct inode *inode = d_inode(dentry);
2064
2065 rc = cifs_revalidate_dentry_attr(dentry);
2066 if (rc)
2067 return rc;
2068
2069 return cifs_revalidate_mapping(inode);
2070}
2071
2072int cifs_getattr(const struct path *path, struct kstat *stat,
2073 u32 request_mask, unsigned int flags)
2074{
2075 struct dentry *dentry = path->dentry;
2076 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2077 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2078 struct inode *inode = d_inode(dentry);
2079 int rc;
2080
2081 /*
2082 * We need to be sure that all dirty pages are written and the server
2083 * has actual ctime, mtime and file length.
2084 */
2085 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2086 inode->i_mapping->nrpages != 0) {
2087 rc = filemap_fdatawait(inode->i_mapping);
2088 if (rc) {
2089 mapping_set_error(inode->i_mapping, rc);
2090 return rc;
2091 }
2092 }
2093
2094 rc = cifs_revalidate_dentry_attr(dentry);
2095 if (rc)
2096 return rc;
2097
2098 generic_fillattr(inode, stat);
2099 stat->blksize = cifs_sb->bsize;
2100 stat->ino = CIFS_I(inode)->uniqueid;
2101
2102 /* old CIFS Unix Extensions doesn't return create time */
2103 if (CIFS_I(inode)->createtime) {
2104 stat->result_mask |= STATX_BTIME;
2105 stat->btime =
2106 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2107 }
2108
2109 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2110 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2111 stat->attributes |= STATX_ATTR_COMPRESSED;
2112 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2113 stat->attributes |= STATX_ATTR_ENCRYPTED;
2114
2115 /*
2116 * If on a multiuser mount without unix extensions or cifsacl being
2117 * enabled, and the admin hasn't overridden them, set the ownership
2118 * to the fsuid/fsgid of the current process.
2119 */
2120 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2121 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2122 !tcon->unix_ext) {
2123 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2124 stat->uid = current_fsuid();
2125 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2126 stat->gid = current_fsgid();
2127 }
2128 return rc;
2129}
2130
2131int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2132 u64 len)
2133{
2134 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2135 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2136 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2137 struct TCP_Server_Info *server = tcon->ses->server;
2138 struct cifsFileInfo *cfile;
2139 int rc;
2140
2141 /*
2142 * We need to be sure that all dirty pages are written as they
2143 * might fill holes on the server.
2144 */
2145 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2146 inode->i_mapping->nrpages != 0) {
2147 rc = filemap_fdatawait(inode->i_mapping);
2148 if (rc) {
2149 mapping_set_error(inode->i_mapping, rc);
2150 return rc;
2151 }
2152 }
2153
2154 cfile = find_readable_file(cifs_i, false);
2155 if (cfile == NULL)
2156 return -EINVAL;
2157
2158 if (server->ops->fiemap) {
2159 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2160 cifsFileInfo_put(cfile);
2161 return rc;
2162 }
2163
2164 cifsFileInfo_put(cfile);
2165 return -ENOTSUPP;
2166}
2167
2168static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2169{
2170 pgoff_t index = from >> PAGE_SHIFT;
2171 unsigned offset = from & (PAGE_SIZE - 1);
2172 struct page *page;
2173 int rc = 0;
2174
2175 page = grab_cache_page(mapping, index);
2176 if (!page)
2177 return -ENOMEM;
2178
2179 zero_user_segment(page, offset, PAGE_SIZE);
2180 unlock_page(page);
2181 put_page(page);
2182 return rc;
2183}
2184
2185static void cifs_setsize(struct inode *inode, loff_t offset)
2186{
2187 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2188
2189 spin_lock(&inode->i_lock);
2190 i_size_write(inode, offset);
2191 spin_unlock(&inode->i_lock);
2192
2193 /* Cached inode must be refreshed on truncate */
2194 cifs_i->time = 0;
2195 truncate_pagecache(inode, offset);
2196}
2197
2198static int
2199cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2200 unsigned int xid, char *full_path)
2201{
2202 int rc;
2203 struct cifsFileInfo *open_file;
2204 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2205 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2206 struct tcon_link *tlink = NULL;
2207 struct cifs_tcon *tcon = NULL;
2208 struct TCP_Server_Info *server;
2209
2210 /*
2211 * To avoid spurious oplock breaks from server, in the case of
2212 * inodes that we already have open, avoid doing path based
2213 * setting of file size if we can do it by handle.
2214 * This keeps our caching token (oplock) and avoids timeouts
2215 * when the local oplock break takes longer to flush
2216 * writebehind data than the SMB timeout for the SetPathInfo
2217 * request would allow
2218 */
2219 open_file = find_writable_file(cifsInode, true);
2220 if (open_file) {
2221 tcon = tlink_tcon(open_file->tlink);
2222 server = tcon->ses->server;
2223 if (server->ops->set_file_size)
2224 rc = server->ops->set_file_size(xid, tcon, open_file,
2225 attrs->ia_size, false);
2226 else
2227 rc = -ENOSYS;
2228 cifsFileInfo_put(open_file);
2229 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2230 } else
2231 rc = -EINVAL;
2232
2233 if (!rc)
2234 goto set_size_out;
2235
2236 if (tcon == NULL) {
2237 tlink = cifs_sb_tlink(cifs_sb);
2238 if (IS_ERR(tlink))
2239 return PTR_ERR(tlink);
2240 tcon = tlink_tcon(tlink);
2241 server = tcon->ses->server;
2242 }
2243
2244 /*
2245 * Set file size by pathname rather than by handle either because no
2246 * valid, writeable file handle for it was found or because there was
2247 * an error setting it by handle.
2248 */
2249 if (server->ops->set_path_size)
2250 rc = server->ops->set_path_size(xid, tcon, full_path,
2251 attrs->ia_size, cifs_sb, false);
2252 else
2253 rc = -ENOSYS;
2254 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2255
2256 if (tlink)
2257 cifs_put_tlink(tlink);
2258
2259set_size_out:
2260 if (rc == 0) {
2261 cifsInode->server_eof = attrs->ia_size;
2262 cifs_setsize(inode, attrs->ia_size);
2263 cifs_truncate_page(inode->i_mapping, inode->i_size);
2264 }
2265
2266 return rc;
2267}
2268
2269static int
2270cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2271{
2272 int rc;
2273 unsigned int xid;
2274 char *full_path = NULL;
2275 struct inode *inode = d_inode(direntry);
2276 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2277 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2278 struct tcon_link *tlink;
2279 struct cifs_tcon *pTcon;
2280 struct cifs_unix_set_info_args *args = NULL;
2281 struct cifsFileInfo *open_file;
2282
2283 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2284 direntry, attrs->ia_valid);
2285
2286 xid = get_xid();
2287
2288 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2289 attrs->ia_valid |= ATTR_FORCE;
2290
2291 rc = setattr_prepare(direntry, attrs);
2292 if (rc < 0)
2293 goto out;
2294
2295 full_path = build_path_from_dentry(direntry);
2296 if (full_path == NULL) {
2297 rc = -ENOMEM;
2298 goto out;
2299 }
2300
2301 /*
2302 * Attempt to flush data before changing attributes. We need to do
2303 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2304 * ownership or mode then we may also need to do this. Here, we take
2305 * the safe way out and just do the flush on all setattr requests. If
2306 * the flush returns error, store it to report later and continue.
2307 *
2308 * BB: This should be smarter. Why bother flushing pages that
2309 * will be truncated anyway? Also, should we error out here if
2310 * the flush returns error?
2311 */
2312 rc = filemap_write_and_wait(inode->i_mapping);
2313 if (is_interrupt_error(rc)) {
2314 rc = -ERESTARTSYS;
2315 goto out;
2316 }
2317
2318 mapping_set_error(inode->i_mapping, rc);
2319 rc = 0;
2320
2321 if (attrs->ia_valid & ATTR_SIZE) {
2322 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2323 if (rc != 0)
2324 goto out;
2325 }
2326
2327 /* skip mode change if it's just for clearing setuid/setgid */
2328 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2329 attrs->ia_valid &= ~ATTR_MODE;
2330
2331 args = kmalloc(sizeof(*args), GFP_KERNEL);
2332 if (args == NULL) {
2333 rc = -ENOMEM;
2334 goto out;
2335 }
2336
2337 /* set up the struct */
2338 if (attrs->ia_valid & ATTR_MODE)
2339 args->mode = attrs->ia_mode;
2340 else
2341 args->mode = NO_CHANGE_64;
2342
2343 if (attrs->ia_valid & ATTR_UID)
2344 args->uid = attrs->ia_uid;
2345 else
2346 args->uid = INVALID_UID; /* no change */
2347
2348 if (attrs->ia_valid & ATTR_GID)
2349 args->gid = attrs->ia_gid;
2350 else
2351 args->gid = INVALID_GID; /* no change */
2352
2353 if (attrs->ia_valid & ATTR_ATIME)
2354 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2355 else
2356 args->atime = NO_CHANGE_64;
2357
2358 if (attrs->ia_valid & ATTR_MTIME)
2359 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2360 else
2361 args->mtime = NO_CHANGE_64;
2362
2363 if (attrs->ia_valid & ATTR_CTIME)
2364 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2365 else
2366 args->ctime = NO_CHANGE_64;
2367
2368 args->device = 0;
2369 open_file = find_writable_file(cifsInode, true);
2370 if (open_file) {
2371 u16 nfid = open_file->fid.netfid;
2372 u32 npid = open_file->pid;
2373 pTcon = tlink_tcon(open_file->tlink);
2374 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2375 cifsFileInfo_put(open_file);
2376 } else {
2377 tlink = cifs_sb_tlink(cifs_sb);
2378 if (IS_ERR(tlink)) {
2379 rc = PTR_ERR(tlink);
2380 goto out;
2381 }
2382 pTcon = tlink_tcon(tlink);
2383 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2384 cifs_sb->local_nls,
2385 cifs_remap(cifs_sb));
2386 cifs_put_tlink(tlink);
2387 }
2388
2389 if (rc)
2390 goto out;
2391
2392 if ((attrs->ia_valid & ATTR_SIZE) &&
2393 attrs->ia_size != i_size_read(inode))
2394 truncate_setsize(inode, attrs->ia_size);
2395
2396 setattr_copy(inode, attrs);
2397 mark_inode_dirty(inode);
2398
2399 /* force revalidate when any of these times are set since some
2400 of the fs types (eg ext3, fat) do not have fine enough
2401 time granularity to match protocol, and we do not have a
2402 a way (yet) to query the server fs's time granularity (and
2403 whether it rounds times down).
2404 */
2405 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2406 cifsInode->time = 0;
2407out:
2408 kfree(args);
2409 kfree(full_path);
2410 free_xid(xid);
2411 return rc;
2412}
2413
2414static int
2415cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2416{
2417 unsigned int xid;
2418 kuid_t uid = INVALID_UID;
2419 kgid_t gid = INVALID_GID;
2420 struct inode *inode = d_inode(direntry);
2421 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2422 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2423 struct cifsFileInfo *wfile;
2424 struct cifs_tcon *tcon;
2425 char *full_path = NULL;
2426 int rc = -EACCES;
2427 __u32 dosattr = 0;
2428 __u64 mode = NO_CHANGE_64;
2429
2430 xid = get_xid();
2431
2432 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2433 direntry, attrs->ia_valid);
2434
2435 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2436 attrs->ia_valid |= ATTR_FORCE;
2437
2438 rc = setattr_prepare(direntry, attrs);
2439 if (rc < 0) {
2440 free_xid(xid);
2441 return rc;
2442 }
2443
2444 full_path = build_path_from_dentry(direntry);
2445 if (full_path == NULL) {
2446 rc = -ENOMEM;
2447 free_xid(xid);
2448 return rc;
2449 }
2450
2451 /*
2452 * Attempt to flush data before changing attributes. We need to do
2453 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2454 * ownership or mode then we may also need to do this. Here, we take
2455 * the safe way out and just do the flush on all setattr requests. If
2456 * the flush returns error, store it to report later and continue.
2457 *
2458 * BB: This should be smarter. Why bother flushing pages that
2459 * will be truncated anyway? Also, should we error out here if
2460 * the flush returns error?
2461 */
2462 rc = filemap_write_and_wait(inode->i_mapping);
2463 if (is_interrupt_error(rc)) {
2464 rc = -ERESTARTSYS;
2465 goto cifs_setattr_exit;
2466 }
2467
2468 mapping_set_error(inode->i_mapping, rc);
2469 rc = 0;
2470
2471 if (attrs->ia_valid & ATTR_MTIME) {
2472 rc = cifs_get_writable_file(cifsInode, false, &wfile);
2473 if (!rc) {
2474 tcon = tlink_tcon(wfile->tlink);
2475 rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2476 cifsFileInfo_put(wfile);
2477 if (rc)
2478 goto cifs_setattr_exit;
2479 } else if (rc != -EBADF)
2480 goto cifs_setattr_exit;
2481 else
2482 rc = 0;
2483 }
2484
2485 if (attrs->ia_valid & ATTR_SIZE) {
2486 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2487 if (rc != 0)
2488 goto cifs_setattr_exit;
2489 }
2490
2491 if (attrs->ia_valid & ATTR_UID)
2492 uid = attrs->ia_uid;
2493
2494 if (attrs->ia_valid & ATTR_GID)
2495 gid = attrs->ia_gid;
2496
2497 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2498 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2499 if (uid_valid(uid) || gid_valid(gid)) {
2500 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2501 uid, gid);
2502 if (rc) {
2503 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2504 __func__, rc);
2505 goto cifs_setattr_exit;
2506 }
2507 }
2508 } else
2509 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2510 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2511
2512 /* skip mode change if it's just for clearing setuid/setgid */
2513 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2514 attrs->ia_valid &= ~ATTR_MODE;
2515
2516 if (attrs->ia_valid & ATTR_MODE) {
2517 mode = attrs->ia_mode;
2518 rc = 0;
2519 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2520 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2521 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2522 INVALID_UID, INVALID_GID);
2523 if (rc) {
2524 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2525 __func__, rc);
2526 goto cifs_setattr_exit;
2527 }
2528 } else
2529 if (((mode & S_IWUGO) == 0) &&
2530 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2531
2532 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2533
2534 /* fix up mode if we're not using dynperm */
2535 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2536 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2537 } else if ((mode & S_IWUGO) &&
2538 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2539
2540 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2541 /* Attributes of 0 are ignored */
2542 if (dosattr == 0)
2543 dosattr |= ATTR_NORMAL;
2544
2545 /* reset local inode permissions to normal */
2546 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2547 attrs->ia_mode &= ~(S_IALLUGO);
2548 if (S_ISDIR(inode->i_mode))
2549 attrs->ia_mode |=
2550 cifs_sb->mnt_dir_mode;
2551 else
2552 attrs->ia_mode |=
2553 cifs_sb->mnt_file_mode;
2554 }
2555 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2556 /* ignore mode change - ATTR_READONLY hasn't changed */
2557 attrs->ia_valid &= ~ATTR_MODE;
2558 }
2559 }
2560
2561 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2562 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2563 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2564 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2565
2566 /* Even if error on time set, no sense failing the call if
2567 the server would set the time to a reasonable value anyway,
2568 and this check ensures that we are not being called from
2569 sys_utimes in which case we ought to fail the call back to
2570 the user when the server rejects the call */
2571 if ((rc) && (attrs->ia_valid &
2572 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2573 rc = 0;
2574 }
2575
2576 /* do not need local check to inode_check_ok since the server does
2577 that */
2578 if (rc)
2579 goto cifs_setattr_exit;
2580
2581 if ((attrs->ia_valid & ATTR_SIZE) &&
2582 attrs->ia_size != i_size_read(inode))
2583 truncate_setsize(inode, attrs->ia_size);
2584
2585 setattr_copy(inode, attrs);
2586 mark_inode_dirty(inode);
2587
2588cifs_setattr_exit:
2589 kfree(full_path);
2590 free_xid(xid);
2591 return rc;
2592}
2593
2594int
2595cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2596{
2597 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2598 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2599
2600 if (pTcon->unix_ext)
2601 return cifs_setattr_unix(direntry, attrs);
2602
2603 return cifs_setattr_nounix(direntry, attrs);
2604
2605 /* BB: add cifs_setattr_legacy for really old servers */
2606}
2607
2608#if 0
2609void cifs_delete_inode(struct inode *inode)
2610{
2611 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2612 /* may have to add back in if and when safe distributed caching of
2613 directories added e.g. via FindNotify */
2614}
2615#endif
1/*
2 * fs/cifs/inode.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2010
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21#include <linux/fs.h>
22#include <linux/stat.h>
23#include <linux/slab.h>
24#include <linux/pagemap.h>
25#include <linux/freezer.h>
26#include <linux/sched/signal.h>
27#include <linux/wait_bit.h>
28#include <linux/fiemap.h>
29
30#include <asm/div64.h>
31#include "cifsfs.h"
32#include "cifspdu.h"
33#include "cifsglob.h"
34#include "cifsproto.h"
35#include "smb2proto.h"
36#include "cifs_debug.h"
37#include "cifs_fs_sb.h"
38#include "cifs_unicode.h"
39#include "fscache.h"
40
41
42static void cifs_set_ops(struct inode *inode)
43{
44 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
45
46 switch (inode->i_mode & S_IFMT) {
47 case S_IFREG:
48 inode->i_op = &cifs_file_inode_ops;
49 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
50 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
51 inode->i_fop = &cifs_file_direct_nobrl_ops;
52 else
53 inode->i_fop = &cifs_file_direct_ops;
54 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
55 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
56 inode->i_fop = &cifs_file_strict_nobrl_ops;
57 else
58 inode->i_fop = &cifs_file_strict_ops;
59 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
60 inode->i_fop = &cifs_file_nobrl_ops;
61 else { /* not direct, send byte range locks */
62 inode->i_fop = &cifs_file_ops;
63 }
64
65 /* check if server can support readpages */
66 if (cifs_sb_master_tcon(cifs_sb)->ses->server->max_read <
67 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
68 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
69 else
70 inode->i_data.a_ops = &cifs_addr_ops;
71 break;
72 case S_IFDIR:
73#ifdef CONFIG_CIFS_DFS_UPCALL
74 if (IS_AUTOMOUNT(inode)) {
75 inode->i_op = &cifs_dfs_referral_inode_operations;
76 } else {
77#else /* NO DFS support, treat as a directory */
78 {
79#endif
80 inode->i_op = &cifs_dir_inode_ops;
81 inode->i_fop = &cifs_dir_ops;
82 }
83 break;
84 case S_IFLNK:
85 inode->i_op = &cifs_symlink_inode_ops;
86 break;
87 default:
88 init_special_inode(inode, inode->i_mode, inode->i_rdev);
89 break;
90 }
91}
92
93/* check inode attributes against fattr. If they don't match, tag the
94 * inode for cache invalidation
95 */
96static void
97cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
98{
99 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
100
101 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
102 __func__, cifs_i->uniqueid);
103
104 if (inode->i_state & I_NEW) {
105 cifs_dbg(FYI, "%s: inode %llu is new\n",
106 __func__, cifs_i->uniqueid);
107 return;
108 }
109
110 /* don't bother with revalidation if we have an oplock */
111 if (CIFS_CACHE_READ(cifs_i)) {
112 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
113 __func__, cifs_i->uniqueid);
114 return;
115 }
116
117 /* revalidate if mtime or size have changed */
118 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
119 if (timespec64_equal(&inode->i_mtime, &fattr->cf_mtime) &&
120 cifs_i->server_eof == fattr->cf_eof) {
121 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
122 __func__, cifs_i->uniqueid);
123 return;
124 }
125
126 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
127 __func__, cifs_i->uniqueid);
128 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
129}
130
131/*
132 * copy nlink to the inode, unless it wasn't provided. Provide
133 * sane values if we don't have an existing one and none was provided
134 */
135static void
136cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
137{
138 /*
139 * if we're in a situation where we can't trust what we
140 * got from the server (readdir, some non-unix cases)
141 * fake reasonable values
142 */
143 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
144 /* only provide fake values on a new inode */
145 if (inode->i_state & I_NEW) {
146 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
147 set_nlink(inode, 2);
148 else
149 set_nlink(inode, 1);
150 }
151 return;
152 }
153
154 /* we trust the server, so update it */
155 set_nlink(inode, fattr->cf_nlink);
156}
157
158/* populate an inode with info from a cifs_fattr struct */
159void
160cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
161{
162 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
163 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
164
165 cifs_revalidate_cache(inode, fattr);
166
167 spin_lock(&inode->i_lock);
168 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
169 fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode);
170 fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);
171 /* we do not want atime to be less than mtime, it broke some apps */
172 if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)
173 inode->i_atime = fattr->cf_mtime;
174 else
175 inode->i_atime = fattr->cf_atime;
176 inode->i_mtime = fattr->cf_mtime;
177 inode->i_ctime = fattr->cf_ctime;
178 inode->i_rdev = fattr->cf_rdev;
179 cifs_nlink_fattr_to_inode(inode, fattr);
180 inode->i_uid = fattr->cf_uid;
181 inode->i_gid = fattr->cf_gid;
182
183 /* if dynperm is set, don't clobber existing mode */
184 if (inode->i_state & I_NEW ||
185 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
186 inode->i_mode = fattr->cf_mode;
187
188 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
189
190 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
191 cifs_i->time = 0;
192 else
193 cifs_i->time = jiffies;
194
195 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
196 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
197 else
198 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
199
200 cifs_i->server_eof = fattr->cf_eof;
201 /*
202 * Can't safely change the file size here if the client is writing to
203 * it due to potential races.
204 */
205 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
206 i_size_write(inode, fattr->cf_eof);
207
208 /*
209 * i_blocks is not related to (i_size / i_blksize),
210 * but instead 512 byte (2**9) size is required for
211 * calculating num blocks.
212 */
213 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
214 }
215 spin_unlock(&inode->i_lock);
216
217 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
218 inode->i_flags |= S_AUTOMOUNT;
219 if (inode->i_state & I_NEW)
220 cifs_set_ops(inode);
221}
222
223void
224cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
225{
226 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
227
228 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
229 return;
230
231 fattr->cf_uniqueid = iunique(sb, ROOT_I);
232}
233
234/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
235void
236cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
237 struct cifs_sb_info *cifs_sb)
238{
239 memset(fattr, 0, sizeof(*fattr));
240 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
241 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
242 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
243
244 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
245 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
246 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
247 /* old POSIX extensions don't get create time */
248
249 fattr->cf_mode = le64_to_cpu(info->Permissions);
250
251 /*
252 * Since we set the inode type below we need to mask off
253 * to avoid strange results if bits set above.
254 */
255 fattr->cf_mode &= ~S_IFMT;
256 switch (le32_to_cpu(info->Type)) {
257 case UNIX_FILE:
258 fattr->cf_mode |= S_IFREG;
259 fattr->cf_dtype = DT_REG;
260 break;
261 case UNIX_SYMLINK:
262 fattr->cf_mode |= S_IFLNK;
263 fattr->cf_dtype = DT_LNK;
264 break;
265 case UNIX_DIR:
266 fattr->cf_mode |= S_IFDIR;
267 fattr->cf_dtype = DT_DIR;
268 break;
269 case UNIX_CHARDEV:
270 fattr->cf_mode |= S_IFCHR;
271 fattr->cf_dtype = DT_CHR;
272 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
273 le64_to_cpu(info->DevMinor) & MINORMASK);
274 break;
275 case UNIX_BLOCKDEV:
276 fattr->cf_mode |= S_IFBLK;
277 fattr->cf_dtype = DT_BLK;
278 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
279 le64_to_cpu(info->DevMinor) & MINORMASK);
280 break;
281 case UNIX_FIFO:
282 fattr->cf_mode |= S_IFIFO;
283 fattr->cf_dtype = DT_FIFO;
284 break;
285 case UNIX_SOCKET:
286 fattr->cf_mode |= S_IFSOCK;
287 fattr->cf_dtype = DT_SOCK;
288 break;
289 default:
290 /* safest to call it a file if we do not know */
291 fattr->cf_mode |= S_IFREG;
292 fattr->cf_dtype = DT_REG;
293 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
294 break;
295 }
296
297 fattr->cf_uid = cifs_sb->mnt_uid;
298 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
299 u64 id = le64_to_cpu(info->Uid);
300 if (id < ((uid_t)-1)) {
301 kuid_t uid = make_kuid(&init_user_ns, id);
302 if (uid_valid(uid))
303 fattr->cf_uid = uid;
304 }
305 }
306
307 fattr->cf_gid = cifs_sb->mnt_gid;
308 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
309 u64 id = le64_to_cpu(info->Gid);
310 if (id < ((gid_t)-1)) {
311 kgid_t gid = make_kgid(&init_user_ns, id);
312 if (gid_valid(gid))
313 fattr->cf_gid = gid;
314 }
315 }
316
317 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
318}
319
320/*
321 * Fill a cifs_fattr struct with fake inode info.
322 *
323 * Needed to setup cifs_fattr data for the directory which is the
324 * junction to the new submount (ie to setup the fake directory
325 * which represents a DFS referral).
326 */
327static void
328cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
329{
330 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
331
332 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
333
334 memset(fattr, 0, sizeof(*fattr));
335 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
336 fattr->cf_uid = cifs_sb->mnt_uid;
337 fattr->cf_gid = cifs_sb->mnt_gid;
338 ktime_get_coarse_real_ts64(&fattr->cf_mtime);
339 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
340 fattr->cf_nlink = 2;
341 fattr->cf_flags = CIFS_FATTR_DFS_REFERRAL;
342}
343
344static int
345cifs_get_file_info_unix(struct file *filp)
346{
347 int rc;
348 unsigned int xid;
349 FILE_UNIX_BASIC_INFO find_data;
350 struct cifs_fattr fattr;
351 struct inode *inode = file_inode(filp);
352 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
353 struct cifsFileInfo *cfile = filp->private_data;
354 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
355
356 xid = get_xid();
357 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
358 if (!rc) {
359 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
360 } else if (rc == -EREMOTE) {
361 cifs_create_dfs_fattr(&fattr, inode->i_sb);
362 rc = 0;
363 }
364
365 cifs_fattr_to_inode(inode, &fattr);
366 free_xid(xid);
367 return rc;
368}
369
370int cifs_get_inode_info_unix(struct inode **pinode,
371 const unsigned char *full_path,
372 struct super_block *sb, unsigned int xid)
373{
374 int rc;
375 FILE_UNIX_BASIC_INFO find_data;
376 struct cifs_fattr fattr;
377 struct cifs_tcon *tcon;
378 struct tcon_link *tlink;
379 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
380
381 cifs_dbg(FYI, "Getting info on %s\n", full_path);
382
383 tlink = cifs_sb_tlink(cifs_sb);
384 if (IS_ERR(tlink))
385 return PTR_ERR(tlink);
386 tcon = tlink_tcon(tlink);
387
388 /* could have done a find first instead but this returns more info */
389 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
390 cifs_sb->local_nls, cifs_remap(cifs_sb));
391 cifs_put_tlink(tlink);
392
393 if (!rc) {
394 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
395 } else if (rc == -EREMOTE) {
396 cifs_create_dfs_fattr(&fattr, sb);
397 rc = 0;
398 } else {
399 return rc;
400 }
401
402 /* check for Minshall+French symlinks */
403 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
404 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
405 full_path);
406 if (tmprc)
407 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
408 }
409
410 if (*pinode == NULL) {
411 /* get new inode */
412 cifs_fill_uniqueid(sb, &fattr);
413 *pinode = cifs_iget(sb, &fattr);
414 if (!*pinode)
415 rc = -ENOMEM;
416 } else {
417 /* we already have inode, update it */
418
419 /* if uniqueid is different, return error */
420 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
421 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
422 CIFS_I(*pinode)->time = 0; /* force reval */
423 rc = -ESTALE;
424 goto cgiiu_exit;
425 }
426
427 /* if filetype is different, return error */
428 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
429 (fattr.cf_mode & S_IFMT))) {
430 CIFS_I(*pinode)->time = 0; /* force reval */
431 rc = -ESTALE;
432 goto cgiiu_exit;
433 }
434
435 cifs_fattr_to_inode(*pinode, &fattr);
436 }
437
438cgiiu_exit:
439 return rc;
440}
441
442static int
443cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
444 struct cifs_sb_info *cifs_sb, unsigned int xid)
445{
446 int rc;
447 __u32 oplock;
448 struct tcon_link *tlink;
449 struct cifs_tcon *tcon;
450 struct cifs_fid fid;
451 struct cifs_open_parms oparms;
452 struct cifs_io_parms io_parms = {0};
453 char buf[24];
454 unsigned int bytes_read;
455 char *pbuf;
456 int buf_type = CIFS_NO_BUFFER;
457
458 pbuf = buf;
459
460 fattr->cf_mode &= ~S_IFMT;
461
462 if (fattr->cf_eof == 0) {
463 fattr->cf_mode |= S_IFIFO;
464 fattr->cf_dtype = DT_FIFO;
465 return 0;
466 } else if (fattr->cf_eof < 8) {
467 fattr->cf_mode |= S_IFREG;
468 fattr->cf_dtype = DT_REG;
469 return -EINVAL; /* EOPNOTSUPP? */
470 }
471
472 tlink = cifs_sb_tlink(cifs_sb);
473 if (IS_ERR(tlink))
474 return PTR_ERR(tlink);
475 tcon = tlink_tcon(tlink);
476
477 oparms.tcon = tcon;
478 oparms.cifs_sb = cifs_sb;
479 oparms.desired_access = GENERIC_READ;
480 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
481 oparms.disposition = FILE_OPEN;
482 oparms.path = path;
483 oparms.fid = &fid;
484 oparms.reconnect = false;
485
486 if (tcon->ses->server->oplocks)
487 oplock = REQ_OPLOCK;
488 else
489 oplock = 0;
490 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
491 if (rc) {
492 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
493 cifs_put_tlink(tlink);
494 return rc;
495 }
496
497 /* Read header */
498 io_parms.netfid = fid.netfid;
499 io_parms.pid = current->tgid;
500 io_parms.tcon = tcon;
501 io_parms.offset = 0;
502 io_parms.length = 24;
503
504 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
505 &bytes_read, &pbuf, &buf_type);
506 if ((rc == 0) && (bytes_read >= 8)) {
507 if (memcmp("IntxBLK", pbuf, 8) == 0) {
508 cifs_dbg(FYI, "Block device\n");
509 fattr->cf_mode |= S_IFBLK;
510 fattr->cf_dtype = DT_BLK;
511 if (bytes_read == 24) {
512 /* we have enough to decode dev num */
513 __u64 mjr; /* major */
514 __u64 mnr; /* minor */
515 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
516 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
517 fattr->cf_rdev = MKDEV(mjr, mnr);
518 }
519 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
520 cifs_dbg(FYI, "Char device\n");
521 fattr->cf_mode |= S_IFCHR;
522 fattr->cf_dtype = DT_CHR;
523 if (bytes_read == 24) {
524 /* we have enough to decode dev num */
525 __u64 mjr; /* major */
526 __u64 mnr; /* minor */
527 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
528 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
529 fattr->cf_rdev = MKDEV(mjr, mnr);
530 }
531 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
532 cifs_dbg(FYI, "Symlink\n");
533 fattr->cf_mode |= S_IFLNK;
534 fattr->cf_dtype = DT_LNK;
535 } else {
536 fattr->cf_mode |= S_IFREG; /* file? */
537 fattr->cf_dtype = DT_REG;
538 rc = -EOPNOTSUPP;
539 }
540 } else {
541 fattr->cf_mode |= S_IFREG; /* then it is a file */
542 fattr->cf_dtype = DT_REG;
543 rc = -EOPNOTSUPP; /* or some unknown SFU type */
544 }
545
546 tcon->ses->server->ops->close(xid, tcon, &fid);
547 cifs_put_tlink(tlink);
548 return rc;
549}
550
551#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
552
553/*
554 * Fetch mode bits as provided by SFU.
555 *
556 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
557 */
558static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
559 struct cifs_sb_info *cifs_sb, unsigned int xid)
560{
561#ifdef CONFIG_CIFS_XATTR
562 ssize_t rc;
563 char ea_value[4];
564 __u32 mode;
565 struct tcon_link *tlink;
566 struct cifs_tcon *tcon;
567
568 tlink = cifs_sb_tlink(cifs_sb);
569 if (IS_ERR(tlink))
570 return PTR_ERR(tlink);
571 tcon = tlink_tcon(tlink);
572
573 if (tcon->ses->server->ops->query_all_EAs == NULL) {
574 cifs_put_tlink(tlink);
575 return -EOPNOTSUPP;
576 }
577
578 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
579 "SETFILEBITS", ea_value, 4 /* size of buf */,
580 cifs_sb);
581 cifs_put_tlink(tlink);
582 if (rc < 0)
583 return (int)rc;
584 else if (rc > 3) {
585 mode = le32_to_cpu(*((__le32 *)ea_value));
586 fattr->cf_mode &= ~SFBITS_MASK;
587 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
588 mode, fattr->cf_mode);
589 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
590 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
591 }
592
593 return 0;
594#else
595 return -EOPNOTSUPP;
596#endif
597}
598
599/* Fill a cifs_fattr struct with info from POSIX info struct */
600static void
601smb311_posix_info_to_fattr(struct cifs_fattr *fattr, struct smb311_posix_qinfo *info,
602 struct super_block *sb, bool adjust_tz, bool symlink)
603{
604 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
605 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
606
607 memset(fattr, 0, sizeof(*fattr));
608
609 /* no fattr->flags to set */
610 fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes);
611 fattr->cf_uniqueid = le64_to_cpu(info->Inode);
612
613 if (info->LastAccessTime)
614 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
615 else
616 ktime_get_coarse_real_ts64(&fattr->cf_atime);
617
618 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
619 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
620
621 if (adjust_tz) {
622 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
623 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
624 }
625
626 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
627 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
628 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
629
630 fattr->cf_nlink = le32_to_cpu(info->HardLinks);
631 fattr->cf_mode = (umode_t) le32_to_cpu(info->Mode);
632 /* The srv fs device id is overridden on network mount so setting rdev isn't needed here */
633 /* fattr->cf_rdev = le32_to_cpu(info->DeviceId); */
634
635 if (symlink) {
636 fattr->cf_mode |= S_IFLNK;
637 fattr->cf_dtype = DT_LNK;
638 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
639 fattr->cf_mode |= S_IFDIR;
640 fattr->cf_dtype = DT_DIR;
641 } else { /* file */
642 fattr->cf_mode |= S_IFREG;
643 fattr->cf_dtype = DT_REG;
644 }
645 /* else if reparse point ... TODO: add support for FIFO and blk dev; special file types */
646
647 fattr->cf_uid = cifs_sb->mnt_uid; /* TODO: map uid and gid from SID */
648 fattr->cf_gid = cifs_sb->mnt_gid;
649
650 cifs_dbg(FYI, "POSIX query info: mode 0x%x uniqueid 0x%llx nlink %d\n",
651 fattr->cf_mode, fattr->cf_uniqueid, fattr->cf_nlink);
652}
653
654
655/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
656static void
657cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
658 struct super_block *sb, bool adjust_tz,
659 bool symlink)
660{
661 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
662 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
663
664 memset(fattr, 0, sizeof(*fattr));
665 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
666 if (info->DeletePending)
667 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
668
669 if (info->LastAccessTime)
670 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
671 else
672 ktime_get_coarse_real_ts64(&fattr->cf_atime);
673
674 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
675 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
676
677 if (adjust_tz) {
678 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
679 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
680 }
681
682 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
683 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
684 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
685
686 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
687
688 if (symlink) {
689 fattr->cf_mode = S_IFLNK;
690 fattr->cf_dtype = DT_LNK;
691 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
692 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
693 fattr->cf_dtype = DT_DIR;
694 /*
695 * Server can return wrong NumberOfLinks value for directories
696 * when Unix extensions are disabled - fake it.
697 */
698 if (!tcon->unix_ext)
699 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
700 } else {
701 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
702 fattr->cf_dtype = DT_REG;
703
704 /* clear write bits if ATTR_READONLY is set */
705 if (fattr->cf_cifsattrs & ATTR_READONLY)
706 fattr->cf_mode &= ~(S_IWUGO);
707
708 /*
709 * Don't accept zero nlink from non-unix servers unless
710 * delete is pending. Instead mark it as unknown.
711 */
712 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
713 !info->DeletePending) {
714 cifs_dbg(VFS, "bogus file nlink value %u\n",
715 fattr->cf_nlink);
716 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
717 }
718 }
719
720 fattr->cf_uid = cifs_sb->mnt_uid;
721 fattr->cf_gid = cifs_sb->mnt_gid;
722}
723
724static int
725cifs_get_file_info(struct file *filp)
726{
727 int rc;
728 unsigned int xid;
729 FILE_ALL_INFO find_data;
730 struct cifs_fattr fattr;
731 struct inode *inode = file_inode(filp);
732 struct cifsFileInfo *cfile = filp->private_data;
733 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
734 struct TCP_Server_Info *server = tcon->ses->server;
735
736 if (!server->ops->query_file_info)
737 return -ENOSYS;
738
739 xid = get_xid();
740 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
741 switch (rc) {
742 case 0:
743 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
744 false);
745 break;
746 case -EREMOTE:
747 cifs_create_dfs_fattr(&fattr, inode->i_sb);
748 rc = 0;
749 break;
750 case -EOPNOTSUPP:
751 case -EINVAL:
752 /*
753 * FIXME: legacy server -- fall back to path-based call?
754 * for now, just skip revalidating and mark inode for
755 * immediate reval.
756 */
757 rc = 0;
758 CIFS_I(inode)->time = 0;
759 default:
760 goto cgfi_exit;
761 }
762
763 /*
764 * don't bother with SFU junk here -- just mark inode as needing
765 * revalidation.
766 */
767 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
768 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
769 cifs_fattr_to_inode(inode, &fattr);
770cgfi_exit:
771 free_xid(xid);
772 return rc;
773}
774
775/* Simple function to return a 64 bit hash of string. Rarely called */
776static __u64 simple_hashstr(const char *str)
777{
778 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
779 __u64 hash = 0;
780
781 while (*str)
782 hash = (hash + (__u64) *str++) * hash_mult;
783
784 return hash;
785}
786
787/**
788 * cifs_backup_query_path_info - SMB1 fallback code to get ino
789 *
790 * Fallback code to get file metadata when we don't have access to
791 * @full_path (EACCES) and have backup creds.
792 *
793 * @data will be set to search info result buffer
794 * @resp_buf will be set to cifs resp buf and needs to be freed with
795 * cifs_buf_release() when done with @data.
796 */
797static int
798cifs_backup_query_path_info(int xid,
799 struct cifs_tcon *tcon,
800 struct super_block *sb,
801 const char *full_path,
802 void **resp_buf,
803 FILE_ALL_INFO **data)
804{
805 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
806 struct cifs_search_info info = {0};
807 u16 flags;
808 int rc;
809
810 *resp_buf = NULL;
811 info.endOfSearch = false;
812 if (tcon->unix_ext)
813 info.info_level = SMB_FIND_FILE_UNIX;
814 else if ((tcon->ses->capabilities &
815 tcon->ses->server->vals->cap_nt_find) == 0)
816 info.info_level = SMB_FIND_FILE_INFO_STANDARD;
817 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
818 info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
819 else /* no srvino useful for fallback to some netapp */
820 info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
821
822 flags = CIFS_SEARCH_CLOSE_ALWAYS |
823 CIFS_SEARCH_CLOSE_AT_END |
824 CIFS_SEARCH_BACKUP_SEARCH;
825
826 rc = CIFSFindFirst(xid, tcon, full_path,
827 cifs_sb, NULL, flags, &info, false);
828 if (rc)
829 return rc;
830
831 *resp_buf = (void *)info.ntwrk_buf_start;
832 *data = (FILE_ALL_INFO *)info.srch_entries_start;
833 return 0;
834}
835
836static void
837cifs_set_fattr_ino(int xid,
838 struct cifs_tcon *tcon,
839 struct super_block *sb,
840 struct inode **inode,
841 const char *full_path,
842 FILE_ALL_INFO *data,
843 struct cifs_fattr *fattr)
844{
845 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
846 struct TCP_Server_Info *server = tcon->ses->server;
847 int rc;
848
849 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
850 if (*inode)
851 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
852 else
853 fattr->cf_uniqueid = iunique(sb, ROOT_I);
854 return;
855 }
856
857 /*
858 * If we have an inode pass a NULL tcon to ensure we don't
859 * make a round trip to the server. This only works for SMB2+.
860 */
861 rc = server->ops->get_srv_inum(xid,
862 *inode ? NULL : tcon,
863 cifs_sb, full_path,
864 &fattr->cf_uniqueid,
865 data);
866 if (rc) {
867 /*
868 * If that fails reuse existing ino or generate one
869 * and disable server ones
870 */
871 if (*inode)
872 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
873 else {
874 fattr->cf_uniqueid = iunique(sb, ROOT_I);
875 cifs_autodisable_serverino(cifs_sb);
876 }
877 return;
878 }
879
880 /* If no errors, check for zero root inode (invalid) */
881 if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
882 cifs_dbg(FYI, "Invalid (0) inodenum\n");
883 if (*inode) {
884 /* reuse */
885 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
886 } else {
887 /* make an ino by hashing the UNC */
888 fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
889 fattr->cf_uniqueid = simple_hashstr(tcon->treeName);
890 }
891 }
892}
893
894static inline bool is_inode_cache_good(struct inode *ino)
895{
896 return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
897}
898
899int
900cifs_get_inode_info(struct inode **inode,
901 const char *full_path,
902 FILE_ALL_INFO *in_data,
903 struct super_block *sb, int xid,
904 const struct cifs_fid *fid)
905{
906
907 struct cifs_tcon *tcon;
908 struct TCP_Server_Info *server;
909 struct tcon_link *tlink;
910 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
911 bool adjust_tz = false;
912 struct cifs_fattr fattr = {0};
913 bool symlink = false;
914 FILE_ALL_INFO *data = in_data;
915 FILE_ALL_INFO *tmp_data = NULL;
916 void *smb1_backup_rsp_buf = NULL;
917 int rc = 0;
918 int tmprc = 0;
919
920 tlink = cifs_sb_tlink(cifs_sb);
921 if (IS_ERR(tlink))
922 return PTR_ERR(tlink);
923 tcon = tlink_tcon(tlink);
924 server = tcon->ses->server;
925
926 /*
927 * 1. Fetch file metadata if not provided (data)
928 */
929
930 if (!data) {
931 if (is_inode_cache_good(*inode)) {
932 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
933 goto out;
934 }
935 tmp_data = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
936 if (!tmp_data) {
937 rc = -ENOMEM;
938 goto out;
939 }
940 rc = server->ops->query_path_info(xid, tcon, cifs_sb,
941 full_path, tmp_data,
942 &adjust_tz, &symlink);
943 data = tmp_data;
944 }
945
946 /*
947 * 2. Convert it to internal cifs metadata (fattr)
948 */
949
950 switch (rc) {
951 case 0:
952 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz, symlink);
953 break;
954 case -EREMOTE:
955 /* DFS link, no metadata available on this server */
956 cifs_create_dfs_fattr(&fattr, sb);
957 rc = 0;
958 break;
959 case -EACCES:
960 /*
961 * perm errors, try again with backup flags if possible
962 *
963 * For SMB2 and later the backup intent flag
964 * is already sent if needed on open and there
965 * is no path based FindFirst operation to use
966 * to retry with
967 */
968 if (backup_cred(cifs_sb) && is_smb1_server(server)) {
969 /* for easier reading */
970 FILE_DIRECTORY_INFO *fdi;
971 SEARCH_ID_FULL_DIR_INFO *si;
972
973 rc = cifs_backup_query_path_info(xid, tcon, sb,
974 full_path,
975 &smb1_backup_rsp_buf,
976 &data);
977 if (rc)
978 goto out;
979
980 fdi = (FILE_DIRECTORY_INFO *)data;
981 si = (SEARCH_ID_FULL_DIR_INFO *)data;
982
983 cifs_dir_info_to_fattr(&fattr, fdi, cifs_sb);
984 fattr.cf_uniqueid = le64_to_cpu(si->UniqueId);
985 /* uniqueid set, skip get inum step */
986 goto handle_mnt_opt;
987 } else {
988 /* nothing we can do, bail out */
989 goto out;
990 }
991 break;
992 default:
993 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
994 goto out;
995 }
996
997 /*
998 * 3. Get or update inode number (fattr.cf_uniqueid)
999 */
1000
1001 cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, &fattr);
1002
1003 /*
1004 * 4. Tweak fattr based on mount options
1005 */
1006
1007handle_mnt_opt:
1008 /* query for SFU type info if supported and needed */
1009 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
1010 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
1011 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
1012 if (tmprc)
1013 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
1014 }
1015
1016 /* fill in 0777 bits from ACL */
1017 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
1018 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
1019 full_path, fid);
1020 if (rc == -EREMOTE)
1021 rc = 0;
1022 if (rc) {
1023 cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
1024 __func__, rc);
1025 goto out;
1026 }
1027 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
1028 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false,
1029 full_path, fid);
1030 if (rc == -EREMOTE)
1031 rc = 0;
1032 if (rc) {
1033 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
1034 __func__, rc);
1035 goto out;
1036 }
1037 }
1038
1039 /* fill in remaining high mode bits e.g. SUID, VTX */
1040 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
1041 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
1042
1043 /* check for Minshall+French symlinks */
1044 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1045 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1046 full_path);
1047 if (tmprc)
1048 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1049 }
1050
1051 /*
1052 * 5. Update inode with final fattr data
1053 */
1054
1055 if (!*inode) {
1056 *inode = cifs_iget(sb, &fattr);
1057 if (!*inode)
1058 rc = -ENOMEM;
1059 } else {
1060 /* we already have inode, update it */
1061
1062 /* if uniqueid is different, return error */
1063 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1064 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1065 CIFS_I(*inode)->time = 0; /* force reval */
1066 rc = -ESTALE;
1067 goto out;
1068 }
1069
1070 /* if filetype is different, return error */
1071 if (unlikely(((*inode)->i_mode & S_IFMT) !=
1072 (fattr.cf_mode & S_IFMT))) {
1073 CIFS_I(*inode)->time = 0; /* force reval */
1074 rc = -ESTALE;
1075 goto out;
1076 }
1077
1078 cifs_fattr_to_inode(*inode, &fattr);
1079 }
1080out:
1081 cifs_buf_release(smb1_backup_rsp_buf);
1082 cifs_put_tlink(tlink);
1083 kfree(tmp_data);
1084 return rc;
1085}
1086
1087int
1088smb311_posix_get_inode_info(struct inode **inode,
1089 const char *full_path,
1090 struct super_block *sb, unsigned int xid)
1091{
1092 struct cifs_tcon *tcon;
1093 struct tcon_link *tlink;
1094 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1095 bool adjust_tz = false;
1096 struct cifs_fattr fattr = {0};
1097 bool symlink = false;
1098 struct smb311_posix_qinfo *data = NULL;
1099 int rc = 0;
1100 int tmprc = 0;
1101
1102 tlink = cifs_sb_tlink(cifs_sb);
1103 if (IS_ERR(tlink))
1104 return PTR_ERR(tlink);
1105 tcon = tlink_tcon(tlink);
1106
1107 /*
1108 * 1. Fetch file metadata
1109 */
1110
1111 if (is_inode_cache_good(*inode)) {
1112 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1113 goto out;
1114 }
1115 data = kmalloc(sizeof(struct smb311_posix_qinfo), GFP_KERNEL);
1116 if (!data) {
1117 rc = -ENOMEM;
1118 goto out;
1119 }
1120
1121 rc = smb311_posix_query_path_info(xid, tcon, cifs_sb,
1122 full_path, data,
1123 &adjust_tz, &symlink);
1124
1125 /*
1126 * 2. Convert it to internal cifs metadata (fattr)
1127 */
1128
1129 switch (rc) {
1130 case 0:
1131 smb311_posix_info_to_fattr(&fattr, data, sb, adjust_tz, symlink);
1132 break;
1133 case -EREMOTE:
1134 /* DFS link, no metadata available on this server */
1135 cifs_create_dfs_fattr(&fattr, sb);
1136 rc = 0;
1137 break;
1138 case -EACCES:
1139 /*
1140 * For SMB2 and later the backup intent flag
1141 * is already sent if needed on open and there
1142 * is no path based FindFirst operation to use
1143 * to retry with so nothing we can do, bail out
1144 */
1145 goto out;
1146 default:
1147 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1148 goto out;
1149 }
1150
1151
1152 /*
1153 * 3. Tweak fattr based on mount options
1154 */
1155
1156 /* check for Minshall+French symlinks */
1157 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1158 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1159 full_path);
1160 if (tmprc)
1161 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1162 }
1163
1164 /*
1165 * 4. Update inode with final fattr data
1166 */
1167
1168 if (!*inode) {
1169 *inode = cifs_iget(sb, &fattr);
1170 if (!*inode)
1171 rc = -ENOMEM;
1172 } else {
1173 /* we already have inode, update it */
1174
1175 /* if uniqueid is different, return error */
1176 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1177 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1178 CIFS_I(*inode)->time = 0; /* force reval */
1179 rc = -ESTALE;
1180 goto out;
1181 }
1182
1183 /* if filetype is different, return error */
1184 if (unlikely(((*inode)->i_mode & S_IFMT) !=
1185 (fattr.cf_mode & S_IFMT))) {
1186 CIFS_I(*inode)->time = 0; /* force reval */
1187 rc = -ESTALE;
1188 goto out;
1189 }
1190
1191 cifs_fattr_to_inode(*inode, &fattr);
1192 }
1193out:
1194 cifs_put_tlink(tlink);
1195 kfree(data);
1196 return rc;
1197}
1198
1199
1200static const struct inode_operations cifs_ipc_inode_ops = {
1201 .lookup = cifs_lookup,
1202};
1203
1204static int
1205cifs_find_inode(struct inode *inode, void *opaque)
1206{
1207 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1208
1209 /* don't match inode with different uniqueid */
1210 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1211 return 0;
1212
1213 /* use createtime like an i_generation field */
1214 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1215 return 0;
1216
1217 /* don't match inode of different type */
1218 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
1219 return 0;
1220
1221 /* if it's not a directory or has no dentries, then flag it */
1222 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
1223 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
1224
1225 return 1;
1226}
1227
1228static int
1229cifs_init_inode(struct inode *inode, void *opaque)
1230{
1231 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1232
1233 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
1234 CIFS_I(inode)->createtime = fattr->cf_createtime;
1235 return 0;
1236}
1237
1238/*
1239 * walk dentry list for an inode and report whether it has aliases that
1240 * are hashed. We use this to determine if a directory inode can actually
1241 * be used.
1242 */
1243static bool
1244inode_has_hashed_dentries(struct inode *inode)
1245{
1246 struct dentry *dentry;
1247
1248 spin_lock(&inode->i_lock);
1249 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1250 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1251 spin_unlock(&inode->i_lock);
1252 return true;
1253 }
1254 }
1255 spin_unlock(&inode->i_lock);
1256 return false;
1257}
1258
1259/* Given fattrs, get a corresponding inode */
1260struct inode *
1261cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1262{
1263 unsigned long hash;
1264 struct inode *inode;
1265
1266retry_iget5_locked:
1267 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1268
1269 /* hash down to 32-bits on 32-bit arch */
1270 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1271
1272 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1273 if (inode) {
1274 /* was there a potentially problematic inode collision? */
1275 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1276 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1277
1278 if (inode_has_hashed_dentries(inode)) {
1279 cifs_autodisable_serverino(CIFS_SB(sb));
1280 iput(inode);
1281 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1282 goto retry_iget5_locked;
1283 }
1284 }
1285
1286 cifs_fattr_to_inode(inode, fattr);
1287 if (sb->s_flags & SB_NOATIME)
1288 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1289 if (inode->i_state & I_NEW) {
1290 inode->i_ino = hash;
1291#ifdef CONFIG_CIFS_FSCACHE
1292 /* initialize per-inode cache cookie pointer */
1293 CIFS_I(inode)->fscache = NULL;
1294#endif
1295 unlock_new_inode(inode);
1296 }
1297 }
1298
1299 return inode;
1300}
1301
1302/* gets root inode */
1303struct inode *cifs_root_iget(struct super_block *sb)
1304{
1305 unsigned int xid;
1306 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1307 struct inode *inode = NULL;
1308 long rc;
1309 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1310 char *path = NULL;
1311 int len;
1312
1313 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1314 && cifs_sb->prepath) {
1315 len = strlen(cifs_sb->prepath);
1316 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1317 if (path == NULL)
1318 return ERR_PTR(-ENOMEM);
1319 path[0] = '/';
1320 memcpy(path+1, cifs_sb->prepath, len);
1321 } else {
1322 path = kstrdup("", GFP_KERNEL);
1323 if (path == NULL)
1324 return ERR_PTR(-ENOMEM);
1325 }
1326
1327 xid = get_xid();
1328 if (tcon->unix_ext) {
1329 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1330 /* some servers mistakenly claim POSIX support */
1331 if (rc != -EOPNOTSUPP)
1332 goto iget_no_retry;
1333 cifs_dbg(VFS, "server does not support POSIX extensions\n");
1334 tcon->unix_ext = false;
1335 }
1336
1337 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1338 if (tcon->posix_extensions)
1339 rc = smb311_posix_get_inode_info(&inode, path, sb, xid);
1340 else
1341 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1342
1343iget_no_retry:
1344 if (!inode) {
1345 inode = ERR_PTR(rc);
1346 goto out;
1347 }
1348
1349#ifdef CONFIG_CIFS_FSCACHE
1350 /* populate tcon->resource_id */
1351 tcon->resource_id = CIFS_I(inode)->uniqueid;
1352#endif
1353
1354 if (rc && tcon->pipe) {
1355 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1356 spin_lock(&inode->i_lock);
1357 inode->i_mode |= S_IFDIR;
1358 set_nlink(inode, 2);
1359 inode->i_op = &cifs_ipc_inode_ops;
1360 inode->i_fop = &simple_dir_operations;
1361 inode->i_uid = cifs_sb->mnt_uid;
1362 inode->i_gid = cifs_sb->mnt_gid;
1363 spin_unlock(&inode->i_lock);
1364 } else if (rc) {
1365 iget_failed(inode);
1366 inode = ERR_PTR(rc);
1367 }
1368
1369out:
1370 kfree(path);
1371 free_xid(xid);
1372 return inode;
1373}
1374
1375int
1376cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1377 char *full_path, __u32 dosattr)
1378{
1379 bool set_time = false;
1380 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1381 struct TCP_Server_Info *server;
1382 FILE_BASIC_INFO info_buf;
1383
1384 if (attrs == NULL)
1385 return -EINVAL;
1386
1387 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1388 if (!server->ops->set_file_info)
1389 return -ENOSYS;
1390
1391 info_buf.Pad = 0;
1392
1393 if (attrs->ia_valid & ATTR_ATIME) {
1394 set_time = true;
1395 info_buf.LastAccessTime =
1396 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1397 } else
1398 info_buf.LastAccessTime = 0;
1399
1400 if (attrs->ia_valid & ATTR_MTIME) {
1401 set_time = true;
1402 info_buf.LastWriteTime =
1403 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1404 } else
1405 info_buf.LastWriteTime = 0;
1406
1407 /*
1408 * Samba throws this field away, but windows may actually use it.
1409 * Do not set ctime unless other time stamps are changed explicitly
1410 * (i.e. by utimes()) since we would then have a mix of client and
1411 * server times.
1412 */
1413 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1414 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1415 info_buf.ChangeTime =
1416 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1417 } else
1418 info_buf.ChangeTime = 0;
1419
1420 info_buf.CreationTime = 0; /* don't change */
1421 info_buf.Attributes = cpu_to_le32(dosattr);
1422
1423 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1424}
1425
1426/*
1427 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1428 * and rename it to a random name that hopefully won't conflict with
1429 * anything else.
1430 */
1431int
1432cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1433 const unsigned int xid)
1434{
1435 int oplock = 0;
1436 int rc;
1437 struct cifs_fid fid;
1438 struct cifs_open_parms oparms;
1439 struct inode *inode = d_inode(dentry);
1440 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1441 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1442 struct tcon_link *tlink;
1443 struct cifs_tcon *tcon;
1444 __u32 dosattr, origattr;
1445 FILE_BASIC_INFO *info_buf = NULL;
1446
1447 tlink = cifs_sb_tlink(cifs_sb);
1448 if (IS_ERR(tlink))
1449 return PTR_ERR(tlink);
1450 tcon = tlink_tcon(tlink);
1451
1452 /*
1453 * We cannot rename the file if the server doesn't support
1454 * CAP_INFOLEVEL_PASSTHRU
1455 */
1456 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1457 rc = -EBUSY;
1458 goto out;
1459 }
1460
1461 oparms.tcon = tcon;
1462 oparms.cifs_sb = cifs_sb;
1463 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1464 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
1465 oparms.disposition = FILE_OPEN;
1466 oparms.path = full_path;
1467 oparms.fid = &fid;
1468 oparms.reconnect = false;
1469
1470 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1471 if (rc != 0)
1472 goto out;
1473
1474 origattr = cifsInode->cifsAttrs;
1475 if (origattr == 0)
1476 origattr |= ATTR_NORMAL;
1477
1478 dosattr = origattr & ~ATTR_READONLY;
1479 if (dosattr == 0)
1480 dosattr |= ATTR_NORMAL;
1481 dosattr |= ATTR_HIDDEN;
1482
1483 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1484 if (dosattr != origattr) {
1485 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1486 if (info_buf == NULL) {
1487 rc = -ENOMEM;
1488 goto out_close;
1489 }
1490 info_buf->Attributes = cpu_to_le32(dosattr);
1491 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1492 current->tgid);
1493 /* although we would like to mark the file hidden
1494 if that fails we will still try to rename it */
1495 if (!rc)
1496 cifsInode->cifsAttrs = dosattr;
1497 else
1498 dosattr = origattr; /* since not able to change them */
1499 }
1500
1501 /* rename the file */
1502 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1503 cifs_sb->local_nls,
1504 cifs_remap(cifs_sb));
1505 if (rc != 0) {
1506 rc = -EBUSY;
1507 goto undo_setattr;
1508 }
1509
1510 /* try to set DELETE_ON_CLOSE */
1511 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1512 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1513 current->tgid);
1514 /*
1515 * some samba versions return -ENOENT when we try to set the
1516 * file disposition here. Likely a samba bug, but work around
1517 * it for now. This means that some cifsXXX files may hang
1518 * around after they shouldn't.
1519 *
1520 * BB: remove this hack after more servers have the fix
1521 */
1522 if (rc == -ENOENT)
1523 rc = 0;
1524 else if (rc != 0) {
1525 rc = -EBUSY;
1526 goto undo_rename;
1527 }
1528 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1529 }
1530
1531out_close:
1532 CIFSSMBClose(xid, tcon, fid.netfid);
1533out:
1534 kfree(info_buf);
1535 cifs_put_tlink(tlink);
1536 return rc;
1537
1538 /*
1539 * reset everything back to the original state. Don't bother
1540 * dealing with errors here since we can't do anything about
1541 * them anyway.
1542 */
1543undo_rename:
1544 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1545 cifs_sb->local_nls, cifs_remap(cifs_sb));
1546undo_setattr:
1547 if (dosattr != origattr) {
1548 info_buf->Attributes = cpu_to_le32(origattr);
1549 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1550 current->tgid))
1551 cifsInode->cifsAttrs = origattr;
1552 }
1553
1554 goto out_close;
1555}
1556
1557/* copied from fs/nfs/dir.c with small changes */
1558static void
1559cifs_drop_nlink(struct inode *inode)
1560{
1561 spin_lock(&inode->i_lock);
1562 if (inode->i_nlink > 0)
1563 drop_nlink(inode);
1564 spin_unlock(&inode->i_lock);
1565}
1566
1567/*
1568 * If d_inode(dentry) is null (usually meaning the cached dentry
1569 * is a negative dentry) then we would attempt a standard SMB delete, but
1570 * if that fails we can not attempt the fall back mechanisms on EACCES
1571 * but will return the EACCES to the caller. Note that the VFS does not call
1572 * unlink on negative dentries currently.
1573 */
1574int cifs_unlink(struct inode *dir, struct dentry *dentry)
1575{
1576 int rc = 0;
1577 unsigned int xid;
1578 char *full_path = NULL;
1579 struct inode *inode = d_inode(dentry);
1580 struct cifsInodeInfo *cifs_inode;
1581 struct super_block *sb = dir->i_sb;
1582 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1583 struct tcon_link *tlink;
1584 struct cifs_tcon *tcon;
1585 struct TCP_Server_Info *server;
1586 struct iattr *attrs = NULL;
1587 __u32 dosattr = 0, origattr = 0;
1588
1589 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1590
1591 tlink = cifs_sb_tlink(cifs_sb);
1592 if (IS_ERR(tlink))
1593 return PTR_ERR(tlink);
1594 tcon = tlink_tcon(tlink);
1595 server = tcon->ses->server;
1596
1597 xid = get_xid();
1598
1599 if (tcon->nodelete) {
1600 rc = -EACCES;
1601 goto unlink_out;
1602 }
1603
1604 /* Unlink can be called from rename so we can not take the
1605 * sb->s_vfs_rename_mutex here */
1606 full_path = build_path_from_dentry(dentry);
1607 if (full_path == NULL) {
1608 rc = -ENOMEM;
1609 goto unlink_out;
1610 }
1611
1612 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1613 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1614 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1615 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1616 cifs_remap(cifs_sb));
1617 cifs_dbg(FYI, "posix del rc %d\n", rc);
1618 if ((rc == 0) || (rc == -ENOENT))
1619 goto psx_del_no_retry;
1620 }
1621
1622retry_std_delete:
1623 if (!server->ops->unlink) {
1624 rc = -ENOSYS;
1625 goto psx_del_no_retry;
1626 }
1627
1628 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1629
1630psx_del_no_retry:
1631 if (!rc) {
1632 if (inode)
1633 cifs_drop_nlink(inode);
1634 } else if (rc == -ENOENT) {
1635 d_drop(dentry);
1636 } else if (rc == -EBUSY) {
1637 if (server->ops->rename_pending_delete) {
1638 rc = server->ops->rename_pending_delete(full_path,
1639 dentry, xid);
1640 if (rc == 0)
1641 cifs_drop_nlink(inode);
1642 }
1643 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1644 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1645 if (attrs == NULL) {
1646 rc = -ENOMEM;
1647 goto out_reval;
1648 }
1649
1650 /* try to reset dos attributes */
1651 cifs_inode = CIFS_I(inode);
1652 origattr = cifs_inode->cifsAttrs;
1653 if (origattr == 0)
1654 origattr |= ATTR_NORMAL;
1655 dosattr = origattr & ~ATTR_READONLY;
1656 if (dosattr == 0)
1657 dosattr |= ATTR_NORMAL;
1658 dosattr |= ATTR_HIDDEN;
1659
1660 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1661 if (rc != 0)
1662 goto out_reval;
1663
1664 goto retry_std_delete;
1665 }
1666
1667 /* undo the setattr if we errored out and it's needed */
1668 if (rc != 0 && dosattr != 0)
1669 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1670
1671out_reval:
1672 if (inode) {
1673 cifs_inode = CIFS_I(inode);
1674 cifs_inode->time = 0; /* will force revalidate to get info
1675 when needed */
1676 inode->i_ctime = current_time(inode);
1677 }
1678 dir->i_ctime = dir->i_mtime = current_time(dir);
1679 cifs_inode = CIFS_I(dir);
1680 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1681unlink_out:
1682 kfree(full_path);
1683 kfree(attrs);
1684 free_xid(xid);
1685 cifs_put_tlink(tlink);
1686 return rc;
1687}
1688
1689static int
1690cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1691 const char *full_path, struct cifs_sb_info *cifs_sb,
1692 struct cifs_tcon *tcon, const unsigned int xid)
1693{
1694 int rc = 0;
1695 struct inode *inode = NULL;
1696
1697 if (tcon->posix_extensions)
1698 rc = smb311_posix_get_inode_info(&inode, full_path, parent->i_sb, xid);
1699 else if (tcon->unix_ext)
1700 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1701 xid);
1702 else
1703 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1704 xid, NULL);
1705
1706 if (rc)
1707 return rc;
1708
1709 /*
1710 * setting nlink not necessary except in cases where we failed to get it
1711 * from the server or was set bogus. Also, since this is a brand new
1712 * inode, no need to grab the i_lock before setting the i_nlink.
1713 */
1714 if (inode->i_nlink < 2)
1715 set_nlink(inode, 2);
1716 mode &= ~current_umask();
1717 /* must turn on setgid bit if parent dir has it */
1718 if (parent->i_mode & S_ISGID)
1719 mode |= S_ISGID;
1720
1721 if (tcon->unix_ext) {
1722 struct cifs_unix_set_info_args args = {
1723 .mode = mode,
1724 .ctime = NO_CHANGE_64,
1725 .atime = NO_CHANGE_64,
1726 .mtime = NO_CHANGE_64,
1727 .device = 0,
1728 };
1729 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1730 args.uid = current_fsuid();
1731 if (parent->i_mode & S_ISGID)
1732 args.gid = parent->i_gid;
1733 else
1734 args.gid = current_fsgid();
1735 } else {
1736 args.uid = INVALID_UID; /* no change */
1737 args.gid = INVALID_GID; /* no change */
1738 }
1739 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1740 cifs_sb->local_nls,
1741 cifs_remap(cifs_sb));
1742 } else {
1743 struct TCP_Server_Info *server = tcon->ses->server;
1744 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1745 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1746 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1747 tcon, xid);
1748 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1749 inode->i_mode = (mode | S_IFDIR);
1750
1751 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1752 inode->i_uid = current_fsuid();
1753 if (inode->i_mode & S_ISGID)
1754 inode->i_gid = parent->i_gid;
1755 else
1756 inode->i_gid = current_fsgid();
1757 }
1758 }
1759 d_instantiate(dentry, inode);
1760 return rc;
1761}
1762
1763static int
1764cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1765 const char *full_path, struct cifs_sb_info *cifs_sb,
1766 struct cifs_tcon *tcon, const unsigned int xid)
1767{
1768 int rc = 0;
1769 u32 oplock = 0;
1770 FILE_UNIX_BASIC_INFO *info = NULL;
1771 struct inode *newinode = NULL;
1772 struct cifs_fattr fattr;
1773
1774 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1775 if (info == NULL) {
1776 rc = -ENOMEM;
1777 goto posix_mkdir_out;
1778 }
1779
1780 mode &= ~current_umask();
1781 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1782 NULL /* netfid */, info, &oplock, full_path,
1783 cifs_sb->local_nls, cifs_remap(cifs_sb));
1784 if (rc == -EOPNOTSUPP)
1785 goto posix_mkdir_out;
1786 else if (rc) {
1787 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1788 d_drop(dentry);
1789 goto posix_mkdir_out;
1790 }
1791
1792 if (info->Type == cpu_to_le32(-1))
1793 /* no return info, go query for it */
1794 goto posix_mkdir_get_info;
1795 /*
1796 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1797 * need to set uid/gid.
1798 */
1799
1800 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1801 cifs_fill_uniqueid(inode->i_sb, &fattr);
1802 newinode = cifs_iget(inode->i_sb, &fattr);
1803 if (!newinode)
1804 goto posix_mkdir_get_info;
1805
1806 d_instantiate(dentry, newinode);
1807
1808#ifdef CONFIG_CIFS_DEBUG2
1809 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1810 dentry, dentry, newinode);
1811
1812 if (newinode->i_nlink != 2)
1813 cifs_dbg(FYI, "unexpected number of links %d\n",
1814 newinode->i_nlink);
1815#endif
1816
1817posix_mkdir_out:
1818 kfree(info);
1819 return rc;
1820posix_mkdir_get_info:
1821 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1822 xid);
1823 goto posix_mkdir_out;
1824}
1825
1826int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1827{
1828 int rc = 0;
1829 unsigned int xid;
1830 struct cifs_sb_info *cifs_sb;
1831 struct tcon_link *tlink;
1832 struct cifs_tcon *tcon;
1833 struct TCP_Server_Info *server;
1834 char *full_path;
1835
1836 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1837 mode, inode);
1838
1839 cifs_sb = CIFS_SB(inode->i_sb);
1840 tlink = cifs_sb_tlink(cifs_sb);
1841 if (IS_ERR(tlink))
1842 return PTR_ERR(tlink);
1843 tcon = tlink_tcon(tlink);
1844
1845 xid = get_xid();
1846
1847 full_path = build_path_from_dentry(direntry);
1848 if (full_path == NULL) {
1849 rc = -ENOMEM;
1850 goto mkdir_out;
1851 }
1852
1853 server = tcon->ses->server;
1854
1855 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1856 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1857 cifs_sb);
1858 d_drop(direntry); /* for time being always refresh inode info */
1859 goto mkdir_out;
1860 }
1861
1862 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1863 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1864 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1865 tcon, xid);
1866 if (rc != -EOPNOTSUPP)
1867 goto mkdir_out;
1868 }
1869
1870 if (!server->ops->mkdir) {
1871 rc = -ENOSYS;
1872 goto mkdir_out;
1873 }
1874
1875 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1876 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1877 if (rc) {
1878 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1879 d_drop(direntry);
1880 goto mkdir_out;
1881 }
1882
1883 /* TODO: skip this for smb2/smb3 */
1884 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1885 xid);
1886mkdir_out:
1887 /*
1888 * Force revalidate to get parent dir info when needed since cached
1889 * attributes are invalid now.
1890 */
1891 CIFS_I(inode)->time = 0;
1892 kfree(full_path);
1893 free_xid(xid);
1894 cifs_put_tlink(tlink);
1895 return rc;
1896}
1897
1898int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1899{
1900 int rc = 0;
1901 unsigned int xid;
1902 struct cifs_sb_info *cifs_sb;
1903 struct tcon_link *tlink;
1904 struct cifs_tcon *tcon;
1905 struct TCP_Server_Info *server;
1906 char *full_path = NULL;
1907 struct cifsInodeInfo *cifsInode;
1908
1909 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1910
1911 xid = get_xid();
1912
1913 full_path = build_path_from_dentry(direntry);
1914 if (full_path == NULL) {
1915 rc = -ENOMEM;
1916 goto rmdir_exit;
1917 }
1918
1919 cifs_sb = CIFS_SB(inode->i_sb);
1920 tlink = cifs_sb_tlink(cifs_sb);
1921 if (IS_ERR(tlink)) {
1922 rc = PTR_ERR(tlink);
1923 goto rmdir_exit;
1924 }
1925 tcon = tlink_tcon(tlink);
1926 server = tcon->ses->server;
1927
1928 if (!server->ops->rmdir) {
1929 rc = -ENOSYS;
1930 cifs_put_tlink(tlink);
1931 goto rmdir_exit;
1932 }
1933
1934 if (tcon->nodelete) {
1935 rc = -EACCES;
1936 cifs_put_tlink(tlink);
1937 goto rmdir_exit;
1938 }
1939
1940 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1941 cifs_put_tlink(tlink);
1942
1943 if (!rc) {
1944 spin_lock(&d_inode(direntry)->i_lock);
1945 i_size_write(d_inode(direntry), 0);
1946 clear_nlink(d_inode(direntry));
1947 spin_unlock(&d_inode(direntry)->i_lock);
1948 }
1949
1950 cifsInode = CIFS_I(d_inode(direntry));
1951 /* force revalidate to go get info when needed */
1952 cifsInode->time = 0;
1953
1954 cifsInode = CIFS_I(inode);
1955 /*
1956 * Force revalidate to get parent dir info when needed since cached
1957 * attributes are invalid now.
1958 */
1959 cifsInode->time = 0;
1960
1961 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1962 current_time(inode);
1963
1964rmdir_exit:
1965 kfree(full_path);
1966 free_xid(xid);
1967 return rc;
1968}
1969
1970static int
1971cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1972 const char *from_path, struct dentry *to_dentry,
1973 const char *to_path)
1974{
1975 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1976 struct tcon_link *tlink;
1977 struct cifs_tcon *tcon;
1978 struct TCP_Server_Info *server;
1979 struct cifs_fid fid;
1980 struct cifs_open_parms oparms;
1981 int oplock, rc;
1982
1983 tlink = cifs_sb_tlink(cifs_sb);
1984 if (IS_ERR(tlink))
1985 return PTR_ERR(tlink);
1986 tcon = tlink_tcon(tlink);
1987 server = tcon->ses->server;
1988
1989 if (!server->ops->rename)
1990 return -ENOSYS;
1991
1992 /* try path-based rename first */
1993 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1994
1995 /*
1996 * Don't bother with rename by filehandle unless file is busy and
1997 * source. Note that cross directory moves do not work with
1998 * rename by filehandle to various Windows servers.
1999 */
2000 if (rc == 0 || rc != -EBUSY)
2001 goto do_rename_exit;
2002
2003 /* Don't fall back to using SMB on SMB 2+ mount */
2004 if (server->vals->protocol_id != 0)
2005 goto do_rename_exit;
2006
2007 /* open-file renames don't work across directories */
2008 if (to_dentry->d_parent != from_dentry->d_parent)
2009 goto do_rename_exit;
2010
2011 oparms.tcon = tcon;
2012 oparms.cifs_sb = cifs_sb;
2013 /* open the file to be renamed -- we need DELETE perms */
2014 oparms.desired_access = DELETE;
2015 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
2016 oparms.disposition = FILE_OPEN;
2017 oparms.path = from_path;
2018 oparms.fid = &fid;
2019 oparms.reconnect = false;
2020
2021 rc = CIFS_open(xid, &oparms, &oplock, NULL);
2022 if (rc == 0) {
2023 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2024 (const char *) to_dentry->d_name.name,
2025 cifs_sb->local_nls, cifs_remap(cifs_sb));
2026 CIFSSMBClose(xid, tcon, fid.netfid);
2027 }
2028do_rename_exit:
2029 if (rc == 0)
2030 d_move(from_dentry, to_dentry);
2031 cifs_put_tlink(tlink);
2032 return rc;
2033}
2034
2035int
2036cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
2037 struct inode *target_dir, struct dentry *target_dentry,
2038 unsigned int flags)
2039{
2040 char *from_name = NULL;
2041 char *to_name = NULL;
2042 struct cifs_sb_info *cifs_sb;
2043 struct tcon_link *tlink;
2044 struct cifs_tcon *tcon;
2045 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2046 FILE_UNIX_BASIC_INFO *info_buf_target;
2047 unsigned int xid;
2048 int rc, tmprc;
2049
2050 if (flags & ~RENAME_NOREPLACE)
2051 return -EINVAL;
2052
2053 cifs_sb = CIFS_SB(source_dir->i_sb);
2054 tlink = cifs_sb_tlink(cifs_sb);
2055 if (IS_ERR(tlink))
2056 return PTR_ERR(tlink);
2057 tcon = tlink_tcon(tlink);
2058
2059 xid = get_xid();
2060
2061 /*
2062 * we already have the rename sem so we do not need to
2063 * grab it again here to protect the path integrity
2064 */
2065 from_name = build_path_from_dentry(source_dentry);
2066 if (from_name == NULL) {
2067 rc = -ENOMEM;
2068 goto cifs_rename_exit;
2069 }
2070
2071 to_name = build_path_from_dentry(target_dentry);
2072 if (to_name == NULL) {
2073 rc = -ENOMEM;
2074 goto cifs_rename_exit;
2075 }
2076
2077 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2078 to_name);
2079
2080 /*
2081 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2082 */
2083 if (flags & RENAME_NOREPLACE)
2084 goto cifs_rename_exit;
2085
2086 if (rc == -EEXIST && tcon->unix_ext) {
2087 /*
2088 * Are src and dst hardlinks of same inode? We can only tell
2089 * with unix extensions enabled.
2090 */
2091 info_buf_source =
2092 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2093 GFP_KERNEL);
2094 if (info_buf_source == NULL) {
2095 rc = -ENOMEM;
2096 goto cifs_rename_exit;
2097 }
2098
2099 info_buf_target = info_buf_source + 1;
2100 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2101 info_buf_source,
2102 cifs_sb->local_nls,
2103 cifs_remap(cifs_sb));
2104 if (tmprc != 0)
2105 goto unlink_target;
2106
2107 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2108 info_buf_target,
2109 cifs_sb->local_nls,
2110 cifs_remap(cifs_sb));
2111
2112 if (tmprc == 0 && (info_buf_source->UniqueId ==
2113 info_buf_target->UniqueId)) {
2114 /* same file, POSIX says that this is a noop */
2115 rc = 0;
2116 goto cifs_rename_exit;
2117 }
2118 }
2119 /*
2120 * else ... BB we could add the same check for Windows by
2121 * checking the UniqueId via FILE_INTERNAL_INFO
2122 */
2123
2124unlink_target:
2125 /* Try unlinking the target dentry if it's not negative */
2126 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
2127 if (d_is_dir(target_dentry))
2128 tmprc = cifs_rmdir(target_dir, target_dentry);
2129 else
2130 tmprc = cifs_unlink(target_dir, target_dentry);
2131 if (tmprc)
2132 goto cifs_rename_exit;
2133 rc = cifs_do_rename(xid, source_dentry, from_name,
2134 target_dentry, to_name);
2135 }
2136
2137 /* force revalidate to go get info when needed */
2138 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2139
2140 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
2141 target_dir->i_mtime = current_time(source_dir);
2142
2143cifs_rename_exit:
2144 kfree(info_buf_source);
2145 kfree(from_name);
2146 kfree(to_name);
2147 free_xid(xid);
2148 cifs_put_tlink(tlink);
2149 return rc;
2150}
2151
2152static bool
2153cifs_inode_needs_reval(struct inode *inode)
2154{
2155 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2156 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2157
2158 if (cifs_i->time == 0)
2159 return true;
2160
2161 if (CIFS_CACHE_READ(cifs_i))
2162 return false;
2163
2164 if (!lookupCacheEnabled)
2165 return true;
2166
2167 if (!cifs_sb->actimeo)
2168 return true;
2169
2170 if (!time_in_range(jiffies, cifs_i->time,
2171 cifs_i->time + cifs_sb->actimeo))
2172 return true;
2173
2174 /* hardlinked files w/ noserverino get "special" treatment */
2175 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2176 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2177 return true;
2178
2179 return false;
2180}
2181
2182/*
2183 * Zap the cache. Called when invalid_mapping flag is set.
2184 */
2185int
2186cifs_invalidate_mapping(struct inode *inode)
2187{
2188 int rc = 0;
2189
2190 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2191 rc = invalidate_inode_pages2(inode->i_mapping);
2192 if (rc)
2193 cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
2194 __func__, inode);
2195 }
2196
2197 cifs_fscache_reset_inode_cookie(inode);
2198 return rc;
2199}
2200
2201/**
2202 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2203 * @word: long word containing the bit lock
2204 */
2205static int
2206cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2207{
2208 freezable_schedule_unsafe();
2209 if (signal_pending_state(mode, current))
2210 return -ERESTARTSYS;
2211 return 0;
2212}
2213
2214int
2215cifs_revalidate_mapping(struct inode *inode)
2216{
2217 int rc;
2218 unsigned long *flags = &CIFS_I(inode)->flags;
2219
2220 /* swapfiles are not supposed to be shared */
2221 if (IS_SWAPFILE(inode))
2222 return 0;
2223
2224 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2225 TASK_KILLABLE);
2226 if (rc)
2227 return rc;
2228
2229 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2230 rc = cifs_invalidate_mapping(inode);
2231 if (rc)
2232 set_bit(CIFS_INO_INVALID_MAPPING, flags);
2233 }
2234
2235 clear_bit_unlock(CIFS_INO_LOCK, flags);
2236 smp_mb__after_atomic();
2237 wake_up_bit(flags, CIFS_INO_LOCK);
2238
2239 return rc;
2240}
2241
2242int
2243cifs_zap_mapping(struct inode *inode)
2244{
2245 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2246 return cifs_revalidate_mapping(inode);
2247}
2248
2249int cifs_revalidate_file_attr(struct file *filp)
2250{
2251 int rc = 0;
2252 struct inode *inode = file_inode(filp);
2253 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2254
2255 if (!cifs_inode_needs_reval(inode))
2256 return rc;
2257
2258 if (tlink_tcon(cfile->tlink)->unix_ext)
2259 rc = cifs_get_file_info_unix(filp);
2260 else
2261 rc = cifs_get_file_info(filp);
2262
2263 return rc;
2264}
2265
2266int cifs_revalidate_dentry_attr(struct dentry *dentry)
2267{
2268 unsigned int xid;
2269 int rc = 0;
2270 struct inode *inode = d_inode(dentry);
2271 struct super_block *sb = dentry->d_sb;
2272 char *full_path = NULL;
2273 int count = 0;
2274
2275 if (inode == NULL)
2276 return -ENOENT;
2277
2278 if (!cifs_inode_needs_reval(inode))
2279 return rc;
2280
2281 xid = get_xid();
2282
2283 /* can not safely grab the rename sem here if rename calls revalidate
2284 since that would deadlock */
2285 full_path = build_path_from_dentry(dentry);
2286 if (full_path == NULL) {
2287 rc = -ENOMEM;
2288 goto out;
2289 }
2290
2291 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2292 full_path, inode, inode->i_count.counter,
2293 dentry, cifs_get_time(dentry), jiffies);
2294
2295again:
2296 if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions)
2297 rc = smb311_posix_get_inode_info(&inode, full_path, sb, xid);
2298 else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2299 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2300 else
2301 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2302 xid, NULL);
2303 if (rc == -EAGAIN && count++ < 10)
2304 goto again;
2305out:
2306 kfree(full_path);
2307 free_xid(xid);
2308
2309 return rc;
2310}
2311
2312int cifs_revalidate_file(struct file *filp)
2313{
2314 int rc;
2315 struct inode *inode = file_inode(filp);
2316
2317 rc = cifs_revalidate_file_attr(filp);
2318 if (rc)
2319 return rc;
2320
2321 return cifs_revalidate_mapping(inode);
2322}
2323
2324/* revalidate a dentry's inode attributes */
2325int cifs_revalidate_dentry(struct dentry *dentry)
2326{
2327 int rc;
2328 struct inode *inode = d_inode(dentry);
2329
2330 rc = cifs_revalidate_dentry_attr(dentry);
2331 if (rc)
2332 return rc;
2333
2334 return cifs_revalidate_mapping(inode);
2335}
2336
2337int cifs_getattr(const struct path *path, struct kstat *stat,
2338 u32 request_mask, unsigned int flags)
2339{
2340 struct dentry *dentry = path->dentry;
2341 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2342 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2343 struct inode *inode = d_inode(dentry);
2344 int rc;
2345
2346 /*
2347 * We need to be sure that all dirty pages are written and the server
2348 * has actual ctime, mtime and file length.
2349 */
2350 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE)) &&
2351 !CIFS_CACHE_READ(CIFS_I(inode)) &&
2352 inode->i_mapping && inode->i_mapping->nrpages != 0) {
2353 rc = filemap_fdatawait(inode->i_mapping);
2354 if (rc) {
2355 mapping_set_error(inode->i_mapping, rc);
2356 return rc;
2357 }
2358 }
2359
2360 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2361 CIFS_I(inode)->time = 0; /* force revalidate */
2362
2363 /*
2364 * If the caller doesn't require syncing, only sync if
2365 * necessary (e.g. due to earlier truncate or setattr
2366 * invalidating the cached metadata)
2367 */
2368 if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2369 (CIFS_I(inode)->time == 0)) {
2370 rc = cifs_revalidate_dentry_attr(dentry);
2371 if (rc)
2372 return rc;
2373 }
2374
2375 generic_fillattr(inode, stat);
2376 stat->blksize = cifs_sb->bsize;
2377 stat->ino = CIFS_I(inode)->uniqueid;
2378
2379 /* old CIFS Unix Extensions doesn't return create time */
2380 if (CIFS_I(inode)->createtime) {
2381 stat->result_mask |= STATX_BTIME;
2382 stat->btime =
2383 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2384 }
2385
2386 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2387 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2388 stat->attributes |= STATX_ATTR_COMPRESSED;
2389 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2390 stat->attributes |= STATX_ATTR_ENCRYPTED;
2391
2392 /*
2393 * If on a multiuser mount without unix extensions or cifsacl being
2394 * enabled, and the admin hasn't overridden them, set the ownership
2395 * to the fsuid/fsgid of the current process.
2396 */
2397 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2398 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2399 !tcon->unix_ext) {
2400 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2401 stat->uid = current_fsuid();
2402 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2403 stat->gid = current_fsgid();
2404 }
2405 return 0;
2406}
2407
2408int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2409 u64 len)
2410{
2411 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2412 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2413 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2414 struct TCP_Server_Info *server = tcon->ses->server;
2415 struct cifsFileInfo *cfile;
2416 int rc;
2417
2418 /*
2419 * We need to be sure that all dirty pages are written as they
2420 * might fill holes on the server.
2421 */
2422 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2423 inode->i_mapping->nrpages != 0) {
2424 rc = filemap_fdatawait(inode->i_mapping);
2425 if (rc) {
2426 mapping_set_error(inode->i_mapping, rc);
2427 return rc;
2428 }
2429 }
2430
2431 cfile = find_readable_file(cifs_i, false);
2432 if (cfile == NULL)
2433 return -EINVAL;
2434
2435 if (server->ops->fiemap) {
2436 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2437 cifsFileInfo_put(cfile);
2438 return rc;
2439 }
2440
2441 cifsFileInfo_put(cfile);
2442 return -ENOTSUPP;
2443}
2444
2445int cifs_truncate_page(struct address_space *mapping, loff_t from)
2446{
2447 pgoff_t index = from >> PAGE_SHIFT;
2448 unsigned offset = from & (PAGE_SIZE - 1);
2449 struct page *page;
2450 int rc = 0;
2451
2452 page = grab_cache_page(mapping, index);
2453 if (!page)
2454 return -ENOMEM;
2455
2456 zero_user_segment(page, offset, PAGE_SIZE);
2457 unlock_page(page);
2458 put_page(page);
2459 return rc;
2460}
2461
2462void cifs_setsize(struct inode *inode, loff_t offset)
2463{
2464 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2465
2466 spin_lock(&inode->i_lock);
2467 i_size_write(inode, offset);
2468 spin_unlock(&inode->i_lock);
2469
2470 /* Cached inode must be refreshed on truncate */
2471 cifs_i->time = 0;
2472 truncate_pagecache(inode, offset);
2473}
2474
2475static int
2476cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2477 unsigned int xid, char *full_path)
2478{
2479 int rc;
2480 struct cifsFileInfo *open_file;
2481 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2482 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2483 struct tcon_link *tlink = NULL;
2484 struct cifs_tcon *tcon = NULL;
2485 struct TCP_Server_Info *server;
2486
2487 /*
2488 * To avoid spurious oplock breaks from server, in the case of
2489 * inodes that we already have open, avoid doing path based
2490 * setting of file size if we can do it by handle.
2491 * This keeps our caching token (oplock) and avoids timeouts
2492 * when the local oplock break takes longer to flush
2493 * writebehind data than the SMB timeout for the SetPathInfo
2494 * request would allow
2495 */
2496 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2497 if (open_file) {
2498 tcon = tlink_tcon(open_file->tlink);
2499 server = tcon->ses->server;
2500 if (server->ops->set_file_size)
2501 rc = server->ops->set_file_size(xid, tcon, open_file,
2502 attrs->ia_size, false);
2503 else
2504 rc = -ENOSYS;
2505 cifsFileInfo_put(open_file);
2506 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2507 } else
2508 rc = -EINVAL;
2509
2510 if (!rc)
2511 goto set_size_out;
2512
2513 if (tcon == NULL) {
2514 tlink = cifs_sb_tlink(cifs_sb);
2515 if (IS_ERR(tlink))
2516 return PTR_ERR(tlink);
2517 tcon = tlink_tcon(tlink);
2518 server = tcon->ses->server;
2519 }
2520
2521 /*
2522 * Set file size by pathname rather than by handle either because no
2523 * valid, writeable file handle for it was found or because there was
2524 * an error setting it by handle.
2525 */
2526 if (server->ops->set_path_size)
2527 rc = server->ops->set_path_size(xid, tcon, full_path,
2528 attrs->ia_size, cifs_sb, false);
2529 else
2530 rc = -ENOSYS;
2531 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2532
2533 if (tlink)
2534 cifs_put_tlink(tlink);
2535
2536set_size_out:
2537 if (rc == 0) {
2538 cifsInode->server_eof = attrs->ia_size;
2539 cifs_setsize(inode, attrs->ia_size);
2540
2541 /*
2542 * The man page of truncate says if the size changed,
2543 * then the st_ctime and st_mtime fields for the file
2544 * are updated.
2545 */
2546 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2547 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2548
2549 cifs_truncate_page(inode->i_mapping, inode->i_size);
2550 }
2551
2552 return rc;
2553}
2554
2555static int
2556cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2557{
2558 int rc;
2559 unsigned int xid;
2560 char *full_path = NULL;
2561 struct inode *inode = d_inode(direntry);
2562 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2563 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2564 struct tcon_link *tlink;
2565 struct cifs_tcon *pTcon;
2566 struct cifs_unix_set_info_args *args = NULL;
2567 struct cifsFileInfo *open_file;
2568
2569 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2570 direntry, attrs->ia_valid);
2571
2572 xid = get_xid();
2573
2574 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2575 attrs->ia_valid |= ATTR_FORCE;
2576
2577 rc = setattr_prepare(direntry, attrs);
2578 if (rc < 0)
2579 goto out;
2580
2581 full_path = build_path_from_dentry(direntry);
2582 if (full_path == NULL) {
2583 rc = -ENOMEM;
2584 goto out;
2585 }
2586
2587 /*
2588 * Attempt to flush data before changing attributes. We need to do
2589 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2590 * ownership or mode then we may also need to do this. Here, we take
2591 * the safe way out and just do the flush on all setattr requests. If
2592 * the flush returns error, store it to report later and continue.
2593 *
2594 * BB: This should be smarter. Why bother flushing pages that
2595 * will be truncated anyway? Also, should we error out here if
2596 * the flush returns error?
2597 */
2598 rc = filemap_write_and_wait(inode->i_mapping);
2599 if (is_interrupt_error(rc)) {
2600 rc = -ERESTARTSYS;
2601 goto out;
2602 }
2603
2604 mapping_set_error(inode->i_mapping, rc);
2605 rc = 0;
2606
2607 if (attrs->ia_valid & ATTR_SIZE) {
2608 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2609 if (rc != 0)
2610 goto out;
2611 }
2612
2613 /* skip mode change if it's just for clearing setuid/setgid */
2614 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2615 attrs->ia_valid &= ~ATTR_MODE;
2616
2617 args = kmalloc(sizeof(*args), GFP_KERNEL);
2618 if (args == NULL) {
2619 rc = -ENOMEM;
2620 goto out;
2621 }
2622
2623 /* set up the struct */
2624 if (attrs->ia_valid & ATTR_MODE)
2625 args->mode = attrs->ia_mode;
2626 else
2627 args->mode = NO_CHANGE_64;
2628
2629 if (attrs->ia_valid & ATTR_UID)
2630 args->uid = attrs->ia_uid;
2631 else
2632 args->uid = INVALID_UID; /* no change */
2633
2634 if (attrs->ia_valid & ATTR_GID)
2635 args->gid = attrs->ia_gid;
2636 else
2637 args->gid = INVALID_GID; /* no change */
2638
2639 if (attrs->ia_valid & ATTR_ATIME)
2640 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2641 else
2642 args->atime = NO_CHANGE_64;
2643
2644 if (attrs->ia_valid & ATTR_MTIME)
2645 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2646 else
2647 args->mtime = NO_CHANGE_64;
2648
2649 if (attrs->ia_valid & ATTR_CTIME)
2650 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2651 else
2652 args->ctime = NO_CHANGE_64;
2653
2654 args->device = 0;
2655 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2656 if (open_file) {
2657 u16 nfid = open_file->fid.netfid;
2658 u32 npid = open_file->pid;
2659 pTcon = tlink_tcon(open_file->tlink);
2660 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2661 cifsFileInfo_put(open_file);
2662 } else {
2663 tlink = cifs_sb_tlink(cifs_sb);
2664 if (IS_ERR(tlink)) {
2665 rc = PTR_ERR(tlink);
2666 goto out;
2667 }
2668 pTcon = tlink_tcon(tlink);
2669 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2670 cifs_sb->local_nls,
2671 cifs_remap(cifs_sb));
2672 cifs_put_tlink(tlink);
2673 }
2674
2675 if (rc)
2676 goto out;
2677
2678 if ((attrs->ia_valid & ATTR_SIZE) &&
2679 attrs->ia_size != i_size_read(inode))
2680 truncate_setsize(inode, attrs->ia_size);
2681
2682 setattr_copy(inode, attrs);
2683 mark_inode_dirty(inode);
2684
2685 /* force revalidate when any of these times are set since some
2686 of the fs types (eg ext3, fat) do not have fine enough
2687 time granularity to match protocol, and we do not have a
2688 a way (yet) to query the server fs's time granularity (and
2689 whether it rounds times down).
2690 */
2691 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2692 cifsInode->time = 0;
2693out:
2694 kfree(args);
2695 kfree(full_path);
2696 free_xid(xid);
2697 return rc;
2698}
2699
2700static int
2701cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2702{
2703 unsigned int xid;
2704 kuid_t uid = INVALID_UID;
2705 kgid_t gid = INVALID_GID;
2706 struct inode *inode = d_inode(direntry);
2707 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2708 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2709 struct cifsFileInfo *wfile;
2710 struct cifs_tcon *tcon;
2711 char *full_path = NULL;
2712 int rc = -EACCES;
2713 __u32 dosattr = 0;
2714 __u64 mode = NO_CHANGE_64;
2715
2716 xid = get_xid();
2717
2718 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2719 direntry, attrs->ia_valid);
2720
2721 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2722 attrs->ia_valid |= ATTR_FORCE;
2723
2724 rc = setattr_prepare(direntry, attrs);
2725 if (rc < 0) {
2726 free_xid(xid);
2727 return rc;
2728 }
2729
2730 full_path = build_path_from_dentry(direntry);
2731 if (full_path == NULL) {
2732 rc = -ENOMEM;
2733 free_xid(xid);
2734 return rc;
2735 }
2736
2737 /*
2738 * Attempt to flush data before changing attributes. We need to do
2739 * this for ATTR_SIZE and ATTR_MTIME. If the flush of the data
2740 * returns error, store it to report later and continue.
2741 *
2742 * BB: This should be smarter. Why bother flushing pages that
2743 * will be truncated anyway? Also, should we error out here if
2744 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
2745 */
2746 if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2747 rc = filemap_write_and_wait(inode->i_mapping);
2748 if (is_interrupt_error(rc)) {
2749 rc = -ERESTARTSYS;
2750 goto cifs_setattr_exit;
2751 }
2752 mapping_set_error(inode->i_mapping, rc);
2753 }
2754
2755 rc = 0;
2756
2757 if ((attrs->ia_valid & ATTR_MTIME) &&
2758 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2759 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2760 if (!rc) {
2761 tcon = tlink_tcon(wfile->tlink);
2762 rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2763 cifsFileInfo_put(wfile);
2764 if (rc)
2765 goto cifs_setattr_exit;
2766 } else if (rc != -EBADF)
2767 goto cifs_setattr_exit;
2768 else
2769 rc = 0;
2770 }
2771
2772 if (attrs->ia_valid & ATTR_SIZE) {
2773 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2774 if (rc != 0)
2775 goto cifs_setattr_exit;
2776 }
2777
2778 if (attrs->ia_valid & ATTR_UID)
2779 uid = attrs->ia_uid;
2780
2781 if (attrs->ia_valid & ATTR_GID)
2782 gid = attrs->ia_gid;
2783
2784 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2785 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2786 if (uid_valid(uid) || gid_valid(gid)) {
2787 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2788 uid, gid);
2789 if (rc) {
2790 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2791 __func__, rc);
2792 goto cifs_setattr_exit;
2793 }
2794 }
2795 } else
2796 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2797 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2798
2799 /* skip mode change if it's just for clearing setuid/setgid */
2800 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2801 attrs->ia_valid &= ~ATTR_MODE;
2802
2803 if (attrs->ia_valid & ATTR_MODE) {
2804 mode = attrs->ia_mode;
2805 rc = 0;
2806 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2807 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2808 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2809 INVALID_UID, INVALID_GID);
2810 if (rc) {
2811 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2812 __func__, rc);
2813 goto cifs_setattr_exit;
2814 }
2815 } else
2816 if (((mode & S_IWUGO) == 0) &&
2817 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2818
2819 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2820
2821 /* fix up mode if we're not using dynperm */
2822 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2823 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2824 } else if ((mode & S_IWUGO) &&
2825 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2826
2827 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2828 /* Attributes of 0 are ignored */
2829 if (dosattr == 0)
2830 dosattr |= ATTR_NORMAL;
2831
2832 /* reset local inode permissions to normal */
2833 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2834 attrs->ia_mode &= ~(S_IALLUGO);
2835 if (S_ISDIR(inode->i_mode))
2836 attrs->ia_mode |=
2837 cifs_sb->mnt_dir_mode;
2838 else
2839 attrs->ia_mode |=
2840 cifs_sb->mnt_file_mode;
2841 }
2842 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2843 /* ignore mode change - ATTR_READONLY hasn't changed */
2844 attrs->ia_valid &= ~ATTR_MODE;
2845 }
2846 }
2847
2848 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2849 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2850 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2851 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2852
2853 /* Even if error on time set, no sense failing the call if
2854 the server would set the time to a reasonable value anyway,
2855 and this check ensures that we are not being called from
2856 sys_utimes in which case we ought to fail the call back to
2857 the user when the server rejects the call */
2858 if ((rc) && (attrs->ia_valid &
2859 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2860 rc = 0;
2861 }
2862
2863 /* do not need local check to inode_check_ok since the server does
2864 that */
2865 if (rc)
2866 goto cifs_setattr_exit;
2867
2868 if ((attrs->ia_valid & ATTR_SIZE) &&
2869 attrs->ia_size != i_size_read(inode))
2870 truncate_setsize(inode, attrs->ia_size);
2871
2872 setattr_copy(inode, attrs);
2873 mark_inode_dirty(inode);
2874
2875cifs_setattr_exit:
2876 kfree(full_path);
2877 free_xid(xid);
2878 return rc;
2879}
2880
2881int
2882cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2883{
2884 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2885 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2886
2887 if (pTcon->unix_ext)
2888 return cifs_setattr_unix(direntry, attrs);
2889
2890 return cifs_setattr_nounix(direntry, attrs);
2891
2892 /* BB: add cifs_setattr_legacy for really old servers */
2893}
2894
2895#if 0
2896void cifs_delete_inode(struct inode *inode)
2897{
2898 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2899 /* may have to add back in if and when safe distributed caching of
2900 directories added e.g. via FindNotify */
2901}
2902#endif