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