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