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