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