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
cifs_set_ops(struct inode * inode)40 static 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 */
94 static void
95 cifs_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 */
132 static void
133 cifs_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 */
156 void
157 cifs_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) < 0)
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
217 void
218 cifs_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. */
229 void
230 cifs_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 */
321 static void
322 cifs_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
339 static int
340 cifs_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
365 int 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
433 cgiiu_exit:
434 return rc;
435 }
436
437 static int
438 cifs_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 = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
476 oparms.disposition = FILE_OPEN;
477 oparms.path = path;
478 oparms.fid = &fid;
479 oparms.reconnect = false;
480
481 if (tcon->ses->server->oplocks)
482 oplock = REQ_OPLOCK;
483 else
484 oplock = 0;
485 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
486 if (rc) {
487 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
488 cifs_put_tlink(tlink);
489 return rc;
490 }
491
492 /* Read header */
493 io_parms.netfid = fid.netfid;
494 io_parms.pid = current->tgid;
495 io_parms.tcon = tcon;
496 io_parms.offset = 0;
497 io_parms.length = 24;
498
499 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
500 &bytes_read, &pbuf, &buf_type);
501 if ((rc == 0) && (bytes_read >= 8)) {
502 if (memcmp("IntxBLK", pbuf, 8) == 0) {
503 cifs_dbg(FYI, "Block device\n");
504 fattr->cf_mode |= S_IFBLK;
505 fattr->cf_dtype = DT_BLK;
506 if (bytes_read == 24) {
507 /* we have enough to decode dev num */
508 __u64 mjr; /* major */
509 __u64 mnr; /* minor */
510 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
511 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
512 fattr->cf_rdev = MKDEV(mjr, mnr);
513 }
514 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
515 cifs_dbg(FYI, "Char device\n");
516 fattr->cf_mode |= S_IFCHR;
517 fattr->cf_dtype = DT_CHR;
518 if (bytes_read == 24) {
519 /* we have enough to decode dev num */
520 __u64 mjr; /* major */
521 __u64 mnr; /* minor */
522 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
523 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
524 fattr->cf_rdev = MKDEV(mjr, mnr);
525 }
526 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
527 cifs_dbg(FYI, "Symlink\n");
528 fattr->cf_mode |= S_IFLNK;
529 fattr->cf_dtype = DT_LNK;
530 } else {
531 fattr->cf_mode |= S_IFREG; /* file? */
532 fattr->cf_dtype = DT_REG;
533 rc = -EOPNOTSUPP;
534 }
535 } else {
536 fattr->cf_mode |= S_IFREG; /* then it is a file */
537 fattr->cf_dtype = DT_REG;
538 rc = -EOPNOTSUPP; /* or some unknown SFU type */
539 }
540
541 tcon->ses->server->ops->close(xid, tcon, &fid);
542 cifs_put_tlink(tlink);
543 return rc;
544 }
545
546 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
547
548 /*
549 * Fetch mode bits as provided by SFU.
550 *
551 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
552 */
553 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
554 struct cifs_sb_info *cifs_sb, unsigned int xid)
555 {
556 #ifdef CONFIG_CIFS_XATTR
557 ssize_t rc;
558 char ea_value[4];
559 __u32 mode;
560 struct tcon_link *tlink;
561 struct cifs_tcon *tcon;
562
563 tlink = cifs_sb_tlink(cifs_sb);
564 if (IS_ERR(tlink))
565 return PTR_ERR(tlink);
566 tcon = tlink_tcon(tlink);
567
568 if (tcon->ses->server->ops->query_all_EAs == NULL) {
569 cifs_put_tlink(tlink);
570 return -EOPNOTSUPP;
571 }
572
573 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
574 "SETFILEBITS", ea_value, 4 /* size of buf */,
575 cifs_sb);
576 cifs_put_tlink(tlink);
577 if (rc < 0)
578 return (int)rc;
579 else if (rc > 3) {
580 mode = le32_to_cpu(*((__le32 *)ea_value));
581 fattr->cf_mode &= ~SFBITS_MASK;
582 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
583 mode, fattr->cf_mode);
584 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
585 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
586 }
587
588 return 0;
589 #else
590 return -EOPNOTSUPP;
591 #endif
592 }
593
594 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
595 static void
596 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
597 struct super_block *sb, bool adjust_tz,
598 bool symlink)
599 {
600 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
601 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
602
603 memset(fattr, 0, sizeof(*fattr));
604 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
605 if (info->DeletePending)
606 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
607
608 if (info->LastAccessTime)
609 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
610 else {
611 ktime_get_real_ts64(&fattr->cf_atime);
612 fattr->cf_atime = timespec64_trunc(fattr->cf_atime, sb->s_time_gran);
613 }
614
615 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
616 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
617
618 if (adjust_tz) {
619 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
620 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
621 }
622
623 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
624 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
625 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
626
627 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
628
629 if (symlink) {
630 fattr->cf_mode = S_IFLNK;
631 fattr->cf_dtype = DT_LNK;
632 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
633 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
634 fattr->cf_dtype = DT_DIR;
635 /*
636 * Server can return wrong NumberOfLinks value for directories
637 * when Unix extensions are disabled - fake it.
638 */
639 if (!tcon->unix_ext)
640 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
641 } else {
642 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
643 fattr->cf_dtype = DT_REG;
644
645 /* clear write bits if ATTR_READONLY is set */
646 if (fattr->cf_cifsattrs & ATTR_READONLY)
647 fattr->cf_mode &= ~(S_IWUGO);
648
649 /*
650 * Don't accept zero nlink from non-unix servers unless
651 * delete is pending. Instead mark it as unknown.
652 */
653 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
654 !info->DeletePending) {
655 cifs_dbg(1, "bogus file nlink value %u\n",
656 fattr->cf_nlink);
657 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
658 }
659 }
660
661 fattr->cf_uid = cifs_sb->mnt_uid;
662 fattr->cf_gid = cifs_sb->mnt_gid;
663 }
664
665 static int
666 cifs_get_file_info(struct file *filp)
667 {
668 int rc;
669 unsigned int xid;
670 FILE_ALL_INFO find_data;
671 struct cifs_fattr fattr;
672 struct inode *inode = file_inode(filp);
673 struct cifsFileInfo *cfile = filp->private_data;
674 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
675 struct TCP_Server_Info *server = tcon->ses->server;
676
677 if (!server->ops->query_file_info)
678 return -ENOSYS;
679
680 xid = get_xid();
681 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
682 switch (rc) {
683 case 0:
684 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
685 false);
686 break;
687 case -EREMOTE:
688 cifs_create_dfs_fattr(&fattr, inode->i_sb);
689 rc = 0;
690 break;
691 case -EOPNOTSUPP:
692 case -EINVAL:
693 /*
694 * FIXME: legacy server -- fall back to path-based call?
695 * for now, just skip revalidating and mark inode for
696 * immediate reval.
697 */
698 rc = 0;
699 CIFS_I(inode)->time = 0;
700 default:
701 goto cgfi_exit;
702 }
703
704 /*
705 * don't bother with SFU junk here -- just mark inode as needing
706 * revalidation.
707 */
708 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
709 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
710 cifs_fattr_to_inode(inode, &fattr);
711 cgfi_exit:
712 free_xid(xid);
713 return rc;
714 }
715
716 /* Simple function to return a 64 bit hash of string. Rarely called */
717 static __u64 simple_hashstr(const char *str)
718 {
719 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
720 __u64 hash = 0;
721
722 while (*str)
723 hash = (hash + (__u64) *str++) * hash_mult;
724
725 return hash;
726 }
727
728 int
729 cifs_get_inode_info(struct inode **inode, const char *full_path,
730 FILE_ALL_INFO *data, struct super_block *sb, int xid,
731 const struct cifs_fid *fid)
732 {
733 __u16 srchflgs;
734 int rc = 0, tmprc = ENOSYS;
735 struct cifs_tcon *tcon;
736 struct TCP_Server_Info *server;
737 struct tcon_link *tlink;
738 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
739 char *buf = NULL;
740 bool adjust_tz = false;
741 struct cifs_fattr fattr;
742 struct cifs_search_info *srchinf = NULL;
743 bool symlink = false;
744
745 tlink = cifs_sb_tlink(cifs_sb);
746 if (IS_ERR(tlink))
747 return PTR_ERR(tlink);
748 tcon = tlink_tcon(tlink);
749 server = tcon->ses->server;
750
751 cifs_dbg(FYI, "Getting info on %s\n", full_path);
752
753 if ((data == NULL) && (*inode != NULL)) {
754 if (CIFS_CACHE_READ(CIFS_I(*inode)) &&
755 CIFS_I(*inode)->time != 0) {
756 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
757 goto cgii_exit;
758 }
759 }
760
761 /* if inode info is not passed, get it from server */
762 if (data == NULL) {
763 if (!server->ops->query_path_info) {
764 rc = -ENOSYS;
765 goto cgii_exit;
766 }
767 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
768 if (buf == NULL) {
769 rc = -ENOMEM;
770 goto cgii_exit;
771 }
772 data = (FILE_ALL_INFO *)buf;
773 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
774 data, &adjust_tz, &symlink);
775 }
776
777 if (!rc) {
778 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz,
779 symlink);
780 } else if (rc == -EREMOTE) {
781 cifs_create_dfs_fattr(&fattr, sb);
782 rc = 0;
783 } else if ((rc == -EACCES) && backup_cred(cifs_sb) &&
784 (strcmp(server->vals->version_string, SMB1_VERSION_STRING)
785 == 0)) {
786 /*
787 * For SMB2 and later the backup intent flag is already
788 * sent if needed on open and there is no path based
789 * FindFirst operation to use to retry with
790 */
791
792 srchinf = kzalloc(sizeof(struct cifs_search_info),
793 GFP_KERNEL);
794 if (srchinf == NULL) {
795 rc = -ENOMEM;
796 goto cgii_exit;
797 }
798
799 srchinf->endOfSearch = false;
800 if (tcon->unix_ext)
801 srchinf->info_level = SMB_FIND_FILE_UNIX;
802 else if ((tcon->ses->capabilities &
803 tcon->ses->server->vals->cap_nt_find) == 0)
804 srchinf->info_level = SMB_FIND_FILE_INFO_STANDARD;
805 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
806 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
807 else /* no srvino useful for fallback to some netapp */
808 srchinf->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
809
810 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
811 CIFS_SEARCH_CLOSE_AT_END |
812 CIFS_SEARCH_BACKUP_SEARCH;
813
814 rc = CIFSFindFirst(xid, tcon, full_path,
815 cifs_sb, NULL, srchflgs, srchinf, false);
816 if (!rc) {
817 data = (FILE_ALL_INFO *)srchinf->srch_entries_start;
818
819 cifs_dir_info_to_fattr(&fattr,
820 (FILE_DIRECTORY_INFO *)data, cifs_sb);
821 fattr.cf_uniqueid = le64_to_cpu(
822 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
823
824 cifs_buf_release(srchinf->ntwrk_buf_start);
825 }
826 kfree(srchinf);
827 if (rc)
828 goto cgii_exit;
829 } else
830 goto cgii_exit;
831
832 /*
833 * If an inode wasn't passed in, then get the inode number
834 *
835 * Is an i_ino of zero legal? Can we use that to check if the server
836 * supports returning inode numbers? Are there other sanity checks we
837 * can use to ensure that the server is really filling in that field?
838 */
839 if (*inode == NULL) {
840 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
841 if (server->ops->get_srv_inum)
842 tmprc = server->ops->get_srv_inum(xid,
843 tcon, cifs_sb, full_path,
844 &fattr.cf_uniqueid, data);
845 if (tmprc) {
846 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
847 tmprc);
848 fattr.cf_uniqueid = iunique(sb, ROOT_I);
849 cifs_autodisable_serverino(cifs_sb);
850 } else if ((fattr.cf_uniqueid == 0) &&
851 strlen(full_path) == 0) {
852 /* some servers ret bad root ino ie 0 */
853 cifs_dbg(FYI, "Invalid (0) inodenum\n");
854 fattr.cf_flags |=
855 CIFS_FATTR_FAKE_ROOT_INO;
856 fattr.cf_uniqueid =
857 simple_hashstr(tcon->treeName);
858 }
859 } else
860 fattr.cf_uniqueid = iunique(sb, ROOT_I);
861 } else {
862 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
863 && server->ops->get_srv_inum) {
864 /*
865 * Pass a NULL tcon to ensure we don't make a round
866 * trip to the server. This only works for SMB2+.
867 */
868 tmprc = server->ops->get_srv_inum(xid,
869 NULL, cifs_sb, full_path,
870 &fattr.cf_uniqueid, data);
871 if (tmprc)
872 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
873 else if ((fattr.cf_uniqueid == 0) &&
874 strlen(full_path) == 0) {
875 /*
876 * Reuse existing root inode num since
877 * inum zero for root causes ls of . and .. to
878 * not be returned
879 */
880 cifs_dbg(FYI, "Srv ret 0 inode num for root\n");
881 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
882 }
883 } else
884 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
885 }
886
887 /* query for SFU type info if supported and needed */
888 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
889 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
890 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
891 if (tmprc)
892 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
893 }
894
895 /* fill in 0777 bits from ACL */
896 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
897 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
898 full_path, fid);
899 if (rc == -EREMOTE)
900 rc = 0;
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 == -EREMOTE)
910 rc = 0;
911 if (rc) {
912 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
913 __func__, rc);
914 goto cgii_exit;
915 }
916 }
917
918 /* fill in remaining high mode bits e.g. SUID, VTX */
919 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
920 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
921
922 /* check for Minshall+French symlinks */
923 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
924 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
925 full_path);
926 if (tmprc)
927 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
928 }
929
930 if (!*inode) {
931 *inode = cifs_iget(sb, &fattr);
932 if (!*inode)
933 rc = -ENOMEM;
934 } else {
935 /* we already have inode, update it */
936
937 /* if uniqueid is different, return error */
938 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
939 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
940 CIFS_I(*inode)->time = 0; /* force reval */
941 rc = -ESTALE;
942 goto cgii_exit;
943 }
944
945 /* if filetype is different, return error */
946 if (unlikely(((*inode)->i_mode & S_IFMT) !=
947 (fattr.cf_mode & S_IFMT))) {
948 CIFS_I(*inode)->time = 0; /* force reval */
949 rc = -ESTALE;
950 goto cgii_exit;
951 }
952
953 cifs_fattr_to_inode(*inode, &fattr);
954 }
955
956 cgii_exit:
957 if ((*inode) && ((*inode)->i_ino == 0))
958 cifs_dbg(FYI, "inode number of zero returned\n");
959
960 kfree(buf);
961 cifs_put_tlink(tlink);
962 return rc;
963 }
964
965 static const struct inode_operations cifs_ipc_inode_ops = {
966 .lookup = cifs_lookup,
967 };
968
969 static int
970 cifs_find_inode(struct inode *inode, void *opaque)
971 {
972 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
973
974 /* don't match inode with different uniqueid */
975 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
976 return 0;
977
978 /* use createtime like an i_generation field */
979 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
980 return 0;
981
982 /* don't match inode of different type */
983 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
984 return 0;
985
986 /* if it's not a directory or has no dentries, then flag it */
987 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
988 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
989
990 return 1;
991 }
992
993 static int
994 cifs_init_inode(struct inode *inode, void *opaque)
995 {
996 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
997
998 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
999 CIFS_I(inode)->createtime = fattr->cf_createtime;
1000 return 0;
1001 }
1002
1003 /*
1004 * walk dentry list for an inode and report whether it has aliases that
1005 * are hashed. We use this to determine if a directory inode can actually
1006 * be used.
1007 */
1008 static bool
1009 inode_has_hashed_dentries(struct inode *inode)
1010 {
1011 struct dentry *dentry;
1012
1013 spin_lock(&inode->i_lock);
1014 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1015 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1016 spin_unlock(&inode->i_lock);
1017 return true;
1018 }
1019 }
1020 spin_unlock(&inode->i_lock);
1021 return false;
1022 }
1023
1024 /* Given fattrs, get a corresponding inode */
1025 struct inode *
1026 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1027 {
1028 unsigned long hash;
1029 struct inode *inode;
1030
1031 retry_iget5_locked:
1032 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1033
1034 /* hash down to 32-bits on 32-bit arch */
1035 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1036
1037 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1038 if (inode) {
1039 /* was there a potentially problematic inode collision? */
1040 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1041 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1042
1043 if (inode_has_hashed_dentries(inode)) {
1044 cifs_autodisable_serverino(CIFS_SB(sb));
1045 iput(inode);
1046 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1047 goto retry_iget5_locked;
1048 }
1049 }
1050
1051 cifs_fattr_to_inode(inode, fattr);
1052 if (sb->s_flags & SB_NOATIME)
1053 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1054 if (inode->i_state & I_NEW) {
1055 inode->i_ino = hash;
1056 #ifdef CONFIG_CIFS_FSCACHE
1057 /* initialize per-inode cache cookie pointer */
1058 CIFS_I(inode)->fscache = NULL;
1059 #endif
1060 unlock_new_inode(inode);
1061 }
1062 }
1063
1064 return inode;
1065 }
1066
1067 /* gets root inode */
1068 struct inode *cifs_root_iget(struct super_block *sb)
1069 {
1070 unsigned int xid;
1071 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1072 struct inode *inode = NULL;
1073 long rc;
1074 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1075 char *path = NULL;
1076 int len;
1077
1078 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1079 && cifs_sb->prepath) {
1080 len = strlen(cifs_sb->prepath);
1081 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1082 if (path == NULL)
1083 return ERR_PTR(-ENOMEM);
1084 path[0] = '/';
1085 memcpy(path+1, cifs_sb->prepath, len);
1086 } else {
1087 path = kstrdup("", GFP_KERNEL);
1088 if (path == NULL)
1089 return ERR_PTR(-ENOMEM);
1090 }
1091
1092 xid = get_xid();
1093 if (tcon->unix_ext) {
1094 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1095 /* some servers mistakenly claim POSIX support */
1096 if (rc != -EOPNOTSUPP)
1097 goto iget_no_retry;
1098 cifs_dbg(VFS, "server does not support POSIX extensions");
1099 tcon->unix_ext = false;
1100 }
1101
1102 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1103 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1104
1105 iget_no_retry:
1106 if (!inode) {
1107 inode = ERR_PTR(rc);
1108 goto out;
1109 }
1110
1111 #ifdef CONFIG_CIFS_FSCACHE
1112 /* populate tcon->resource_id */
1113 tcon->resource_id = CIFS_I(inode)->uniqueid;
1114 #endif
1115
1116 if (rc && tcon->pipe) {
1117 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1118 spin_lock(&inode->i_lock);
1119 inode->i_mode |= S_IFDIR;
1120 set_nlink(inode, 2);
1121 inode->i_op = &cifs_ipc_inode_ops;
1122 inode->i_fop = &simple_dir_operations;
1123 inode->i_uid = cifs_sb->mnt_uid;
1124 inode->i_gid = cifs_sb->mnt_gid;
1125 spin_unlock(&inode->i_lock);
1126 } else if (rc) {
1127 iget_failed(inode);
1128 inode = ERR_PTR(rc);
1129 }
1130
1131 out:
1132 kfree(path);
1133 free_xid(xid);
1134 return inode;
1135 }
1136
1137 int
1138 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1139 char *full_path, __u32 dosattr)
1140 {
1141 bool set_time = false;
1142 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1143 struct TCP_Server_Info *server;
1144 FILE_BASIC_INFO info_buf;
1145
1146 if (attrs == NULL)
1147 return -EINVAL;
1148
1149 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1150 if (!server->ops->set_file_info)
1151 return -ENOSYS;
1152
1153 info_buf.Pad = 0;
1154
1155 if (attrs->ia_valid & ATTR_ATIME) {
1156 set_time = true;
1157 info_buf.LastAccessTime =
1158 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1159 } else
1160 info_buf.LastAccessTime = 0;
1161
1162 if (attrs->ia_valid & ATTR_MTIME) {
1163 set_time = true;
1164 info_buf.LastWriteTime =
1165 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1166 } else
1167 info_buf.LastWriteTime = 0;
1168
1169 /*
1170 * Samba throws this field away, but windows may actually use it.
1171 * Do not set ctime unless other time stamps are changed explicitly
1172 * (i.e. by utimes()) since we would then have a mix of client and
1173 * server times.
1174 */
1175 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1176 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1177 info_buf.ChangeTime =
1178 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1179 } else
1180 info_buf.ChangeTime = 0;
1181
1182 info_buf.CreationTime = 0; /* don't change */
1183 info_buf.Attributes = cpu_to_le32(dosattr);
1184
1185 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1186 }
1187
1188 /*
1189 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1190 * and rename it to a random name that hopefully won't conflict with
1191 * anything else.
1192 */
1193 int
1194 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1195 const unsigned int xid)
1196 {
1197 int oplock = 0;
1198 int rc;
1199 struct cifs_fid fid;
1200 struct cifs_open_parms oparms;
1201 struct inode *inode = d_inode(dentry);
1202 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1203 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1204 struct tcon_link *tlink;
1205 struct cifs_tcon *tcon;
1206 __u32 dosattr, origattr;
1207 FILE_BASIC_INFO *info_buf = NULL;
1208
1209 tlink = cifs_sb_tlink(cifs_sb);
1210 if (IS_ERR(tlink))
1211 return PTR_ERR(tlink);
1212 tcon = tlink_tcon(tlink);
1213
1214 /*
1215 * We cannot rename the file if the server doesn't support
1216 * CAP_INFOLEVEL_PASSTHRU
1217 */
1218 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1219 rc = -EBUSY;
1220 goto out;
1221 }
1222
1223 oparms.tcon = tcon;
1224 oparms.cifs_sb = cifs_sb;
1225 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1226 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
1227 oparms.disposition = FILE_OPEN;
1228 oparms.path = full_path;
1229 oparms.fid = &fid;
1230 oparms.reconnect = false;
1231
1232 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1233 if (rc != 0)
1234 goto out;
1235
1236 origattr = cifsInode->cifsAttrs;
1237 if (origattr == 0)
1238 origattr |= ATTR_NORMAL;
1239
1240 dosattr = origattr & ~ATTR_READONLY;
1241 if (dosattr == 0)
1242 dosattr |= ATTR_NORMAL;
1243 dosattr |= ATTR_HIDDEN;
1244
1245 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1246 if (dosattr != origattr) {
1247 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1248 if (info_buf == NULL) {
1249 rc = -ENOMEM;
1250 goto out_close;
1251 }
1252 info_buf->Attributes = cpu_to_le32(dosattr);
1253 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1254 current->tgid);
1255 /* although we would like to mark the file hidden
1256 if that fails we will still try to rename it */
1257 if (!rc)
1258 cifsInode->cifsAttrs = dosattr;
1259 else
1260 dosattr = origattr; /* since not able to change them */
1261 }
1262
1263 /* rename the file */
1264 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1265 cifs_sb->local_nls,
1266 cifs_remap(cifs_sb));
1267 if (rc != 0) {
1268 rc = -EBUSY;
1269 goto undo_setattr;
1270 }
1271
1272 /* try to set DELETE_ON_CLOSE */
1273 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1274 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1275 current->tgid);
1276 /*
1277 * some samba versions return -ENOENT when we try to set the
1278 * file disposition here. Likely a samba bug, but work around
1279 * it for now. This means that some cifsXXX files may hang
1280 * around after they shouldn't.
1281 *
1282 * BB: remove this hack after more servers have the fix
1283 */
1284 if (rc == -ENOENT)
1285 rc = 0;
1286 else if (rc != 0) {
1287 rc = -EBUSY;
1288 goto undo_rename;
1289 }
1290 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1291 }
1292
1293 out_close:
1294 CIFSSMBClose(xid, tcon, fid.netfid);
1295 out:
1296 kfree(info_buf);
1297 cifs_put_tlink(tlink);
1298 return rc;
1299
1300 /*
1301 * reset everything back to the original state. Don't bother
1302 * dealing with errors here since we can't do anything about
1303 * them anyway.
1304 */
1305 undo_rename:
1306 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1307 cifs_sb->local_nls, cifs_remap(cifs_sb));
1308 undo_setattr:
1309 if (dosattr != origattr) {
1310 info_buf->Attributes = cpu_to_le32(origattr);
1311 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1312 current->tgid))
1313 cifsInode->cifsAttrs = origattr;
1314 }
1315
1316 goto out_close;
1317 }
1318
1319 /* copied from fs/nfs/dir.c with small changes */
1320 static void
1321 cifs_drop_nlink(struct inode *inode)
1322 {
1323 spin_lock(&inode->i_lock);
1324 if (inode->i_nlink > 0)
1325 drop_nlink(inode);
1326 spin_unlock(&inode->i_lock);
1327 }
1328
1329 /*
1330 * If d_inode(dentry) is null (usually meaning the cached dentry
1331 * is a negative dentry) then we would attempt a standard SMB delete, but
1332 * if that fails we can not attempt the fall back mechanisms on EACCES
1333 * but will return the EACCES to the caller. Note that the VFS does not call
1334 * unlink on negative dentries currently.
1335 */
1336 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1337 {
1338 int rc = 0;
1339 unsigned int xid;
1340 char *full_path = NULL;
1341 struct inode *inode = d_inode(dentry);
1342 struct cifsInodeInfo *cifs_inode;
1343 struct super_block *sb = dir->i_sb;
1344 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1345 struct tcon_link *tlink;
1346 struct cifs_tcon *tcon;
1347 struct TCP_Server_Info *server;
1348 struct iattr *attrs = NULL;
1349 __u32 dosattr = 0, origattr = 0;
1350
1351 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1352
1353 tlink = cifs_sb_tlink(cifs_sb);
1354 if (IS_ERR(tlink))
1355 return PTR_ERR(tlink);
1356 tcon = tlink_tcon(tlink);
1357 server = tcon->ses->server;
1358
1359 xid = get_xid();
1360
1361 /* Unlink can be called from rename so we can not take the
1362 * sb->s_vfs_rename_mutex here */
1363 full_path = build_path_from_dentry(dentry);
1364 if (full_path == NULL) {
1365 rc = -ENOMEM;
1366 goto unlink_out;
1367 }
1368
1369 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1370 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1371 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1372 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1373 cifs_remap(cifs_sb));
1374 cifs_dbg(FYI, "posix del rc %d\n", rc);
1375 if ((rc == 0) || (rc == -ENOENT))
1376 goto psx_del_no_retry;
1377 }
1378
1379 retry_std_delete:
1380 if (!server->ops->unlink) {
1381 rc = -ENOSYS;
1382 goto psx_del_no_retry;
1383 }
1384
1385 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1386
1387 psx_del_no_retry:
1388 if (!rc) {
1389 if (inode)
1390 cifs_drop_nlink(inode);
1391 } else if (rc == -ENOENT) {
1392 d_drop(dentry);
1393 } else if (rc == -EBUSY) {
1394 if (server->ops->rename_pending_delete) {
1395 rc = server->ops->rename_pending_delete(full_path,
1396 dentry, xid);
1397 if (rc == 0)
1398 cifs_drop_nlink(inode);
1399 }
1400 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1401 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1402 if (attrs == NULL) {
1403 rc = -ENOMEM;
1404 goto out_reval;
1405 }
1406
1407 /* try to reset dos attributes */
1408 cifs_inode = CIFS_I(inode);
1409 origattr = cifs_inode->cifsAttrs;
1410 if (origattr == 0)
1411 origattr |= ATTR_NORMAL;
1412 dosattr = origattr & ~ATTR_READONLY;
1413 if (dosattr == 0)
1414 dosattr |= ATTR_NORMAL;
1415 dosattr |= ATTR_HIDDEN;
1416
1417 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1418 if (rc != 0)
1419 goto out_reval;
1420
1421 goto retry_std_delete;
1422 }
1423
1424 /* undo the setattr if we errored out and it's needed */
1425 if (rc != 0 && dosattr != 0)
1426 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1427
1428 out_reval:
1429 if (inode) {
1430 cifs_inode = CIFS_I(inode);
1431 cifs_inode->time = 0; /* will force revalidate to get info
1432 when needed */
1433 inode->i_ctime = current_time(inode);
1434 }
1435 dir->i_ctime = dir->i_mtime = current_time(dir);
1436 cifs_inode = CIFS_I(dir);
1437 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1438 unlink_out:
1439 kfree(full_path);
1440 kfree(attrs);
1441 free_xid(xid);
1442 cifs_put_tlink(tlink);
1443 return rc;
1444 }
1445
1446 static int
1447 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1448 const char *full_path, struct cifs_sb_info *cifs_sb,
1449 struct cifs_tcon *tcon, const unsigned int xid)
1450 {
1451 int rc = 0;
1452 struct inode *inode = NULL;
1453
1454 if (tcon->unix_ext)
1455 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1456 xid);
1457 else
1458 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1459 xid, NULL);
1460
1461 if (rc)
1462 return rc;
1463
1464 /*
1465 * setting nlink not necessary except in cases where we failed to get it
1466 * from the server or was set bogus. Also, since this is a brand new
1467 * inode, no need to grab the i_lock before setting the i_nlink.
1468 */
1469 if (inode->i_nlink < 2)
1470 set_nlink(inode, 2);
1471 mode &= ~current_umask();
1472 /* must turn on setgid bit if parent dir has it */
1473 if (parent->i_mode & S_ISGID)
1474 mode |= S_ISGID;
1475
1476 if (tcon->unix_ext) {
1477 struct cifs_unix_set_info_args args = {
1478 .mode = mode,
1479 .ctime = NO_CHANGE_64,
1480 .atime = NO_CHANGE_64,
1481 .mtime = NO_CHANGE_64,
1482 .device = 0,
1483 };
1484 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1485 args.uid = current_fsuid();
1486 if (parent->i_mode & S_ISGID)
1487 args.gid = parent->i_gid;
1488 else
1489 args.gid = current_fsgid();
1490 } else {
1491 args.uid = INVALID_UID; /* no change */
1492 args.gid = INVALID_GID; /* no change */
1493 }
1494 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1495 cifs_sb->local_nls,
1496 cifs_remap(cifs_sb));
1497 } else {
1498 struct TCP_Server_Info *server = tcon->ses->server;
1499 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1500 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1501 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1502 tcon, xid);
1503 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1504 inode->i_mode = (mode | S_IFDIR);
1505
1506 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1507 inode->i_uid = current_fsuid();
1508 if (inode->i_mode & S_ISGID)
1509 inode->i_gid = parent->i_gid;
1510 else
1511 inode->i_gid = current_fsgid();
1512 }
1513 }
1514 d_instantiate(dentry, inode);
1515 return rc;
1516 }
1517
1518 static int
1519 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1520 const char *full_path, struct cifs_sb_info *cifs_sb,
1521 struct cifs_tcon *tcon, const unsigned int xid)
1522 {
1523 int rc = 0;
1524 u32 oplock = 0;
1525 FILE_UNIX_BASIC_INFO *info = NULL;
1526 struct inode *newinode = NULL;
1527 struct cifs_fattr fattr;
1528
1529 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1530 if (info == NULL) {
1531 rc = -ENOMEM;
1532 goto posix_mkdir_out;
1533 }
1534
1535 mode &= ~current_umask();
1536 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1537 NULL /* netfid */, info, &oplock, full_path,
1538 cifs_sb->local_nls, cifs_remap(cifs_sb));
1539 if (rc == -EOPNOTSUPP)
1540 goto posix_mkdir_out;
1541 else if (rc) {
1542 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1543 d_drop(dentry);
1544 goto posix_mkdir_out;
1545 }
1546
1547 if (info->Type == cpu_to_le32(-1))
1548 /* no return info, go query for it */
1549 goto posix_mkdir_get_info;
1550 /*
1551 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1552 * need to set uid/gid.
1553 */
1554
1555 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1556 cifs_fill_uniqueid(inode->i_sb, &fattr);
1557 newinode = cifs_iget(inode->i_sb, &fattr);
1558 if (!newinode)
1559 goto posix_mkdir_get_info;
1560
1561 d_instantiate(dentry, newinode);
1562
1563 #ifdef CONFIG_CIFS_DEBUG2
1564 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1565 dentry, dentry, newinode);
1566
1567 if (newinode->i_nlink != 2)
1568 cifs_dbg(FYI, "unexpected number of links %d\n",
1569 newinode->i_nlink);
1570 #endif
1571
1572 posix_mkdir_out:
1573 kfree(info);
1574 return rc;
1575 posix_mkdir_get_info:
1576 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1577 xid);
1578 goto posix_mkdir_out;
1579 }
1580
1581 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1582 {
1583 int rc = 0;
1584 unsigned int xid;
1585 struct cifs_sb_info *cifs_sb;
1586 struct tcon_link *tlink;
1587 struct cifs_tcon *tcon;
1588 struct TCP_Server_Info *server;
1589 char *full_path;
1590
1591 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1592 mode, inode);
1593
1594 cifs_sb = CIFS_SB(inode->i_sb);
1595 tlink = cifs_sb_tlink(cifs_sb);
1596 if (IS_ERR(tlink))
1597 return PTR_ERR(tlink);
1598 tcon = tlink_tcon(tlink);
1599
1600 xid = get_xid();
1601
1602 full_path = build_path_from_dentry(direntry);
1603 if (full_path == NULL) {
1604 rc = -ENOMEM;
1605 goto mkdir_out;
1606 }
1607
1608 server = tcon->ses->server;
1609
1610 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1611 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1612 cifs_sb);
1613 d_drop(direntry); /* for time being always refresh inode info */
1614 goto mkdir_out;
1615 }
1616
1617 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1618 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1619 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1620 tcon, xid);
1621 if (rc != -EOPNOTSUPP)
1622 goto mkdir_out;
1623 }
1624
1625 if (!server->ops->mkdir) {
1626 rc = -ENOSYS;
1627 goto mkdir_out;
1628 }
1629
1630 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1631 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1632 if (rc) {
1633 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1634 d_drop(direntry);
1635 goto mkdir_out;
1636 }
1637
1638 /* TODO: skip this for smb2/smb3 */
1639 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1640 xid);
1641 mkdir_out:
1642 /*
1643 * Force revalidate to get parent dir info when needed since cached
1644 * attributes are invalid now.
1645 */
1646 CIFS_I(inode)->time = 0;
1647 kfree(full_path);
1648 free_xid(xid);
1649 cifs_put_tlink(tlink);
1650 return rc;
1651 }
1652
1653 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1654 {
1655 int rc = 0;
1656 unsigned int xid;
1657 struct cifs_sb_info *cifs_sb;
1658 struct tcon_link *tlink;
1659 struct cifs_tcon *tcon;
1660 struct TCP_Server_Info *server;
1661 char *full_path = NULL;
1662 struct cifsInodeInfo *cifsInode;
1663
1664 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1665
1666 xid = get_xid();
1667
1668 full_path = build_path_from_dentry(direntry);
1669 if (full_path == NULL) {
1670 rc = -ENOMEM;
1671 goto rmdir_exit;
1672 }
1673
1674 cifs_sb = CIFS_SB(inode->i_sb);
1675 tlink = cifs_sb_tlink(cifs_sb);
1676 if (IS_ERR(tlink)) {
1677 rc = PTR_ERR(tlink);
1678 goto rmdir_exit;
1679 }
1680 tcon = tlink_tcon(tlink);
1681 server = tcon->ses->server;
1682
1683 if (!server->ops->rmdir) {
1684 rc = -ENOSYS;
1685 cifs_put_tlink(tlink);
1686 goto rmdir_exit;
1687 }
1688
1689 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1690 cifs_put_tlink(tlink);
1691
1692 if (!rc) {
1693 spin_lock(&d_inode(direntry)->i_lock);
1694 i_size_write(d_inode(direntry), 0);
1695 clear_nlink(d_inode(direntry));
1696 spin_unlock(&d_inode(direntry)->i_lock);
1697 }
1698
1699 cifsInode = CIFS_I(d_inode(direntry));
1700 /* force revalidate to go get info when needed */
1701 cifsInode->time = 0;
1702
1703 cifsInode = CIFS_I(inode);
1704 /*
1705 * Force revalidate to get parent dir info when needed since cached
1706 * attributes are invalid now.
1707 */
1708 cifsInode->time = 0;
1709
1710 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1711 current_time(inode);
1712
1713 rmdir_exit:
1714 kfree(full_path);
1715 free_xid(xid);
1716 return rc;
1717 }
1718
1719 static int
1720 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1721 const char *from_path, struct dentry *to_dentry,
1722 const char *to_path)
1723 {
1724 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1725 struct tcon_link *tlink;
1726 struct cifs_tcon *tcon;
1727 struct TCP_Server_Info *server;
1728 struct cifs_fid fid;
1729 struct cifs_open_parms oparms;
1730 int oplock, rc;
1731
1732 tlink = cifs_sb_tlink(cifs_sb);
1733 if (IS_ERR(tlink))
1734 return PTR_ERR(tlink);
1735 tcon = tlink_tcon(tlink);
1736 server = tcon->ses->server;
1737
1738 if (!server->ops->rename)
1739 return -ENOSYS;
1740
1741 /* try path-based rename first */
1742 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1743
1744 /*
1745 * Don't bother with rename by filehandle unless file is busy and
1746 * source. Note that cross directory moves do not work with
1747 * rename by filehandle to various Windows servers.
1748 */
1749 if (rc == 0 || rc != -EBUSY)
1750 goto do_rename_exit;
1751
1752 /* Don't fall back to using SMB on SMB 2+ mount */
1753 if (server->vals->protocol_id != 0)
1754 goto do_rename_exit;
1755
1756 /* open-file renames don't work across directories */
1757 if (to_dentry->d_parent != from_dentry->d_parent)
1758 goto do_rename_exit;
1759
1760 oparms.tcon = tcon;
1761 oparms.cifs_sb = cifs_sb;
1762 /* open the file to be renamed -- we need DELETE perms */
1763 oparms.desired_access = DELETE;
1764 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
1765 oparms.disposition = FILE_OPEN;
1766 oparms.path = from_path;
1767 oparms.fid = &fid;
1768 oparms.reconnect = false;
1769
1770 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1771 if (rc == 0) {
1772 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1773 (const char *) to_dentry->d_name.name,
1774 cifs_sb->local_nls, cifs_remap(cifs_sb));
1775 CIFSSMBClose(xid, tcon, fid.netfid);
1776 }
1777 do_rename_exit:
1778 cifs_put_tlink(tlink);
1779 return rc;
1780 }
1781
1782 int
1783 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1784 struct inode *target_dir, struct dentry *target_dentry,
1785 unsigned int flags)
1786 {
1787 char *from_name = NULL;
1788 char *to_name = NULL;
1789 struct cifs_sb_info *cifs_sb;
1790 struct tcon_link *tlink;
1791 struct cifs_tcon *tcon;
1792 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1793 FILE_UNIX_BASIC_INFO *info_buf_target;
1794 unsigned int xid;
1795 int rc, tmprc;
1796
1797 if (flags & ~RENAME_NOREPLACE)
1798 return -EINVAL;
1799
1800 cifs_sb = CIFS_SB(source_dir->i_sb);
1801 tlink = cifs_sb_tlink(cifs_sb);
1802 if (IS_ERR(tlink))
1803 return PTR_ERR(tlink);
1804 tcon = tlink_tcon(tlink);
1805
1806 xid = get_xid();
1807
1808 /*
1809 * we already have the rename sem so we do not need to
1810 * grab it again here to protect the path integrity
1811 */
1812 from_name = build_path_from_dentry(source_dentry);
1813 if (from_name == NULL) {
1814 rc = -ENOMEM;
1815 goto cifs_rename_exit;
1816 }
1817
1818 to_name = build_path_from_dentry(target_dentry);
1819 if (to_name == NULL) {
1820 rc = -ENOMEM;
1821 goto cifs_rename_exit;
1822 }
1823
1824 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1825 to_name);
1826
1827 /*
1828 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1829 */
1830 if (flags & RENAME_NOREPLACE)
1831 goto cifs_rename_exit;
1832
1833 if (rc == -EEXIST && tcon->unix_ext) {
1834 /*
1835 * Are src and dst hardlinks of same inode? We can only tell
1836 * with unix extensions enabled.
1837 */
1838 info_buf_source =
1839 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
1840 GFP_KERNEL);
1841 if (info_buf_source == NULL) {
1842 rc = -ENOMEM;
1843 goto cifs_rename_exit;
1844 }
1845
1846 info_buf_target = info_buf_source + 1;
1847 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1848 info_buf_source,
1849 cifs_sb->local_nls,
1850 cifs_remap(cifs_sb));
1851 if (tmprc != 0)
1852 goto unlink_target;
1853
1854 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1855 info_buf_target,
1856 cifs_sb->local_nls,
1857 cifs_remap(cifs_sb));
1858
1859 if (tmprc == 0 && (info_buf_source->UniqueId ==
1860 info_buf_target->UniqueId)) {
1861 /* same file, POSIX says that this is a noop */
1862 rc = 0;
1863 goto cifs_rename_exit;
1864 }
1865 }
1866 /*
1867 * else ... BB we could add the same check for Windows by
1868 * checking the UniqueId via FILE_INTERNAL_INFO
1869 */
1870
1871 unlink_target:
1872 /* Try unlinking the target dentry if it's not negative */
1873 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1874 if (d_is_dir(target_dentry))
1875 tmprc = cifs_rmdir(target_dir, target_dentry);
1876 else
1877 tmprc = cifs_unlink(target_dir, target_dentry);
1878 if (tmprc)
1879 goto cifs_rename_exit;
1880 rc = cifs_do_rename(xid, source_dentry, from_name,
1881 target_dentry, to_name);
1882 }
1883
1884 /* force revalidate to go get info when needed */
1885 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1886
1887 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1888 target_dir->i_mtime = current_time(source_dir);
1889
1890 cifs_rename_exit:
1891 kfree(info_buf_source);
1892 kfree(from_name);
1893 kfree(to_name);
1894 free_xid(xid);
1895 cifs_put_tlink(tlink);
1896 return rc;
1897 }
1898
1899 static bool
1900 cifs_inode_needs_reval(struct inode *inode)
1901 {
1902 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1903 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1904
1905 if (cifs_i->time == 0)
1906 return true;
1907
1908 if (CIFS_CACHE_READ(cifs_i))
1909 return false;
1910
1911 if (!lookupCacheEnabled)
1912 return true;
1913
1914 if (!cifs_sb->actimeo)
1915 return true;
1916
1917 if (!time_in_range(jiffies, cifs_i->time,
1918 cifs_i->time + cifs_sb->actimeo))
1919 return true;
1920
1921 /* hardlinked files w/ noserverino get "special" treatment */
1922 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1923 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1924 return true;
1925
1926 return false;
1927 }
1928
1929 /*
1930 * Zap the cache. Called when invalid_mapping flag is set.
1931 */
1932 int
1933 cifs_invalidate_mapping(struct inode *inode)
1934 {
1935 int rc = 0;
1936
1937 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1938 rc = invalidate_inode_pages2(inode->i_mapping);
1939 if (rc)
1940 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1941 __func__, inode);
1942 }
1943
1944 cifs_fscache_reset_inode_cookie(inode);
1945 return rc;
1946 }
1947
1948 /**
1949 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1950 * @word: long word containing the bit lock
1951 */
1952 static int
1953 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
1954 {
1955 freezable_schedule_unsafe();
1956 if (signal_pending_state(mode, current))
1957 return -ERESTARTSYS;
1958 return 0;
1959 }
1960
1961 int
1962 cifs_revalidate_mapping(struct inode *inode)
1963 {
1964 int rc;
1965 unsigned long *flags = &CIFS_I(inode)->flags;
1966
1967 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1968 TASK_KILLABLE);
1969 if (rc)
1970 return rc;
1971
1972 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1973 rc = cifs_invalidate_mapping(inode);
1974 if (rc)
1975 set_bit(CIFS_INO_INVALID_MAPPING, flags);
1976 }
1977
1978 clear_bit_unlock(CIFS_INO_LOCK, flags);
1979 smp_mb__after_atomic();
1980 wake_up_bit(flags, CIFS_INO_LOCK);
1981
1982 return rc;
1983 }
1984
1985 int
1986 cifs_zap_mapping(struct inode *inode)
1987 {
1988 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1989 return cifs_revalidate_mapping(inode);
1990 }
1991
1992 int cifs_revalidate_file_attr(struct file *filp)
1993 {
1994 int rc = 0;
1995 struct inode *inode = file_inode(filp);
1996 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1997
1998 if (!cifs_inode_needs_reval(inode))
1999 return rc;
2000
2001 if (tlink_tcon(cfile->tlink)->unix_ext)
2002 rc = cifs_get_file_info_unix(filp);
2003 else
2004 rc = cifs_get_file_info(filp);
2005
2006 return rc;
2007 }
2008
2009 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2010 {
2011 unsigned int xid;
2012 int rc = 0;
2013 struct inode *inode = d_inode(dentry);
2014 struct super_block *sb = dentry->d_sb;
2015 char *full_path = NULL;
2016 int count = 0;
2017
2018 if (inode == NULL)
2019 return -ENOENT;
2020
2021 if (!cifs_inode_needs_reval(inode))
2022 return rc;
2023
2024 xid = get_xid();
2025
2026 /* can not safely grab the rename sem here if rename calls revalidate
2027 since that would deadlock */
2028 full_path = build_path_from_dentry(dentry);
2029 if (full_path == NULL) {
2030 rc = -ENOMEM;
2031 goto out;
2032 }
2033
2034 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2035 full_path, inode, inode->i_count.counter,
2036 dentry, cifs_get_time(dentry), jiffies);
2037
2038 again:
2039 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2040 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2041 else
2042 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2043 xid, NULL);
2044 if (rc == -EAGAIN && count++ < 10)
2045 goto again;
2046 out:
2047 kfree(full_path);
2048 free_xid(xid);
2049
2050 return rc;
2051 }
2052
2053 int cifs_revalidate_file(struct file *filp)
2054 {
2055 int rc;
2056 struct inode *inode = file_inode(filp);
2057
2058 rc = cifs_revalidate_file_attr(filp);
2059 if (rc)
2060 return rc;
2061
2062 return cifs_revalidate_mapping(inode);
2063 }
2064
2065 /* revalidate a dentry's inode attributes */
2066 int cifs_revalidate_dentry(struct dentry *dentry)
2067 {
2068 int rc;
2069 struct inode *inode = d_inode(dentry);
2070
2071 rc = cifs_revalidate_dentry_attr(dentry);
2072 if (rc)
2073 return rc;
2074
2075 return cifs_revalidate_mapping(inode);
2076 }
2077
2078 int cifs_getattr(const struct path *path, struct kstat *stat,
2079 u32 request_mask, unsigned int flags)
2080 {
2081 struct dentry *dentry = path->dentry;
2082 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2083 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2084 struct inode *inode = d_inode(dentry);
2085 int rc;
2086
2087 /*
2088 * We need to be sure that all dirty pages are written and the server
2089 * has actual ctime, mtime and file length.
2090 */
2091 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2092 inode->i_mapping->nrpages != 0) {
2093 rc = filemap_fdatawait(inode->i_mapping);
2094 if (rc) {
2095 mapping_set_error(inode->i_mapping, rc);
2096 return rc;
2097 }
2098 }
2099
2100 rc = cifs_revalidate_dentry_attr(dentry);
2101 if (rc)
2102 return rc;
2103
2104 generic_fillattr(inode, stat);
2105 stat->blksize = cifs_sb->bsize;
2106 stat->ino = CIFS_I(inode)->uniqueid;
2107
2108 /* old CIFS Unix Extensions doesn't return create time */
2109 if (CIFS_I(inode)->createtime) {
2110 stat->result_mask |= STATX_BTIME;
2111 stat->btime =
2112 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2113 }
2114
2115 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2116 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2117 stat->attributes |= STATX_ATTR_COMPRESSED;
2118 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2119 stat->attributes |= STATX_ATTR_ENCRYPTED;
2120
2121 /*
2122 * If on a multiuser mount without unix extensions or cifsacl being
2123 * enabled, and the admin hasn't overridden them, set the ownership
2124 * to the fsuid/fsgid of the current process.
2125 */
2126 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2127 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2128 !tcon->unix_ext) {
2129 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2130 stat->uid = current_fsuid();
2131 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2132 stat->gid = current_fsgid();
2133 }
2134 return rc;
2135 }
2136
2137 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2138 u64 len)
2139 {
2140 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2141 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2142 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2143 struct TCP_Server_Info *server = tcon->ses->server;
2144 struct cifsFileInfo *cfile;
2145 int rc;
2146
2147 /*
2148 * We need to be sure that all dirty pages are written as they
2149 * might fill holes on the server.
2150 */
2151 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2152 inode->i_mapping->nrpages != 0) {
2153 rc = filemap_fdatawait(inode->i_mapping);
2154 if (rc) {
2155 mapping_set_error(inode->i_mapping, rc);
2156 return rc;
2157 }
2158 }
2159
2160 cfile = find_readable_file(cifs_i, false);
2161 if (cfile == NULL)
2162 return -EINVAL;
2163
2164 if (server->ops->fiemap) {
2165 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2166 cifsFileInfo_put(cfile);
2167 return rc;
2168 }
2169
2170 cifsFileInfo_put(cfile);
2171 return -ENOTSUPP;
2172 }
2173
2174 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2175 {
2176 pgoff_t index = from >> PAGE_SHIFT;
2177 unsigned offset = from & (PAGE_SIZE - 1);
2178 struct page *page;
2179 int rc = 0;
2180
2181 page = grab_cache_page(mapping, index);
2182 if (!page)
2183 return -ENOMEM;
2184
2185 zero_user_segment(page, offset, PAGE_SIZE);
2186 unlock_page(page);
2187 put_page(page);
2188 return rc;
2189 }
2190
2191 static void cifs_setsize(struct inode *inode, loff_t offset)
2192 {
2193 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2194
2195 spin_lock(&inode->i_lock);
2196 i_size_write(inode, offset);
2197 spin_unlock(&inode->i_lock);
2198
2199 /* Cached inode must be refreshed on truncate */
2200 cifs_i->time = 0;
2201 truncate_pagecache(inode, offset);
2202 }
2203
2204 static int
2205 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2206 unsigned int xid, char *full_path)
2207 {
2208 int rc;
2209 struct cifsFileInfo *open_file;
2210 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2211 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2212 struct tcon_link *tlink = NULL;
2213 struct cifs_tcon *tcon = NULL;
2214 struct TCP_Server_Info *server;
2215
2216 /*
2217 * To avoid spurious oplock breaks from server, in the case of
2218 * inodes that we already have open, avoid doing path based
2219 * setting of file size if we can do it by handle.
2220 * This keeps our caching token (oplock) and avoids timeouts
2221 * when the local oplock break takes longer to flush
2222 * writebehind data than the SMB timeout for the SetPathInfo
2223 * request would allow
2224 */
2225 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2226 if (open_file) {
2227 tcon = tlink_tcon(open_file->tlink);
2228 server = tcon->ses->server;
2229 if (server->ops->set_file_size)
2230 rc = server->ops->set_file_size(xid, tcon, open_file,
2231 attrs->ia_size, false);
2232 else
2233 rc = -ENOSYS;
2234 cifsFileInfo_put(open_file);
2235 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2236 } else
2237 rc = -EINVAL;
2238
2239 if (!rc)
2240 goto set_size_out;
2241
2242 if (tcon == NULL) {
2243 tlink = cifs_sb_tlink(cifs_sb);
2244 if (IS_ERR(tlink))
2245 return PTR_ERR(tlink);
2246 tcon = tlink_tcon(tlink);
2247 server = tcon->ses->server;
2248 }
2249
2250 /*
2251 * Set file size by pathname rather than by handle either because no
2252 * valid, writeable file handle for it was found or because there was
2253 * an error setting it by handle.
2254 */
2255 if (server->ops->set_path_size)
2256 rc = server->ops->set_path_size(xid, tcon, full_path,
2257 attrs->ia_size, cifs_sb, false);
2258 else
2259 rc = -ENOSYS;
2260 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2261
2262 if (tlink)
2263 cifs_put_tlink(tlink);
2264
2265 set_size_out:
2266 if (rc == 0) {
2267 cifsInode->server_eof = attrs->ia_size;
2268 cifs_setsize(inode, attrs->ia_size);
2269
2270 /*
2271 * The man page of truncate says if the size changed,
2272 * then the st_ctime and st_mtime fields for the file
2273 * are updated.
2274 */
2275 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2276 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2277
2278 cifs_truncate_page(inode->i_mapping, inode->i_size);
2279 }
2280
2281 return rc;
2282 }
2283
2284 static int
2285 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2286 {
2287 int rc;
2288 unsigned int xid;
2289 char *full_path = NULL;
2290 struct inode *inode = d_inode(direntry);
2291 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2292 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2293 struct tcon_link *tlink;
2294 struct cifs_tcon *pTcon;
2295 struct cifs_unix_set_info_args *args = NULL;
2296 struct cifsFileInfo *open_file;
2297
2298 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2299 direntry, attrs->ia_valid);
2300
2301 xid = get_xid();
2302
2303 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2304 attrs->ia_valid |= ATTR_FORCE;
2305
2306 rc = setattr_prepare(direntry, attrs);
2307 if (rc < 0)
2308 goto out;
2309
2310 full_path = build_path_from_dentry(direntry);
2311 if (full_path == NULL) {
2312 rc = -ENOMEM;
2313 goto out;
2314 }
2315
2316 /*
2317 * Attempt to flush data before changing attributes. We need to do
2318 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2319 * ownership or mode then we may also need to do this. Here, we take
2320 * the safe way out and just do the flush on all setattr requests. If
2321 * the flush returns error, store it to report later and continue.
2322 *
2323 * BB: This should be smarter. Why bother flushing pages that
2324 * will be truncated anyway? Also, should we error out here if
2325 * the flush returns error?
2326 */
2327 rc = filemap_write_and_wait(inode->i_mapping);
2328 if (is_interrupt_error(rc)) {
2329 rc = -ERESTARTSYS;
2330 goto out;
2331 }
2332
2333 mapping_set_error(inode->i_mapping, rc);
2334 rc = 0;
2335
2336 if (attrs->ia_valid & ATTR_SIZE) {
2337 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2338 if (rc != 0)
2339 goto out;
2340 }
2341
2342 /* skip mode change if it's just for clearing setuid/setgid */
2343 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2344 attrs->ia_valid &= ~ATTR_MODE;
2345
2346 args = kmalloc(sizeof(*args), GFP_KERNEL);
2347 if (args == NULL) {
2348 rc = -ENOMEM;
2349 goto out;
2350 }
2351
2352 /* set up the struct */
2353 if (attrs->ia_valid & ATTR_MODE)
2354 args->mode = attrs->ia_mode;
2355 else
2356 args->mode = NO_CHANGE_64;
2357
2358 if (attrs->ia_valid & ATTR_UID)
2359 args->uid = attrs->ia_uid;
2360 else
2361 args->uid = INVALID_UID; /* no change */
2362
2363 if (attrs->ia_valid & ATTR_GID)
2364 args->gid = attrs->ia_gid;
2365 else
2366 args->gid = INVALID_GID; /* no change */
2367
2368 if (attrs->ia_valid & ATTR_ATIME)
2369 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2370 else
2371 args->atime = NO_CHANGE_64;
2372
2373 if (attrs->ia_valid & ATTR_MTIME)
2374 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2375 else
2376 args->mtime = NO_CHANGE_64;
2377
2378 if (attrs->ia_valid & ATTR_CTIME)
2379 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2380 else
2381 args->ctime = NO_CHANGE_64;
2382
2383 args->device = 0;
2384 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2385 if (open_file) {
2386 u16 nfid = open_file->fid.netfid;
2387 u32 npid = open_file->pid;
2388 pTcon = tlink_tcon(open_file->tlink);
2389 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2390 cifsFileInfo_put(open_file);
2391 } else {
2392 tlink = cifs_sb_tlink(cifs_sb);
2393 if (IS_ERR(tlink)) {
2394 rc = PTR_ERR(tlink);
2395 goto out;
2396 }
2397 pTcon = tlink_tcon(tlink);
2398 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2399 cifs_sb->local_nls,
2400 cifs_remap(cifs_sb));
2401 cifs_put_tlink(tlink);
2402 }
2403
2404 if (rc)
2405 goto out;
2406
2407 if ((attrs->ia_valid & ATTR_SIZE) &&
2408 attrs->ia_size != i_size_read(inode))
2409 truncate_setsize(inode, attrs->ia_size);
2410
2411 setattr_copy(inode, attrs);
2412 mark_inode_dirty(inode);
2413
2414 /* force revalidate when any of these times are set since some
2415 of the fs types (eg ext3, fat) do not have fine enough
2416 time granularity to match protocol, and we do not have a
2417 a way (yet) to query the server fs's time granularity (and
2418 whether it rounds times down).
2419 */
2420 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2421 cifsInode->time = 0;
2422 out:
2423 kfree(args);
2424 kfree(full_path);
2425 free_xid(xid);
2426 return rc;
2427 }
2428
2429 static int
2430 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2431 {
2432 unsigned int xid;
2433 kuid_t uid = INVALID_UID;
2434 kgid_t gid = INVALID_GID;
2435 struct inode *inode = d_inode(direntry);
2436 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2437 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2438 struct cifsFileInfo *wfile;
2439 struct cifs_tcon *tcon;
2440 char *full_path = NULL;
2441 int rc = -EACCES;
2442 __u32 dosattr = 0;
2443 __u64 mode = NO_CHANGE_64;
2444
2445 xid = get_xid();
2446
2447 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2448 direntry, attrs->ia_valid);
2449
2450 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2451 attrs->ia_valid |= ATTR_FORCE;
2452
2453 rc = setattr_prepare(direntry, attrs);
2454 if (rc < 0) {
2455 free_xid(xid);
2456 return rc;
2457 }
2458
2459 full_path = build_path_from_dentry(direntry);
2460 if (full_path == NULL) {
2461 rc = -ENOMEM;
2462 free_xid(xid);
2463 return rc;
2464 }
2465
2466 /*
2467 * Attempt to flush data before changing attributes. We need to do
2468 * this for ATTR_SIZE and ATTR_MTIME. If the flush of the data
2469 * returns error, store it to report later and continue.
2470 *
2471 * BB: This should be smarter. Why bother flushing pages that
2472 * will be truncated anyway? Also, should we error out here if
2473 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
2474 */
2475 if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2476 rc = filemap_write_and_wait(inode->i_mapping);
2477 if (is_interrupt_error(rc)) {
2478 rc = -ERESTARTSYS;
2479 goto cifs_setattr_exit;
2480 }
2481 mapping_set_error(inode->i_mapping, rc);
2482 }
2483
2484 rc = 0;
2485
2486 if ((attrs->ia_valid & ATTR_MTIME) &&
2487 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2488 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2489 if (!rc) {
2490 tcon = tlink_tcon(wfile->tlink);
2491 rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2492 cifsFileInfo_put(wfile);
2493 if (rc)
2494 goto cifs_setattr_exit;
2495 } else if (rc != -EBADF)
2496 goto cifs_setattr_exit;
2497 else
2498 rc = 0;
2499 }
2500
2501 if (attrs->ia_valid & ATTR_SIZE) {
2502 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2503 if (rc != 0)
2504 goto cifs_setattr_exit;
2505 }
2506
2507 if (attrs->ia_valid & ATTR_UID)
2508 uid = attrs->ia_uid;
2509
2510 if (attrs->ia_valid & ATTR_GID)
2511 gid = attrs->ia_gid;
2512
2513 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2514 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2515 if (uid_valid(uid) || gid_valid(gid)) {
2516 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2517 uid, gid);
2518 if (rc) {
2519 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2520 __func__, rc);
2521 goto cifs_setattr_exit;
2522 }
2523 }
2524 } else
2525 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2526 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2527
2528 /* skip mode change if it's just for clearing setuid/setgid */
2529 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2530 attrs->ia_valid &= ~ATTR_MODE;
2531
2532 if (attrs->ia_valid & ATTR_MODE) {
2533 mode = attrs->ia_mode;
2534 rc = 0;
2535 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2536 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2537 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2538 INVALID_UID, INVALID_GID);
2539 if (rc) {
2540 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2541 __func__, rc);
2542 goto cifs_setattr_exit;
2543 }
2544 } else
2545 if (((mode & S_IWUGO) == 0) &&
2546 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2547
2548 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2549
2550 /* fix up mode if we're not using dynperm */
2551 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2552 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2553 } else if ((mode & S_IWUGO) &&
2554 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2555
2556 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2557 /* Attributes of 0 are ignored */
2558 if (dosattr == 0)
2559 dosattr |= ATTR_NORMAL;
2560
2561 /* reset local inode permissions to normal */
2562 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2563 attrs->ia_mode &= ~(S_IALLUGO);
2564 if (S_ISDIR(inode->i_mode))
2565 attrs->ia_mode |=
2566 cifs_sb->mnt_dir_mode;
2567 else
2568 attrs->ia_mode |=
2569 cifs_sb->mnt_file_mode;
2570 }
2571 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2572 /* ignore mode change - ATTR_READONLY hasn't changed */
2573 attrs->ia_valid &= ~ATTR_MODE;
2574 }
2575 }
2576
2577 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2578 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2579 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2580 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2581
2582 /* Even if error on time set, no sense failing the call if
2583 the server would set the time to a reasonable value anyway,
2584 and this check ensures that we are not being called from
2585 sys_utimes in which case we ought to fail the call back to
2586 the user when the server rejects the call */
2587 if ((rc) && (attrs->ia_valid &
2588 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2589 rc = 0;
2590 }
2591
2592 /* do not need local check to inode_check_ok since the server does
2593 that */
2594 if (rc)
2595 goto cifs_setattr_exit;
2596
2597 if ((attrs->ia_valid & ATTR_SIZE) &&
2598 attrs->ia_size != i_size_read(inode))
2599 truncate_setsize(inode, attrs->ia_size);
2600
2601 setattr_copy(inode, attrs);
2602 mark_inode_dirty(inode);
2603
2604 cifs_setattr_exit:
2605 kfree(full_path);
2606 free_xid(xid);
2607 return rc;
2608 }
2609
2610 int
2611 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2612 {
2613 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2614 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2615 int rc, retries = 0;
2616
2617 do {
2618 if (pTcon->unix_ext)
2619 rc = cifs_setattr_unix(direntry, attrs);
2620 else
2621 rc = cifs_setattr_nounix(direntry, attrs);
2622 retries++;
2623 } while (is_retryable_error(rc) && retries < 2);
2624
2625 /* BB: add cifs_setattr_legacy for really old servers */
2626 return rc;
2627 }
2628
2629 #if 0
2630 void cifs_delete_inode(struct inode *inode)
2631 {
2632 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2633 /* may have to add back in if and when safe distributed caching of
2634 directories added e.g. via FindNotify */
2635 }
2636 #endif
2637