projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'bugfix' of git://git.kernel.org/pub/scm/linux/kernel/git/jeremy/xen
[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 || !fattr.cf_uniqueid) {
516 cFYI(1, ("GetSrvInodeNum rc %d", rc1));
517 fattr.cf_uniqueid = iunique(sb, ROOT_I);
518 cifs_autodisable_serverino(cifs_sb);
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 cifsFileInfo_put(open_file);
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 EACCESS
918 * but will return the EACCESS 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 loff_t oldsize;
1558 int err;
1559
1560 spin_lock(&inode->i_lock);
1561 err = inode_newsize_ok(inode, offset);
1562 if (err) {
1563 spin_unlock(&inode->i_lock);
1564 goto out;
1565 }
1566
1567 oldsize = inode->i_size;
1568 i_size_write(inode, offset);
1569 spin_unlock(&inode->i_lock);
1570 truncate_pagecache(inode, oldsize, offset);
1571 if (inode->i_op->truncate)
1572 inode->i_op->truncate(inode);
1573 out:
1574 return err;
1575 }
1576
1577 static int
1578 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1579 int xid, char *full_path)
1580 {
1581 int rc;
1582 struct cifsFileInfo *open_file;
1583 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1584 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1585 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1586
1587 /*
1588 * To avoid spurious oplock breaks from server, in the case of
1589 * inodes that we already have open, avoid doing path based
1590 * setting of file size if we can do it by handle.
1591 * This keeps our caching token (oplock) and avoids timeouts
1592 * when the local oplock break takes longer to flush
1593 * writebehind data than the SMB timeout for the SetPathInfo
1594 * request would allow
1595 */
1596 open_file = find_writable_file(cifsInode);
1597 if (open_file) {
1598 __u16 nfid = open_file->netfid;
1599 __u32 npid = open_file->pid;
1600 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1601 npid, false);
1602 cifsFileInfo_put(open_file);
1603 cFYI(1, ("SetFSize for attrs rc = %d", rc));
1604 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1605 unsigned int bytes_written;
1606 rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
1607 &bytes_written, NULL, NULL, 1);
1608 cFYI(1, ("Wrt seteof rc %d", rc));
1609 }
1610 } else
1611 rc = -EINVAL;
1612
1613 if (rc != 0) {
1614 /* Set file size by pathname rather than by handle
1615 either because no valid, writeable file handle for
1616 it was found or because there was an error setting
1617 it by handle */
1618 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1619 false, cifs_sb->local_nls,
1620 cifs_sb->mnt_cifs_flags &
1621 CIFS_MOUNT_MAP_SPECIAL_CHR);
1622 cFYI(1, ("SetEOF by path (setattrs) rc = %d", rc));
1623 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1624 __u16 netfid;
1625 int oplock = 0;
1626
1627 rc = SMBLegacyOpen(xid, pTcon, full_path,
1628 FILE_OPEN, GENERIC_WRITE,
1629 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1630 cifs_sb->local_nls,
1631 cifs_sb->mnt_cifs_flags &
1632 CIFS_MOUNT_MAP_SPECIAL_CHR);
1633 if (rc == 0) {
1634 unsigned int bytes_written;
1635 rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
1636 attrs->ia_size,
1637 &bytes_written, NULL,
1638 NULL, 1);
1639 cFYI(1, ("wrt seteof rc %d", rc));
1640 CIFSSMBClose(xid, pTcon, netfid);
1641 }
1642 }
1643 }
1644
1645 if (rc == 0) {
1646 cifsInode->server_eof = attrs->ia_size;
1647 rc = cifs_vmtruncate(inode, attrs->ia_size);
1648 cifs_truncate_page(inode->i_mapping, inode->i_size);
1649 }
1650
1651 return rc;
1652 }
1653
1654 static int
1655 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1656 {
1657 int rc;
1658 int xid;
1659 char *full_path = NULL;
1660 struct inode *inode = direntry->d_inode;
1661 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1662 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1663 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1664 struct cifs_unix_set_info_args *args = NULL;
1665 struct cifsFileInfo *open_file;
1666
1667 cFYI(1, ("setattr_unix on file %s attrs->ia_valid=0x%x",
1668 direntry->d_name.name, attrs->ia_valid));
1669
1670 xid = GetXid();
1671
1672 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1673 /* check if we have permission to change attrs */
1674 rc = inode_change_ok(inode, attrs);
1675 if (rc < 0)
1676 goto out;
1677 else
1678 rc = 0;
1679 }
1680
1681 full_path = build_path_from_dentry(direntry);
1682 if (full_path == NULL) {
1683 rc = -ENOMEM;
1684 goto out;
1685 }
1686
1687 /*
1688 * Attempt to flush data before changing attributes. We need to do
1689 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1690 * ownership or mode then we may also need to do this. Here, we take
1691 * the safe way out and just do the flush on all setattr requests. If
1692 * the flush returns error, store it to report later and continue.
1693 *
1694 * BB: This should be smarter. Why bother flushing pages that
1695 * will be truncated anyway? Also, should we error out here if
1696 * the flush returns error?
1697 */
1698 rc = filemap_write_and_wait(inode->i_mapping);
1699 if (rc != 0) {
1700 cifsInode->write_behind_rc = rc;
1701 rc = 0;
1702 }
1703
1704 if (attrs->ia_valid & ATTR_SIZE) {
1705 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1706 if (rc != 0)
1707 goto out;
1708 }
1709
1710 /* skip mode change if it's just for clearing setuid/setgid */
1711 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1712 attrs->ia_valid &= ~ATTR_MODE;
1713
1714 args = kmalloc(sizeof(*args), GFP_KERNEL);
1715 if (args == NULL) {
1716 rc = -ENOMEM;
1717 goto out;
1718 }
1719
1720 /* set up the struct */
1721 if (attrs->ia_valid & ATTR_MODE)
1722 args->mode = attrs->ia_mode;
1723 else
1724 args->mode = NO_CHANGE_64;
1725
1726 if (attrs->ia_valid & ATTR_UID)
1727 args->uid = attrs->ia_uid;
1728 else
1729 args->uid = NO_CHANGE_64;
1730
1731 if (attrs->ia_valid & ATTR_GID)
1732 args->gid = attrs->ia_gid;
1733 else
1734 args->gid = NO_CHANGE_64;
1735
1736 if (attrs->ia_valid & ATTR_ATIME)
1737 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
1738 else
1739 args->atime = NO_CHANGE_64;
1740
1741 if (attrs->ia_valid & ATTR_MTIME)
1742 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
1743 else
1744 args->mtime = NO_CHANGE_64;
1745
1746 if (attrs->ia_valid & ATTR_CTIME)
1747 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
1748 else
1749 args->ctime = NO_CHANGE_64;
1750
1751 args->device = 0;
1752 open_file = find_writable_file(cifsInode);
1753 if (open_file) {
1754 u16 nfid = open_file->netfid;
1755 u32 npid = open_file->pid;
1756 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
1757 cifsFileInfo_put(open_file);
1758 } else {
1759 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
1760 cifs_sb->local_nls,
1761 cifs_sb->mnt_cifs_flags &
1762 CIFS_MOUNT_MAP_SPECIAL_CHR);
1763 }
1764
1765 if (!rc)
1766 rc = inode_setattr(inode, attrs);
1767 out:
1768 kfree(args);
1769 kfree(full_path);
1770 FreeXid(xid);
1771 return rc;
1772 }
1773
1774 static int
1775 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
1776 {
1777 int xid;
1778 struct inode *inode = direntry->d_inode;
1779 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1780 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1781 char *full_path = NULL;
1782 int rc = -EACCES;
1783 __u32 dosattr = 0;
1784 __u64 mode = NO_CHANGE_64;
1785
1786 xid = GetXid();
1787
1788 cFYI(1, ("setattr on file %s attrs->iavalid 0x%x",
1789 direntry->d_name.name, attrs->ia_valid));
1790
1791 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1792 /* check if we have permission to change attrs */
1793 rc = inode_change_ok(inode, attrs);
1794 if (rc < 0) {
1795 FreeXid(xid);
1796 return rc;
1797 } else
1798 rc = 0;
1799 }
1800
1801 full_path = build_path_from_dentry(direntry);
1802 if (full_path == NULL) {
1803 rc = -ENOMEM;
1804 FreeXid(xid);
1805 return rc;
1806 }
1807
1808 /*
1809 * Attempt to flush data before changing attributes. We need to do
1810 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1811 * ownership or mode then we may also need to do this. Here, we take
1812 * the safe way out and just do the flush on all setattr requests. If
1813 * the flush returns error, store it to report later and continue.
1814 *
1815 * BB: This should be smarter. Why bother flushing pages that
1816 * will be truncated anyway? Also, should we error out here if
1817 * the flush returns error?
1818 */
1819 rc = filemap_write_and_wait(inode->i_mapping);
1820 if (rc != 0) {
1821 cifsInode->write_behind_rc = rc;
1822 rc = 0;
1823 }
1824
1825 if (attrs->ia_valid & ATTR_SIZE) {
1826 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1827 if (rc != 0)
1828 goto cifs_setattr_exit;
1829 }
1830
1831 /*
1832 * Without unix extensions we can't send ownership changes to the
1833 * server, so silently ignore them. This is consistent with how
1834 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
1835 * CIFSACL support + proper Windows to Unix idmapping, we may be
1836 * able to support this in the future.
1837 */
1838 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
1839 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
1840
1841 /* skip mode change if it's just for clearing setuid/setgid */
1842 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1843 attrs->ia_valid &= ~ATTR_MODE;
1844
1845 if (attrs->ia_valid & ATTR_MODE) {
1846 cFYI(1, ("Mode changed to 0%o", attrs->ia_mode));
1847 mode = attrs->ia_mode;
1848 }
1849
1850 if (attrs->ia_valid & ATTR_MODE) {
1851 rc = 0;
1852 #ifdef CONFIG_CIFS_EXPERIMENTAL
1853 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
1854 rc = mode_to_acl(inode, full_path, mode);
1855 else
1856 #endif
1857 if (((mode & S_IWUGO) == 0) &&
1858 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
1859
1860 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
1861
1862 /* fix up mode if we're not using dynperm */
1863 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
1864 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
1865 } else if ((mode & S_IWUGO) &&
1866 (cifsInode->cifsAttrs & ATTR_READONLY)) {
1867
1868 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
1869 /* Attributes of 0 are ignored */
1870 if (dosattr == 0)
1871 dosattr |= ATTR_NORMAL;
1872
1873 /* reset local inode permissions to normal */
1874 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
1875 attrs->ia_mode &= ~(S_IALLUGO);
1876 if (S_ISDIR(inode->i_mode))
1877 attrs->ia_mode |=
1878 cifs_sb->mnt_dir_mode;
1879 else
1880 attrs->ia_mode |=
1881 cifs_sb->mnt_file_mode;
1882 }
1883 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
1884 /* ignore mode change - ATTR_READONLY hasn't changed */
1885 attrs->ia_valid &= ~ATTR_MODE;
1886 }
1887 }
1888
1889 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
1890 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
1891 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1892 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
1893
1894 /* Even if error on time set, no sense failing the call if
1895 the server would set the time to a reasonable value anyway,
1896 and this check ensures that we are not being called from
1897 sys_utimes in which case we ought to fail the call back to
1898 the user when the server rejects the call */
1899 if ((rc) && (attrs->ia_valid &
1900 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
1901 rc = 0;
1902 }
1903
1904 /* do not need local check to inode_check_ok since the server does
1905 that */
1906 if (!rc)
1907 rc = inode_setattr(inode, attrs);
1908 cifs_setattr_exit:
1909 kfree(full_path);
1910 FreeXid(xid);
1911 return rc;
1912 }
1913
1914 int
1915 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
1916 {
1917 struct inode *inode = direntry->d_inode;
1918 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1919 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1920
1921 if (pTcon->unix_ext)
1922 return cifs_setattr_unix(direntry, attrs);
1923
1924 return cifs_setattr_nounix(direntry, attrs);
1925
1926 /* BB: add cifs_setattr_legacy for really old servers */
1927 }
1928
1929 #if 0
1930 void cifs_delete_inode(struct inode *inode)
1931 {
1932 cFYI(1, ("In cifs_delete_inode, inode = 0x%p", inode));
1933 /* may have to add back in if and when safe distributed caching of
1934 directories added e.g. via FindNotify */
1935 }
1936 #endif
kernel source for telekom puls (alcatel/mediatek)