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