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