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