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