?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix a series of Documentation/ broken file name references
[linux-2.6/btrfs-unstable.git] / fs / cifs / inode.c
blobf4697f548a394dbf5c42f731bf13bd529c9aaea0
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
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 struct timespec ts;
99
100 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
101 __func__, cifs_i->uniqueid);
102
103 if (inode->i_state & I_NEW) {
104 cifs_dbg(FYI, "%s: inode %llu is new\n",
105 __func__, cifs_i->uniqueid);
106 return;
107 }
108
109 /* don't bother with revalidation if we have an oplock */
110 if (CIFS_CACHE_READ(cifs_i)) {
111 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
112 __func__, cifs_i->uniqueid);
113 return;
114 }
115
116 /* revalidate if mtime or size have changed */
117 ts = timespec64_to_timespec(inode->i_mtime);
118 if (timespec_equal(&ts, &fattr->cf_mtime) &&
119 cifs_i->server_eof == fattr->cf_eof) {
120 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
121 __func__, cifs_i->uniqueid);
122 return;
123 }
124
125 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
126 __func__, cifs_i->uniqueid);
127 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
128 }
129
130 /*
131 * copy nlink to the inode, unless it wasn't provided. Provide
132 * sane values if we don't have an existing one and none was provided
133 */
134 static void
135 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
136 {
137 /*
138 * if we're in a situation where we can't trust what we
139 * got from the server (readdir, some non-unix cases)
140 * fake reasonable values
141 */
142 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
143 /* only provide fake values on a new inode */
144 if (inode->i_state & I_NEW) {
145 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
146 set_nlink(inode, 2);
147 else
148 set_nlink(inode, 1);
149 }
150 return;
151 }
152
153 /* we trust the server, so update it */
154 set_nlink(inode, fattr->cf_nlink);
155 }
156
157 /* populate an inode with info from a cifs_fattr struct */
158 void
159 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
160 {
161 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
162 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
163
164 cifs_revalidate_cache(inode, fattr);
165
166 spin_lock(&inode->i_lock);
167 inode->i_atime = timespec_to_timespec64(fattr->cf_atime);
168 inode->i_mtime = timespec_to_timespec64(fattr->cf_mtime);
169 inode->i_ctime = timespec_to_timespec64(fattr->cf_ctime);
170 inode->i_rdev = fattr->cf_rdev;
171 cifs_nlink_fattr_to_inode(inode, fattr);
172 inode->i_uid = fattr->cf_uid;
173 inode->i_gid = fattr->cf_gid;
174
175 /* if dynperm is set, don't clobber existing mode */
176 if (inode->i_state & I_NEW ||
177 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
178 inode->i_mode = fattr->cf_mode;
179
180 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
181
182 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
183 cifs_i->time = 0;
184 else
185 cifs_i->time = jiffies;
186
187 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
188 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
189 else
190 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
191
192 cifs_i->server_eof = fattr->cf_eof;
193 /*
194 * Can't safely change the file size here if the client is writing to
195 * it due to potential races.
196 */
197 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
198 i_size_write(inode, fattr->cf_eof);
199
200 /*
201 * i_blocks is not related to (i_size / i_blksize),
202 * but instead 512 byte (2**9) size is required for
203 * calculating num blocks.
204 */
205 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
206 }
207 spin_unlock(&inode->i_lock);
208
209 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
210 inode->i_flags |= S_AUTOMOUNT;
211 if (inode->i_state & I_NEW)
212 cifs_set_ops(inode);
213 }
214
215 void
216 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
217 {
218 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
219
220 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
221 return;
222
223 fattr->cf_uniqueid = iunique(sb, ROOT_I);
224 }
225
226 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
227 void
228 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
229 struct cifs_sb_info *cifs_sb)
230 {
231 memset(fattr, 0, sizeof(*fattr));
232 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
233 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
234 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
235
236 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
237 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
238 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
239 /* old POSIX extensions don't get create time */
240
241 fattr->cf_mode = le64_to_cpu(info->Permissions);
242
243 /*
244 * Since we set the inode type below we need to mask off
245 * to avoid strange results if bits set above.
246 */
247 fattr->cf_mode &= ~S_IFMT;
248 switch (le32_to_cpu(info->Type)) {
249 case UNIX_FILE:
250 fattr->cf_mode |= S_IFREG;
251 fattr->cf_dtype = DT_REG;
252 break;
253 case UNIX_SYMLINK:
254 fattr->cf_mode |= S_IFLNK;
255 fattr->cf_dtype = DT_LNK;
256 break;
257 case UNIX_DIR:
258 fattr->cf_mode |= S_IFDIR;
259 fattr->cf_dtype = DT_DIR;
260 break;
261 case UNIX_CHARDEV:
262 fattr->cf_mode |= S_IFCHR;
263 fattr->cf_dtype = DT_CHR;
264 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
265 le64_to_cpu(info->DevMinor) & MINORMASK);
266 break;
267 case UNIX_BLOCKDEV:
268 fattr->cf_mode |= S_IFBLK;
269 fattr->cf_dtype = DT_BLK;
270 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
271 le64_to_cpu(info->DevMinor) & MINORMASK);
272 break;
273 case UNIX_FIFO:
274 fattr->cf_mode |= S_IFIFO;
275 fattr->cf_dtype = DT_FIFO;
276 break;
277 case UNIX_SOCKET:
278 fattr->cf_mode |= S_IFSOCK;
279 fattr->cf_dtype = DT_SOCK;
280 break;
281 default:
282 /* safest to call it a file if we do not know */
283 fattr->cf_mode |= S_IFREG;
284 fattr->cf_dtype = DT_REG;
285 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
286 break;
287 }
288
289 fattr->cf_uid = cifs_sb->mnt_uid;
290 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
291 u64 id = le64_to_cpu(info->Uid);
292 if (id < ((uid_t)-1)) {
293 kuid_t uid = make_kuid(&init_user_ns, id);
294 if (uid_valid(uid))
295 fattr->cf_uid = uid;
296 }
297 }
298
299 fattr->cf_gid = cifs_sb->mnt_gid;
300 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
301 u64 id = le64_to_cpu(info->Gid);
302 if (id < ((gid_t)-1)) {
303 kgid_t gid = make_kgid(&init_user_ns, id);
304 if (gid_valid(gid))
305 fattr->cf_gid = gid;
306 }
307 }
308
309 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
310 }
311
312 /*
313 * Fill a cifs_fattr struct with fake inode info.
314 *
315 * Needed to setup cifs_fattr data for the directory which is the
316 * junction to the new submount (ie to setup the fake directory
317 * which represents a DFS referral).
318 */
319 static void
320 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
321 {
322 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
323
324 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
325
326 memset(fattr, 0, sizeof(*fattr));
327 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
328 fattr->cf_uid = cifs_sb->mnt_uid;
329 fattr->cf_gid = cifs_sb->mnt_gid;
330 ktime_get_real_ts(&fattr->cf_mtime);
331 fattr->cf_mtime = timespec_trunc(fattr->cf_mtime, sb->s_time_gran);
332 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
333 fattr->cf_nlink = 2;
334 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
335 }
336
337 static int
338 cifs_get_file_info_unix(struct file *filp)
339 {
340 int rc;
341 unsigned int xid;
342 FILE_UNIX_BASIC_INFO find_data;
343 struct cifs_fattr fattr;
344 struct inode *inode = file_inode(filp);
345 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
346 struct cifsFileInfo *cfile = filp->private_data;
347 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
348
349 xid = get_xid();
350 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
351 if (!rc) {
352 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
353 } else if (rc == -EREMOTE) {
354 cifs_create_dfs_fattr(&fattr, inode->i_sb);
355 rc = 0;
356 }
357
358 cifs_fattr_to_inode(inode, &fattr);
359 free_xid(xid);
360 return rc;
361 }
362
363 int cifs_get_inode_info_unix(struct inode **pinode,
364 const unsigned char *full_path,
365 struct super_block *sb, unsigned int xid)
366 {
367 int rc;
368 FILE_UNIX_BASIC_INFO find_data;
369 struct cifs_fattr fattr;
370 struct cifs_tcon *tcon;
371 struct tcon_link *tlink;
372 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
373
374 cifs_dbg(FYI, "Getting info on %s\n", full_path);
375
376 tlink = cifs_sb_tlink(cifs_sb);
377 if (IS_ERR(tlink))
378 return PTR_ERR(tlink);
379 tcon = tlink_tcon(tlink);
380
381 /* could have done a find first instead but this returns more info */
382 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
383 cifs_sb->local_nls, cifs_remap(cifs_sb));
384 cifs_put_tlink(tlink);
385
386 if (!rc) {
387 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
388 } else if (rc == -EREMOTE) {
389 cifs_create_dfs_fattr(&fattr, sb);
390 rc = 0;
391 } else {
392 return rc;
393 }
394
395 /* check for Minshall+French symlinks */
396 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
397 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
398 full_path);
399 if (tmprc)
400 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
401 }
402
403 if (*pinode == NULL) {
404 /* get new inode */
405 cifs_fill_uniqueid(sb, &fattr);
406 *pinode = cifs_iget(sb, &fattr);
407 if (!*pinode)
408 rc = -ENOMEM;
409 } else {
410 /* we already have inode, update it */
411
412 /* if uniqueid is different, return error */
413 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
414 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
415 rc = -ESTALE;
416 goto cgiiu_exit;
417 }
418
419 /* if filetype is different, return error */
420 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
421 (fattr.cf_mode & S_IFMT))) {
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 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_ts(&fattr->cf_atime);
608 fattr->cf_atime = timespec_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 if (attrs->ia_valid & ATTR_ATIME) {
1126 set_time = true;
1127 info_buf.LastAccessTime =
1128 cpu_to_le64(cifs_UnixTimeToNT(timespec64_to_timespec(attrs->ia_atime)));
1129 } else
1130 info_buf.LastAccessTime = 0;
1131
1132 if (attrs->ia_valid & ATTR_MTIME) {
1133 set_time = true;
1134 info_buf.LastWriteTime =
1135 cpu_to_le64(cifs_UnixTimeToNT(timespec64_to_timespec(attrs->ia_mtime)));
1136 } else
1137 info_buf.LastWriteTime = 0;
1138
1139 /*
1140 * Samba throws this field away, but windows may actually use it.
1141 * Do not set ctime unless other time stamps are changed explicitly
1142 * (i.e. by utimes()) since we would then have a mix of client and
1143 * server times.
1144 */
1145 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1146 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1147 info_buf.ChangeTime =
1148 cpu_to_le64(cifs_UnixTimeToNT(timespec64_to_timespec(attrs->ia_ctime)));
1149 } else
1150 info_buf.ChangeTime = 0;
1151
1152 info_buf.CreationTime = 0; /* don't change */
1153 info_buf.Attributes = cpu_to_le32(dosattr);
1154
1155 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1156 }
1157
1158 /*
1159 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1160 * and rename it to a random name that hopefully won't conflict with
1161 * anything else.
1162 */
1163 int
1164 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1165 const unsigned int xid)
1166 {
1167 int oplock = 0;
1168 int rc;
1169 struct cifs_fid fid;
1170 struct cifs_open_parms oparms;
1171 struct inode *inode = d_inode(dentry);
1172 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1173 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1174 struct tcon_link *tlink;
1175 struct cifs_tcon *tcon;
1176 __u32 dosattr, origattr;
1177 FILE_BASIC_INFO *info_buf = NULL;
1178
1179 tlink = cifs_sb_tlink(cifs_sb);
1180 if (IS_ERR(tlink))
1181 return PTR_ERR(tlink);
1182 tcon = tlink_tcon(tlink);
1183
1184 /*
1185 * We cannot rename the file if the server doesn't support
1186 * CAP_INFOLEVEL_PASSTHRU
1187 */
1188 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1189 rc = -EBUSY;
1190 goto out;
1191 }
1192
1193 oparms.tcon = tcon;
1194 oparms.cifs_sb = cifs_sb;
1195 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1196 oparms.create_options = CREATE_NOT_DIR;
1197 oparms.disposition = FILE_OPEN;
1198 oparms.path = full_path;
1199 oparms.fid = &fid;
1200 oparms.reconnect = false;
1201
1202 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1203 if (rc != 0)
1204 goto out;
1205
1206 origattr = cifsInode->cifsAttrs;
1207 if (origattr == 0)
1208 origattr |= ATTR_NORMAL;
1209
1210 dosattr = origattr & ~ATTR_READONLY;
1211 if (dosattr == 0)
1212 dosattr |= ATTR_NORMAL;
1213 dosattr |= ATTR_HIDDEN;
1214
1215 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1216 if (dosattr != origattr) {
1217 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1218 if (info_buf == NULL) {
1219 rc = -ENOMEM;
1220 goto out_close;
1221 }
1222 info_buf->Attributes = cpu_to_le32(dosattr);
1223 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1224 current->tgid);
1225 /* although we would like to mark the file hidden
1226 if that fails we will still try to rename it */
1227 if (!rc)
1228 cifsInode->cifsAttrs = dosattr;
1229 else
1230 dosattr = origattr; /* since not able to change them */
1231 }
1232
1233 /* rename the file */
1234 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1235 cifs_sb->local_nls,
1236 cifs_remap(cifs_sb));
1237 if (rc != 0) {
1238 rc = -EBUSY;
1239 goto undo_setattr;
1240 }
1241
1242 /* try to set DELETE_ON_CLOSE */
1243 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1244 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1245 current->tgid);
1246 /*
1247 * some samba versions return -ENOENT when we try to set the
1248 * file disposition here. Likely a samba bug, but work around
1249 * it for now. This means that some cifsXXX files may hang
1250 * around after they shouldn't.
1251 *
1252 * BB: remove this hack after more servers have the fix
1253 */
1254 if (rc == -ENOENT)
1255 rc = 0;
1256 else if (rc != 0) {
1257 rc = -EBUSY;
1258 goto undo_rename;
1259 }
1260 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1261 }
1262
1263 out_close:
1264 CIFSSMBClose(xid, tcon, fid.netfid);
1265 out:
1266 kfree(info_buf);
1267 cifs_put_tlink(tlink);
1268 return rc;
1269
1270 /*
1271 * reset everything back to the original state. Don't bother
1272 * dealing with errors here since we can't do anything about
1273 * them anyway.
1274 */
1275 undo_rename:
1276 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1277 cifs_sb->local_nls, cifs_remap(cifs_sb));
1278 undo_setattr:
1279 if (dosattr != origattr) {
1280 info_buf->Attributes = cpu_to_le32(origattr);
1281 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1282 current->tgid))
1283 cifsInode->cifsAttrs = origattr;
1284 }
1285
1286 goto out_close;
1287 }
1288
1289 /* copied from fs/nfs/dir.c with small changes */
1290 static void
1291 cifs_drop_nlink(struct inode *inode)
1292 {
1293 spin_lock(&inode->i_lock);
1294 if (inode->i_nlink > 0)
1295 drop_nlink(inode);
1296 spin_unlock(&inode->i_lock);
1297 }
1298
1299 /*
1300 * If d_inode(dentry) is null (usually meaning the cached dentry
1301 * is a negative dentry) then we would attempt a standard SMB delete, but
1302 * if that fails we can not attempt the fall back mechanisms on EACCESS
1303 * but will return the EACCESS to the caller. Note that the VFS does not call
1304 * unlink on negative dentries currently.
1305 */
1306 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1307 {
1308 int rc = 0;
1309 unsigned int xid;
1310 char *full_path = NULL;
1311 struct inode *inode = d_inode(dentry);
1312 struct cifsInodeInfo *cifs_inode;
1313 struct super_block *sb = dir->i_sb;
1314 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1315 struct tcon_link *tlink;
1316 struct cifs_tcon *tcon;
1317 struct TCP_Server_Info *server;
1318 struct iattr *attrs = NULL;
1319 __u32 dosattr = 0, origattr = 0;
1320
1321 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1322
1323 tlink = cifs_sb_tlink(cifs_sb);
1324 if (IS_ERR(tlink))
1325 return PTR_ERR(tlink);
1326 tcon = tlink_tcon(tlink);
1327 server = tcon->ses->server;
1328
1329 xid = get_xid();
1330
1331 /* Unlink can be called from rename so we can not take the
1332 * sb->s_vfs_rename_mutex here */
1333 full_path = build_path_from_dentry(dentry);
1334 if (full_path == NULL) {
1335 rc = -ENOMEM;
1336 goto unlink_out;
1337 }
1338
1339 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1340 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1341 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1342 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1343 cifs_remap(cifs_sb));
1344 cifs_dbg(FYI, "posix del rc %d\n", rc);
1345 if ((rc == 0) || (rc == -ENOENT))
1346 goto psx_del_no_retry;
1347 }
1348
1349 retry_std_delete:
1350 if (!server->ops->unlink) {
1351 rc = -ENOSYS;
1352 goto psx_del_no_retry;
1353 }
1354
1355 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1356
1357 psx_del_no_retry:
1358 if (!rc) {
1359 if (inode)
1360 cifs_drop_nlink(inode);
1361 } else if (rc == -ENOENT) {
1362 d_drop(dentry);
1363 } else if (rc == -EBUSY) {
1364 if (server->ops->rename_pending_delete) {
1365 rc = server->ops->rename_pending_delete(full_path,
1366 dentry, xid);
1367 if (rc == 0)
1368 cifs_drop_nlink(inode);
1369 }
1370 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1371 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1372 if (attrs == NULL) {
1373 rc = -ENOMEM;
1374 goto out_reval;
1375 }
1376
1377 /* try to reset dos attributes */
1378 cifs_inode = CIFS_I(inode);
1379 origattr = cifs_inode->cifsAttrs;
1380 if (origattr == 0)
1381 origattr |= ATTR_NORMAL;
1382 dosattr = origattr & ~ATTR_READONLY;
1383 if (dosattr == 0)
1384 dosattr |= ATTR_NORMAL;
1385 dosattr |= ATTR_HIDDEN;
1386
1387 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1388 if (rc != 0)
1389 goto out_reval;
1390
1391 goto retry_std_delete;
1392 }
1393
1394 /* undo the setattr if we errored out and it's needed */
1395 if (rc != 0 && dosattr != 0)
1396 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1397
1398 out_reval:
1399 if (inode) {
1400 cifs_inode = CIFS_I(inode);
1401 cifs_inode->time = 0; /* will force revalidate to get info
1402 when needed */
1403 inode->i_ctime = current_time(inode);
1404 }
1405 dir->i_ctime = dir->i_mtime = current_time(dir);
1406 cifs_inode = CIFS_I(dir);
1407 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1408 unlink_out:
1409 kfree(full_path);
1410 kfree(attrs);
1411 free_xid(xid);
1412 cifs_put_tlink(tlink);
1413 return rc;
1414 }
1415
1416 static int
1417 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1418 const char *full_path, struct cifs_sb_info *cifs_sb,
1419 struct cifs_tcon *tcon, const unsigned int xid)
1420 {
1421 int rc = 0;
1422 struct inode *inode = NULL;
1423
1424 if (tcon->unix_ext)
1425 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1426 xid);
1427 else
1428 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1429 xid, NULL);
1430
1431 if (rc)
1432 return rc;
1433
1434 /*
1435 * setting nlink not necessary except in cases where we failed to get it
1436 * from the server or was set bogus. Also, since this is a brand new
1437 * inode, no need to grab the i_lock before setting the i_nlink.
1438 */
1439 if (inode->i_nlink < 2)
1440 set_nlink(inode, 2);
1441 mode &= ~current_umask();
1442 /* must turn on setgid bit if parent dir has it */
1443 if (parent->i_mode & S_ISGID)
1444 mode |= S_ISGID;
1445
1446 if (tcon->unix_ext) {
1447 struct cifs_unix_set_info_args args = {
1448 .mode = mode,
1449 .ctime = NO_CHANGE_64,
1450 .atime = NO_CHANGE_64,
1451 .mtime = NO_CHANGE_64,
1452 .device = 0,
1453 };
1454 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1455 args.uid = current_fsuid();
1456 if (parent->i_mode & S_ISGID)
1457 args.gid = parent->i_gid;
1458 else
1459 args.gid = current_fsgid();
1460 } else {
1461 args.uid = INVALID_UID; /* no change */
1462 args.gid = INVALID_GID; /* no change */
1463 }
1464 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1465 cifs_sb->local_nls,
1466 cifs_remap(cifs_sb));
1467 } else {
1468 struct TCP_Server_Info *server = tcon->ses->server;
1469 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1470 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1471 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1472 tcon, xid);
1473 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1474 inode->i_mode = (mode | S_IFDIR);
1475
1476 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1477 inode->i_uid = current_fsuid();
1478 if (inode->i_mode & S_ISGID)
1479 inode->i_gid = parent->i_gid;
1480 else
1481 inode->i_gid = current_fsgid();
1482 }
1483 }
1484 d_instantiate(dentry, inode);
1485 return rc;
1486 }
1487
1488 static int
1489 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1490 const char *full_path, struct cifs_sb_info *cifs_sb,
1491 struct cifs_tcon *tcon, const unsigned int xid)
1492 {
1493 int rc = 0;
1494 u32 oplock = 0;
1495 FILE_UNIX_BASIC_INFO *info = NULL;
1496 struct inode *newinode = NULL;
1497 struct cifs_fattr fattr;
1498
1499 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1500 if (info == NULL) {
1501 rc = -ENOMEM;
1502 goto posix_mkdir_out;
1503 }
1504
1505 mode &= ~current_umask();
1506 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1507 NULL /* netfid */, info, &oplock, full_path,
1508 cifs_sb->local_nls, cifs_remap(cifs_sb));
1509 if (rc == -EOPNOTSUPP)
1510 goto posix_mkdir_out;
1511 else if (rc) {
1512 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1513 d_drop(dentry);
1514 goto posix_mkdir_out;
1515 }
1516
1517 if (info->Type == cpu_to_le32(-1))
1518 /* no return info, go query for it */
1519 goto posix_mkdir_get_info;
1520 /*
1521 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1522 * need to set uid/gid.
1523 */
1524
1525 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1526 cifs_fill_uniqueid(inode->i_sb, &fattr);
1527 newinode = cifs_iget(inode->i_sb, &fattr);
1528 if (!newinode)
1529 goto posix_mkdir_get_info;
1530
1531 d_instantiate(dentry, newinode);
1532
1533 #ifdef CONFIG_CIFS_DEBUG2
1534 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1535 dentry, dentry, newinode);
1536
1537 if (newinode->i_nlink != 2)
1538 cifs_dbg(FYI, "unexpected number of links %d\n",
1539 newinode->i_nlink);
1540 #endif
1541
1542 posix_mkdir_out:
1543 kfree(info);
1544 return rc;
1545 posix_mkdir_get_info:
1546 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1547 xid);
1548 goto posix_mkdir_out;
1549 }
1550
1551 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1552 {
1553 int rc = 0;
1554 unsigned int xid;
1555 struct cifs_sb_info *cifs_sb;
1556 struct tcon_link *tlink;
1557 struct cifs_tcon *tcon;
1558 struct TCP_Server_Info *server;
1559 char *full_path;
1560
1561 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1562 mode, inode);
1563
1564 cifs_sb = CIFS_SB(inode->i_sb);
1565 tlink = cifs_sb_tlink(cifs_sb);
1566 if (IS_ERR(tlink))
1567 return PTR_ERR(tlink);
1568 tcon = tlink_tcon(tlink);
1569
1570 xid = get_xid();
1571
1572 full_path = build_path_from_dentry(direntry);
1573 if (full_path == NULL) {
1574 rc = -ENOMEM;
1575 goto mkdir_out;
1576 }
1577
1578 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1579 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1580 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1581 tcon, xid);
1582 if (rc != -EOPNOTSUPP)
1583 goto mkdir_out;
1584 }
1585
1586 server = tcon->ses->server;
1587
1588 if (!server->ops->mkdir) {
1589 rc = -ENOSYS;
1590 goto mkdir_out;
1591 }
1592
1593 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1594 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1595 if (rc) {
1596 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1597 d_drop(direntry);
1598 goto mkdir_out;
1599 }
1600
1601 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1602 xid);
1603 mkdir_out:
1604 /*
1605 * Force revalidate to get parent dir info when needed since cached
1606 * attributes are invalid now.
1607 */
1608 CIFS_I(inode)->time = 0;
1609 kfree(full_path);
1610 free_xid(xid);
1611 cifs_put_tlink(tlink);
1612 return rc;
1613 }
1614
1615 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1616 {
1617 int rc = 0;
1618 unsigned int xid;
1619 struct cifs_sb_info *cifs_sb;
1620 struct tcon_link *tlink;
1621 struct cifs_tcon *tcon;
1622 struct TCP_Server_Info *server;
1623 char *full_path = NULL;
1624 struct cifsInodeInfo *cifsInode;
1625
1626 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1627
1628 xid = get_xid();
1629
1630 full_path = build_path_from_dentry(direntry);
1631 if (full_path == NULL) {
1632 rc = -ENOMEM;
1633 goto rmdir_exit;
1634 }
1635
1636 cifs_sb = CIFS_SB(inode->i_sb);
1637 tlink = cifs_sb_tlink(cifs_sb);
1638 if (IS_ERR(tlink)) {
1639 rc = PTR_ERR(tlink);
1640 goto rmdir_exit;
1641 }
1642 tcon = tlink_tcon(tlink);
1643 server = tcon->ses->server;
1644
1645 if (!server->ops->rmdir) {
1646 rc = -ENOSYS;
1647 cifs_put_tlink(tlink);
1648 goto rmdir_exit;
1649 }
1650
1651 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1652 cifs_put_tlink(tlink);
1653
1654 if (!rc) {
1655 spin_lock(&d_inode(direntry)->i_lock);
1656 i_size_write(d_inode(direntry), 0);
1657 clear_nlink(d_inode(direntry));
1658 spin_unlock(&d_inode(direntry)->i_lock);
1659 }
1660
1661 cifsInode = CIFS_I(d_inode(direntry));
1662 /* force revalidate to go get info when needed */
1663 cifsInode->time = 0;
1664
1665 cifsInode = CIFS_I(inode);
1666 /*
1667 * Force revalidate to get parent dir info when needed since cached
1668 * attributes are invalid now.
1669 */
1670 cifsInode->time = 0;
1671
1672 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1673 current_time(inode);
1674
1675 rmdir_exit:
1676 kfree(full_path);
1677 free_xid(xid);
1678 return rc;
1679 }
1680
1681 static int
1682 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1683 const char *from_path, struct dentry *to_dentry,
1684 const char *to_path)
1685 {
1686 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1687 struct tcon_link *tlink;
1688 struct cifs_tcon *tcon;
1689 struct TCP_Server_Info *server;
1690 struct cifs_fid fid;
1691 struct cifs_open_parms oparms;
1692 int oplock, rc;
1693
1694 tlink = cifs_sb_tlink(cifs_sb);
1695 if (IS_ERR(tlink))
1696 return PTR_ERR(tlink);
1697 tcon = tlink_tcon(tlink);
1698 server = tcon->ses->server;
1699
1700 if (!server->ops->rename)
1701 return -ENOSYS;
1702
1703 /* try path-based rename first */
1704 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1705
1706 /*
1707 * Don't bother with rename by filehandle unless file is busy and
1708 * source. Note that cross directory moves do not work with
1709 * rename by filehandle to various Windows servers.
1710 */
1711 if (rc == 0 || rc != -EBUSY)
1712 goto do_rename_exit;
1713
1714 /* open-file renames don't work across directories */
1715 if (to_dentry->d_parent != from_dentry->d_parent)
1716 goto do_rename_exit;
1717
1718 oparms.tcon = tcon;
1719 oparms.cifs_sb = cifs_sb;
1720 /* open the file to be renamed -- we need DELETE perms */
1721 oparms.desired_access = DELETE;
1722 oparms.create_options = CREATE_NOT_DIR;
1723 oparms.disposition = FILE_OPEN;
1724 oparms.path = from_path;
1725 oparms.fid = &fid;
1726 oparms.reconnect = false;
1727
1728 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1729 if (rc == 0) {
1730 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1731 (const char *) to_dentry->d_name.name,
1732 cifs_sb->local_nls, cifs_remap(cifs_sb));
1733 CIFSSMBClose(xid, tcon, fid.netfid);
1734 }
1735 do_rename_exit:
1736 cifs_put_tlink(tlink);
1737 return rc;
1738 }
1739
1740 int
1741 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1742 struct inode *target_dir, struct dentry *target_dentry,
1743 unsigned int flags)
1744 {
1745 char *from_name = NULL;
1746 char *to_name = NULL;
1747 struct cifs_sb_info *cifs_sb;
1748 struct tcon_link *tlink;
1749 struct cifs_tcon *tcon;
1750 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1751 FILE_UNIX_BASIC_INFO *info_buf_target;
1752 unsigned int xid;
1753 int rc, tmprc;
1754
1755 if (flags & ~RENAME_NOREPLACE)
1756 return -EINVAL;
1757
1758 cifs_sb = CIFS_SB(source_dir->i_sb);
1759 tlink = cifs_sb_tlink(cifs_sb);
1760 if (IS_ERR(tlink))
1761 return PTR_ERR(tlink);
1762 tcon = tlink_tcon(tlink);
1763
1764 xid = get_xid();
1765
1766 /*
1767 * we already have the rename sem so we do not need to
1768 * grab it again here to protect the path integrity
1769 */
1770 from_name = build_path_from_dentry(source_dentry);
1771 if (from_name == NULL) {
1772 rc = -ENOMEM;
1773 goto cifs_rename_exit;
1774 }
1775
1776 to_name = build_path_from_dentry(target_dentry);
1777 if (to_name == NULL) {
1778 rc = -ENOMEM;
1779 goto cifs_rename_exit;
1780 }
1781
1782 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1783 to_name);
1784
1785 /*
1786 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1787 */
1788 if (flags & RENAME_NOREPLACE)
1789 goto cifs_rename_exit;
1790
1791 if (rc == -EEXIST && tcon->unix_ext) {
1792 /*
1793 * Are src and dst hardlinks of same inode? We can only tell
1794 * with unix extensions enabled.
1795 */
1796 info_buf_source =
1797 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
1798 GFP_KERNEL);
1799 if (info_buf_source == NULL) {
1800 rc = -ENOMEM;
1801 goto cifs_rename_exit;
1802 }
1803
1804 info_buf_target = info_buf_source + 1;
1805 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1806 info_buf_source,
1807 cifs_sb->local_nls,
1808 cifs_remap(cifs_sb));
1809 if (tmprc != 0)
1810 goto unlink_target;
1811
1812 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1813 info_buf_target,
1814 cifs_sb->local_nls,
1815 cifs_remap(cifs_sb));
1816
1817 if (tmprc == 0 && (info_buf_source->UniqueId ==
1818 info_buf_target->UniqueId)) {
1819 /* same file, POSIX says that this is a noop */
1820 rc = 0;
1821 goto cifs_rename_exit;
1822 }
1823 }
1824 /*
1825 * else ... BB we could add the same check for Windows by
1826 * checking the UniqueId via FILE_INTERNAL_INFO
1827 */
1828
1829 unlink_target:
1830 /* Try unlinking the target dentry if it's not negative */
1831 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1832 if (d_is_dir(target_dentry))
1833 tmprc = cifs_rmdir(target_dir, target_dentry);
1834 else
1835 tmprc = cifs_unlink(target_dir, target_dentry);
1836 if (tmprc)
1837 goto cifs_rename_exit;
1838 rc = cifs_do_rename(xid, source_dentry, from_name,
1839 target_dentry, to_name);
1840 }
1841
1842 /* force revalidate to go get info when needed */
1843 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1844
1845 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1846 target_dir->i_mtime = current_time(source_dir);
1847
1848 cifs_rename_exit:
1849 kfree(info_buf_source);
1850 kfree(from_name);
1851 kfree(to_name);
1852 free_xid(xid);
1853 cifs_put_tlink(tlink);
1854 return rc;
1855 }
1856
1857 static bool
1858 cifs_inode_needs_reval(struct inode *inode)
1859 {
1860 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1861 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1862
1863 if (cifs_i->time == 0)
1864 return true;
1865
1866 if (CIFS_CACHE_READ(cifs_i))
1867 return false;
1868
1869 if (!lookupCacheEnabled)
1870 return true;
1871
1872 if (!cifs_sb->actimeo)
1873 return true;
1874
1875 if (!time_in_range(jiffies, cifs_i->time,
1876 cifs_i->time + cifs_sb->actimeo))
1877 return true;
1878
1879 /* hardlinked files w/ noserverino get "special" treatment */
1880 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1881 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1882 return true;
1883
1884 return false;
1885 }
1886
1887 /*
1888 * Zap the cache. Called when invalid_mapping flag is set.
1889 */
1890 int
1891 cifs_invalidate_mapping(struct inode *inode)
1892 {
1893 int rc = 0;
1894
1895 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1896 rc = invalidate_inode_pages2(inode->i_mapping);
1897 if (rc)
1898 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1899 __func__, inode);
1900 }
1901
1902 cifs_fscache_reset_inode_cookie(inode);
1903 return rc;
1904 }
1905
1906 /**
1907 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1908 * @word: long word containing the bit lock
1909 */
1910 static int
1911 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
1912 {
1913 freezable_schedule_unsafe();
1914 if (signal_pending_state(mode, current))
1915 return -ERESTARTSYS;
1916 return 0;
1917 }
1918
1919 int
1920 cifs_revalidate_mapping(struct inode *inode)
1921 {
1922 int rc;
1923 unsigned long *flags = &CIFS_I(inode)->flags;
1924
1925 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1926 TASK_KILLABLE);
1927 if (rc)
1928 return rc;
1929
1930 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1931 rc = cifs_invalidate_mapping(inode);
1932 if (rc)
1933 set_bit(CIFS_INO_INVALID_MAPPING, flags);
1934 }
1935
1936 clear_bit_unlock(CIFS_INO_LOCK, flags);
1937 smp_mb__after_atomic();
1938 wake_up_bit(flags, CIFS_INO_LOCK);
1939
1940 return rc;
1941 }
1942
1943 int
1944 cifs_zap_mapping(struct inode *inode)
1945 {
1946 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1947 return cifs_revalidate_mapping(inode);
1948 }
1949
1950 int cifs_revalidate_file_attr(struct file *filp)
1951 {
1952 int rc = 0;
1953 struct inode *inode = file_inode(filp);
1954 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1955
1956 if (!cifs_inode_needs_reval(inode))
1957 return rc;
1958
1959 if (tlink_tcon(cfile->tlink)->unix_ext)
1960 rc = cifs_get_file_info_unix(filp);
1961 else
1962 rc = cifs_get_file_info(filp);
1963
1964 return rc;
1965 }
1966
1967 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1968 {
1969 unsigned int xid;
1970 int rc = 0;
1971 struct inode *inode = d_inode(dentry);
1972 struct super_block *sb = dentry->d_sb;
1973 char *full_path = NULL;
1974
1975 if (inode == NULL)
1976 return -ENOENT;
1977
1978 if (!cifs_inode_needs_reval(inode))
1979 return rc;
1980
1981 xid = get_xid();
1982
1983 /* can not safely grab the rename sem here if rename calls revalidate
1984 since that would deadlock */
1985 full_path = build_path_from_dentry(dentry);
1986 if (full_path == NULL) {
1987 rc = -ENOMEM;
1988 goto out;
1989 }
1990
1991 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1992 full_path, inode, inode->i_count.counter,
1993 dentry, cifs_get_time(dentry), jiffies);
1994
1995 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1996 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1997 else
1998 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1999 xid, NULL);
2000
2001 out:
2002 kfree(full_path);
2003 free_xid(xid);
2004 return rc;
2005 }
2006
2007 int cifs_revalidate_file(struct file *filp)
2008 {
2009 int rc;
2010 struct inode *inode = file_inode(filp);
2011
2012 rc = cifs_revalidate_file_attr(filp);
2013 if (rc)
2014 return rc;
2015
2016 return cifs_revalidate_mapping(inode);
2017 }
2018
2019 /* revalidate a dentry's inode attributes */
2020 int cifs_revalidate_dentry(struct dentry *dentry)
2021 {
2022 int rc;
2023 struct inode *inode = d_inode(dentry);
2024
2025 rc = cifs_revalidate_dentry_attr(dentry);
2026 if (rc)
2027 return rc;
2028
2029 return cifs_revalidate_mapping(inode);
2030 }
2031
2032 int cifs_getattr(const struct path *path, struct kstat *stat,
2033 u32 request_mask, unsigned int flags)
2034 {
2035 struct dentry *dentry = path->dentry;
2036 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2037 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2038 struct inode *inode = d_inode(dentry);
2039 int rc;
2040
2041 /*
2042 * We need to be sure that all dirty pages are written and the server
2043 * has actual ctime, mtime and file length.
2044 */
2045 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2046 inode->i_mapping->nrpages != 0) {
2047 rc = filemap_fdatawait(inode->i_mapping);
2048 if (rc) {
2049 mapping_set_error(inode->i_mapping, rc);
2050 return rc;
2051 }
2052 }
2053
2054 rc = cifs_revalidate_dentry_attr(dentry);
2055 if (rc)
2056 return rc;
2057
2058 generic_fillattr(inode, stat);
2059 stat->blksize = CIFS_MAX_MSGSIZE;
2060 stat->ino = CIFS_I(inode)->uniqueid;
2061
2062 /* old CIFS Unix Extensions doesn't return create time */
2063 if (CIFS_I(inode)->createtime) {
2064 stat->result_mask |= STATX_BTIME;
2065 stat->btime = timespec_to_timespec64(
2066 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime)));
2067 }
2068
2069 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2070 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2071 stat->attributes |= STATX_ATTR_COMPRESSED;
2072 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2073 stat->attributes |= STATX_ATTR_ENCRYPTED;
2074
2075 /*
2076 * If on a multiuser mount without unix extensions or cifsacl being
2077 * enabled, and the admin hasn't overridden them, set the ownership
2078 * to the fsuid/fsgid of the current process.
2079 */
2080 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2081 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2082 !tcon->unix_ext) {
2083 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2084 stat->uid = current_fsuid();
2085 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2086 stat->gid = current_fsgid();
2087 }
2088 return rc;
2089 }
2090
2091 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2092 {
2093 pgoff_t index = from >> PAGE_SHIFT;
2094 unsigned offset = from & (PAGE_SIZE - 1);
2095 struct page *page;
2096 int rc = 0;
2097
2098 page = grab_cache_page(mapping, index);
2099 if (!page)
2100 return -ENOMEM;
2101
2102 zero_user_segment(page, offset, PAGE_SIZE);
2103 unlock_page(page);
2104 put_page(page);
2105 return rc;
2106 }
2107
2108 static void cifs_setsize(struct inode *inode, loff_t offset)
2109 {
2110 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2111
2112 spin_lock(&inode->i_lock);
2113 i_size_write(inode, offset);
2114 spin_unlock(&inode->i_lock);
2115
2116 /* Cached inode must be refreshed on truncate */
2117 cifs_i->time = 0;
2118 truncate_pagecache(inode, offset);
2119 }
2120
2121 static int
2122 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2123 unsigned int xid, char *full_path)
2124 {
2125 int rc;
2126 struct cifsFileInfo *open_file;
2127 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2128 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2129 struct tcon_link *tlink = NULL;
2130 struct cifs_tcon *tcon = NULL;
2131 struct TCP_Server_Info *server;
2132
2133 /*
2134 * To avoid spurious oplock breaks from server, in the case of
2135 * inodes that we already have open, avoid doing path based
2136 * setting of file size if we can do it by handle.
2137 * This keeps our caching token (oplock) and avoids timeouts
2138 * when the local oplock break takes longer to flush
2139 * writebehind data than the SMB timeout for the SetPathInfo
2140 * request would allow
2141 */
2142 open_file = find_writable_file(cifsInode, true);
2143 if (open_file) {
2144 tcon = tlink_tcon(open_file->tlink);
2145 server = tcon->ses->server;
2146 if (server->ops->set_file_size)
2147 rc = server->ops->set_file_size(xid, tcon, open_file,
2148 attrs->ia_size, false);
2149 else
2150 rc = -ENOSYS;
2151 cifsFileInfo_put(open_file);
2152 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2153 } else
2154 rc = -EINVAL;
2155
2156 if (!rc)
2157 goto set_size_out;
2158
2159 if (tcon == NULL) {
2160 tlink = cifs_sb_tlink(cifs_sb);
2161 if (IS_ERR(tlink))
2162 return PTR_ERR(tlink);
2163 tcon = tlink_tcon(tlink);
2164 server = tcon->ses->server;
2165 }
2166
2167 /*
2168 * Set file size by pathname rather than by handle either because no
2169 * valid, writeable file handle for it was found or because there was
2170 * an error setting it by handle.
2171 */
2172 if (server->ops->set_path_size)
2173 rc = server->ops->set_path_size(xid, tcon, full_path,
2174 attrs->ia_size, cifs_sb, false);
2175 else
2176 rc = -ENOSYS;
2177 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2178
2179 if (tlink)
2180 cifs_put_tlink(tlink);
2181
2182 set_size_out:
2183 if (rc == 0) {
2184 cifsInode->server_eof = attrs->ia_size;
2185 cifs_setsize(inode, attrs->ia_size);
2186 cifs_truncate_page(inode->i_mapping, inode->i_size);
2187 }
2188
2189 return rc;
2190 }
2191
2192 static int
2193 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2194 {
2195 int rc;
2196 unsigned int xid;
2197 char *full_path = NULL;
2198 struct inode *inode = d_inode(direntry);
2199 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2200 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2201 struct tcon_link *tlink;
2202 struct cifs_tcon *pTcon;
2203 struct cifs_unix_set_info_args *args = NULL;
2204 struct cifsFileInfo *open_file;
2205
2206 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2207 direntry, attrs->ia_valid);
2208
2209 xid = get_xid();
2210
2211 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2212 attrs->ia_valid |= ATTR_FORCE;
2213
2214 rc = setattr_prepare(direntry, attrs);
2215 if (rc < 0)
2216 goto out;
2217
2218 full_path = build_path_from_dentry(direntry);
2219 if (full_path == NULL) {
2220 rc = -ENOMEM;
2221 goto out;
2222 }
2223
2224 /*
2225 * Attempt to flush data before changing attributes. We need to do
2226 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2227 * ownership or mode then we may also need to do this. Here, we take
2228 * the safe way out and just do the flush on all setattr requests. If
2229 * the flush returns error, store it to report later and continue.
2230 *
2231 * BB: This should be smarter. Why bother flushing pages that
2232 * will be truncated anyway? Also, should we error out here if
2233 * the flush returns error?
2234 */
2235 rc = filemap_write_and_wait(inode->i_mapping);
2236 mapping_set_error(inode->i_mapping, rc);
2237 rc = 0;
2238
2239 if (attrs->ia_valid & ATTR_SIZE) {
2240 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2241 if (rc != 0)
2242 goto out;
2243 }
2244
2245 /* skip mode change if it's just for clearing setuid/setgid */
2246 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2247 attrs->ia_valid &= ~ATTR_MODE;
2248
2249 args = kmalloc(sizeof(*args), GFP_KERNEL);
2250 if (args == NULL) {
2251 rc = -ENOMEM;
2252 goto out;
2253 }
2254
2255 /* set up the struct */
2256 if (attrs->ia_valid & ATTR_MODE)
2257 args->mode = attrs->ia_mode;
2258 else
2259 args->mode = NO_CHANGE_64;
2260
2261 if (attrs->ia_valid & ATTR_UID)
2262 args->uid = attrs->ia_uid;
2263 else
2264 args->uid = INVALID_UID; /* no change */
2265
2266 if (attrs->ia_valid & ATTR_GID)
2267 args->gid = attrs->ia_gid;
2268 else
2269 args->gid = INVALID_GID; /* no change */
2270
2271 if (attrs->ia_valid & ATTR_ATIME)
2272 args->atime = cifs_UnixTimeToNT(timespec64_to_timespec(attrs->ia_atime));
2273 else
2274 args->atime = NO_CHANGE_64;
2275
2276 if (attrs->ia_valid & ATTR_MTIME)
2277 args->mtime = cifs_UnixTimeToNT(timespec64_to_timespec(attrs->ia_mtime));
2278 else
2279 args->mtime = NO_CHANGE_64;
2280
2281 if (attrs->ia_valid & ATTR_CTIME)
2282 args->ctime = cifs_UnixTimeToNT(timespec64_to_timespec(attrs->ia_ctime));
2283 else
2284 args->ctime = NO_CHANGE_64;
2285
2286 args->device = 0;
2287 open_file = find_writable_file(cifsInode, true);
2288 if (open_file) {
2289 u16 nfid = open_file->fid.netfid;
2290 u32 npid = open_file->pid;
2291 pTcon = tlink_tcon(open_file->tlink);
2292 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2293 cifsFileInfo_put(open_file);
2294 } else {
2295 tlink = cifs_sb_tlink(cifs_sb);
2296 if (IS_ERR(tlink)) {
2297 rc = PTR_ERR(tlink);
2298 goto out;
2299 }
2300 pTcon = tlink_tcon(tlink);
2301 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2302 cifs_sb->local_nls,
2303 cifs_remap(cifs_sb));
2304 cifs_put_tlink(tlink);
2305 }
2306
2307 if (rc)
2308 goto out;
2309
2310 if ((attrs->ia_valid & ATTR_SIZE) &&
2311 attrs->ia_size != i_size_read(inode))
2312 truncate_setsize(inode, attrs->ia_size);
2313
2314 setattr_copy(inode, attrs);
2315 mark_inode_dirty(inode);
2316
2317 /* force revalidate when any of these times are set since some
2318 of the fs types (eg ext3, fat) do not have fine enough
2319 time granularity to match protocol, and we do not have a
2320 a way (yet) to query the server fs's time granularity (and
2321 whether it rounds times down).
2322 */
2323 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2324 cifsInode->time = 0;
2325 out:
2326 kfree(args);
2327 kfree(full_path);
2328 free_xid(xid);
2329 return rc;
2330 }
2331
2332 static int
2333 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2334 {
2335 unsigned int xid;
2336 kuid_t uid = INVALID_UID;
2337 kgid_t gid = INVALID_GID;
2338 struct inode *inode = d_inode(direntry);
2339 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2340 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2341 char *full_path = NULL;
2342 int rc = -EACCES;
2343 __u32 dosattr = 0;
2344 __u64 mode = NO_CHANGE_64;
2345
2346 xid = get_xid();
2347
2348 cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2349 direntry, attrs->ia_valid);
2350
2351 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2352 attrs->ia_valid |= ATTR_FORCE;
2353
2354 rc = setattr_prepare(direntry, attrs);
2355 if (rc < 0) {
2356 free_xid(xid);
2357 return rc;
2358 }
2359
2360 full_path = build_path_from_dentry(direntry);
2361 if (full_path == NULL) {
2362 rc = -ENOMEM;
2363 free_xid(xid);
2364 return rc;
2365 }
2366
2367 /*
2368 * Attempt to flush data before changing attributes. We need to do
2369 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2370 * ownership or mode then we may also need to do this. Here, we take
2371 * the safe way out and just do the flush on all setattr requests. If
2372 * the flush returns error, store it to report later and continue.
2373 *
2374 * BB: This should be smarter. Why bother flushing pages that
2375 * will be truncated anyway? Also, should we error out here if
2376 * the flush returns error?
2377 */
2378 rc = filemap_write_and_wait(inode->i_mapping);
2379 mapping_set_error(inode->i_mapping, rc);
2380 rc = 0;
2381
2382 if (attrs->ia_valid & ATTR_SIZE) {
2383 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2384 if (rc != 0)
2385 goto cifs_setattr_exit;
2386 }
2387
2388 if (attrs->ia_valid & ATTR_UID)
2389 uid = attrs->ia_uid;
2390
2391 if (attrs->ia_valid & ATTR_GID)
2392 gid = attrs->ia_gid;
2393
2394 #ifdef CONFIG_CIFS_ACL
2395 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2396 if (uid_valid(uid) || gid_valid(gid)) {
2397 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2398 uid, gid);
2399 if (rc) {
2400 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2401 __func__, rc);
2402 goto cifs_setattr_exit;
2403 }
2404 }
2405 } else
2406 #endif /* CONFIG_CIFS_ACL */
2407 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2408 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2409
2410 /* skip mode change if it's just for clearing setuid/setgid */
2411 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2412 attrs->ia_valid &= ~ATTR_MODE;
2413
2414 if (attrs->ia_valid & ATTR_MODE) {
2415 mode = attrs->ia_mode;
2416 rc = 0;
2417 #ifdef CONFIG_CIFS_ACL
2418 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2419 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2420 INVALID_UID, INVALID_GID);
2421 if (rc) {
2422 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2423 __func__, rc);
2424 goto cifs_setattr_exit;
2425 }
2426 } else
2427 #endif /* CONFIG_CIFS_ACL */
2428 if (((mode & S_IWUGO) == 0) &&
2429 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2430
2431 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2432
2433 /* fix up mode if we're not using dynperm */
2434 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2435 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2436 } else if ((mode & S_IWUGO) &&
2437 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2438
2439 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2440 /* Attributes of 0 are ignored */
2441 if (dosattr == 0)
2442 dosattr |= ATTR_NORMAL;
2443
2444 /* reset local inode permissions to normal */
2445 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2446 attrs->ia_mode &= ~(S_IALLUGO);
2447 if (S_ISDIR(inode->i_mode))
2448 attrs->ia_mode |=
2449 cifs_sb->mnt_dir_mode;
2450 else
2451 attrs->ia_mode |=
2452 cifs_sb->mnt_file_mode;
2453 }
2454 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2455 /* ignore mode change - ATTR_READONLY hasn't changed */
2456 attrs->ia_valid &= ~ATTR_MODE;
2457 }
2458 }
2459
2460 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2461 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2462 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2463 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2464
2465 /* Even if error on time set, no sense failing the call if
2466 the server would set the time to a reasonable value anyway,
2467 and this check ensures that we are not being called from
2468 sys_utimes in which case we ought to fail the call back to
2469 the user when the server rejects the call */
2470 if ((rc) && (attrs->ia_valid &
2471 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2472 rc = 0;
2473 }
2474
2475 /* do not need local check to inode_check_ok since the server does
2476 that */
2477 if (rc)
2478 goto cifs_setattr_exit;
2479
2480 if ((attrs->ia_valid & ATTR_SIZE) &&
2481 attrs->ia_size != i_size_read(inode))
2482 truncate_setsize(inode, attrs->ia_size);
2483
2484 setattr_copy(inode, attrs);
2485 mark_inode_dirty(inode);
2486
2487 cifs_setattr_exit:
2488 kfree(full_path);
2489 free_xid(xid);
2490 return rc;
2491 }
2492
2493 int
2494 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2495 {
2496 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2497 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2498
2499 if (pTcon->unix_ext)
2500 return cifs_setattr_unix(direntry, attrs);
2501
2502 return cifs_setattr_nounix(direntry, attrs);
2503
2504 /* BB: add cifs_setattr_legacy for really old servers */
2505 }
2506
2507 #if 0
2508 void cifs_delete_inode(struct inode *inode)
2509 {
2510 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2511 /* may have to add back in if and when safe distributed caching of
2512 directories added e.g. via FindNotify */
2513 }
2514 #endif
(deprecated) Btrfs devel tree