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