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