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