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