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