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