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