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