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