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