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