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