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