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