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