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