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