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