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