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