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