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