?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mtd: gen_nand: fix support for multiple chips
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / fs / cifs / inode.c
blob6f0683c689523894cb6fae3edd79181876084d42
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-file renames don't work across directories */
1405 if (to_dentry->d_parent != from_dentry->d_parent)
1406 return rc;
1407
1408 /* open the file to be renamed -- we need DELETE perms */
1409 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1410 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1411 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1412 CIFS_MOUNT_MAP_SPECIAL_CHR);
1413
1414 if (rc == 0) {
1415 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1416 (const char *) to_dentry->d_name.name,
1417 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1418 CIFS_MOUNT_MAP_SPECIAL_CHR);
1419
1420 CIFSSMBClose(xid, pTcon, srcfid);
1421 }
1422
1423 return rc;
1424 }
1425
1426 int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1427 struct inode *target_dir, struct dentry *target_dentry)
1428 {
1429 char *fromName = NULL;
1430 char *toName = NULL;
1431 struct cifs_sb_info *cifs_sb_source;
1432 struct cifs_sb_info *cifs_sb_target;
1433 struct cifsTconInfo *tcon;
1434 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1435 FILE_UNIX_BASIC_INFO *info_buf_target;
1436 int xid, rc, tmprc;
1437
1438 cifs_sb_target = CIFS_SB(target_dir->i_sb);
1439 cifs_sb_source = CIFS_SB(source_dir->i_sb);
1440 tcon = cifs_sb_source->tcon;
1441
1442 xid = GetXid();
1443
1444 /*
1445 * BB: this might be allowed if same server, but different share.
1446 * Consider adding support for this
1447 */
1448 if (tcon != cifs_sb_target->tcon) {
1449 rc = -EXDEV;
1450 goto cifs_rename_exit;
1451 }
1452
1453 /*
1454 * we already have the rename sem so we do not need to
1455 * grab it again here to protect the path integrity
1456 */
1457 fromName = build_path_from_dentry(source_dentry);
1458 if (fromName == NULL) {
1459 rc = -ENOMEM;
1460 goto cifs_rename_exit;
1461 }
1462
1463 toName = build_path_from_dentry(target_dentry);
1464 if (toName == NULL) {
1465 rc = -ENOMEM;
1466 goto cifs_rename_exit;
1467 }
1468
1469 rc = cifs_do_rename(xid, source_dentry, fromName,
1470 target_dentry, toName);
1471
1472 if (rc == -EEXIST && tcon->unix_ext) {
1473 /*
1474 * Are src and dst hardlinks of same inode? We can
1475 * only tell with unix extensions enabled
1476 */
1477 info_buf_source =
1478 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1479 GFP_KERNEL);
1480 if (info_buf_source == NULL) {
1481 rc = -ENOMEM;
1482 goto cifs_rename_exit;
1483 }
1484
1485 info_buf_target = info_buf_source + 1;
1486 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
1487 info_buf_source,
1488 cifs_sb_source->local_nls,
1489 cifs_sb_source->mnt_cifs_flags &
1490 CIFS_MOUNT_MAP_SPECIAL_CHR);
1491 if (tmprc != 0)
1492 goto unlink_target;
1493
1494 tmprc = CIFSSMBUnixQPathInfo(xid, tcon,
1495 toName, info_buf_target,
1496 cifs_sb_target->local_nls,
1497 /* remap based on source sb */
1498 cifs_sb_source->mnt_cifs_flags &
1499 CIFS_MOUNT_MAP_SPECIAL_CHR);
1500
1501 if (tmprc == 0 && (info_buf_source->UniqueId ==
1502 info_buf_target->UniqueId)) {
1503 /* same file, POSIX says that this is a noop */
1504 rc = 0;
1505 goto cifs_rename_exit;
1506 }
1507 } /* else ... BB we could add the same check for Windows by
1508 checking the UniqueId via FILE_INTERNAL_INFO */
1509
1510 unlink_target:
1511 /* Try unlinking the target dentry if it's not negative */
1512 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1513 tmprc = cifs_unlink(target_dir, target_dentry);
1514 if (tmprc)
1515 goto cifs_rename_exit;
1516
1517 rc = cifs_do_rename(xid, source_dentry, fromName,
1518 target_dentry, toName);
1519 }
1520
1521 cifs_rename_exit:
1522 kfree(info_buf_source);
1523 kfree(fromName);
1524 kfree(toName);
1525 FreeXid(xid);
1526 return rc;
1527 }
1528
1529 static bool
1530 cifs_inode_needs_reval(struct inode *inode)
1531 {
1532 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1533
1534 if (cifs_i->clientCanCacheRead)
1535 return false;
1536
1537 if (!lookupCacheEnabled)
1538 return true;
1539
1540 if (cifs_i->time == 0)
1541 return true;
1542
1543 /* FIXME: the actimeo should be tunable */
1544 if (time_after_eq(jiffies, cifs_i->time + HZ))
1545 return true;
1546
1547 /* hardlinked files w/ noserverino get "special" treatment */
1548 if (!(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1549 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1550 return true;
1551
1552 return false;
1553 }
1554
1555 /* check invalid_mapping flag and zap the cache if it's set */
1556 static void
1557 cifs_invalidate_mapping(struct inode *inode)
1558 {
1559 int rc;
1560 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1561
1562 cifs_i->invalid_mapping = false;
1563
1564 /* write back any cached data */
1565 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1566 rc = filemap_write_and_wait(inode->i_mapping);
1567 if (rc)
1568 cifs_i->write_behind_rc = rc;
1569 }
1570 invalidate_remote_inode(inode);
1571 }
1572
1573 int cifs_revalidate_file(struct file *filp)
1574 {
1575 int rc = 0;
1576 struct inode *inode = filp->f_path.dentry->d_inode;
1577
1578 if (!cifs_inode_needs_reval(inode))
1579 goto check_inval;
1580
1581 if (CIFS_SB(inode->i_sb)->tcon->unix_ext)
1582 rc = cifs_get_file_info_unix(filp);
1583 else
1584 rc = cifs_get_file_info(filp);
1585
1586 check_inval:
1587 if (CIFS_I(inode)->invalid_mapping)
1588 cifs_invalidate_mapping(inode);
1589
1590 return rc;
1591 }
1592
1593 /* revalidate a dentry's inode attributes */
1594 int cifs_revalidate_dentry(struct dentry *dentry)
1595 {
1596 int xid;
1597 int rc = 0;
1598 char *full_path = NULL;
1599 struct inode *inode = dentry->d_inode;
1600 struct super_block *sb = dentry->d_sb;
1601
1602 if (inode == NULL)
1603 return -ENOENT;
1604
1605 xid = GetXid();
1606
1607 if (!cifs_inode_needs_reval(inode))
1608 goto check_inval;
1609
1610 /* can not safely grab the rename sem here if rename calls revalidate
1611 since that would deadlock */
1612 full_path = build_path_from_dentry(dentry);
1613 if (full_path == NULL) {
1614 rc = -ENOMEM;
1615 goto check_inval;
1616 }
1617
1618 cFYI(1, "Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1619 "jiffies %ld", full_path, inode, inode->i_count.counter,
1620 dentry, dentry->d_time, jiffies);
1621
1622 if (CIFS_SB(sb)->tcon->unix_ext)
1623 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1624 else
1625 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1626 xid, NULL);
1627
1628 check_inval:
1629 if (CIFS_I(inode)->invalid_mapping)
1630 cifs_invalidate_mapping(inode);
1631
1632 kfree(full_path);
1633 FreeXid(xid);
1634 return rc;
1635 }
1636
1637 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1638 struct kstat *stat)
1639 {
1640 int err = cifs_revalidate_dentry(dentry);
1641 if (!err) {
1642 generic_fillattr(dentry->d_inode, stat);
1643 stat->blksize = CIFS_MAX_MSGSIZE;
1644 stat->ino = CIFS_I(dentry->d_inode)->uniqueid;
1645 }
1646 return err;
1647 }
1648
1649 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1650 {
1651 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1652 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1653 struct page *page;
1654 int rc = 0;
1655
1656 page = grab_cache_page(mapping, index);
1657 if (!page)
1658 return -ENOMEM;
1659
1660 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1661 unlock_page(page);
1662 page_cache_release(page);
1663 return rc;
1664 }
1665
1666 static int cifs_vmtruncate(struct inode *inode, loff_t offset)
1667 {
1668 loff_t oldsize;
1669 int err;
1670
1671 spin_lock(&inode->i_lock);
1672 err = inode_newsize_ok(inode, offset);
1673 if (err) {
1674 spin_unlock(&inode->i_lock);
1675 goto out;
1676 }
1677
1678 oldsize = inode->i_size;
1679 i_size_write(inode, offset);
1680 spin_unlock(&inode->i_lock);
1681 truncate_pagecache(inode, oldsize, offset);
1682 if (inode->i_op->truncate)
1683 inode->i_op->truncate(inode);
1684 out:
1685 return err;
1686 }
1687
1688 static int
1689 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1690 int xid, char *full_path)
1691 {
1692 int rc;
1693 struct cifsFileInfo *open_file;
1694 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1695 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1696 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1697
1698 /*
1699 * To avoid spurious oplock breaks from server, in the case of
1700 * inodes that we already have open, avoid doing path based
1701 * setting of file size if we can do it by handle.
1702 * This keeps our caching token (oplock) and avoids timeouts
1703 * when the local oplock break takes longer to flush
1704 * writebehind data than the SMB timeout for the SetPathInfo
1705 * request would allow
1706 */
1707 open_file = find_writable_file(cifsInode);
1708 if (open_file) {
1709 __u16 nfid = open_file->netfid;
1710 __u32 npid = open_file->pid;
1711 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1712 npid, false);
1713 cifsFileInfo_put(open_file);
1714 cFYI(1, "SetFSize for attrs rc = %d", rc);
1715 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1716 unsigned int bytes_written;
1717 rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
1718 &bytes_written, NULL, NULL, 1);
1719 cFYI(1, "Wrt seteof rc %d", rc);
1720 }
1721 } else
1722 rc = -EINVAL;
1723
1724 if (rc != 0) {
1725 /* Set file size by pathname rather than by handle
1726 either because no valid, writeable file handle for
1727 it was found or because there was an error setting
1728 it by handle */
1729 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1730 false, cifs_sb->local_nls,
1731 cifs_sb->mnt_cifs_flags &
1732 CIFS_MOUNT_MAP_SPECIAL_CHR);
1733 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1734 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1735 __u16 netfid;
1736 int oplock = 0;
1737
1738 rc = SMBLegacyOpen(xid, pTcon, full_path,
1739 FILE_OPEN, GENERIC_WRITE,
1740 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1741 cifs_sb->local_nls,
1742 cifs_sb->mnt_cifs_flags &
1743 CIFS_MOUNT_MAP_SPECIAL_CHR);
1744 if (rc == 0) {
1745 unsigned int bytes_written;
1746 rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
1747 attrs->ia_size,
1748 &bytes_written, NULL,
1749 NULL, 1);
1750 cFYI(1, "wrt seteof rc %d", rc);
1751 CIFSSMBClose(xid, pTcon, netfid);
1752 }
1753 }
1754 }
1755
1756 if (rc == 0) {
1757 cifsInode->server_eof = attrs->ia_size;
1758 rc = cifs_vmtruncate(inode, attrs->ia_size);
1759 cifs_truncate_page(inode->i_mapping, inode->i_size);
1760 }
1761
1762 return rc;
1763 }
1764
1765 static int
1766 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1767 {
1768 int rc;
1769 int xid;
1770 char *full_path = NULL;
1771 struct inode *inode = direntry->d_inode;
1772 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1773 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1774 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1775 struct cifs_unix_set_info_args *args = NULL;
1776 struct cifsFileInfo *open_file;
1777
1778 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1779 direntry->d_name.name, attrs->ia_valid);
1780
1781 xid = GetXid();
1782
1783 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1784 /* check if we have permission to change attrs */
1785 rc = inode_change_ok(inode, attrs);
1786 if (rc < 0)
1787 goto out;
1788 else
1789 rc = 0;
1790 }
1791
1792 full_path = build_path_from_dentry(direntry);
1793 if (full_path == NULL) {
1794 rc = -ENOMEM;
1795 goto out;
1796 }
1797
1798 /*
1799 * Attempt to flush data before changing attributes. We need to do
1800 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1801 * ownership or mode then we may also need to do this. Here, we take
1802 * the safe way out and just do the flush on all setattr requests. If
1803 * the flush returns error, store it to report later and continue.
1804 *
1805 * BB: This should be smarter. Why bother flushing pages that
1806 * will be truncated anyway? Also, should we error out here if
1807 * the flush returns error?
1808 */
1809 rc = filemap_write_and_wait(inode->i_mapping);
1810 if (rc != 0) {
1811 cifsInode->write_behind_rc = rc;
1812 rc = 0;
1813 }
1814
1815 if (attrs->ia_valid & ATTR_SIZE) {
1816 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1817 if (rc != 0)
1818 goto out;
1819 }
1820
1821 /* skip mode change if it's just for clearing setuid/setgid */
1822 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1823 attrs->ia_valid &= ~ATTR_MODE;
1824
1825 args = kmalloc(sizeof(*args), GFP_KERNEL);
1826 if (args == NULL) {
1827 rc = -ENOMEM;
1828 goto out;
1829 }
1830
1831 /* set up the struct */
1832 if (attrs->ia_valid & ATTR_MODE)
1833 args->mode = attrs->ia_mode;
1834 else
1835 args->mode = NO_CHANGE_64;
1836
1837 if (attrs->ia_valid & ATTR_UID)
1838 args->uid = attrs->ia_uid;
1839 else
1840 args->uid = NO_CHANGE_64;
1841
1842 if (attrs->ia_valid & ATTR_GID)
1843 args->gid = attrs->ia_gid;
1844 else
1845 args->gid = NO_CHANGE_64;
1846
1847 if (attrs->ia_valid & ATTR_ATIME)
1848 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
1849 else
1850 args->atime = NO_CHANGE_64;
1851
1852 if (attrs->ia_valid & ATTR_MTIME)
1853 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
1854 else
1855 args->mtime = NO_CHANGE_64;
1856
1857 if (attrs->ia_valid & ATTR_CTIME)
1858 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
1859 else
1860 args->ctime = NO_CHANGE_64;
1861
1862 args->device = 0;
1863 open_file = find_writable_file(cifsInode);
1864 if (open_file) {
1865 u16 nfid = open_file->netfid;
1866 u32 npid = open_file->pid;
1867 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
1868 cifsFileInfo_put(open_file);
1869 } else {
1870 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
1871 cifs_sb->local_nls,
1872 cifs_sb->mnt_cifs_flags &
1873 CIFS_MOUNT_MAP_SPECIAL_CHR);
1874 }
1875
1876 if (!rc) {
1877 rc = inode_setattr(inode, attrs);
1878
1879 /* force revalidate when any of these times are set since some
1880 of the fs types (eg ext3, fat) do not have fine enough
1881 time granularity to match protocol, and we do not have a
1882 a way (yet) to query the server fs's time granularity (and
1883 whether it rounds times down).
1884 */
1885 if (!rc && (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME)))
1886 cifsInode->time = 0;
1887 }
1888 out:
1889 kfree(args);
1890 kfree(full_path);
1891 FreeXid(xid);
1892 return rc;
1893 }
1894
1895 static int
1896 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
1897 {
1898 int xid;
1899 struct inode *inode = direntry->d_inode;
1900 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1901 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1902 char *full_path = NULL;
1903 int rc = -EACCES;
1904 __u32 dosattr = 0;
1905 __u64 mode = NO_CHANGE_64;
1906
1907 xid = GetXid();
1908
1909 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
1910 direntry->d_name.name, attrs->ia_valid);
1911
1912 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1913 /* check if we have permission to change attrs */
1914 rc = inode_change_ok(inode, attrs);
1915 if (rc < 0) {
1916 FreeXid(xid);
1917 return rc;
1918 } else
1919 rc = 0;
1920 }
1921
1922 full_path = build_path_from_dentry(direntry);
1923 if (full_path == NULL) {
1924 rc = -ENOMEM;
1925 FreeXid(xid);
1926 return rc;
1927 }
1928
1929 /*
1930 * Attempt to flush data before changing attributes. We need to do
1931 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1932 * ownership or mode then we may also need to do this. Here, we take
1933 * the safe way out and just do the flush on all setattr requests. If
1934 * the flush returns error, store it to report later and continue.
1935 *
1936 * BB: This should be smarter. Why bother flushing pages that
1937 * will be truncated anyway? Also, should we error out here if
1938 * the flush returns error?
1939 */
1940 rc = filemap_write_and_wait(inode->i_mapping);
1941 if (rc != 0) {
1942 cifsInode->write_behind_rc = rc;
1943 rc = 0;
1944 }
1945
1946 if (attrs->ia_valid & ATTR_SIZE) {
1947 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1948 if (rc != 0)
1949 goto cifs_setattr_exit;
1950 }
1951
1952 /*
1953 * Without unix extensions we can't send ownership changes to the
1954 * server, so silently ignore them. This is consistent with how
1955 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
1956 * CIFSACL support + proper Windows to Unix idmapping, we may be
1957 * able to support this in the future.
1958 */
1959 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
1960 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
1961
1962 /* skip mode change if it's just for clearing setuid/setgid */
1963 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1964 attrs->ia_valid &= ~ATTR_MODE;
1965
1966 if (attrs->ia_valid & ATTR_MODE) {
1967 cFYI(1, "Mode changed to 0%o", attrs->ia_mode);
1968 mode = attrs->ia_mode;
1969 }
1970
1971 if (attrs->ia_valid & ATTR_MODE) {
1972 rc = 0;
1973 #ifdef CONFIG_CIFS_EXPERIMENTAL
1974 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
1975 rc = mode_to_acl(inode, full_path, mode);
1976 else
1977 #endif
1978 if (((mode & S_IWUGO) == 0) &&
1979 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
1980
1981 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
1982
1983 /* fix up mode if we're not using dynperm */
1984 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
1985 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
1986 } else if ((mode & S_IWUGO) &&
1987 (cifsInode->cifsAttrs & ATTR_READONLY)) {
1988
1989 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
1990 /* Attributes of 0 are ignored */
1991 if (dosattr == 0)
1992 dosattr |= ATTR_NORMAL;
1993
1994 /* reset local inode permissions to normal */
1995 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
1996 attrs->ia_mode &= ~(S_IALLUGO);
1997 if (S_ISDIR(inode->i_mode))
1998 attrs->ia_mode |=
1999 cifs_sb->mnt_dir_mode;
2000 else
2001 attrs->ia_mode |=
2002 cifs_sb->mnt_file_mode;
2003 }
2004 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2005 /* ignore mode change - ATTR_READONLY hasn't changed */
2006 attrs->ia_valid &= ~ATTR_MODE;
2007 }
2008 }
2009
2010 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2011 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2012 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2013 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2014
2015 /* Even if error on time set, no sense failing the call if
2016 the server would set the time to a reasonable value anyway,
2017 and this check ensures that we are not being called from
2018 sys_utimes in which case we ought to fail the call back to
2019 the user when the server rejects the call */
2020 if ((rc) && (attrs->ia_valid &
2021 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2022 rc = 0;
2023 }
2024
2025 /* do not need local check to inode_check_ok since the server does
2026 that */
2027 if (!rc)
2028 rc = inode_setattr(inode, attrs);
2029 cifs_setattr_exit:
2030 kfree(full_path);
2031 FreeXid(xid);
2032 return rc;
2033 }
2034
2035 int
2036 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2037 {
2038 struct inode *inode = direntry->d_inode;
2039 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2040 struct cifsTconInfo *pTcon = cifs_sb->tcon;
2041
2042 if (pTcon->unix_ext)
2043 return cifs_setattr_unix(direntry, attrs);
2044
2045 return cifs_setattr_nounix(direntry, attrs);
2046
2047 /* BB: add cifs_setattr_legacy for really old servers */
2048 }
2049
2050 #if 0
2051 void cifs_delete_inode(struct inode *inode)
2052 {
2053 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
2054 /* may have to add back in if and when safe distributed caching of
2055 directories added e.g. via FindNotify */
2056 }
2057 #endif
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree