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