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