projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'pm-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/suspe...
[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_EXPERIMENTAL
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
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 {
733 int pplen = cifs_sb->prepathlen;
734 int dfsplen;
735 char *full_path = NULL;
736 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
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 list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
814 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
815 spin_unlock(&dcache_lock);
816 return true;
817 }
818 }
819 spin_unlock(&dcache_lock);
820 return false;
821 }
822
823 /* Given fattrs, get a corresponding inode */
824 struct inode *
825 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
826 {
827 unsigned long hash;
828 struct inode *inode;
829
830 retry_iget5_locked:
831 cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
832
833 /* hash down to 32-bits on 32-bit arch */
834 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
835
836 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
837 if (inode) {
838 /* was there a potentially problematic inode collision? */
839 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
840 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
841
842 if (inode_has_hashed_dentries(inode)) {
843 cifs_autodisable_serverino(CIFS_SB(sb));
844 iput(inode);
845 fattr->cf_uniqueid = iunique(sb, ROOT_I);
846 goto retry_iget5_locked;
847 }
848 }
849
850 cifs_fattr_to_inode(inode, fattr);
851 if (sb->s_flags & MS_NOATIME)
852 inode->i_flags |= S_NOATIME | S_NOCMTIME;
853 if (inode->i_state & I_NEW) {
854 inode->i_ino = hash;
855 if (S_ISREG(inode->i_mode))
856 inode->i_data.backing_dev_info = sb->s_bdi;
857 #ifdef CONFIG_CIFS_FSCACHE
858 /* initialize per-inode cache cookie pointer */
859 CIFS_I(inode)->fscache = NULL;
860 #endif
861 unlock_new_inode(inode);
862 }
863 }
864
865 return inode;
866 }
867
868 /* gets root inode */
869 struct inode *cifs_root_iget(struct super_block *sb, unsigned long ino)
870 {
871 int xid;
872 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
873 struct inode *inode = NULL;
874 long rc;
875 char *full_path;
876 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
877
878 full_path = cifs_build_path_to_root(cifs_sb);
879 if (full_path == NULL)
880 return ERR_PTR(-ENOMEM);
881
882 xid = GetXid();
883 if (tcon->unix_ext)
884 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
885 else
886 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
887 xid, NULL);
888
889 if (!inode) {
890 inode = ERR_PTR(rc);
891 goto out;
892 }
893
894 #ifdef CONFIG_CIFS_FSCACHE
895 /* populate tcon->resource_id */
896 tcon->resource_id = CIFS_I(inode)->uniqueid;
897 #endif
898
899 if (rc && tcon->ipc) {
900 cFYI(1, "ipc connection - fake read inode");
901 inode->i_mode |= S_IFDIR;
902 inode->i_nlink = 2;
903 inode->i_op = &cifs_ipc_inode_ops;
904 inode->i_fop = &simple_dir_operations;
905 inode->i_uid = cifs_sb->mnt_uid;
906 inode->i_gid = cifs_sb->mnt_gid;
907 } else if (rc) {
908 iget_failed(inode);
909 inode = ERR_PTR(rc);
910 }
911
912 out:
913 kfree(full_path);
914 /* can not call macro FreeXid here since in a void func
915 * TODO: This is no longer true
916 */
917 _FreeXid(xid);
918 return inode;
919 }
920
921 static int
922 cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
923 char *full_path, __u32 dosattr)
924 {
925 int rc;
926 int oplock = 0;
927 __u16 netfid;
928 __u32 netpid;
929 bool set_time = false;
930 struct cifsFileInfo *open_file;
931 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
932 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
933 struct tcon_link *tlink = NULL;
934 struct cifsTconInfo *pTcon;
935 FILE_BASIC_INFO info_buf;
936
937 if (attrs == NULL)
938 return -EINVAL;
939
940 if (attrs->ia_valid & ATTR_ATIME) {
941 set_time = true;
942 info_buf.LastAccessTime =
943 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
944 } else
945 info_buf.LastAccessTime = 0;
946
947 if (attrs->ia_valid & ATTR_MTIME) {
948 set_time = true;
949 info_buf.LastWriteTime =
950 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
951 } else
952 info_buf.LastWriteTime = 0;
953
954 /*
955 * Samba throws this field away, but windows may actually use it.
956 * Do not set ctime unless other time stamps are changed explicitly
957 * (i.e. by utimes()) since we would then have a mix of client and
958 * server times.
959 */
960 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
961 cFYI(1, "CIFS - CTIME changed");
962 info_buf.ChangeTime =
963 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
964 } else
965 info_buf.ChangeTime = 0;
966
967 info_buf.CreationTime = 0; /* don't change */
968 info_buf.Attributes = cpu_to_le32(dosattr);
969
970 /*
971 * If the file is already open for write, just use that fileid
972 */
973 open_file = find_writable_file(cifsInode, true);
974 if (open_file) {
975 netfid = open_file->netfid;
976 netpid = open_file->pid;
977 pTcon = tlink_tcon(open_file->tlink);
978 goto set_via_filehandle;
979 }
980
981 tlink = cifs_sb_tlink(cifs_sb);
982 if (IS_ERR(tlink)) {
983 rc = PTR_ERR(tlink);
984 tlink = NULL;
985 goto out;
986 }
987 pTcon = tlink_tcon(tlink);
988
989 /*
990 * NT4 apparently returns success on this call, but it doesn't
991 * really work.
992 */
993 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
994 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
995 &info_buf, cifs_sb->local_nls,
996 cifs_sb->mnt_cifs_flags &
997 CIFS_MOUNT_MAP_SPECIAL_CHR);
998 if (rc == 0) {
999 cifsInode->cifsAttrs = dosattr;
1000 goto out;
1001 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
1002 goto out;
1003 }
1004
1005 cFYI(1, "calling SetFileInfo since SetPathInfo for "
1006 "times not supported by this server");
1007 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1008 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1009 CREATE_NOT_DIR, &netfid, &oplock,
1010 NULL, cifs_sb->local_nls,
1011 cifs_sb->mnt_cifs_flags &
1012 CIFS_MOUNT_MAP_SPECIAL_CHR);
1013
1014 if (rc != 0) {
1015 if (rc == -EIO)
1016 rc = -EINVAL;
1017 goto out;
1018 }
1019
1020 netpid = current->tgid;
1021
1022 set_via_filehandle:
1023 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
1024 if (!rc)
1025 cifsInode->cifsAttrs = dosattr;
1026
1027 if (open_file == NULL)
1028 CIFSSMBClose(xid, pTcon, netfid);
1029 else
1030 cifsFileInfo_put(open_file);
1031 out:
1032 if (tlink != NULL)
1033 cifs_put_tlink(tlink);
1034 return rc;
1035 }
1036
1037 /*
1038 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1039 * and rename it to a random name that hopefully won't conflict with
1040 * anything else.
1041 */
1042 static int
1043 cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
1044 {
1045 int oplock = 0;
1046 int rc;
1047 __u16 netfid;
1048 struct inode *inode = dentry->d_inode;
1049 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1050 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1051 struct tcon_link *tlink;
1052 struct cifsTconInfo *tcon;
1053 __u32 dosattr, origattr;
1054 FILE_BASIC_INFO *info_buf = NULL;
1055
1056 tlink = cifs_sb_tlink(cifs_sb);
1057 if (IS_ERR(tlink))
1058 return PTR_ERR(tlink);
1059 tcon = tlink_tcon(tlink);
1060
1061 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1062 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1063 &netfid, &oplock, NULL, cifs_sb->local_nls,
1064 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1065 if (rc != 0)
1066 goto out;
1067
1068 origattr = cifsInode->cifsAttrs;
1069 if (origattr == 0)
1070 origattr |= ATTR_NORMAL;
1071
1072 dosattr = origattr & ~ATTR_READONLY;
1073 if (dosattr == 0)
1074 dosattr |= ATTR_NORMAL;
1075 dosattr |= ATTR_HIDDEN;
1076
1077 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1078 if (dosattr != origattr) {
1079 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1080 if (info_buf == NULL) {
1081 rc = -ENOMEM;
1082 goto out_close;
1083 }
1084 info_buf->Attributes = cpu_to_le32(dosattr);
1085 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1086 current->tgid);
1087 /* although we would like to mark the file hidden
1088 if that fails we will still try to rename it */
1089 if (rc != 0)
1090 cifsInode->cifsAttrs = dosattr;
1091 else
1092 dosattr = origattr; /* since not able to change them */
1093 }
1094
1095 /* rename the file */
1096 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1097 cifs_sb->mnt_cifs_flags &
1098 CIFS_MOUNT_MAP_SPECIAL_CHR);
1099 if (rc != 0) {
1100 rc = -ETXTBSY;
1101 goto undo_setattr;
1102 }
1103
1104 /* try to set DELETE_ON_CLOSE */
1105 if (!cifsInode->delete_pending) {
1106 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1107 current->tgid);
1108 /*
1109 * some samba versions return -ENOENT when we try to set the
1110 * file disposition here. Likely a samba bug, but work around
1111 * it for now. This means that some cifsXXX files may hang
1112 * around after they shouldn't.
1113 *
1114 * BB: remove this hack after more servers have the fix
1115 */
1116 if (rc == -ENOENT)
1117 rc = 0;
1118 else if (rc != 0) {
1119 rc = -ETXTBSY;
1120 goto undo_rename;
1121 }
1122 cifsInode->delete_pending = true;
1123 }
1124
1125 out_close:
1126 CIFSSMBClose(xid, tcon, netfid);
1127 out:
1128 kfree(info_buf);
1129 cifs_put_tlink(tlink);
1130 return rc;
1131
1132 /*
1133 * reset everything back to the original state. Don't bother
1134 * dealing with errors here since we can't do anything about
1135 * them anyway.
1136 */
1137 undo_rename:
1138 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1139 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1140 CIFS_MOUNT_MAP_SPECIAL_CHR);
1141 undo_setattr:
1142 if (dosattr != origattr) {
1143 info_buf->Attributes = cpu_to_le32(origattr);
1144 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1145 current->tgid))
1146 cifsInode->cifsAttrs = origattr;
1147 }
1148
1149 goto out_close;
1150 }
1151
1152
1153 /*
1154 * If dentry->d_inode is null (usually meaning the cached dentry
1155 * is a negative dentry) then we would attempt a standard SMB delete, but
1156 * if that fails we can not attempt the fall back mechanisms on EACCESS
1157 * but will return the EACCESS to the caller. Note that the VFS does not call
1158 * unlink on negative dentries currently.
1159 */
1160 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1161 {
1162 int rc = 0;
1163 int xid;
1164 char *full_path = NULL;
1165 struct inode *inode = dentry->d_inode;
1166 struct cifsInodeInfo *cifs_inode;
1167 struct super_block *sb = dir->i_sb;
1168 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1169 struct tcon_link *tlink;
1170 struct cifsTconInfo *tcon;
1171 struct iattr *attrs = NULL;
1172 __u32 dosattr = 0, origattr = 0;
1173
1174 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
1175
1176 tlink = cifs_sb_tlink(cifs_sb);
1177 if (IS_ERR(tlink))
1178 return PTR_ERR(tlink);
1179 tcon = tlink_tcon(tlink);
1180
1181 xid = GetXid();
1182
1183 /* Unlink can be called from rename so we can not take the
1184 * sb->s_vfs_rename_mutex here */
1185 full_path = build_path_from_dentry(dentry);
1186 if (full_path == NULL) {
1187 rc = -ENOMEM;
1188 goto unlink_out;
1189 }
1190
1191 if ((tcon->ses->capabilities & CAP_UNIX) &&
1192 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1193 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1194 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1195 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1196 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1197 cFYI(1, "posix del rc %d", rc);
1198 if ((rc == 0) || (rc == -ENOENT))
1199 goto psx_del_no_retry;
1200 }
1201
1202 retry_std_delete:
1203 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
1204 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1205
1206 psx_del_no_retry:
1207 if (!rc) {
1208 if (inode)
1209 drop_nlink(inode);
1210 } else if (rc == -ENOENT) {
1211 d_drop(dentry);
1212 } else if (rc == -ETXTBSY) {
1213 rc = cifs_rename_pending_delete(full_path, dentry, xid);
1214 if (rc == 0)
1215 drop_nlink(inode);
1216 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1217 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1218 if (attrs == NULL) {
1219 rc = -ENOMEM;
1220 goto out_reval;
1221 }
1222
1223 /* try to reset dos attributes */
1224 cifs_inode = CIFS_I(inode);
1225 origattr = cifs_inode->cifsAttrs;
1226 if (origattr == 0)
1227 origattr |= ATTR_NORMAL;
1228 dosattr = origattr & ~ATTR_READONLY;
1229 if (dosattr == 0)
1230 dosattr |= ATTR_NORMAL;
1231 dosattr |= ATTR_HIDDEN;
1232
1233 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1234 if (rc != 0)
1235 goto out_reval;
1236
1237 goto retry_std_delete;
1238 }
1239
1240 /* undo the setattr if we errored out and it's needed */
1241 if (rc != 0 && dosattr != 0)
1242 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1243
1244 out_reval:
1245 if (inode) {
1246 cifs_inode = CIFS_I(inode);
1247 cifs_inode->time = 0; /* will force revalidate to get info
1248 when needed */
1249 inode->i_ctime = current_fs_time(sb);
1250 }
1251 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1252 cifs_inode = CIFS_I(dir);
1253 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1254 unlink_out:
1255 kfree(full_path);
1256 kfree(attrs);
1257 FreeXid(xid);
1258 cifs_put_tlink(tlink);
1259 return rc;
1260 }
1261
1262 int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1263 {
1264 int rc = 0, tmprc;
1265 int xid;
1266 struct cifs_sb_info *cifs_sb;
1267 struct tcon_link *tlink;
1268 struct cifsTconInfo *pTcon;
1269 char *full_path = NULL;
1270 struct inode *newinode = NULL;
1271 struct cifs_fattr fattr;
1272
1273 cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
1274
1275 cifs_sb = CIFS_SB(inode->i_sb);
1276 tlink = cifs_sb_tlink(cifs_sb);
1277 if (IS_ERR(tlink))
1278 return PTR_ERR(tlink);
1279 pTcon = tlink_tcon(tlink);
1280
1281 xid = GetXid();
1282
1283 full_path = build_path_from_dentry(direntry);
1284 if (full_path == NULL) {
1285 rc = -ENOMEM;
1286 goto mkdir_out;
1287 }
1288
1289 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1290 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1291 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1292 u32 oplock = 0;
1293 FILE_UNIX_BASIC_INFO *pInfo =
1294 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1295 if (pInfo == NULL) {
1296 rc = -ENOMEM;
1297 goto mkdir_out;
1298 }
1299
1300 mode &= ~current_umask();
1301 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1302 mode, NULL /* netfid */, pInfo, &oplock,
1303 full_path, cifs_sb->local_nls,
1304 cifs_sb->mnt_cifs_flags &
1305 CIFS_MOUNT_MAP_SPECIAL_CHR);
1306 if (rc == -EOPNOTSUPP) {
1307 kfree(pInfo);
1308 goto mkdir_retry_old;
1309 } else if (rc) {
1310 cFYI(1, "posix mkdir returned 0x%x", rc);
1311 d_drop(direntry);
1312 } else {
1313 if (pInfo->Type == cpu_to_le32(-1)) {
1314 /* no return info, go query for it */
1315 kfree(pInfo);
1316 goto mkdir_get_info;
1317 }
1318 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1319 to set uid/gid */
1320 inc_nlink(inode);
1321 if (pTcon->nocase)
1322 direntry->d_op = &cifs_ci_dentry_ops;
1323 else
1324 direntry->d_op = &cifs_dentry_ops;
1325
1326 cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
1327 cifs_fill_uniqueid(inode->i_sb, &fattr);
1328 newinode = cifs_iget(inode->i_sb, &fattr);
1329 if (!newinode) {
1330 kfree(pInfo);
1331 goto mkdir_get_info;
1332 }
1333
1334 d_instantiate(direntry, newinode);
1335
1336 #ifdef CONFIG_CIFS_DEBUG2
1337 cFYI(1, "instantiated dentry %p %s to inode %p",
1338 direntry, direntry->d_name.name, newinode);
1339
1340 if (newinode->i_nlink != 2)
1341 cFYI(1, "unexpected number of links %d",
1342 newinode->i_nlink);
1343 #endif
1344 }
1345 kfree(pInfo);
1346 goto mkdir_out;
1347 }
1348 mkdir_retry_old:
1349 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1350 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1351 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1352 if (rc) {
1353 cFYI(1, "cifs_mkdir returned 0x%x", rc);
1354 d_drop(direntry);
1355 } else {
1356 mkdir_get_info:
1357 inc_nlink(inode);
1358 if (pTcon->unix_ext)
1359 rc = cifs_get_inode_info_unix(&newinode, full_path,
1360 inode->i_sb, xid);
1361 else
1362 rc = cifs_get_inode_info(&newinode, full_path, NULL,
1363 inode->i_sb, xid, NULL);
1364
1365 if (pTcon->nocase)
1366 direntry->d_op = &cifs_ci_dentry_ops;
1367 else
1368 direntry->d_op = &cifs_dentry_ops;
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
1657 if (cifs_i->clientCanCacheRead)
1658 return false;
1659
1660 if (!lookupCacheEnabled)
1661 return true;
1662
1663 if (cifs_i->time == 0)
1664 return true;
1665
1666 /* FIXME: the actimeo should be tunable */
1667 if (time_after_eq(jiffies, cifs_i->time + HZ))
1668 return true;
1669
1670 /* hardlinked files w/ noserverino get "special" treatment */
1671 if (!(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1672 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1673 return true;
1674
1675 return false;
1676 }
1677
1678 /*
1679 * Zap the cache. Called when invalid_mapping flag is set.
1680 */
1681 static void
1682 cifs_invalidate_mapping(struct inode *inode)
1683 {
1684 int rc;
1685 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1686
1687 cifs_i->invalid_mapping = false;
1688
1689 /* write back any cached data */
1690 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1691 rc = filemap_write_and_wait(inode->i_mapping);
1692 mapping_set_error(inode->i_mapping, rc);
1693 }
1694 invalidate_remote_inode(inode);
1695 cifs_fscache_reset_inode_cookie(inode);
1696 }
1697
1698 int cifs_revalidate_file(struct file *filp)
1699 {
1700 int rc = 0;
1701 struct inode *inode = filp->f_path.dentry->d_inode;
1702 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1703
1704 if (!cifs_inode_needs_reval(inode))
1705 goto check_inval;
1706
1707 if (tlink_tcon(cfile->tlink)->unix_ext)
1708 rc = cifs_get_file_info_unix(filp);
1709 else
1710 rc = cifs_get_file_info(filp);
1711
1712 check_inval:
1713 if (CIFS_I(inode)->invalid_mapping)
1714 cifs_invalidate_mapping(inode);
1715
1716 return rc;
1717 }
1718
1719 /* revalidate a dentry's inode attributes */
1720 int cifs_revalidate_dentry(struct dentry *dentry)
1721 {
1722 int xid;
1723 int rc = 0;
1724 char *full_path = NULL;
1725 struct inode *inode = dentry->d_inode;
1726 struct super_block *sb = dentry->d_sb;
1727
1728 if (inode == NULL)
1729 return -ENOENT;
1730
1731 xid = GetXid();
1732
1733 if (!cifs_inode_needs_reval(inode))
1734 goto check_inval;
1735
1736 /* can not safely grab the rename sem here if rename calls revalidate
1737 since that would deadlock */
1738 full_path = build_path_from_dentry(dentry);
1739 if (full_path == NULL) {
1740 rc = -ENOMEM;
1741 goto check_inval;
1742 }
1743
1744 cFYI(1, "Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1745 "jiffies %ld", full_path, inode, inode->i_count.counter,
1746 dentry, dentry->d_time, jiffies);
1747
1748 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1749 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1750 else
1751 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1752 xid, NULL);
1753
1754 check_inval:
1755 if (CIFS_I(inode)->invalid_mapping)
1756 cifs_invalidate_mapping(inode);
1757
1758 kfree(full_path);
1759 FreeXid(xid);
1760 return rc;
1761 }
1762
1763 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1764 struct kstat *stat)
1765 {
1766 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1767 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
1768 int err = cifs_revalidate_dentry(dentry);
1769
1770 if (!err) {
1771 generic_fillattr(dentry->d_inode, stat);
1772 stat->blksize = CIFS_MAX_MSGSIZE;
1773 stat->ino = CIFS_I(dentry->d_inode)->uniqueid;
1774
1775 /*
1776 * If on a multiuser mount without unix extensions, and the
1777 * admin hasn't overridden them, set the ownership to the
1778 * fsuid/fsgid of the current process.
1779 */
1780 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1781 !tcon->unix_ext) {
1782 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1783 stat->uid = current_fsuid();
1784 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1785 stat->gid = current_fsgid();
1786 }
1787 }
1788 return err;
1789 }
1790
1791 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1792 {
1793 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1794 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1795 struct page *page;
1796 int rc = 0;
1797
1798 page = grab_cache_page(mapping, index);
1799 if (!page)
1800 return -ENOMEM;
1801
1802 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1803 unlock_page(page);
1804 page_cache_release(page);
1805 return rc;
1806 }
1807
1808 static void cifs_setsize(struct inode *inode, loff_t offset)
1809 {
1810 loff_t oldsize;
1811
1812 spin_lock(&inode->i_lock);
1813 oldsize = inode->i_size;
1814 i_size_write(inode, offset);
1815 spin_unlock(&inode->i_lock);
1816
1817 truncate_pagecache(inode, oldsize, offset);
1818 }
1819
1820 static int
1821 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1822 int xid, char *full_path)
1823 {
1824 int rc;
1825 struct cifsFileInfo *open_file;
1826 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1827 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1828 struct tcon_link *tlink = NULL;
1829 struct cifsTconInfo *pTcon = NULL;
1830
1831 /*
1832 * To avoid spurious oplock breaks from server, in the case of
1833 * inodes that we already have open, avoid doing path based
1834 * setting of file size if we can do it by handle.
1835 * This keeps our caching token (oplock) and avoids timeouts
1836 * when the local oplock break takes longer to flush
1837 * writebehind data than the SMB timeout for the SetPathInfo
1838 * request would allow
1839 */
1840 open_file = find_writable_file(cifsInode, true);
1841 if (open_file) {
1842 __u16 nfid = open_file->netfid;
1843 __u32 npid = open_file->pid;
1844 pTcon = tlink_tcon(open_file->tlink);
1845 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1846 npid, false);
1847 cifsFileInfo_put(open_file);
1848 cFYI(1, "SetFSize for attrs rc = %d", rc);
1849 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1850 unsigned int bytes_written;
1851 rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
1852 &bytes_written, NULL, NULL, 1);
1853 cFYI(1, "Wrt seteof rc %d", rc);
1854 }
1855 } else
1856 rc = -EINVAL;
1857
1858 if (rc != 0) {
1859 if (pTcon == NULL) {
1860 tlink = cifs_sb_tlink(cifs_sb);
1861 if (IS_ERR(tlink))
1862 return PTR_ERR(tlink);
1863 pTcon = tlink_tcon(tlink);
1864 }
1865
1866 /* Set file size by pathname rather than by handle
1867 either because no valid, writeable file handle for
1868 it was found or because there was an error setting
1869 it by handle */
1870 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1871 false, cifs_sb->local_nls,
1872 cifs_sb->mnt_cifs_flags &
1873 CIFS_MOUNT_MAP_SPECIAL_CHR);
1874 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1875 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1876 __u16 netfid;
1877 int oplock = 0;
1878
1879 rc = SMBLegacyOpen(xid, pTcon, full_path,
1880 FILE_OPEN, GENERIC_WRITE,
1881 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1882 cifs_sb->local_nls,
1883 cifs_sb->mnt_cifs_flags &
1884 CIFS_MOUNT_MAP_SPECIAL_CHR);
1885 if (rc == 0) {
1886 unsigned int bytes_written;
1887 rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
1888 attrs->ia_size,
1889 &bytes_written, NULL,
1890 NULL, 1);
1891 cFYI(1, "wrt seteof rc %d", rc);
1892 CIFSSMBClose(xid, pTcon, netfid);
1893 }
1894 }
1895 if (tlink)
1896 cifs_put_tlink(tlink);
1897 }
1898
1899 if (rc == 0) {
1900 cifsInode->server_eof = attrs->ia_size;
1901 cifs_setsize(inode, attrs->ia_size);
1902 cifs_truncate_page(inode->i_mapping, inode->i_size);
1903 }
1904
1905 return rc;
1906 }
1907
1908 static int
1909 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1910 {
1911 int rc;
1912 int xid;
1913 char *full_path = NULL;
1914 struct inode *inode = direntry->d_inode;
1915 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1916 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1917 struct tcon_link *tlink;
1918 struct cifsTconInfo *pTcon;
1919 struct cifs_unix_set_info_args *args = NULL;
1920 struct cifsFileInfo *open_file;
1921
1922 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1923 direntry->d_name.name, attrs->ia_valid);
1924
1925 xid = GetXid();
1926
1927 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1928 attrs->ia_valid |= ATTR_FORCE;
1929
1930 rc = inode_change_ok(inode, attrs);
1931 if (rc < 0)
1932 goto out;
1933
1934 full_path = build_path_from_dentry(direntry);
1935 if (full_path == NULL) {
1936 rc = -ENOMEM;
1937 goto out;
1938 }
1939
1940 /*
1941 * Attempt to flush data before changing attributes. We need to do
1942 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1943 * ownership or mode then we may also need to do this. Here, we take
1944 * the safe way out and just do the flush on all setattr requests. If
1945 * the flush returns error, store it to report later and continue.
1946 *
1947 * BB: This should be smarter. Why bother flushing pages that
1948 * will be truncated anyway? Also, should we error out here if
1949 * the flush returns error?
1950 */
1951 rc = filemap_write_and_wait(inode->i_mapping);
1952 mapping_set_error(inode->i_mapping, rc);
1953 rc = 0;
1954
1955 if (attrs->ia_valid & ATTR_SIZE) {
1956 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1957 if (rc != 0)
1958 goto out;
1959 }
1960
1961 /* skip mode change if it's just for clearing setuid/setgid */
1962 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1963 attrs->ia_valid &= ~ATTR_MODE;
1964
1965 args = kmalloc(sizeof(*args), GFP_KERNEL);
1966 if (args == NULL) {
1967 rc = -ENOMEM;
1968 goto out;
1969 }
1970
1971 /* set up the struct */
1972 if (attrs->ia_valid & ATTR_MODE)
1973 args->mode = attrs->ia_mode;
1974 else
1975 args->mode = NO_CHANGE_64;
1976
1977 if (attrs->ia_valid & ATTR_UID)
1978 args->uid = attrs->ia_uid;
1979 else
1980 args->uid = NO_CHANGE_64;
1981
1982 if (attrs->ia_valid & ATTR_GID)
1983 args->gid = attrs->ia_gid;
1984 else
1985 args->gid = NO_CHANGE_64;
1986
1987 if (attrs->ia_valid & ATTR_ATIME)
1988 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
1989 else
1990 args->atime = NO_CHANGE_64;
1991
1992 if (attrs->ia_valid & ATTR_MTIME)
1993 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
1994 else
1995 args->mtime = NO_CHANGE_64;
1996
1997 if (attrs->ia_valid & ATTR_CTIME)
1998 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
1999 else
2000 args->ctime = NO_CHANGE_64;
2001
2002 args->device = 0;
2003 open_file = find_writable_file(cifsInode, true);
2004 if (open_file) {
2005 u16 nfid = open_file->netfid;
2006 u32 npid = open_file->pid;
2007 pTcon = tlink_tcon(open_file->tlink);
2008 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2009 cifsFileInfo_put(open_file);
2010 } else {
2011 tlink = cifs_sb_tlink(cifs_sb);
2012 if (IS_ERR(tlink)) {
2013 rc = PTR_ERR(tlink);
2014 goto out;
2015 }
2016 pTcon = tlink_tcon(tlink);
2017 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2018 cifs_sb->local_nls,
2019 cifs_sb->mnt_cifs_flags &
2020 CIFS_MOUNT_MAP_SPECIAL_CHR);
2021 cifs_put_tlink(tlink);
2022 }
2023
2024 if (rc)
2025 goto out;
2026
2027 if ((attrs->ia_valid & ATTR_SIZE) &&
2028 attrs->ia_size != i_size_read(inode))
2029 truncate_setsize(inode, attrs->ia_size);
2030
2031 setattr_copy(inode, attrs);
2032 mark_inode_dirty(inode);
2033
2034 /* force revalidate when any of these times are set since some
2035 of the fs types (eg ext3, fat) do not have fine enough
2036 time granularity to match protocol, and we do not have a
2037 a way (yet) to query the server fs's time granularity (and
2038 whether it rounds times down).
2039 */
2040 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2041 cifsInode->time = 0;
2042 out:
2043 kfree(args);
2044 kfree(full_path);
2045 FreeXid(xid);
2046 return rc;
2047 }
2048
2049 static int
2050 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2051 {
2052 int xid;
2053 struct inode *inode = direntry->d_inode;
2054 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2055 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2056 char *full_path = NULL;
2057 int rc = -EACCES;
2058 __u32 dosattr = 0;
2059 __u64 mode = NO_CHANGE_64;
2060
2061 xid = GetXid();
2062
2063 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2064 direntry->d_name.name, attrs->ia_valid);
2065
2066 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2067 attrs->ia_valid |= ATTR_FORCE;
2068
2069 rc = inode_change_ok(inode, attrs);
2070 if (rc < 0) {
2071 FreeXid(xid);
2072 return rc;
2073 }
2074
2075 full_path = build_path_from_dentry(direntry);
2076 if (full_path == NULL) {
2077 rc = -ENOMEM;
2078 FreeXid(xid);
2079 return rc;
2080 }
2081
2082 /*
2083 * Attempt to flush data before changing attributes. We need to do
2084 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2085 * ownership or mode then we may also need to do this. Here, we take
2086 * the safe way out and just do the flush on all setattr requests. If
2087 * the flush returns error, store it to report later and continue.
2088 *
2089 * BB: This should be smarter. Why bother flushing pages that
2090 * will be truncated anyway? Also, should we error out here if
2091 * the flush returns error?
2092 */
2093 rc = filemap_write_and_wait(inode->i_mapping);
2094 mapping_set_error(inode->i_mapping, rc);
2095 rc = 0;
2096
2097 if (attrs->ia_valid & ATTR_SIZE) {
2098 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2099 if (rc != 0)
2100 goto cifs_setattr_exit;
2101 }
2102
2103 /*
2104 * Without unix extensions we can't send ownership changes to the
2105 * server, so silently ignore them. This is consistent with how
2106 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
2107 * CIFSACL support + proper Windows to Unix idmapping, we may be
2108 * able to support this in the future.
2109 */
2110 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2111 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2112
2113 /* skip mode change if it's just for clearing setuid/setgid */
2114 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2115 attrs->ia_valid &= ~ATTR_MODE;
2116
2117 if (attrs->ia_valid & ATTR_MODE) {
2118 cFYI(1, "Mode changed to 0%o", attrs->ia_mode);
2119 mode = attrs->ia_mode;
2120 }
2121
2122 if (attrs->ia_valid & ATTR_MODE) {
2123 rc = 0;
2124 #ifdef CONFIG_CIFS_EXPERIMENTAL
2125 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2126 rc = mode_to_cifs_acl(inode, full_path, mode);
2127 if (rc) {
2128 cFYI(1, "%s: Setting ACL failed with error: %d",
2129 __func__, rc);
2130 goto cifs_setattr_exit;
2131 }
2132 } else
2133 #endif
2134 if (((mode & S_IWUGO) == 0) &&
2135 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2136
2137 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2138
2139 /* fix up mode if we're not using dynperm */
2140 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2141 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2142 } else if ((mode & S_IWUGO) &&
2143 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2144
2145 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2146 /* Attributes of 0 are ignored */
2147 if (dosattr == 0)
2148 dosattr |= ATTR_NORMAL;
2149
2150 /* reset local inode permissions to normal */
2151 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2152 attrs->ia_mode &= ~(S_IALLUGO);
2153 if (S_ISDIR(inode->i_mode))
2154 attrs->ia_mode |=
2155 cifs_sb->mnt_dir_mode;
2156 else
2157 attrs->ia_mode |=
2158 cifs_sb->mnt_file_mode;
2159 }
2160 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2161 /* ignore mode change - ATTR_READONLY hasn't changed */
2162 attrs->ia_valid &= ~ATTR_MODE;
2163 }
2164 }
2165
2166 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2167 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2168 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2169 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2170
2171 /* Even if error on time set, no sense failing the call if
2172 the server would set the time to a reasonable value anyway,
2173 and this check ensures that we are not being called from
2174 sys_utimes in which case we ought to fail the call back to
2175 the user when the server rejects the call */
2176 if ((rc) && (attrs->ia_valid &
2177 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2178 rc = 0;
2179 }
2180
2181 /* do not need local check to inode_check_ok since the server does
2182 that */
2183 if (rc)
2184 goto cifs_setattr_exit;
2185
2186 if ((attrs->ia_valid & ATTR_SIZE) &&
2187 attrs->ia_size != i_size_read(inode))
2188 truncate_setsize(inode, attrs->ia_size);
2189
2190 setattr_copy(inode, attrs);
2191 mark_inode_dirty(inode);
2192
2193 cifs_setattr_exit:
2194 kfree(full_path);
2195 FreeXid(xid);
2196 return rc;
2197 }
2198
2199 int
2200 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2201 {
2202 struct inode *inode = direntry->d_inode;
2203 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2204 struct cifsTconInfo *pTcon = cifs_sb_master_tcon(cifs_sb);
2205
2206 if (pTcon->unix_ext)
2207 return cifs_setattr_unix(direntry, attrs);
2208
2209 return cifs_setattr_nounix(direntry, attrs);
2210
2211 /* BB: add cifs_setattr_legacy for really old servers */
2212 }
2213
2214 #if 0
2215 void cifs_delete_inode(struct inode *inode)
2216 {
2217 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
2218 /* may have to add back in if and when safe distributed caching of
2219 directories added e.g. via FindNotify */
2220 }
2221 #endif
kernel source for telekom puls (alcatel/mediatek)