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