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