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