]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - fs/cifs/inode.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:


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