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