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