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