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