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