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