]> git.ipfire.org Git - thirdparty/kernel/stable.git/blob - fs/cifs/inode.c
projects / thirdparty / kernel / stable.git / blob
? search:


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