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