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