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