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