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