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