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 #define POSIX_TYPE_FILE 0
667 #define POSIX_TYPE_DIR 1
668 #define POSIX_TYPE_SYMLINK 2
669 #define POSIX_TYPE_CHARDEV 3
670 #define POSIX_TYPE_BLKDEV 4
671 #define POSIX_TYPE_FIFO 5
672 #define POSIX_TYPE_SOCKET 6
673
674 #define POSIX_X_OTH 0000001
675 #define POSIX_W_OTH 0000002
676 #define POSIX_R_OTH 0000004
677 #define POSIX_X_GRP 0000010
678 #define POSIX_W_GRP 0000020
679 #define POSIX_R_GRP 0000040
680 #define POSIX_X_USR 0000100
681 #define POSIX_W_USR 0000200
682 #define POSIX_R_USR 0000400
683 #define POSIX_STICKY 0001000
684 #define POSIX_SET_GID 0002000
685 #define POSIX_SET_UID 0004000
686
687 #define POSIX_OTH_MASK 0000007
688 #define POSIX_GRP_MASK 0000070
689 #define POSIX_USR_MASK 0000700
690 #define POSIX_PERM_MASK 0000777
691 #define POSIX_FILETYPE_MASK 0070000
692
693 #define POSIX_FILETYPE_SHIFT 12
694
wire_perms_to_posix(u32 wire)695 static u32 wire_perms_to_posix(u32 wire)
696 {
697 u32 mode = 0;
698
699 mode |= (wire & POSIX_X_OTH) ? S_IXOTH : 0;
700 mode |= (wire & POSIX_W_OTH) ? S_IWOTH : 0;
701 mode |= (wire & POSIX_R_OTH) ? S_IROTH : 0;
702 mode |= (wire & POSIX_X_GRP) ? S_IXGRP : 0;
703 mode |= (wire & POSIX_W_GRP) ? S_IWGRP : 0;
704 mode |= (wire & POSIX_R_GRP) ? S_IRGRP : 0;
705 mode |= (wire & POSIX_X_USR) ? S_IXUSR : 0;
706 mode |= (wire & POSIX_W_USR) ? S_IWUSR : 0;
707 mode |= (wire & POSIX_R_USR) ? S_IRUSR : 0;
708 mode |= (wire & POSIX_STICKY) ? S_ISVTX : 0;
709 mode |= (wire & POSIX_SET_GID) ? S_ISGID : 0;
710 mode |= (wire & POSIX_SET_UID) ? S_ISUID : 0;
711
712 return mode;
713 }
714
715 static u32 posix_filetypes[] = {
716 S_IFREG,
717 S_IFDIR,
718 S_IFLNK,
719 S_IFCHR,
720 S_IFBLK,
721 S_IFIFO,
722 S_IFSOCK
723 };
724
wire_filetype_to_posix(u32 wire_type)725 static u32 wire_filetype_to_posix(u32 wire_type)
726 {
727 if (wire_type >= ARRAY_SIZE(posix_filetypes)) {
728 pr_warn("Unexpected type %u", wire_type);
729 return 0;
730 }
731 return posix_filetypes[wire_type];
732 }
733
wire_mode_to_posix(u32 wire,bool is_dir)734 umode_t wire_mode_to_posix(u32 wire, bool is_dir)
735 {
736 u32 wire_type;
737 u32 mode;
738
739 wire_type = (wire & POSIX_FILETYPE_MASK) >> POSIX_FILETYPE_SHIFT;
740 /* older servers do not set POSIX file type in the mode field in the response */
741 if ((wire_type == 0) && is_dir)
742 mode = wire_perms_to_posix(wire) | S_IFDIR;
743 else
744 mode = (wire_perms_to_posix(wire) | wire_filetype_to_posix(wire_type));
745 return (umode_t)mode;
746 }
747
748 /* 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)749 static void smb311_posix_info_to_fattr(struct cifs_fattr *fattr,
750 struct cifs_open_info_data *data,
751 struct super_block *sb)
752 {
753 struct smb311_posix_qinfo *info = &data->posix_fi;
754 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
755 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
756
757 memset(fattr, 0, sizeof(*fattr));
758
759 /* no fattr->flags to set */
760 fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes);
761 fattr->cf_uniqueid = le64_to_cpu(info->Inode);
762
763 if (info->LastAccessTime)
764 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
765 else
766 ktime_get_coarse_real_ts64(&fattr->cf_atime);
767
768 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
769 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
770
771 if (data->adjust_tz) {
772 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
773 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
774 }
775
776 /*
777 * The srv fs device id is overridden on network mount so setting
778 * @fattr->cf_rdev isn't needed here.
779 */
780 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
781 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
782 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
783 fattr->cf_nlink = le32_to_cpu(info->HardLinks);
784 fattr->cf_mode = wire_mode_to_posix(le32_to_cpu(info->Mode),
785 fattr->cf_cifsattrs & ATTR_DIRECTORY);
786
787 if (cifs_open_data_reparse(data) &&
788 cifs_reparse_point_to_fattr(cifs_sb, fattr, data))
789 goto out_reparse;
790
791 fattr->cf_dtype = S_DT(fattr->cf_mode);
792
793 out_reparse:
794 if (S_ISLNK(fattr->cf_mode)) {
795 if (likely(data->symlink_target))
796 fattr->cf_eof = strnlen(data->symlink_target, PATH_MAX);
797 fattr->cf_symlink_target = data->symlink_target;
798 data->symlink_target = NULL;
799 }
800 sid_to_id(cifs_sb, &data->posix_owner, fattr, SIDOWNER);
801 sid_to_id(cifs_sb, &data->posix_group, fattr, SIDGROUP);
802
803 cifs_dbg(FYI, "POSIX query info: mode 0x%x uniqueid 0x%llx nlink %d\n",
804 fattr->cf_mode, fattr->cf_uniqueid, fattr->cf_nlink);
805 }
806
cifs_open_info_to_fattr(struct cifs_fattr * fattr,struct cifs_open_info_data * data,struct super_block * sb)807 static void cifs_open_info_to_fattr(struct cifs_fattr *fattr,
808 struct cifs_open_info_data *data,
809 struct super_block *sb)
810 {
811 struct smb2_file_all_info *info = &data->fi;
812 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
813 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
814
815 memset(fattr, 0, sizeof(*fattr));
816 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
817 if (info->DeletePending)
818 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
819
820 if (info->LastAccessTime)
821 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
822 else
823 ktime_get_coarse_real_ts64(&fattr->cf_atime);
824
825 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
826 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
827
828 if (data->adjust_tz) {
829 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
830 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
831 }
832
833 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
834 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
835 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
836 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
837 fattr->cf_uid = cifs_sb->ctx->linux_uid;
838 fattr->cf_gid = cifs_sb->ctx->linux_gid;
839
840 fattr->cf_mode = cifs_sb->ctx->file_mode;
841 if (cifs_open_data_reparse(data) &&
842 cifs_reparse_point_to_fattr(cifs_sb, fattr, data))
843 goto out_reparse;
844
845 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
846 fattr->cf_mode = S_IFDIR | cifs_sb->ctx->dir_mode;
847 fattr->cf_dtype = DT_DIR;
848 /*
849 * Server can return wrong NumberOfLinks value for directories
850 * when Unix extensions are disabled - fake it.
851 */
852 if (!tcon->unix_ext)
853 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
854 } else {
855 fattr->cf_mode = S_IFREG | cifs_sb->ctx->file_mode;
856 fattr->cf_dtype = DT_REG;
857
858 /*
859 * Don't accept zero nlink from non-unix servers unless
860 * delete is pending. Instead mark it as unknown.
861 */
862 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
863 !info->DeletePending) {
864 cifs_dbg(VFS, "bogus file nlink value %u\n",
865 fattr->cf_nlink);
866 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
867 }
868 }
869
870 /* clear write bits if ATTR_READONLY is set */
871 if (fattr->cf_cifsattrs & ATTR_READONLY)
872 fattr->cf_mode &= ~(S_IWUGO);
873
874 out_reparse:
875 if (S_ISLNK(fattr->cf_mode)) {
876 if (likely(data->symlink_target))
877 fattr->cf_eof = strnlen(data->symlink_target, PATH_MAX);
878 fattr->cf_symlink_target = data->symlink_target;
879 data->symlink_target = NULL;
880 }
881 }
882
883 static int
cifs_get_file_info(struct file * filp)884 cifs_get_file_info(struct file *filp)
885 {
886 int rc;
887 unsigned int xid;
888 struct cifs_open_info_data data = {};
889 struct cifs_fattr fattr;
890 struct inode *inode = file_inode(filp);
891 struct cifsFileInfo *cfile = filp->private_data;
892 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
893 struct TCP_Server_Info *server = tcon->ses->server;
894 struct dentry *dentry = filp->f_path.dentry;
895 void *page = alloc_dentry_path();
896 const unsigned char *path;
897
898 if (!server->ops->query_file_info) {
899 free_dentry_path(page);
900 return -ENOSYS;
901 }
902
903 xid = get_xid();
904 rc = server->ops->query_file_info(xid, tcon, cfile, &data);
905 switch (rc) {
906 case 0:
907 /* TODO: add support to query reparse tag */
908 data.adjust_tz = false;
909 if (data.symlink_target) {
910 data.symlink = true;
911 data.reparse.tag = IO_REPARSE_TAG_SYMLINK;
912 }
913 path = build_path_from_dentry(dentry, page);
914 if (IS_ERR(path)) {
915 rc = PTR_ERR(path);
916 goto cgfi_exit;
917 }
918 cifs_open_info_to_fattr(&fattr, &data, inode->i_sb);
919 if (fattr.cf_flags & CIFS_FATTR_DELETE_PENDING)
920 cifs_mark_open_handles_for_deleted_file(inode, path);
921 break;
922 case -EREMOTE:
923 cifs_create_junction_fattr(&fattr, inode->i_sb);
924 break;
925 case -EOPNOTSUPP:
926 case -EINVAL:
927 /*
928 * FIXME: legacy server -- fall back to path-based call?
929 * for now, just skip revalidating and mark inode for
930 * immediate reval.
931 */
932 rc = 0;
933 CIFS_I(inode)->time = 0;
934 goto cgfi_exit;
935 default:
936 goto cgfi_exit;
937 }
938
939 /*
940 * don't bother with SFU junk here -- just mark inode as needing
941 * revalidation.
942 */
943 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
944 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
945 /* if filetype is different, return error */
946 rc = cifs_fattr_to_inode(inode, &fattr, false);
947 cgfi_exit:
948 cifs_free_open_info(&data);
949 free_dentry_path(page);
950 free_xid(xid);
951 return rc;
952 }
953
954 /* Simple function to return a 64 bit hash of string. Rarely called */
simple_hashstr(const char * str)955 static __u64 simple_hashstr(const char *str)
956 {
957 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
958 __u64 hash = 0;
959
960 while (*str)
961 hash = (hash + (__u64) *str++) * hash_mult;
962
963 return hash;
964 }
965
966 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
967 /**
968 * cifs_backup_query_path_info - SMB1 fallback code to get ino
969 *
970 * Fallback code to get file metadata when we don't have access to
971 * full_path (EACCES) and have backup creds.
972 *
973 * @xid: transaction id used to identify original request in logs
974 * @tcon: information about the server share we have mounted
975 * @sb: the superblock stores info such as disk space available
976 * @full_path: name of the file we are getting the metadata for
977 * @resp_buf: will be set to cifs resp buf and needs to be freed with
978 * cifs_buf_release() when done with @data
979 * @data: will be set to search info result buffer
980 */
981 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)982 cifs_backup_query_path_info(int xid,
983 struct cifs_tcon *tcon,
984 struct super_block *sb,
985 const char *full_path,
986 void **resp_buf,
987 FILE_ALL_INFO **data)
988 {
989 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
990 struct cifs_search_info info = {0};
991 u16 flags;
992 int rc;
993
994 *resp_buf = NULL;
995 info.endOfSearch = false;
996 if (tcon->unix_ext)
997 info.info_level = SMB_FIND_FILE_UNIX;
998 else if ((tcon->ses->capabilities &
999 tcon->ses->server->vals->cap_nt_find) == 0)
1000 info.info_level = SMB_FIND_FILE_INFO_STANDARD;
1001 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
1002 info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
1003 else /* no srvino useful for fallback to some netapp */
1004 info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
1005
1006 flags = CIFS_SEARCH_CLOSE_ALWAYS |
1007 CIFS_SEARCH_CLOSE_AT_END |
1008 CIFS_SEARCH_BACKUP_SEARCH;
1009
1010 rc = CIFSFindFirst(xid, tcon, full_path,
1011 cifs_sb, NULL, flags, &info, false);
1012 if (rc)
1013 return rc;
1014
1015 *resp_buf = (void *)info.ntwrk_buf_start;
1016 *data = (FILE_ALL_INFO *)info.srch_entries_start;
1017 return 0;
1018 }
1019 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1020
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)1021 static void cifs_set_fattr_ino(int xid, struct cifs_tcon *tcon, struct super_block *sb,
1022 struct inode **inode, const char *full_path,
1023 struct cifs_open_info_data *data, struct cifs_fattr *fattr)
1024 {
1025 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1026 struct TCP_Server_Info *server = tcon->ses->server;
1027 int rc;
1028
1029 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
1030 if (*inode)
1031 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
1032 else
1033 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1034 return;
1035 }
1036
1037 /*
1038 * If we have an inode pass a NULL tcon to ensure we don't
1039 * make a round trip to the server. This only works for SMB2+.
1040 */
1041 rc = server->ops->get_srv_inum(xid, *inode ? NULL : tcon, cifs_sb, full_path,
1042 &fattr->cf_uniqueid, data);
1043 if (rc) {
1044 /*
1045 * If that fails reuse existing ino or generate one
1046 * and disable server ones
1047 */
1048 if (*inode)
1049 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
1050 else {
1051 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1052 cifs_autodisable_serverino(cifs_sb);
1053 }
1054 return;
1055 }
1056
1057 /* If no errors, check for zero root inode (invalid) */
1058 if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
1059 cifs_dbg(FYI, "Invalid (0) inodenum\n");
1060 if (*inode) {
1061 /* reuse */
1062 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
1063 } else {
1064 /* make an ino by hashing the UNC */
1065 fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
1066 fattr->cf_uniqueid = simple_hashstr(tcon->tree_name);
1067 }
1068 }
1069 }
1070
is_inode_cache_good(struct inode * ino)1071 static inline bool is_inode_cache_good(struct inode *ino)
1072 {
1073 return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
1074 }
1075
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)1076 static int reparse_info_to_fattr(struct cifs_open_info_data *data,
1077 struct super_block *sb,
1078 const unsigned int xid,
1079 struct cifs_tcon *tcon,
1080 const char *full_path,
1081 struct cifs_fattr *fattr)
1082 {
1083 struct TCP_Server_Info *server = tcon->ses->server;
1084 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1085 struct kvec rsp_iov, *iov = NULL;
1086 int rsp_buftype = CIFS_NO_BUFFER;
1087 u32 tag = data->reparse.tag;
1088 int rc = 0;
1089
1090 if (!tag && server->ops->query_reparse_point) {
1091 rc = server->ops->query_reparse_point(xid, tcon, cifs_sb,
1092 full_path, &tag,
1093 &rsp_iov, &rsp_buftype);
1094 if (!rc)
1095 iov = &rsp_iov;
1096 } else if (data->reparse.io.buftype != CIFS_NO_BUFFER &&
1097 data->reparse.io.iov.iov_base) {
1098 iov = &data->reparse.io.iov;
1099 }
1100
1101 rc = -EOPNOTSUPP;
1102 data->reparse.tag = tag;
1103 if (!data->reparse.tag) {
1104 if (server->ops->query_symlink) {
1105 rc = server->ops->query_symlink(xid, tcon,
1106 cifs_sb, full_path,
1107 &data->symlink_target);
1108 }
1109 if (rc == -EOPNOTSUPP)
1110 data->reparse.tag = IO_REPARSE_TAG_INTERNAL;
1111 }
1112
1113 switch (data->reparse.tag) {
1114 case 0: /* SMB1 symlink */
1115 break;
1116 case IO_REPARSE_TAG_INTERNAL:
1117 rc = 0;
1118 if (le32_to_cpu(data->fi.Attributes) & ATTR_DIRECTORY) {
1119 cifs_create_junction_fattr(fattr, sb);
1120 goto out;
1121 }
1122 break;
1123 case IO_REPARSE_TAG_MOUNT_POINT:
1124 cifs_create_junction_fattr(fattr, sb);
1125 rc = 0;
1126 goto out;
1127 default:
1128 /* Check for cached reparse point data */
1129 if (data->symlink_target || data->reparse.buf) {
1130 rc = 0;
1131 } else if (iov && server->ops->parse_reparse_point) {
1132 rc = server->ops->parse_reparse_point(cifs_sb,
1133 full_path,
1134 iov, data);
1135 /*
1136 * If the reparse point was not handled but it is the
1137 * name surrogate which points to directory, then treat
1138 * is as a new mount point. Name surrogate reparse point
1139 * represents another named entity in the system.
1140 */
1141 if (rc == -EOPNOTSUPP &&
1142 IS_REPARSE_TAG_NAME_SURROGATE(data->reparse.tag) &&
1143 (le32_to_cpu(data->fi.Attributes) & ATTR_DIRECTORY)) {
1144 rc = 0;
1145 cifs_create_junction_fattr(fattr, sb);
1146 goto out;
1147 }
1148 }
1149 break;
1150 }
1151
1152 if (tcon->posix_extensions)
1153 smb311_posix_info_to_fattr(fattr, data, sb);
1154 else
1155 cifs_open_info_to_fattr(fattr, data, sb);
1156 out:
1157 fattr->cf_cifstag = data->reparse.tag;
1158 free_rsp_buf(rsp_buftype, rsp_iov.iov_base);
1159 return rc;
1160 }
1161
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)1162 static int cifs_get_fattr(struct cifs_open_info_data *data,
1163 struct super_block *sb, int xid,
1164 const struct cifs_fid *fid,
1165 struct cifs_fattr *fattr,
1166 struct inode **inode,
1167 const char *full_path)
1168 {
1169 struct cifs_open_info_data tmp_data = {};
1170 struct cifs_tcon *tcon;
1171 struct TCP_Server_Info *server;
1172 struct tcon_link *tlink;
1173 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1174 void *smb1_backup_rsp_buf = NULL;
1175 int rc = 0;
1176 int tmprc = 0;
1177
1178 tlink = cifs_sb_tlink(cifs_sb);
1179 if (IS_ERR(tlink))
1180 return PTR_ERR(tlink);
1181 tcon = tlink_tcon(tlink);
1182 server = tcon->ses->server;
1183
1184 /*
1185 * 1. Fetch file metadata if not provided (data)
1186 */
1187
1188 if (!data) {
1189 rc = server->ops->query_path_info(xid, tcon, cifs_sb,
1190 full_path, &tmp_data);
1191 data = &tmp_data;
1192 }
1193
1194 /*
1195 * 2. Convert it to internal cifs metadata (fattr)
1196 */
1197
1198 switch (rc) {
1199 case 0:
1200 /*
1201 * If the file is a reparse point, it is more complicated
1202 * since we have to check if its reparse tag matches a known
1203 * special file type e.g. symlink or fifo or char etc.
1204 */
1205 if (cifs_open_data_reparse(data)) {
1206 rc = reparse_info_to_fattr(data, sb, xid, tcon,
1207 full_path, fattr);
1208 } else {
1209 cifs_open_info_to_fattr(fattr, data, sb);
1210 }
1211 if (!rc && *inode &&
1212 (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING))
1213 cifs_mark_open_handles_for_deleted_file(*inode, full_path);
1214 break;
1215 case -EREMOTE:
1216 /* DFS link, no metadata available on this server */
1217 cifs_create_junction_fattr(fattr, sb);
1218 rc = 0;
1219 break;
1220 case -EACCES:
1221 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1222 /*
1223 * perm errors, try again with backup flags if possible
1224 *
1225 * For SMB2 and later the backup intent flag
1226 * is already sent if needed on open and there
1227 * is no path based FindFirst operation to use
1228 * to retry with
1229 */
1230 if (backup_cred(cifs_sb) && is_smb1_server(server)) {
1231 /* for easier reading */
1232 FILE_ALL_INFO *fi;
1233 FILE_DIRECTORY_INFO *fdi;
1234 SEARCH_ID_FULL_DIR_INFO *si;
1235
1236 rc = cifs_backup_query_path_info(xid, tcon, sb,
1237 full_path,
1238 &smb1_backup_rsp_buf,
1239 &fi);
1240 if (rc)
1241 goto out;
1242
1243 move_cifs_info_to_smb2(&data->fi, fi);
1244 fdi = (FILE_DIRECTORY_INFO *)fi;
1245 si = (SEARCH_ID_FULL_DIR_INFO *)fi;
1246
1247 cifs_dir_info_to_fattr(fattr, fdi, cifs_sb);
1248 fattr->cf_uniqueid = le64_to_cpu(si->UniqueId);
1249 /* uniqueid set, skip get inum step */
1250 goto handle_mnt_opt;
1251 } else {
1252 /* nothing we can do, bail out */
1253 goto out;
1254 }
1255 #else
1256 goto out;
1257 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1258 break;
1259 default:
1260 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1261 goto out;
1262 }
1263
1264 /*
1265 * 3. Get or update inode number (fattr->cf_uniqueid)
1266 */
1267
1268 cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, fattr);
1269
1270 /*
1271 * 4. Tweak fattr based on mount options
1272 */
1273 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1274 handle_mnt_opt:
1275 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1276 /* query for SFU type info if supported and needed */
1277 if ((fattr->cf_cifsattrs & ATTR_SYSTEM) &&
1278 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)) {
1279 tmprc = cifs_sfu_type(fattr, full_path, cifs_sb, xid);
1280 if (tmprc)
1281 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
1282 }
1283
1284 /* fill in 0777 bits from ACL */
1285 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
1286 rc = cifs_acl_to_fattr(cifs_sb, fattr, *inode,
1287 true, full_path, fid);
1288 if (rc == -EREMOTE)
1289 rc = 0;
1290 if (rc) {
1291 cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
1292 __func__, rc);
1293 goto out;
1294 }
1295 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
1296 rc = cifs_acl_to_fattr(cifs_sb, fattr, *inode,
1297 false, full_path, fid);
1298 if (rc == -EREMOTE)
1299 rc = 0;
1300 if (rc) {
1301 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
1302 __func__, rc);
1303 goto out;
1304 }
1305 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
1306 /* fill in remaining high mode bits e.g. SUID, VTX */
1307 cifs_sfu_mode(fattr, full_path, cifs_sb, xid);
1308 else if (!(tcon->posix_extensions))
1309 /* clear write bits if ATTR_READONLY is set */
1310 if (fattr->cf_cifsattrs & ATTR_READONLY)
1311 fattr->cf_mode &= ~(S_IWUGO);
1312
1313
1314 /* check for Minshall+French symlinks */
1315 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1316 tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path);
1317 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1318 }
1319
1320 out:
1321 cifs_buf_release(smb1_backup_rsp_buf);
1322 cifs_put_tlink(tlink);
1323 cifs_free_open_info(&tmp_data);
1324 return rc;
1325 }
1326
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)1327 int cifs_get_inode_info(struct inode **inode,
1328 const char *full_path,
1329 struct cifs_open_info_data *data,
1330 struct super_block *sb, int xid,
1331 const struct cifs_fid *fid)
1332 {
1333 struct cifs_fattr fattr = {};
1334 int rc;
1335
1336 if (!data && is_inode_cache_good(*inode)) {
1337 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1338 return 0;
1339 }
1340
1341 rc = cifs_get_fattr(data, sb, xid, fid, &fattr, inode, full_path);
1342 if (rc)
1343 goto out;
1344
1345 rc = update_inode_info(sb, &fattr, inode);
1346 out:
1347 kfree(fattr.cf_symlink_target);
1348 return rc;
1349 }
1350
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)1351 static int smb311_posix_get_fattr(struct cifs_open_info_data *data,
1352 struct cifs_fattr *fattr,
1353 const char *full_path,
1354 struct super_block *sb,
1355 const unsigned int xid)
1356 {
1357 struct cifs_open_info_data tmp_data = {};
1358 struct TCP_Server_Info *server;
1359 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1360 struct cifs_tcon *tcon;
1361 struct tcon_link *tlink;
1362 int tmprc;
1363 int rc = 0;
1364
1365 tlink = cifs_sb_tlink(cifs_sb);
1366 if (IS_ERR(tlink))
1367 return PTR_ERR(tlink);
1368 tcon = tlink_tcon(tlink);
1369 server = tcon->ses->server;
1370
1371 /*
1372 * 1. Fetch file metadata if not provided (data)
1373 */
1374 if (!data) {
1375 rc = server->ops->query_path_info(xid, tcon, cifs_sb,
1376 full_path, &tmp_data);
1377 data = &tmp_data;
1378 }
1379
1380 /*
1381 * 2. Convert it to internal cifs metadata (fattr)
1382 */
1383
1384 switch (rc) {
1385 case 0:
1386 if (cifs_open_data_reparse(data)) {
1387 rc = reparse_info_to_fattr(data, sb, xid, tcon,
1388 full_path, fattr);
1389 } else {
1390 smb311_posix_info_to_fattr(fattr, data, sb);
1391 }
1392 break;
1393 case -EREMOTE:
1394 /* DFS link, no metadata available on this server */
1395 cifs_create_junction_fattr(fattr, sb);
1396 rc = 0;
1397 break;
1398 case -EACCES:
1399 /*
1400 * For SMB2 and later the backup intent flag
1401 * is already sent if needed on open and there
1402 * is no path based FindFirst operation to use
1403 * to retry with so nothing we can do, bail out
1404 */
1405 goto out;
1406 default:
1407 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1408 goto out;
1409 }
1410
1411 /*
1412 * 3. Tweak fattr based on mount options
1413 */
1414 /* check for Minshall+French symlinks */
1415 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1416 tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path);
1417 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1418 }
1419
1420 out:
1421 cifs_put_tlink(tlink);
1422 cifs_free_open_info(data);
1423 return rc;
1424 }
1425
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)1426 int smb311_posix_get_inode_info(struct inode **inode,
1427 const char *full_path,
1428 struct cifs_open_info_data *data,
1429 struct super_block *sb,
1430 const unsigned int xid)
1431 {
1432 struct cifs_fattr fattr = {};
1433 int rc;
1434
1435 if (!data && is_inode_cache_good(*inode)) {
1436 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1437 return 0;
1438 }
1439
1440 rc = smb311_posix_get_fattr(data, &fattr, full_path, sb, xid);
1441 if (rc)
1442 goto out;
1443
1444 rc = update_inode_info(sb, &fattr, inode);
1445 if (!rc && fattr.cf_flags & CIFS_FATTR_DELETE_PENDING)
1446 cifs_mark_open_handles_for_deleted_file(*inode, full_path);
1447 out:
1448 kfree(fattr.cf_symlink_target);
1449 return rc;
1450 }
1451
1452 static const struct inode_operations cifs_ipc_inode_ops = {
1453 .lookup = cifs_lookup,
1454 };
1455
1456 static int
cifs_find_inode(struct inode * inode,void * opaque)1457 cifs_find_inode(struct inode *inode, void *opaque)
1458 {
1459 struct cifs_fattr *fattr = opaque;
1460
1461 /* [!] The compared values must be the same in struct cifs_fscache_inode_key. */
1462
1463 /* don't match inode with different uniqueid */
1464 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1465 return 0;
1466
1467 /* use createtime like an i_generation field */
1468 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1469 return 0;
1470
1471 /* don't match inode of different type */
1472 if (inode_wrong_type(inode, fattr->cf_mode))
1473 return 0;
1474
1475 /* if it's not a directory or has no dentries, then flag it */
1476 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
1477 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
1478
1479 return 1;
1480 }
1481
1482 static int
cifs_init_inode(struct inode * inode,void * opaque)1483 cifs_init_inode(struct inode *inode, void *opaque)
1484 {
1485 struct cifs_fattr *fattr = opaque;
1486
1487 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
1488 CIFS_I(inode)->createtime = fattr->cf_createtime;
1489 return 0;
1490 }
1491
1492 /*
1493 * walk dentry list for an inode and report whether it has aliases that
1494 * are hashed. We use this to determine if a directory inode can actually
1495 * be used.
1496 */
1497 static bool
inode_has_hashed_dentries(struct inode * inode)1498 inode_has_hashed_dentries(struct inode *inode)
1499 {
1500 struct dentry *dentry;
1501
1502 spin_lock(&inode->i_lock);
1503 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1504 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1505 spin_unlock(&inode->i_lock);
1506 return true;
1507 }
1508 }
1509 spin_unlock(&inode->i_lock);
1510 return false;
1511 }
1512
1513 /* Given fattrs, get a corresponding inode */
1514 struct inode *
cifs_iget(struct super_block * sb,struct cifs_fattr * fattr)1515 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1516 {
1517 unsigned long hash;
1518 struct inode *inode;
1519
1520 retry_iget5_locked:
1521 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1522
1523 /* hash down to 32-bits on 32-bit arch */
1524 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1525
1526 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1527 if (inode) {
1528 /* was there a potentially problematic inode collision? */
1529 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1530 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1531
1532 if (inode_has_hashed_dentries(inode)) {
1533 cifs_autodisable_serverino(CIFS_SB(sb));
1534 iput(inode);
1535 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1536 goto retry_iget5_locked;
1537 }
1538 }
1539
1540 /* can't fail - see cifs_find_inode() */
1541 cifs_fattr_to_inode(inode, fattr, false);
1542 if (sb->s_flags & SB_NOATIME)
1543 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1544 if (inode->i_state & I_NEW) {
1545 inode->i_ino = hash;
1546 cifs_fscache_get_inode_cookie(inode);
1547 unlock_new_inode(inode);
1548 }
1549 }
1550
1551 return inode;
1552 }
1553
1554 /* gets root inode */
cifs_root_iget(struct super_block * sb)1555 struct inode *cifs_root_iget(struct super_block *sb)
1556 {
1557 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1558 struct cifs_fattr fattr = {};
1559 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1560 struct inode *inode = NULL;
1561 unsigned int xid;
1562 char *path = NULL;
1563 int len;
1564 int rc;
1565
1566 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1567 && cifs_sb->prepath) {
1568 len = strlen(cifs_sb->prepath);
1569 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1570 if (path == NULL)
1571 return ERR_PTR(-ENOMEM);
1572 path[0] = '/';
1573 memcpy(path+1, cifs_sb->prepath, len);
1574 } else {
1575 path = kstrdup("", GFP_KERNEL);
1576 if (path == NULL)
1577 return ERR_PTR(-ENOMEM);
1578 }
1579
1580 xid = get_xid();
1581 if (tcon->unix_ext) {
1582 rc = cifs_get_unix_fattr(path, sb, &fattr, &inode, xid);
1583 /* some servers mistakenly claim POSIX support */
1584 if (rc != -EOPNOTSUPP)
1585 goto iget_root;
1586 cifs_dbg(VFS, "server does not support POSIX extensions\n");
1587 tcon->unix_ext = false;
1588 }
1589
1590 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1591 if (tcon->posix_extensions)
1592 rc = smb311_posix_get_fattr(NULL, &fattr, path, sb, xid);
1593 else
1594 rc = cifs_get_fattr(NULL, sb, xid, NULL, &fattr, &inode, path);
1595
1596 iget_root:
1597 if (!rc) {
1598 if (fattr.cf_flags & CIFS_FATTR_JUNCTION) {
1599 fattr.cf_flags &= ~CIFS_FATTR_JUNCTION;
1600 cifs_autodisable_serverino(cifs_sb);
1601 }
1602 inode = cifs_iget(sb, &fattr);
1603 }
1604
1605 if (!inode) {
1606 inode = ERR_PTR(rc);
1607 goto out;
1608 }
1609
1610 if (!rc && fattr.cf_flags & CIFS_FATTR_DELETE_PENDING)
1611 cifs_mark_open_handles_for_deleted_file(inode, path);
1612
1613 if (rc && tcon->pipe) {
1614 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1615 spin_lock(&inode->i_lock);
1616 inode->i_mode |= S_IFDIR;
1617 set_nlink(inode, 2);
1618 inode->i_op = &cifs_ipc_inode_ops;
1619 inode->i_fop = &simple_dir_operations;
1620 inode->i_uid = cifs_sb->ctx->linux_uid;
1621 inode->i_gid = cifs_sb->ctx->linux_gid;
1622 spin_unlock(&inode->i_lock);
1623 } else if (rc) {
1624 iget_failed(inode);
1625 inode = ERR_PTR(rc);
1626 }
1627
1628 out:
1629 kfree(path);
1630 free_xid(xid);
1631 kfree(fattr.cf_symlink_target);
1632 return inode;
1633 }
1634
1635 int
cifs_set_file_info(struct inode * inode,struct iattr * attrs,unsigned int xid,const char * full_path,__u32 dosattr)1636 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1637 const char *full_path, __u32 dosattr)
1638 {
1639 bool set_time = false;
1640 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1641 struct TCP_Server_Info *server;
1642 FILE_BASIC_INFO info_buf;
1643
1644 if (attrs == NULL)
1645 return -EINVAL;
1646
1647 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1648 if (!server->ops->set_file_info)
1649 return -ENOSYS;
1650
1651 info_buf.Pad = 0;
1652
1653 if (attrs->ia_valid & ATTR_ATIME) {
1654 set_time = true;
1655 info_buf.LastAccessTime =
1656 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1657 } else
1658 info_buf.LastAccessTime = 0;
1659
1660 if (attrs->ia_valid & ATTR_MTIME) {
1661 set_time = true;
1662 info_buf.LastWriteTime =
1663 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1664 } else
1665 info_buf.LastWriteTime = 0;
1666
1667 /*
1668 * Samba throws this field away, but windows may actually use it.
1669 * Do not set ctime unless other time stamps are changed explicitly
1670 * (i.e. by utimes()) since we would then have a mix of client and
1671 * server times.
1672 */
1673 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1674 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1675 info_buf.ChangeTime =
1676 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1677 } else
1678 info_buf.ChangeTime = 0;
1679
1680 info_buf.CreationTime = 0; /* don't change */
1681 info_buf.Attributes = cpu_to_le32(dosattr);
1682
1683 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1684 }
1685
1686 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1687 /*
1688 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1689 * and rename it to a random name that hopefully won't conflict with
1690 * anything else.
1691 */
1692 int
cifs_rename_pending_delete(const char * full_path,struct dentry * dentry,const unsigned int xid)1693 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1694 const unsigned int xid)
1695 {
1696 int oplock = 0;
1697 int rc;
1698 struct cifs_fid fid;
1699 struct cifs_open_parms oparms;
1700 struct inode *inode = d_inode(dentry);
1701 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1702 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1703 struct tcon_link *tlink;
1704 struct cifs_tcon *tcon;
1705 __u32 dosattr, origattr;
1706 FILE_BASIC_INFO *info_buf = NULL;
1707
1708 tlink = cifs_sb_tlink(cifs_sb);
1709 if (IS_ERR(tlink))
1710 return PTR_ERR(tlink);
1711 tcon = tlink_tcon(tlink);
1712
1713 /*
1714 * We cannot rename the file if the server doesn't support
1715 * CAP_INFOLEVEL_PASSTHRU
1716 */
1717 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1718 rc = -EBUSY;
1719 goto out;
1720 }
1721
1722 oparms = (struct cifs_open_parms) {
1723 .tcon = tcon,
1724 .cifs_sb = cifs_sb,
1725 .desired_access = DELETE | FILE_WRITE_ATTRIBUTES,
1726 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
1727 .disposition = FILE_OPEN,
1728 .path = full_path,
1729 .fid = &fid,
1730 };
1731
1732 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1733 if (rc != 0)
1734 goto out;
1735
1736 origattr = cifsInode->cifsAttrs;
1737 if (origattr == 0)
1738 origattr |= ATTR_NORMAL;
1739
1740 dosattr = origattr & ~ATTR_READONLY;
1741 if (dosattr == 0)
1742 dosattr |= ATTR_NORMAL;
1743 dosattr |= ATTR_HIDDEN;
1744
1745 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1746 if (dosattr != origattr) {
1747 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1748 if (info_buf == NULL) {
1749 rc = -ENOMEM;
1750 goto out_close;
1751 }
1752 info_buf->Attributes = cpu_to_le32(dosattr);
1753 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1754 current->tgid);
1755 /* although we would like to mark the file hidden
1756 if that fails we will still try to rename it */
1757 if (!rc)
1758 cifsInode->cifsAttrs = dosattr;
1759 else
1760 dosattr = origattr; /* since not able to change them */
1761 }
1762
1763 /* rename the file */
1764 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1765 cifs_sb->local_nls,
1766 cifs_remap(cifs_sb));
1767 if (rc != 0) {
1768 rc = -EBUSY;
1769 goto undo_setattr;
1770 }
1771
1772 /* try to set DELETE_ON_CLOSE */
1773 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1774 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1775 current->tgid);
1776 /*
1777 * some samba versions return -ENOENT when we try to set the
1778 * file disposition here. Likely a samba bug, but work around
1779 * it for now. This means that some cifsXXX files may hang
1780 * around after they shouldn't.
1781 *
1782 * BB: remove this hack after more servers have the fix
1783 */
1784 if (rc == -ENOENT)
1785 rc = 0;
1786 else if (rc != 0) {
1787 rc = -EBUSY;
1788 goto undo_rename;
1789 }
1790 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1791 }
1792
1793 out_close:
1794 CIFSSMBClose(xid, tcon, fid.netfid);
1795 out:
1796 kfree(info_buf);
1797 cifs_put_tlink(tlink);
1798 return rc;
1799
1800 /*
1801 * reset everything back to the original state. Don't bother
1802 * dealing with errors here since we can't do anything about
1803 * them anyway.
1804 */
1805 undo_rename:
1806 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1807 cifs_sb->local_nls, cifs_remap(cifs_sb));
1808 undo_setattr:
1809 if (dosattr != origattr) {
1810 info_buf->Attributes = cpu_to_le32(origattr);
1811 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1812 current->tgid))
1813 cifsInode->cifsAttrs = origattr;
1814 }
1815
1816 goto out_close;
1817 }
1818 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1819
1820 /* copied from fs/nfs/dir.c with small changes */
1821 static void
cifs_drop_nlink(struct inode * inode)1822 cifs_drop_nlink(struct inode *inode)
1823 {
1824 spin_lock(&inode->i_lock);
1825 if (inode->i_nlink > 0)
1826 drop_nlink(inode);
1827 spin_unlock(&inode->i_lock);
1828 }
1829
1830 /*
1831 * If d_inode(dentry) is null (usually meaning the cached dentry
1832 * is a negative dentry) then we would attempt a standard SMB delete, but
1833 * if that fails we can not attempt the fall back mechanisms on EACCES
1834 * but will return the EACCES to the caller. Note that the VFS does not call
1835 * unlink on negative dentries currently.
1836 */
cifs_unlink(struct inode * dir,struct dentry * dentry)1837 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1838 {
1839 int rc = 0;
1840 unsigned int xid;
1841 const char *full_path;
1842 void *page;
1843 struct inode *inode = d_inode(dentry);
1844 struct cifsInodeInfo *cifs_inode;
1845 struct super_block *sb = dir->i_sb;
1846 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1847 struct tcon_link *tlink;
1848 struct cifs_tcon *tcon;
1849 struct TCP_Server_Info *server;
1850 struct iattr *attrs = NULL;
1851 __u32 dosattr = 0, origattr = 0;
1852
1853 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1854
1855 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1856 return -EIO;
1857
1858 tlink = cifs_sb_tlink(cifs_sb);
1859 if (IS_ERR(tlink))
1860 return PTR_ERR(tlink);
1861 tcon = tlink_tcon(tlink);
1862 server = tcon->ses->server;
1863
1864 xid = get_xid();
1865 page = alloc_dentry_path();
1866
1867 if (tcon->nodelete) {
1868 rc = -EACCES;
1869 goto unlink_out;
1870 }
1871
1872 /* Unlink can be called from rename so we can not take the
1873 * sb->s_vfs_rename_mutex here */
1874 full_path = build_path_from_dentry(dentry, page);
1875 if (IS_ERR(full_path)) {
1876 rc = PTR_ERR(full_path);
1877 goto unlink_out;
1878 }
1879
1880 cifs_close_deferred_file_under_dentry(tcon, full_path);
1881 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1882 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1883 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1884 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1885 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1886 cifs_remap(cifs_sb));
1887 cifs_dbg(FYI, "posix del rc %d\n", rc);
1888 if ((rc == 0) || (rc == -ENOENT))
1889 goto psx_del_no_retry;
1890 }
1891 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1892
1893 retry_std_delete:
1894 if (!server->ops->unlink) {
1895 rc = -ENOSYS;
1896 goto psx_del_no_retry;
1897 }
1898
1899 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb, dentry);
1900
1901 psx_del_no_retry:
1902 if (!rc) {
1903 if (inode) {
1904 cifs_mark_open_handles_for_deleted_file(inode, full_path);
1905 cifs_drop_nlink(inode);
1906 }
1907 } else if (rc == -ENOENT) {
1908 d_drop(dentry);
1909 } else if (rc == -EBUSY) {
1910 if (server->ops->rename_pending_delete) {
1911 rc = server->ops->rename_pending_delete(full_path,
1912 dentry, xid);
1913 if (rc == 0) {
1914 cifs_mark_open_handles_for_deleted_file(inode, full_path);
1915 cifs_drop_nlink(inode);
1916 }
1917 }
1918 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1919 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1920 if (attrs == NULL) {
1921 rc = -ENOMEM;
1922 goto out_reval;
1923 }
1924
1925 /* try to reset dos attributes */
1926 cifs_inode = CIFS_I(inode);
1927 origattr = cifs_inode->cifsAttrs;
1928 if (origattr == 0)
1929 origattr |= ATTR_NORMAL;
1930 dosattr = origattr & ~ATTR_READONLY;
1931 if (dosattr == 0)
1932 dosattr |= ATTR_NORMAL;
1933 dosattr |= ATTR_HIDDEN;
1934
1935 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1936 if (rc != 0)
1937 goto out_reval;
1938
1939 goto retry_std_delete;
1940 }
1941
1942 /* undo the setattr if we errored out and it's needed */
1943 if (rc != 0 && dosattr != 0)
1944 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1945
1946 out_reval:
1947 if (inode) {
1948 cifs_inode = CIFS_I(inode);
1949 cifs_inode->time = 0; /* will force revalidate to get info
1950 when needed */
1951 inode_set_ctime_current(inode);
1952 }
1953 inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
1954 cifs_inode = CIFS_I(dir);
1955 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1956 unlink_out:
1957 free_dentry_path(page);
1958 kfree(attrs);
1959 free_xid(xid);
1960 cifs_put_tlink(tlink);
1961 return rc;
1962 }
1963
1964 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)1965 cifs_mkdir_qinfo(struct inode *parent, 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 struct inode *inode = NULL;
1971
1972 if (tcon->posix_extensions) {
1973 rc = smb311_posix_get_inode_info(&inode, full_path,
1974 NULL, parent->i_sb, xid);
1975 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1976 } else if (tcon->unix_ext) {
1977 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1978 xid);
1979 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1980 } else {
1981 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1982 xid, NULL);
1983 }
1984
1985 if (rc)
1986 return rc;
1987
1988 if (!S_ISDIR(inode->i_mode)) {
1989 /*
1990 * mkdir succeeded, but another client has managed to remove the
1991 * sucker and replace it with non-directory. Return success,
1992 * but don't leave the child in dcache.
1993 */
1994 iput(inode);
1995 d_drop(dentry);
1996 return 0;
1997 }
1998 /*
1999 * setting nlink not necessary except in cases where we failed to get it
2000 * from the server or was set bogus. Also, since this is a brand new
2001 * inode, no need to grab the i_lock before setting the i_nlink.
2002 */
2003 if (inode->i_nlink < 2)
2004 set_nlink(inode, 2);
2005 mode &= ~current_umask();
2006 /* must turn on setgid bit if parent dir has it */
2007 if (parent->i_mode & S_ISGID)
2008 mode |= S_ISGID;
2009
2010 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2011 if (tcon->unix_ext) {
2012 struct cifs_unix_set_info_args args = {
2013 .mode = mode,
2014 .ctime = NO_CHANGE_64,
2015 .atime = NO_CHANGE_64,
2016 .mtime = NO_CHANGE_64,
2017 .device = 0,
2018 };
2019 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
2020 args.uid = current_fsuid();
2021 if (parent->i_mode & S_ISGID)
2022 args.gid = parent->i_gid;
2023 else
2024 args.gid = current_fsgid();
2025 } else {
2026 args.uid = INVALID_UID; /* no change */
2027 args.gid = INVALID_GID; /* no change */
2028 }
2029 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
2030 cifs_sb->local_nls,
2031 cifs_remap(cifs_sb));
2032 } else {
2033 #else
2034 {
2035 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2036 struct TCP_Server_Info *server = tcon->ses->server;
2037 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2038 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
2039 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
2040 tcon, xid);
2041 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
2042 inode->i_mode = (mode | S_IFDIR);
2043
2044 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
2045 inode->i_uid = current_fsuid();
2046 if (inode->i_mode & S_ISGID)
2047 inode->i_gid = parent->i_gid;
2048 else
2049 inode->i_gid = current_fsgid();
2050 }
2051 }
2052 d_instantiate(dentry, inode);
2053 return 0;
2054 }
2055
2056 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2057 static int
2058 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
2059 const char *full_path, struct cifs_sb_info *cifs_sb,
2060 struct cifs_tcon *tcon, const unsigned int xid)
2061 {
2062 int rc = 0;
2063 u32 oplock = 0;
2064 FILE_UNIX_BASIC_INFO *info = NULL;
2065 struct inode *newinode = NULL;
2066 struct cifs_fattr fattr;
2067
2068 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
2069 if (info == NULL) {
2070 rc = -ENOMEM;
2071 goto posix_mkdir_out;
2072 }
2073
2074 mode &= ~current_umask();
2075 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
2076 NULL /* netfid */, info, &oplock, full_path,
2077 cifs_sb->local_nls, cifs_remap(cifs_sb));
2078 if (rc == -EOPNOTSUPP)
2079 goto posix_mkdir_out;
2080 else if (rc) {
2081 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
2082 d_drop(dentry);
2083 goto posix_mkdir_out;
2084 }
2085
2086 if (info->Type == cpu_to_le32(-1))
2087 /* no return info, go query for it */
2088 goto posix_mkdir_get_info;
2089 /*
2090 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
2091 * need to set uid/gid.
2092 */
2093
2094 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
2095 cifs_fill_uniqueid(inode->i_sb, &fattr);
2096 newinode = cifs_iget(inode->i_sb, &fattr);
2097 if (!newinode)
2098 goto posix_mkdir_get_info;
2099
2100 d_instantiate(dentry, newinode);
2101
2102 #ifdef CONFIG_CIFS_DEBUG2
2103 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
2104 dentry, dentry, newinode);
2105
2106 if (newinode->i_nlink != 2)
2107 cifs_dbg(FYI, "unexpected number of links %d\n",
2108 newinode->i_nlink);
2109 #endif
2110
2111 posix_mkdir_out:
2112 kfree(info);
2113 return rc;
2114 posix_mkdir_get_info:
2115 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
2116 xid);
2117 goto posix_mkdir_out;
2118 }
2119 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2120
2121 int cifs_mkdir(struct mnt_idmap *idmap, struct inode *inode,
2122 struct dentry *direntry, umode_t mode)
2123 {
2124 int rc = 0;
2125 unsigned int xid;
2126 struct cifs_sb_info *cifs_sb;
2127 struct tcon_link *tlink;
2128 struct cifs_tcon *tcon;
2129 struct TCP_Server_Info *server;
2130 const char *full_path;
2131 void *page;
2132
2133 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
2134 mode, inode);
2135
2136 cifs_sb = CIFS_SB(inode->i_sb);
2137 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2138 return -EIO;
2139 tlink = cifs_sb_tlink(cifs_sb);
2140 if (IS_ERR(tlink))
2141 return PTR_ERR(tlink);
2142 tcon = tlink_tcon(tlink);
2143
2144 xid = get_xid();
2145
2146 page = alloc_dentry_path();
2147 full_path = build_path_from_dentry(direntry, page);
2148 if (IS_ERR(full_path)) {
2149 rc = PTR_ERR(full_path);
2150 goto mkdir_out;
2151 }
2152
2153 server = tcon->ses->server;
2154
2155 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
2156 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
2157 cifs_sb);
2158 d_drop(direntry); /* for time being always refresh inode info */
2159 goto mkdir_out;
2160 }
2161
2162 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2163 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
2164 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
2165 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
2166 tcon, xid);
2167 if (rc != -EOPNOTSUPP)
2168 goto mkdir_out;
2169 }
2170 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2171
2172 if (!server->ops->mkdir) {
2173 rc = -ENOSYS;
2174 goto mkdir_out;
2175 }
2176
2177 /* BB add setting the equivalent of mode via CreateX w/ACLs */
2178 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
2179 if (rc) {
2180 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
2181 d_drop(direntry);
2182 goto mkdir_out;
2183 }
2184
2185 /* TODO: skip this for smb2/smb3 */
2186 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
2187 xid);
2188 mkdir_out:
2189 /*
2190 * Force revalidate to get parent dir info when needed since cached
2191 * attributes are invalid now.
2192 */
2193 CIFS_I(inode)->time = 0;
2194 free_dentry_path(page);
2195 free_xid(xid);
2196 cifs_put_tlink(tlink);
2197 return rc;
2198 }
2199
2200 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
2201 {
2202 int rc = 0;
2203 unsigned int xid;
2204 struct cifs_sb_info *cifs_sb;
2205 struct tcon_link *tlink;
2206 struct cifs_tcon *tcon;
2207 struct TCP_Server_Info *server;
2208 const char *full_path;
2209 void *page = alloc_dentry_path();
2210 struct cifsInodeInfo *cifsInode;
2211
2212 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
2213
2214 xid = get_xid();
2215
2216 full_path = build_path_from_dentry(direntry, page);
2217 if (IS_ERR(full_path)) {
2218 rc = PTR_ERR(full_path);
2219 goto rmdir_exit;
2220 }
2221
2222 cifs_sb = CIFS_SB(inode->i_sb);
2223 if (unlikely(cifs_forced_shutdown(cifs_sb))) {
2224 rc = -EIO;
2225 goto rmdir_exit;
2226 }
2227
2228 tlink = cifs_sb_tlink(cifs_sb);
2229 if (IS_ERR(tlink)) {
2230 rc = PTR_ERR(tlink);
2231 goto rmdir_exit;
2232 }
2233 tcon = tlink_tcon(tlink);
2234 server = tcon->ses->server;
2235
2236 if (!server->ops->rmdir) {
2237 rc = -ENOSYS;
2238 cifs_put_tlink(tlink);
2239 goto rmdir_exit;
2240 }
2241
2242 if (tcon->nodelete) {
2243 rc = -EACCES;
2244 cifs_put_tlink(tlink);
2245 goto rmdir_exit;
2246 }
2247
2248 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
2249 cifs_put_tlink(tlink);
2250
2251 if (!rc) {
2252 spin_lock(&d_inode(direntry)->i_lock);
2253 i_size_write(d_inode(direntry), 0);
2254 clear_nlink(d_inode(direntry));
2255 spin_unlock(&d_inode(direntry)->i_lock);
2256 }
2257
2258 cifsInode = CIFS_I(d_inode(direntry));
2259 /* force revalidate to go get info when needed */
2260 cifsInode->time = 0;
2261
2262 cifsInode = CIFS_I(inode);
2263 /*
2264 * Force revalidate to get parent dir info when needed since cached
2265 * attributes are invalid now.
2266 */
2267 cifsInode->time = 0;
2268
2269 inode_set_ctime_current(d_inode(direntry));
2270 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
2271
2272 rmdir_exit:
2273 free_dentry_path(page);
2274 free_xid(xid);
2275 return rc;
2276 }
2277
2278 static int
2279 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
2280 const char *from_path, struct dentry *to_dentry,
2281 const char *to_path)
2282 {
2283 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
2284 struct tcon_link *tlink;
2285 struct cifs_tcon *tcon;
2286 struct TCP_Server_Info *server;
2287 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2288 struct cifs_fid fid;
2289 struct cifs_open_parms oparms;
2290 int oplock;
2291 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2292 int rc;
2293
2294 tlink = cifs_sb_tlink(cifs_sb);
2295 if (IS_ERR(tlink))
2296 return PTR_ERR(tlink);
2297 tcon = tlink_tcon(tlink);
2298 server = tcon->ses->server;
2299
2300 if (!server->ops->rename)
2301 return -ENOSYS;
2302
2303 /* try path-based rename first */
2304 rc = server->ops->rename(xid, tcon, from_dentry,
2305 from_path, to_path, cifs_sb);
2306
2307 /*
2308 * Don't bother with rename by filehandle unless file is busy and
2309 * source. Note that cross directory moves do not work with
2310 * rename by filehandle to various Windows servers.
2311 */
2312 if (rc == 0 || rc != -EBUSY)
2313 goto do_rename_exit;
2314
2315 /* Don't fall back to using SMB on SMB 2+ mount */
2316 if (server->vals->protocol_id != 0)
2317 goto do_rename_exit;
2318
2319 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2320 /* open-file renames don't work across directories */
2321 if (to_dentry->d_parent != from_dentry->d_parent)
2322 goto do_rename_exit;
2323
2324 oparms = (struct cifs_open_parms) {
2325 .tcon = tcon,
2326 .cifs_sb = cifs_sb,
2327 /* open the file to be renamed -- we need DELETE perms */
2328 .desired_access = DELETE,
2329 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
2330 .disposition = FILE_OPEN,
2331 .path = from_path,
2332 .fid = &fid,
2333 };
2334
2335 rc = CIFS_open(xid, &oparms, &oplock, NULL);
2336 if (rc == 0) {
2337 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2338 (const char *) to_dentry->d_name.name,
2339 cifs_sb->local_nls, cifs_remap(cifs_sb));
2340 CIFSSMBClose(xid, tcon, fid.netfid);
2341 }
2342 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2343 do_rename_exit:
2344 if (rc == 0)
2345 d_move(from_dentry, to_dentry);
2346 cifs_put_tlink(tlink);
2347 return rc;
2348 }
2349
2350 int
2351 cifs_rename2(struct mnt_idmap *idmap, struct inode *source_dir,
2352 struct dentry *source_dentry, struct inode *target_dir,
2353 struct dentry *target_dentry, unsigned int flags)
2354 {
2355 const char *from_name, *to_name;
2356 void *page1, *page2;
2357 struct cifs_sb_info *cifs_sb;
2358 struct tcon_link *tlink;
2359 struct cifs_tcon *tcon;
2360 unsigned int xid;
2361 int rc, tmprc;
2362 int retry_count = 0;
2363 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2364 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2365 FILE_UNIX_BASIC_INFO *info_buf_target;
2366 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2367
2368 if (flags & ~RENAME_NOREPLACE)
2369 return -EINVAL;
2370
2371 cifs_sb = CIFS_SB(source_dir->i_sb);
2372 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2373 return -EIO;
2374
2375 tlink = cifs_sb_tlink(cifs_sb);
2376 if (IS_ERR(tlink))
2377 return PTR_ERR(tlink);
2378 tcon = tlink_tcon(tlink);
2379
2380 page1 = alloc_dentry_path();
2381 page2 = alloc_dentry_path();
2382 xid = get_xid();
2383
2384 from_name = build_path_from_dentry(source_dentry, page1);
2385 if (IS_ERR(from_name)) {
2386 rc = PTR_ERR(from_name);
2387 goto cifs_rename_exit;
2388 }
2389
2390 to_name = build_path_from_dentry(target_dentry, page2);
2391 if (IS_ERR(to_name)) {
2392 rc = PTR_ERR(to_name);
2393 goto cifs_rename_exit;
2394 }
2395
2396 cifs_close_deferred_file_under_dentry(tcon, from_name);
2397 if (d_inode(target_dentry) != NULL)
2398 cifs_close_deferred_file_under_dentry(tcon, to_name);
2399
2400 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2401 to_name);
2402
2403 if (rc == -EACCES) {
2404 while (retry_count < 3) {
2405 cifs_close_all_deferred_files(tcon);
2406 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2407 to_name);
2408 if (rc != -EACCES)
2409 break;
2410 retry_count++;
2411 }
2412 }
2413
2414 /*
2415 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2416 */
2417 if (flags & RENAME_NOREPLACE)
2418 goto cifs_rename_exit;
2419
2420 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2421 if (rc == -EEXIST && tcon->unix_ext) {
2422 /*
2423 * Are src and dst hardlinks of same inode? We can only tell
2424 * with unix extensions enabled.
2425 */
2426 info_buf_source =
2427 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2428 GFP_KERNEL);
2429 if (info_buf_source == NULL) {
2430 rc = -ENOMEM;
2431 goto cifs_rename_exit;
2432 }
2433
2434 info_buf_target = info_buf_source + 1;
2435 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2436 info_buf_source,
2437 cifs_sb->local_nls,
2438 cifs_remap(cifs_sb));
2439 if (tmprc != 0)
2440 goto unlink_target;
2441
2442 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2443 info_buf_target,
2444 cifs_sb->local_nls,
2445 cifs_remap(cifs_sb));
2446
2447 if (tmprc == 0 && (info_buf_source->UniqueId ==
2448 info_buf_target->UniqueId)) {
2449 /* same file, POSIX says that this is a noop */
2450 rc = 0;
2451 goto cifs_rename_exit;
2452 }
2453 }
2454 /*
2455 * else ... BB we could add the same check for Windows by
2456 * checking the UniqueId via FILE_INTERNAL_INFO
2457 */
2458
2459 unlink_target:
2460 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2461
2462 /* Try unlinking the target dentry if it's not negative */
2463 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
2464 if (d_is_dir(target_dentry))
2465 tmprc = cifs_rmdir(target_dir, target_dentry);
2466 else
2467 tmprc = cifs_unlink(target_dir, target_dentry);
2468 if (tmprc)
2469 goto cifs_rename_exit;
2470 rc = cifs_do_rename(xid, source_dentry, from_name,
2471 target_dentry, to_name);
2472 }
2473
2474 /* force revalidate to go get info when needed */
2475 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2476
2477 cifs_rename_exit:
2478 kfree(info_buf_source);
2479 free_dentry_path(page2);
2480 free_dentry_path(page1);
2481 free_xid(xid);
2482 cifs_put_tlink(tlink);
2483 return rc;
2484 }
2485
2486 static bool
2487 cifs_dentry_needs_reval(struct dentry *dentry)
2488 {
2489 struct inode *inode = d_inode(dentry);
2490 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2491 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2492 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2493 struct cached_fid *cfid = NULL;
2494
2495 if (cifs_i->time == 0)
2496 return true;
2497
2498 if (CIFS_CACHE_READ(cifs_i))
2499 return false;
2500
2501 if (!lookupCacheEnabled)
2502 return true;
2503
2504 if (!open_cached_dir_by_dentry(tcon, dentry->d_parent, &cfid)) {
2505 if (cfid->time && cifs_i->time > cfid->time) {
2506 close_cached_dir(cfid);
2507 return false;
2508 }
2509 close_cached_dir(cfid);
2510 }
2511 /*
2512 * depending on inode type, check if attribute caching disabled for
2513 * files or directories
2514 */
2515 if (S_ISDIR(inode->i_mode)) {
2516 if (!cifs_sb->ctx->acdirmax)
2517 return true;
2518 if (!time_in_range(jiffies, cifs_i->time,
2519 cifs_i->time + cifs_sb->ctx->acdirmax))
2520 return true;
2521 } else { /* file */
2522 if (!cifs_sb->ctx->acregmax)
2523 return true;
2524 if (!time_in_range(jiffies, cifs_i->time,
2525 cifs_i->time + cifs_sb->ctx->acregmax))
2526 return true;
2527 }
2528
2529 /* hardlinked files w/ noserverino get "special" treatment */
2530 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2531 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2532 return true;
2533
2534 return false;
2535 }
2536
2537 /*
2538 * Zap the cache. Called when invalid_mapping flag is set.
2539 */
2540 int
2541 cifs_invalidate_mapping(struct inode *inode)
2542 {
2543 int rc = 0;
2544
2545 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2546 rc = invalidate_inode_pages2(inode->i_mapping);
2547 if (rc)
2548 cifs_dbg(VFS, "%s: invalidate inode %p failed with rc %d\n",
2549 __func__, inode, rc);
2550 }
2551
2552 return rc;
2553 }
2554
2555 /**
2556 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2557 *
2558 * @key: currently unused
2559 * @mode: the task state to sleep in
2560 */
2561 static int
2562 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2563 {
2564 schedule();
2565 if (signal_pending_state(mode, current))
2566 return -ERESTARTSYS;
2567 return 0;
2568 }
2569
2570 int
2571 cifs_revalidate_mapping(struct inode *inode)
2572 {
2573 int rc;
2574 unsigned long *flags = &CIFS_I(inode)->flags;
2575 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2576
2577 /* swapfiles are not supposed to be shared */
2578 if (IS_SWAPFILE(inode))
2579 return 0;
2580
2581 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2582 TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
2583 if (rc)
2584 return rc;
2585
2586 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2587 /* for cache=singleclient, do not invalidate */
2588 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
2589 goto skip_invalidate;
2590
2591 rc = cifs_invalidate_mapping(inode);
2592 if (rc)
2593 set_bit(CIFS_INO_INVALID_MAPPING, flags);
2594 }
2595
2596 skip_invalidate:
2597 clear_bit_unlock(CIFS_INO_LOCK, flags);
2598 smp_mb__after_atomic();
2599 wake_up_bit(flags, CIFS_INO_LOCK);
2600
2601 return rc;
2602 }
2603
2604 int
2605 cifs_zap_mapping(struct inode *inode)
2606 {
2607 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2608 return cifs_revalidate_mapping(inode);
2609 }
2610
2611 int cifs_revalidate_file_attr(struct file *filp)
2612 {
2613 int rc = 0;
2614 struct dentry *dentry = file_dentry(filp);
2615 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2616 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2617 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2618
2619 if (!cifs_dentry_needs_reval(dentry))
2620 return rc;
2621
2622 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2623 if (tlink_tcon(cfile->tlink)->unix_ext)
2624 rc = cifs_get_file_info_unix(filp);
2625 else
2626 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2627 rc = cifs_get_file_info(filp);
2628
2629 return rc;
2630 }
2631
2632 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2633 {
2634 unsigned int xid;
2635 int rc = 0;
2636 struct inode *inode = d_inode(dentry);
2637 struct super_block *sb = dentry->d_sb;
2638 const char *full_path;
2639 void *page;
2640 int count = 0;
2641
2642 if (inode == NULL)
2643 return -ENOENT;
2644
2645 if (!cifs_dentry_needs_reval(dentry))
2646 return rc;
2647
2648 xid = get_xid();
2649
2650 page = alloc_dentry_path();
2651 full_path = build_path_from_dentry(dentry, page);
2652 if (IS_ERR(full_path)) {
2653 rc = PTR_ERR(full_path);
2654 goto out;
2655 }
2656
2657 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2658 full_path, inode, inode->i_count.counter,
2659 dentry, cifs_get_time(dentry), jiffies);
2660
2661 again:
2662 if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions) {
2663 rc = smb311_posix_get_inode_info(&inode, full_path,
2664 NULL, sb, xid);
2665 } else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext) {
2666 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2667 } else {
2668 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2669 xid, NULL);
2670 }
2671 if (rc == -EAGAIN && count++ < 10)
2672 goto again;
2673 out:
2674 free_dentry_path(page);
2675 free_xid(xid);
2676
2677 return rc;
2678 }
2679
2680 int cifs_revalidate_file(struct file *filp)
2681 {
2682 int rc;
2683 struct inode *inode = file_inode(filp);
2684
2685 rc = cifs_revalidate_file_attr(filp);
2686 if (rc)
2687 return rc;
2688
2689 return cifs_revalidate_mapping(inode);
2690 }
2691
2692 /* revalidate a dentry's inode attributes */
2693 int cifs_revalidate_dentry(struct dentry *dentry)
2694 {
2695 int rc;
2696 struct inode *inode = d_inode(dentry);
2697
2698 rc = cifs_revalidate_dentry_attr(dentry);
2699 if (rc)
2700 return rc;
2701
2702 return cifs_revalidate_mapping(inode);
2703 }
2704
2705 int cifs_getattr(struct mnt_idmap *idmap, const struct path *path,
2706 struct kstat *stat, u32 request_mask, unsigned int flags)
2707 {
2708 struct dentry *dentry = path->dentry;
2709 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2710 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2711 struct inode *inode = d_inode(dentry);
2712 int rc;
2713
2714 if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb))))
2715 return -EIO;
2716
2717 /*
2718 * We need to be sure that all dirty pages are written and the server
2719 * has actual ctime, mtime and file length.
2720 */
2721 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
2722 !CIFS_CACHE_READ(CIFS_I(inode)) &&
2723 inode->i_mapping && inode->i_mapping->nrpages != 0) {
2724 rc = filemap_fdatawait(inode->i_mapping);
2725 if (rc) {
2726 mapping_set_error(inode->i_mapping, rc);
2727 return rc;
2728 }
2729 }
2730
2731 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2732 CIFS_I(inode)->time = 0; /* force revalidate */
2733
2734 /*
2735 * If the caller doesn't require syncing, only sync if
2736 * necessary (e.g. due to earlier truncate or setattr
2737 * invalidating the cached metadata)
2738 */
2739 if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2740 (CIFS_I(inode)->time == 0)) {
2741 rc = cifs_revalidate_dentry_attr(dentry);
2742 if (rc)
2743 return rc;
2744 }
2745
2746 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
2747 stat->blksize = cifs_sb->ctx->bsize;
2748 stat->ino = CIFS_I(inode)->uniqueid;
2749
2750 /* old CIFS Unix Extensions doesn't return create time */
2751 if (CIFS_I(inode)->createtime) {
2752 stat->result_mask |= STATX_BTIME;
2753 stat->btime =
2754 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2755 }
2756
2757 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2758 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2759 stat->attributes |= STATX_ATTR_COMPRESSED;
2760 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2761 stat->attributes |= STATX_ATTR_ENCRYPTED;
2762
2763 /*
2764 * If on a multiuser mount without unix extensions or cifsacl being
2765 * enabled, and the admin hasn't overridden them, set the ownership
2766 * to the fsuid/fsgid of the current process.
2767 */
2768 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2769 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2770 !tcon->unix_ext) {
2771 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2772 stat->uid = current_fsuid();
2773 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2774 stat->gid = current_fsgid();
2775 }
2776 return 0;
2777 }
2778
2779 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2780 u64 len)
2781 {
2782 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2783 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->netfs.inode.i_sb);
2784 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2785 struct TCP_Server_Info *server = tcon->ses->server;
2786 struct cifsFileInfo *cfile;
2787 int rc;
2788
2789 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2790 return -EIO;
2791
2792 /*
2793 * We need to be sure that all dirty pages are written as they
2794 * might fill holes on the server.
2795 */
2796 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2797 inode->i_mapping->nrpages != 0) {
2798 rc = filemap_fdatawait(inode->i_mapping);
2799 if (rc) {
2800 mapping_set_error(inode->i_mapping, rc);
2801 return rc;
2802 }
2803 }
2804
2805 cfile = find_readable_file(cifs_i, false);
2806 if (cfile == NULL)
2807 return -EINVAL;
2808
2809 if (server->ops->fiemap) {
2810 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2811 cifsFileInfo_put(cfile);
2812 return rc;
2813 }
2814
2815 cifsFileInfo_put(cfile);
2816 return -EOPNOTSUPP;
2817 }
2818
2819 int cifs_truncate_page(struct address_space *mapping, loff_t from)
2820 {
2821 pgoff_t index = from >> PAGE_SHIFT;
2822 unsigned offset = from & (PAGE_SIZE - 1);
2823 struct page *page;
2824 int rc = 0;
2825
2826 page = grab_cache_page(mapping, index);
2827 if (!page)
2828 return -ENOMEM;
2829
2830 zero_user_segment(page, offset, PAGE_SIZE);
2831 unlock_page(page);
2832 put_page(page);
2833 return rc;
2834 }
2835
2836 void cifs_setsize(struct inode *inode, loff_t offset)
2837 {
2838 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2839
2840 spin_lock(&inode->i_lock);
2841 i_size_write(inode, offset);
2842 spin_unlock(&inode->i_lock);
2843
2844 /* Cached inode must be refreshed on truncate */
2845 cifs_i->time = 0;
2846 truncate_pagecache(inode, offset);
2847 }
2848
2849 static int
2850 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2851 unsigned int xid, const char *full_path, struct dentry *dentry)
2852 {
2853 int rc;
2854 struct cifsFileInfo *open_file;
2855 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2856 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2857 struct tcon_link *tlink = NULL;
2858 struct cifs_tcon *tcon = NULL;
2859 struct TCP_Server_Info *server;
2860
2861 /*
2862 * To avoid spurious oplock breaks from server, in the case of
2863 * inodes that we already have open, avoid doing path based
2864 * setting of file size if we can do it by handle.
2865 * This keeps our caching token (oplock) and avoids timeouts
2866 * when the local oplock break takes longer to flush
2867 * writebehind data than the SMB timeout for the SetPathInfo
2868 * request would allow
2869 */
2870 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2871 if (open_file) {
2872 tcon = tlink_tcon(open_file->tlink);
2873 server = tcon->ses->server;
2874 if (server->ops->set_file_size)
2875 rc = server->ops->set_file_size(xid, tcon, open_file,
2876 attrs->ia_size, false);
2877 else
2878 rc = -ENOSYS;
2879 cifsFileInfo_put(open_file);
2880 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2881 } else
2882 rc = -EINVAL;
2883
2884 if (!rc)
2885 goto set_size_out;
2886
2887 if (tcon == NULL) {
2888 tlink = cifs_sb_tlink(cifs_sb);
2889 if (IS_ERR(tlink))
2890 return PTR_ERR(tlink);
2891 tcon = tlink_tcon(tlink);
2892 server = tcon->ses->server;
2893 }
2894
2895 /*
2896 * Set file size by pathname rather than by handle either because no
2897 * valid, writeable file handle for it was found or because there was
2898 * an error setting it by handle.
2899 */
2900 if (server->ops->set_path_size)
2901 rc = server->ops->set_path_size(xid, tcon, full_path,
2902 attrs->ia_size, cifs_sb, false, dentry);
2903 else
2904 rc = -ENOSYS;
2905 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2906
2907 if (tlink)
2908 cifs_put_tlink(tlink);
2909
2910 set_size_out:
2911 if (rc == 0) {
2912 cifsInode->server_eof = attrs->ia_size;
2913 cifs_setsize(inode, attrs->ia_size);
2914 /*
2915 * i_blocks is not related to (i_size / i_blksize), but instead
2916 * 512 byte (2**9) size is required for calculating num blocks.
2917 * Until we can query the server for actual allocation size,
2918 * this is best estimate we have for blocks allocated for a file
2919 * Number of blocks must be rounded up so size 1 is not 0 blocks
2920 */
2921 inode->i_blocks = (512 - 1 + attrs->ia_size) >> 9;
2922
2923 /*
2924 * The man page of truncate says if the size changed,
2925 * then the st_ctime and st_mtime fields for the file
2926 * are updated.
2927 */
2928 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2929 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2930
2931 cifs_truncate_page(inode->i_mapping, inode->i_size);
2932 }
2933
2934 return rc;
2935 }
2936
2937 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2938 static int
2939 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2940 {
2941 int rc;
2942 unsigned int xid;
2943 const char *full_path;
2944 void *page = alloc_dentry_path();
2945 struct inode *inode = d_inode(direntry);
2946 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2947 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2948 struct tcon_link *tlink;
2949 struct cifs_tcon *pTcon;
2950 struct cifs_unix_set_info_args *args = NULL;
2951 struct cifsFileInfo *open_file;
2952
2953 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2954 direntry, attrs->ia_valid);
2955
2956 xid = get_xid();
2957
2958 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2959 attrs->ia_valid |= ATTR_FORCE;
2960
2961 rc = setattr_prepare(&nop_mnt_idmap, direntry, attrs);
2962 if (rc < 0)
2963 goto out;
2964
2965 full_path = build_path_from_dentry(direntry, page);
2966 if (IS_ERR(full_path)) {
2967 rc = PTR_ERR(full_path);
2968 goto out;
2969 }
2970
2971 /*
2972 * Attempt to flush data before changing attributes. We need to do
2973 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2974 * ownership or mode then we may also need to do this. Here, we take
2975 * the safe way out and just do the flush on all setattr requests. If
2976 * the flush returns error, store it to report later and continue.
2977 *
2978 * BB: This should be smarter. Why bother flushing pages that
2979 * will be truncated anyway? Also, should we error out here if
2980 * the flush returns error?
2981 */
2982 rc = filemap_write_and_wait(inode->i_mapping);
2983 if (is_interrupt_error(rc)) {
2984 rc = -ERESTARTSYS;
2985 goto out;
2986 }
2987
2988 mapping_set_error(inode->i_mapping, rc);
2989 rc = 0;
2990
2991 if (attrs->ia_valid & ATTR_SIZE) {
2992 rc = cifs_set_file_size(inode, attrs, xid, full_path, direntry);
2993 if (rc != 0)
2994 goto out;
2995 }
2996
2997 /* skip mode change if it's just for clearing setuid/setgid */
2998 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2999 attrs->ia_valid &= ~ATTR_MODE;
3000
3001 args = kmalloc(sizeof(*args), GFP_KERNEL);
3002 if (args == NULL) {
3003 rc = -ENOMEM;
3004 goto out;
3005 }
3006
3007 /* set up the struct */
3008 if (attrs->ia_valid & ATTR_MODE)
3009 args->mode = attrs->ia_mode;
3010 else
3011 args->mode = NO_CHANGE_64;
3012
3013 if (attrs->ia_valid & ATTR_UID)
3014 args->uid = attrs->ia_uid;
3015 else
3016 args->uid = INVALID_UID; /* no change */
3017
3018 if (attrs->ia_valid & ATTR_GID)
3019 args->gid = attrs->ia_gid;
3020 else
3021 args->gid = INVALID_GID; /* no change */
3022
3023 if (attrs->ia_valid & ATTR_ATIME)
3024 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
3025 else
3026 args->atime = NO_CHANGE_64;
3027
3028 if (attrs->ia_valid & ATTR_MTIME)
3029 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
3030 else
3031 args->mtime = NO_CHANGE_64;
3032
3033 if (attrs->ia_valid & ATTR_CTIME)
3034 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
3035 else
3036 args->ctime = NO_CHANGE_64;
3037
3038 args->device = 0;
3039 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
3040 if (open_file) {
3041 u16 nfid = open_file->fid.netfid;
3042 u32 npid = open_file->pid;
3043 pTcon = tlink_tcon(open_file->tlink);
3044 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
3045 cifsFileInfo_put(open_file);
3046 } else {
3047 tlink = cifs_sb_tlink(cifs_sb);
3048 if (IS_ERR(tlink)) {
3049 rc = PTR_ERR(tlink);
3050 goto out;
3051 }
3052 pTcon = tlink_tcon(tlink);
3053 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
3054 cifs_sb->local_nls,
3055 cifs_remap(cifs_sb));
3056 cifs_put_tlink(tlink);
3057 }
3058
3059 if (rc)
3060 goto out;
3061
3062 if ((attrs->ia_valid & ATTR_SIZE) &&
3063 attrs->ia_size != i_size_read(inode)) {
3064 truncate_setsize(inode, attrs->ia_size);
3065 fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
3066 }
3067
3068 setattr_copy(&nop_mnt_idmap, inode, attrs);
3069 mark_inode_dirty(inode);
3070
3071 /* force revalidate when any of these times are set since some
3072 of the fs types (eg ext3, fat) do not have fine enough
3073 time granularity to match protocol, and we do not have a
3074 a way (yet) to query the server fs's time granularity (and
3075 whether it rounds times down).
3076 */
3077 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
3078 cifsInode->time = 0;
3079 out:
3080 kfree(args);
3081 free_dentry_path(page);
3082 free_xid(xid);
3083 return rc;
3084 }
3085 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3086
3087 static int
3088 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
3089 {
3090 unsigned int xid;
3091 kuid_t uid = INVALID_UID;
3092 kgid_t gid = INVALID_GID;
3093 struct inode *inode = d_inode(direntry);
3094 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3095 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
3096 struct cifsFileInfo *wfile;
3097 struct cifs_tcon *tcon;
3098 const char *full_path;
3099 void *page = alloc_dentry_path();
3100 int rc = -EACCES;
3101 __u32 dosattr = 0;
3102 __u64 mode = NO_CHANGE_64;
3103 bool posix = cifs_sb_master_tcon(cifs_sb)->posix_extensions;
3104
3105 xid = get_xid();
3106
3107 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
3108 direntry, attrs->ia_valid);
3109
3110 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
3111 attrs->ia_valid |= ATTR_FORCE;
3112
3113 rc = setattr_prepare(&nop_mnt_idmap, direntry, attrs);
3114 if (rc < 0)
3115 goto cifs_setattr_exit;
3116
3117 full_path = build_path_from_dentry(direntry, page);
3118 if (IS_ERR(full_path)) {
3119 rc = PTR_ERR(full_path);
3120 goto cifs_setattr_exit;
3121 }
3122
3123 /*
3124 * Attempt to flush data before changing attributes. We need to do
3125 * this for ATTR_SIZE and ATTR_MTIME. If the flush of the data
3126 * returns error, store it to report later and continue.
3127 *
3128 * BB: This should be smarter. Why bother flushing pages that
3129 * will be truncated anyway? Also, should we error out here if
3130 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
3131 */
3132 if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
3133 rc = filemap_write_and_wait(inode->i_mapping);
3134 if (is_interrupt_error(rc)) {
3135 rc = -ERESTARTSYS;
3136 goto cifs_setattr_exit;
3137 }
3138 mapping_set_error(inode->i_mapping, rc);
3139 }
3140
3141 rc = 0;
3142
3143 if ((attrs->ia_valid & ATTR_MTIME) &&
3144 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
3145 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
3146 if (!rc) {
3147 tcon = tlink_tcon(wfile->tlink);
3148 rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
3149 cifsFileInfo_put(wfile);
3150 if (rc)
3151 goto cifs_setattr_exit;
3152 } else if (rc != -EBADF)
3153 goto cifs_setattr_exit;
3154 else
3155 rc = 0;
3156 }
3157
3158 if (attrs->ia_valid & ATTR_SIZE) {
3159 rc = cifs_set_file_size(inode, attrs, xid, full_path, direntry);
3160 if (rc != 0)
3161 goto cifs_setattr_exit;
3162 }
3163
3164 if (attrs->ia_valid & ATTR_UID)
3165 uid = attrs->ia_uid;
3166
3167 if (attrs->ia_valid & ATTR_GID)
3168 gid = attrs->ia_gid;
3169
3170 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
3171 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
3172 if (uid_valid(uid) || gid_valid(gid)) {
3173 mode = NO_CHANGE_64;
3174 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
3175 uid, gid);
3176 if (rc) {
3177 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
3178 __func__, rc);
3179 goto cifs_setattr_exit;
3180 }
3181 }
3182 } else
3183 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
3184 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
3185
3186 /* skip mode change if it's just for clearing setuid/setgid */
3187 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
3188 attrs->ia_valid &= ~ATTR_MODE;
3189
3190 if (attrs->ia_valid & ATTR_MODE) {
3191 mode = attrs->ia_mode;
3192 rc = 0;
3193 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
3194 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) ||
3195 posix) {
3196 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
3197 INVALID_UID, INVALID_GID);
3198 if (rc) {
3199 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
3200 __func__, rc);
3201 goto cifs_setattr_exit;
3202 }
3203
3204 /*
3205 * In case of CIFS_MOUNT_CIFS_ACL, we cannot support all modes.
3206 * Pick up the actual mode bits that were set.
3207 */
3208 if (mode != attrs->ia_mode)
3209 attrs->ia_mode = mode;
3210 } else
3211 if (((mode & S_IWUGO) == 0) &&
3212 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
3213
3214 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
3215
3216 /* fix up mode if we're not using dynperm */
3217 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
3218 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
3219 } else if ((mode & S_IWUGO) &&
3220 (cifsInode->cifsAttrs & ATTR_READONLY)) {
3221
3222 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
3223 /* Attributes of 0 are ignored */
3224 if (dosattr == 0)
3225 dosattr |= ATTR_NORMAL;
3226
3227 /* reset local inode permissions to normal */
3228 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
3229 attrs->ia_mode &= ~(S_IALLUGO);
3230 if (S_ISDIR(inode->i_mode))
3231 attrs->ia_mode |=
3232 cifs_sb->ctx->dir_mode;
3233 else
3234 attrs->ia_mode |=
3235 cifs_sb->ctx->file_mode;
3236 }
3237 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
3238 /* ignore mode change - ATTR_READONLY hasn't changed */
3239 attrs->ia_valid &= ~ATTR_MODE;
3240 }
3241 }
3242
3243 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
3244 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
3245 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
3246 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
3247
3248 /* Even if error on time set, no sense failing the call if
3249 the server would set the time to a reasonable value anyway,
3250 and this check ensures that we are not being called from
3251 sys_utimes in which case we ought to fail the call back to
3252 the user when the server rejects the call */
3253 if ((rc) && (attrs->ia_valid &
3254 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
3255 rc = 0;
3256 }
3257
3258 /* do not need local check to inode_check_ok since the server does
3259 that */
3260 if (rc)
3261 goto cifs_setattr_exit;
3262
3263 if ((attrs->ia_valid & ATTR_SIZE) &&
3264 attrs->ia_size != i_size_read(inode)) {
3265 truncate_setsize(inode, attrs->ia_size);
3266 fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
3267 }
3268
3269 setattr_copy(&nop_mnt_idmap, inode, attrs);
3270 mark_inode_dirty(inode);
3271
3272 cifs_setattr_exit:
3273 free_xid(xid);
3274 free_dentry_path(page);
3275 return rc;
3276 }
3277
3278 int
3279 cifs_setattr(struct mnt_idmap *idmap, struct dentry *direntry,
3280 struct iattr *attrs)
3281 {
3282 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
3283 int rc, retries = 0;
3284 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3285 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
3286 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3287
3288 if (unlikely(cifs_forced_shutdown(cifs_sb)))
3289 return -EIO;
3290
3291 do {
3292 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3293 if (pTcon->unix_ext)
3294 rc = cifs_setattr_unix(direntry, attrs);
3295 else
3296 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3297 rc = cifs_setattr_nounix(direntry, attrs);
3298 retries++;
3299 } while (is_retryable_error(rc) && retries < 2);
3300
3301 /* BB: add cifs_setattr_legacy for really old servers */
3302 return rc;
3303 }
3304