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