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