]> git.ipfire.org Git - thirdparty/kernel/stable.git/blob - fs/cifs/inode.c
projects / thirdparty / kernel / stable.git / blob
? search:


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