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