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