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