4 * Copyright (C) International Business Machines Corp., 2002,2010
5 * Author(s): Steve French (sfrench@us.ibm.com)
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.
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.
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
22 #include <linux/stat.h>
23 #include <linux/slab.h>
24 #include <linux/pagemap.h>
25 #include <asm/div64.h>
29 #include "cifsproto.h"
30 #include "cifs_debug.h"
31 #include "cifs_fs_sb.h"
35 static void cifs_set_ops(struct inode
*inode
)
37 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
39 switch (inode
->i_mode
& S_IFMT
) {
41 inode
->i_op
= &cifs_file_inode_ops
;
42 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
43 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
44 inode
->i_fop
= &cifs_file_direct_nobrl_ops
;
46 inode
->i_fop
= &cifs_file_direct_ops
;
47 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_STRICT_IO
) {
48 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
49 inode
->i_fop
= &cifs_file_strict_nobrl_ops
;
51 inode
->i_fop
= &cifs_file_strict_ops
;
52 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
53 inode
->i_fop
= &cifs_file_nobrl_ops
;
54 else { /* not direct, send byte range locks */
55 inode
->i_fop
= &cifs_file_ops
;
58 /* check if server can support readpages */
59 if (cifs_sb_master_tcon(cifs_sb
)->ses
->server
->maxBuf
<
60 PAGE_CACHE_SIZE
+ MAX_CIFS_HDR_SIZE
)
61 inode
->i_data
.a_ops
= &cifs_addr_ops_smallbuf
;
63 inode
->i_data
.a_ops
= &cifs_addr_ops
;
66 #ifdef CONFIG_CIFS_DFS_UPCALL
67 if (IS_AUTOMOUNT(inode
)) {
68 inode
->i_op
= &cifs_dfs_referral_inode_operations
;
70 #else /* NO DFS support, treat as a directory */
73 inode
->i_op
= &cifs_dir_inode_ops
;
74 inode
->i_fop
= &cifs_dir_ops
;
78 inode
->i_op
= &cifs_symlink_inode_ops
;
81 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
86 /* check inode attributes against fattr. If they don't match, tag the
87 * inode for cache invalidation
90 cifs_revalidate_cache(struct inode
*inode
, struct cifs_fattr
*fattr
)
92 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
94 cifs_dbg(FYI
, "%s: revalidating inode %llu\n",
95 __func__
, cifs_i
->uniqueid
);
97 if (inode
->i_state
& I_NEW
) {
98 cifs_dbg(FYI
, "%s: inode %llu is new\n",
99 __func__
, cifs_i
->uniqueid
);
103 /* don't bother with revalidation if we have an oplock */
104 if (CIFS_CACHE_READ(cifs_i
)) {
105 cifs_dbg(FYI
, "%s: inode %llu is oplocked\n",
106 __func__
, cifs_i
->uniqueid
);
110 /* revalidate if mtime or size have changed */
111 if (timespec_equal(&inode
->i_mtime
, &fattr
->cf_mtime
) &&
112 cifs_i
->server_eof
== fattr
->cf_eof
) {
113 cifs_dbg(FYI
, "%s: inode %llu is unchanged\n",
114 __func__
, cifs_i
->uniqueid
);
118 cifs_dbg(FYI
, "%s: invalidating inode %llu mapping\n",
119 __func__
, cifs_i
->uniqueid
);
120 cifs_i
->invalid_mapping
= true;
124 * copy nlink to the inode, unless it wasn't provided. Provide
125 * sane values if we don't have an existing one and none was provided
128 cifs_nlink_fattr_to_inode(struct inode
*inode
, struct cifs_fattr
*fattr
)
131 * if we're in a situation where we can't trust what we
132 * got from the server (readdir, some non-unix cases)
133 * fake reasonable values
135 if (fattr
->cf_flags
& CIFS_FATTR_UNKNOWN_NLINK
) {
136 /* only provide fake values on a new inode */
137 if (inode
->i_state
& I_NEW
) {
138 if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
)
146 /* we trust the server, so update it */
147 set_nlink(inode
, fattr
->cf_nlink
);
150 /* populate an inode with info from a cifs_fattr struct */
152 cifs_fattr_to_inode(struct inode
*inode
, struct cifs_fattr
*fattr
)
154 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
155 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
157 cifs_revalidate_cache(inode
, fattr
);
159 spin_lock(&inode
->i_lock
);
160 inode
->i_atime
= fattr
->cf_atime
;
161 inode
->i_mtime
= fattr
->cf_mtime
;
162 inode
->i_ctime
= fattr
->cf_ctime
;
163 inode
->i_rdev
= fattr
->cf_rdev
;
164 cifs_nlink_fattr_to_inode(inode
, fattr
);
165 inode
->i_uid
= fattr
->cf_uid
;
166 inode
->i_gid
= fattr
->cf_gid
;
168 /* if dynperm is set, don't clobber existing mode */
169 if (inode
->i_state
& I_NEW
||
170 !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
))
171 inode
->i_mode
= fattr
->cf_mode
;
173 cifs_i
->cifsAttrs
= fattr
->cf_cifsattrs
;
175 if (fattr
->cf_flags
& CIFS_FATTR_NEED_REVAL
)
178 cifs_i
->time
= jiffies
;
180 cifs_i
->delete_pending
= fattr
->cf_flags
& CIFS_FATTR_DELETE_PENDING
;
182 cifs_i
->server_eof
= fattr
->cf_eof
;
184 * Can't safely change the file size here if the client is writing to
185 * it due to potential races.
187 if (is_size_safe_to_change(cifs_i
, fattr
->cf_eof
)) {
188 i_size_write(inode
, fattr
->cf_eof
);
191 * i_blocks is not related to (i_size / i_blksize),
192 * but instead 512 byte (2**9) size is required for
193 * calculating num blocks.
195 inode
->i_blocks
= (512 - 1 + fattr
->cf_bytes
) >> 9;
197 spin_unlock(&inode
->i_lock
);
199 if (fattr
->cf_flags
& CIFS_FATTR_DFS_REFERRAL
)
200 inode
->i_flags
|= S_AUTOMOUNT
;
201 if (inode
->i_state
& I_NEW
)
206 cifs_fill_uniqueid(struct super_block
*sb
, struct cifs_fattr
*fattr
)
208 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
210 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)
213 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
216 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
218 cifs_unix_basic_to_fattr(struct cifs_fattr
*fattr
, FILE_UNIX_BASIC_INFO
*info
,
219 struct cifs_sb_info
*cifs_sb
)
221 memset(fattr
, 0, sizeof(*fattr
));
222 fattr
->cf_uniqueid
= le64_to_cpu(info
->UniqueId
);
223 fattr
->cf_bytes
= le64_to_cpu(info
->NumOfBytes
);
224 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
226 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
227 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastModificationTime
);
228 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->LastStatusChange
);
229 fattr
->cf_mode
= le64_to_cpu(info
->Permissions
);
232 * Since we set the inode type below we need to mask off
233 * to avoid strange results if bits set above.
235 fattr
->cf_mode
&= ~S_IFMT
;
236 switch (le32_to_cpu(info
->Type
)) {
238 fattr
->cf_mode
|= S_IFREG
;
239 fattr
->cf_dtype
= DT_REG
;
242 fattr
->cf_mode
|= S_IFLNK
;
243 fattr
->cf_dtype
= DT_LNK
;
246 fattr
->cf_mode
|= S_IFDIR
;
247 fattr
->cf_dtype
= DT_DIR
;
250 fattr
->cf_mode
|= S_IFCHR
;
251 fattr
->cf_dtype
= DT_CHR
;
252 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
253 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
256 fattr
->cf_mode
|= S_IFBLK
;
257 fattr
->cf_dtype
= DT_BLK
;
258 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
259 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
262 fattr
->cf_mode
|= S_IFIFO
;
263 fattr
->cf_dtype
= DT_FIFO
;
266 fattr
->cf_mode
|= S_IFSOCK
;
267 fattr
->cf_dtype
= DT_SOCK
;
270 /* safest to call it a file if we do not know */
271 fattr
->cf_mode
|= S_IFREG
;
272 fattr
->cf_dtype
= DT_REG
;
273 cifs_dbg(FYI
, "unknown type %d\n", le32_to_cpu(info
->Type
));
277 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
278 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
)) {
279 u64 id
= le64_to_cpu(info
->Uid
);
280 if (id
< ((uid_t
)-1)) {
281 kuid_t uid
= make_kuid(&init_user_ns
, id
);
287 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
288 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
)) {
289 u64 id
= le64_to_cpu(info
->Gid
);
290 if (id
< ((gid_t
)-1)) {
291 kgid_t gid
= make_kgid(&init_user_ns
, id
);
297 fattr
->cf_nlink
= le64_to_cpu(info
->Nlinks
);
301 * Fill a cifs_fattr struct with fake inode info.
303 * Needed to setup cifs_fattr data for the directory which is the
304 * junction to the new submount (ie to setup the fake directory
305 * which represents a DFS referral).
308 cifs_create_dfs_fattr(struct cifs_fattr
*fattr
, struct super_block
*sb
)
310 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
312 cifs_dbg(FYI
, "creating fake fattr for DFS referral\n");
314 memset(fattr
, 0, sizeof(*fattr
));
315 fattr
->cf_mode
= S_IFDIR
| S_IXUGO
| S_IRWXU
;
316 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
317 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
318 fattr
->cf_atime
= CURRENT_TIME
;
319 fattr
->cf_ctime
= CURRENT_TIME
;
320 fattr
->cf_mtime
= CURRENT_TIME
;
322 fattr
->cf_flags
|= CIFS_FATTR_DFS_REFERRAL
;
326 cifs_get_file_info_unix(struct file
*filp
)
330 FILE_UNIX_BASIC_INFO find_data
;
331 struct cifs_fattr fattr
;
332 struct inode
*inode
= file_inode(filp
);
333 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
334 struct cifsFileInfo
*cfile
= filp
->private_data
;
335 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
338 rc
= CIFSSMBUnixQFileInfo(xid
, tcon
, cfile
->fid
.netfid
, &find_data
);
340 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
341 } else if (rc
== -EREMOTE
) {
342 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
346 cifs_fattr_to_inode(inode
, &fattr
);
351 int cifs_get_inode_info_unix(struct inode
**pinode
,
352 const unsigned char *full_path
,
353 struct super_block
*sb
, unsigned int xid
)
356 FILE_UNIX_BASIC_INFO find_data
;
357 struct cifs_fattr fattr
;
358 struct cifs_tcon
*tcon
;
359 struct tcon_link
*tlink
;
360 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
362 cifs_dbg(FYI
, "Getting info on %s\n", full_path
);
364 tlink
= cifs_sb_tlink(cifs_sb
);
366 return PTR_ERR(tlink
);
367 tcon
= tlink_tcon(tlink
);
369 /* could have done a find first instead but this returns more info */
370 rc
= CIFSSMBUnixQPathInfo(xid
, tcon
, full_path
, &find_data
,
371 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
372 CIFS_MOUNT_MAP_SPECIAL_CHR
);
373 cifs_put_tlink(tlink
);
376 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
377 } else if (rc
== -EREMOTE
) {
378 cifs_create_dfs_fattr(&fattr
, sb
);
384 /* check for Minshall+French symlinks */
385 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) {
386 int tmprc
= CIFSCheckMFSymlink(xid
, tcon
, cifs_sb
, &fattr
,
389 cifs_dbg(FYI
, "CIFSCheckMFSymlink: %d\n", tmprc
);
392 if (*pinode
== NULL
) {
394 cifs_fill_uniqueid(sb
, &fattr
);
395 *pinode
= cifs_iget(sb
, &fattr
);
399 /* we already have inode, update it */
400 cifs_fattr_to_inode(*pinode
, &fattr
);
407 cifs_sfu_type(struct cifs_fattr
*fattr
, const unsigned char *path
,
408 struct cifs_sb_info
*cifs_sb
, unsigned int xid
)
413 struct tcon_link
*tlink
;
414 struct cifs_tcon
*tcon
;
415 struct cifs_io_parms io_parms
;
417 unsigned int bytes_read
;
422 fattr
->cf_mode
&= ~S_IFMT
;
424 if (fattr
->cf_eof
== 0) {
425 fattr
->cf_mode
|= S_IFIFO
;
426 fattr
->cf_dtype
= DT_FIFO
;
428 } else if (fattr
->cf_eof
< 8) {
429 fattr
->cf_mode
|= S_IFREG
;
430 fattr
->cf_dtype
= DT_REG
;
431 return -EINVAL
; /* EOPNOTSUPP? */
434 tlink
= cifs_sb_tlink(cifs_sb
);
436 return PTR_ERR(tlink
);
437 tcon
= tlink_tcon(tlink
);
439 rc
= CIFSSMBOpen(xid
, tcon
, path
, FILE_OPEN
, GENERIC_READ
,
440 CREATE_NOT_DIR
, &netfid
, &oplock
, NULL
,
442 cifs_sb
->mnt_cifs_flags
&
443 CIFS_MOUNT_MAP_SPECIAL_CHR
);
445 int buf_type
= CIFS_NO_BUFFER
;
447 io_parms
.netfid
= netfid
;
448 io_parms
.pid
= current
->tgid
;
449 io_parms
.tcon
= tcon
;
451 io_parms
.length
= 24;
452 rc
= CIFSSMBRead(xid
, &io_parms
, &bytes_read
, &pbuf
,
454 if ((rc
== 0) && (bytes_read
>= 8)) {
455 if (memcmp("IntxBLK", pbuf
, 8) == 0) {
456 cifs_dbg(FYI
, "Block device\n");
457 fattr
->cf_mode
|= S_IFBLK
;
458 fattr
->cf_dtype
= DT_BLK
;
459 if (bytes_read
== 24) {
460 /* we have enough to decode dev num */
461 __u64 mjr
; /* major */
462 __u64 mnr
; /* minor */
463 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
464 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
465 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
467 } else if (memcmp("IntxCHR", pbuf
, 8) == 0) {
468 cifs_dbg(FYI
, "Char device\n");
469 fattr
->cf_mode
|= S_IFCHR
;
470 fattr
->cf_dtype
= DT_CHR
;
471 if (bytes_read
== 24) {
472 /* we have enough to decode dev num */
473 __u64 mjr
; /* major */
474 __u64 mnr
; /* minor */
475 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
476 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
477 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
479 } else if (memcmp("IntxLNK", pbuf
, 7) == 0) {
480 cifs_dbg(FYI
, "Symlink\n");
481 fattr
->cf_mode
|= S_IFLNK
;
482 fattr
->cf_dtype
= DT_LNK
;
484 fattr
->cf_mode
|= S_IFREG
; /* file? */
485 fattr
->cf_dtype
= DT_REG
;
489 fattr
->cf_mode
|= S_IFREG
; /* then it is a file */
490 fattr
->cf_dtype
= DT_REG
;
491 rc
= -EOPNOTSUPP
; /* or some unknown SFU type */
493 CIFSSMBClose(xid
, tcon
, netfid
);
495 cifs_put_tlink(tlink
);
499 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
502 * Fetch mode bits as provided by SFU.
504 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
506 static int cifs_sfu_mode(struct cifs_fattr
*fattr
, const unsigned char *path
,
507 struct cifs_sb_info
*cifs_sb
, unsigned int xid
)
509 #ifdef CONFIG_CIFS_XATTR
513 struct tcon_link
*tlink
;
514 struct cifs_tcon
*tcon
;
516 tlink
= cifs_sb_tlink(cifs_sb
);
518 return PTR_ERR(tlink
);
519 tcon
= tlink_tcon(tlink
);
521 rc
= CIFSSMBQAllEAs(xid
, tcon
, path
, "SETFILEBITS",
522 ea_value
, 4 /* size of buf */, cifs_sb
->local_nls
,
523 cifs_sb
->mnt_cifs_flags
&
524 CIFS_MOUNT_MAP_SPECIAL_CHR
);
525 cifs_put_tlink(tlink
);
529 mode
= le32_to_cpu(*((__le32
*)ea_value
));
530 fattr
->cf_mode
&= ~SFBITS_MASK
;
531 cifs_dbg(FYI
, "special bits 0%o org mode 0%o\n",
532 mode
, fattr
->cf_mode
);
533 fattr
->cf_mode
= (mode
& SFBITS_MASK
) | fattr
->cf_mode
;
534 cifs_dbg(FYI
, "special mode bits 0%o\n", mode
);
543 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
545 cifs_all_info_to_fattr(struct cifs_fattr
*fattr
, FILE_ALL_INFO
*info
,
546 struct cifs_sb_info
*cifs_sb
, bool adjust_tz
,
549 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
551 memset(fattr
, 0, sizeof(*fattr
));
552 fattr
->cf_cifsattrs
= le32_to_cpu(info
->Attributes
);
553 if (info
->DeletePending
)
554 fattr
->cf_flags
|= CIFS_FATTR_DELETE_PENDING
;
556 if (info
->LastAccessTime
)
557 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
559 fattr
->cf_atime
= CURRENT_TIME
;
561 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->ChangeTime
);
562 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastWriteTime
);
565 fattr
->cf_ctime
.tv_sec
+= tcon
->ses
->server
->timeAdj
;
566 fattr
->cf_mtime
.tv_sec
+= tcon
->ses
->server
->timeAdj
;
569 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
570 fattr
->cf_bytes
= le64_to_cpu(info
->AllocationSize
);
571 fattr
->cf_createtime
= le64_to_cpu(info
->CreationTime
);
573 fattr
->cf_nlink
= le32_to_cpu(info
->NumberOfLinks
);
576 fattr
->cf_mode
= S_IFLNK
;
577 fattr
->cf_dtype
= DT_LNK
;
578 } else if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
) {
579 fattr
->cf_mode
= S_IFDIR
| cifs_sb
->mnt_dir_mode
;
580 fattr
->cf_dtype
= DT_DIR
;
582 * Server can return wrong NumberOfLinks value for directories
583 * when Unix extensions are disabled - fake it.
586 fattr
->cf_flags
|= CIFS_FATTR_UNKNOWN_NLINK
;
588 fattr
->cf_mode
= S_IFREG
| cifs_sb
->mnt_file_mode
;
589 fattr
->cf_dtype
= DT_REG
;
591 /* clear write bits if ATTR_READONLY is set */
592 if (fattr
->cf_cifsattrs
& ATTR_READONLY
)
593 fattr
->cf_mode
&= ~(S_IWUGO
);
596 * Don't accept zero nlink from non-unix servers unless
597 * delete is pending. Instead mark it as unknown.
599 if ((fattr
->cf_nlink
< 1) && !tcon
->unix_ext
&&
600 !info
->DeletePending
) {
601 cifs_dbg(1, "bogus file nlink value %u\n",
603 fattr
->cf_flags
|= CIFS_FATTR_UNKNOWN_NLINK
;
607 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
608 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
612 cifs_get_file_info(struct file
*filp
)
616 FILE_ALL_INFO find_data
;
617 struct cifs_fattr fattr
;
618 struct inode
*inode
= file_inode(filp
);
619 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
620 struct cifsFileInfo
*cfile
= filp
->private_data
;
621 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
622 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
624 if (!server
->ops
->query_file_info
)
628 rc
= server
->ops
->query_file_info(xid
, tcon
, &cfile
->fid
, &find_data
);
631 cifs_all_info_to_fattr(&fattr
, &find_data
, cifs_sb
, false,
635 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
641 * FIXME: legacy server -- fall back to path-based call?
642 * for now, just skip revalidating and mark inode for
646 CIFS_I(inode
)->time
= 0;
652 * don't bother with SFU junk here -- just mark inode as needing
655 fattr
.cf_uniqueid
= CIFS_I(inode
)->uniqueid
;
656 fattr
.cf_flags
|= CIFS_FATTR_NEED_REVAL
;
657 cifs_fattr_to_inode(inode
, &fattr
);
664 cifs_get_inode_info(struct inode
**inode
, const char *full_path
,
665 FILE_ALL_INFO
*data
, struct super_block
*sb
, int xid
,
668 bool validinum
= false;
670 int rc
= 0, tmprc
= ENOSYS
;
671 struct cifs_tcon
*tcon
;
672 struct TCP_Server_Info
*server
;
673 struct tcon_link
*tlink
;
674 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
676 bool adjust_tz
= false;
677 struct cifs_fattr fattr
;
678 struct cifs_search_info
*srchinf
= NULL
;
679 bool symlink
= false;
681 tlink
= cifs_sb_tlink(cifs_sb
);
683 return PTR_ERR(tlink
);
684 tcon
= tlink_tcon(tlink
);
685 server
= tcon
->ses
->server
;
687 cifs_dbg(FYI
, "Getting info on %s\n", full_path
);
689 if ((data
== NULL
) && (*inode
!= NULL
)) {
690 if (CIFS_CACHE_READ(CIFS_I(*inode
))) {
691 cifs_dbg(FYI
, "No need to revalidate cached inode sizes\n");
696 /* if inode info is not passed, get it from server */
698 if (!server
->ops
->query_path_info
) {
702 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
707 data
= (FILE_ALL_INFO
*)buf
;
708 rc
= server
->ops
->query_path_info(xid
, tcon
, cifs_sb
, full_path
,
709 data
, &adjust_tz
, &symlink
);
713 cifs_all_info_to_fattr(&fattr
, data
, cifs_sb
, adjust_tz
,
715 } else if (rc
== -EREMOTE
) {
716 cifs_create_dfs_fattr(&fattr
, sb
);
718 } else if (rc
== -EACCES
&& backup_cred(cifs_sb
)) {
719 srchinf
= kzalloc(sizeof(struct cifs_search_info
),
721 if (srchinf
== NULL
) {
726 srchinf
->endOfSearch
= false;
727 srchinf
->info_level
= SMB_FIND_FILE_ID_FULL_DIR_INFO
;
729 srchflgs
= CIFS_SEARCH_CLOSE_ALWAYS
|
730 CIFS_SEARCH_CLOSE_AT_END
|
731 CIFS_SEARCH_BACKUP_SEARCH
;
733 rc
= CIFSFindFirst(xid
, tcon
, full_path
,
734 cifs_sb
, NULL
, srchflgs
, srchinf
, false);
737 (FILE_ALL_INFO
*)srchinf
->srch_entries_start
;
739 cifs_dir_info_to_fattr(&fattr
,
740 (FILE_DIRECTORY_INFO
*)data
, cifs_sb
);
741 fattr
.cf_uniqueid
= le64_to_cpu(
742 ((SEARCH_ID_FULL_DIR_INFO
*)data
)->UniqueId
);
745 cifs_buf_release(srchinf
->ntwrk_buf_start
);
752 * If an inode wasn't passed in, then get the inode number
754 * Is an i_ino of zero legal? Can we use that to check if the server
755 * supports returning inode numbers? Are there other sanity checks we
756 * can use to ensure that the server is really filling in that field?
758 if (*inode
== NULL
) {
759 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) {
760 if (validinum
== false) {
761 if (server
->ops
->get_srv_inum
)
762 tmprc
= server
->ops
->get_srv_inum(xid
,
763 tcon
, cifs_sb
, full_path
,
764 &fattr
.cf_uniqueid
, data
);
766 cifs_dbg(FYI
, "GetSrvInodeNum rc %d\n",
768 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
769 cifs_autodisable_serverino(cifs_sb
);
773 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
775 fattr
.cf_uniqueid
= CIFS_I(*inode
)->uniqueid
;
777 /* query for SFU type info if supported and needed */
778 if (fattr
.cf_cifsattrs
& ATTR_SYSTEM
&&
779 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
) {
780 tmprc
= cifs_sfu_type(&fattr
, full_path
, cifs_sb
, xid
);
782 cifs_dbg(FYI
, "cifs_sfu_type failed: %d\n", tmprc
);
785 #ifdef CONFIG_CIFS_ACL
786 /* fill in 0777 bits from ACL */
787 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
788 rc
= cifs_acl_to_fattr(cifs_sb
, &fattr
, *inode
, full_path
, fid
);
790 cifs_dbg(FYI
, "%s: Getting ACL failed with error: %d\n",
795 #endif /* CONFIG_CIFS_ACL */
797 /* fill in remaining high mode bits e.g. SUID, VTX */
798 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
)
799 cifs_sfu_mode(&fattr
, full_path
, cifs_sb
, xid
);
801 /* check for Minshall+French symlinks */
802 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) {
803 tmprc
= CIFSCheckMFSymlink(xid
, tcon
, cifs_sb
, &fattr
,
806 cifs_dbg(FYI
, "CIFSCheckMFSymlink: %d\n", tmprc
);
810 *inode
= cifs_iget(sb
, &fattr
);
814 cifs_fattr_to_inode(*inode
, &fattr
);
819 cifs_put_tlink(tlink
);
823 static const struct inode_operations cifs_ipc_inode_ops
= {
824 .lookup
= cifs_lookup
,
828 cifs_find_inode(struct inode
*inode
, void *opaque
)
830 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
832 /* don't match inode with different uniqueid */
833 if (CIFS_I(inode
)->uniqueid
!= fattr
->cf_uniqueid
)
836 /* use createtime like an i_generation field */
837 if (CIFS_I(inode
)->createtime
!= fattr
->cf_createtime
)
840 /* don't match inode of different type */
841 if ((inode
->i_mode
& S_IFMT
) != (fattr
->cf_mode
& S_IFMT
))
844 /* if it's not a directory or has no dentries, then flag it */
845 if (S_ISDIR(inode
->i_mode
) && !hlist_empty(&inode
->i_dentry
))
846 fattr
->cf_flags
|= CIFS_FATTR_INO_COLLISION
;
852 cifs_init_inode(struct inode
*inode
, void *opaque
)
854 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
856 CIFS_I(inode
)->uniqueid
= fattr
->cf_uniqueid
;
857 CIFS_I(inode
)->createtime
= fattr
->cf_createtime
;
862 * walk dentry list for an inode and report whether it has aliases that
863 * are hashed. We use this to determine if a directory inode can actually
867 inode_has_hashed_dentries(struct inode
*inode
)
869 struct dentry
*dentry
;
871 spin_lock(&inode
->i_lock
);
872 hlist_for_each_entry(dentry
, &inode
->i_dentry
, d_alias
) {
873 if (!d_unhashed(dentry
) || IS_ROOT(dentry
)) {
874 spin_unlock(&inode
->i_lock
);
878 spin_unlock(&inode
->i_lock
);
882 /* Given fattrs, get a corresponding inode */
884 cifs_iget(struct super_block
*sb
, struct cifs_fattr
*fattr
)
890 cifs_dbg(FYI
, "looking for uniqueid=%llu\n", fattr
->cf_uniqueid
);
892 /* hash down to 32-bits on 32-bit arch */
893 hash
= cifs_uniqueid_to_ino_t(fattr
->cf_uniqueid
);
895 inode
= iget5_locked(sb
, hash
, cifs_find_inode
, cifs_init_inode
, fattr
);
897 /* was there a potentially problematic inode collision? */
898 if (fattr
->cf_flags
& CIFS_FATTR_INO_COLLISION
) {
899 fattr
->cf_flags
&= ~CIFS_FATTR_INO_COLLISION
;
901 if (inode_has_hashed_dentries(inode
)) {
902 cifs_autodisable_serverino(CIFS_SB(sb
));
904 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
905 goto retry_iget5_locked
;
909 cifs_fattr_to_inode(inode
, fattr
);
910 if (sb
->s_flags
& MS_NOATIME
)
911 inode
->i_flags
|= S_NOATIME
| S_NOCMTIME
;
912 if (inode
->i_state
& I_NEW
) {
914 if (S_ISREG(inode
->i_mode
))
915 inode
->i_data
.backing_dev_info
= sb
->s_bdi
;
916 #ifdef CONFIG_CIFS_FSCACHE
917 /* initialize per-inode cache cookie pointer */
918 CIFS_I(inode
)->fscache
= NULL
;
920 unlock_new_inode(inode
);
927 /* gets root inode */
928 struct inode
*cifs_root_iget(struct super_block
*sb
)
931 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
932 struct inode
*inode
= NULL
;
934 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
938 rc
= cifs_get_inode_info_unix(&inode
, "", sb
, xid
);
940 rc
= cifs_get_inode_info(&inode
, "", NULL
, sb
, xid
, NULL
);
947 #ifdef CONFIG_CIFS_FSCACHE
948 /* populate tcon->resource_id */
949 tcon
->resource_id
= CIFS_I(inode
)->uniqueid
;
952 if (rc
&& tcon
->ipc
) {
953 cifs_dbg(FYI
, "ipc connection - fake read inode\n");
954 spin_lock(&inode
->i_lock
);
955 inode
->i_mode
|= S_IFDIR
;
957 inode
->i_op
= &cifs_ipc_inode_ops
;
958 inode
->i_fop
= &simple_dir_operations
;
959 inode
->i_uid
= cifs_sb
->mnt_uid
;
960 inode
->i_gid
= cifs_sb
->mnt_gid
;
961 spin_unlock(&inode
->i_lock
);
968 /* can not call macro free_xid here since in a void func
969 * TODO: This is no longer true
976 cifs_set_file_info(struct inode
*inode
, struct iattr
*attrs
, unsigned int xid
,
977 char *full_path
, __u32 dosattr
)
979 bool set_time
= false;
980 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
981 struct TCP_Server_Info
*server
;
982 FILE_BASIC_INFO info_buf
;
987 server
= cifs_sb_master_tcon(cifs_sb
)->ses
->server
;
988 if (!server
->ops
->set_file_info
)
991 if (attrs
->ia_valid
& ATTR_ATIME
) {
993 info_buf
.LastAccessTime
=
994 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_atime
));
996 info_buf
.LastAccessTime
= 0;
998 if (attrs
->ia_valid
& ATTR_MTIME
) {
1000 info_buf
.LastWriteTime
=
1001 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_mtime
));
1003 info_buf
.LastWriteTime
= 0;
1006 * Samba throws this field away, but windows may actually use it.
1007 * Do not set ctime unless other time stamps are changed explicitly
1008 * (i.e. by utimes()) since we would then have a mix of client and
1011 if (set_time
&& (attrs
->ia_valid
& ATTR_CTIME
)) {
1012 cifs_dbg(FYI
, "CIFS - CTIME changed\n");
1013 info_buf
.ChangeTime
=
1014 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_ctime
));
1016 info_buf
.ChangeTime
= 0;
1018 info_buf
.CreationTime
= 0; /* don't change */
1019 info_buf
.Attributes
= cpu_to_le32(dosattr
);
1021 return server
->ops
->set_file_info(inode
, full_path
, &info_buf
, xid
);
1025 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1026 * and rename it to a random name that hopefully won't conflict with
1030 cifs_rename_pending_delete(const char *full_path
, struct dentry
*dentry
,
1031 const unsigned int xid
)
1036 struct inode
*inode
= dentry
->d_inode
;
1037 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1038 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1039 struct tcon_link
*tlink
;
1040 struct cifs_tcon
*tcon
;
1041 __u32 dosattr
, origattr
;
1042 FILE_BASIC_INFO
*info_buf
= NULL
;
1044 tlink
= cifs_sb_tlink(cifs_sb
);
1046 return PTR_ERR(tlink
);
1047 tcon
= tlink_tcon(tlink
);
1050 * We cannot rename the file if the server doesn't support
1051 * CAP_INFOLEVEL_PASSTHRU
1053 if (!(tcon
->ses
->capabilities
& CAP_INFOLEVEL_PASSTHRU
)) {
1058 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, FILE_OPEN
,
1059 DELETE
|FILE_WRITE_ATTRIBUTES
, CREATE_NOT_DIR
,
1060 &netfid
, &oplock
, NULL
, cifs_sb
->local_nls
,
1061 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
1065 origattr
= cifsInode
->cifsAttrs
;
1067 origattr
|= ATTR_NORMAL
;
1069 dosattr
= origattr
& ~ATTR_READONLY
;
1071 dosattr
|= ATTR_NORMAL
;
1072 dosattr
|= ATTR_HIDDEN
;
1074 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1075 if (dosattr
!= origattr
) {
1076 info_buf
= kzalloc(sizeof(*info_buf
), GFP_KERNEL
);
1077 if (info_buf
== NULL
) {
1081 info_buf
->Attributes
= cpu_to_le32(dosattr
);
1082 rc
= CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, netfid
,
1084 /* although we would like to mark the file hidden
1085 if that fails we will still try to rename it */
1087 cifsInode
->cifsAttrs
= dosattr
;
1089 dosattr
= origattr
; /* since not able to change them */
1092 /* rename the file */
1093 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, netfid
, NULL
, cifs_sb
->local_nls
,
1094 cifs_sb
->mnt_cifs_flags
&
1095 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1101 /* try to set DELETE_ON_CLOSE */
1102 if (!cifsInode
->delete_pending
) {
1103 rc
= CIFSSMBSetFileDisposition(xid
, tcon
, true, netfid
,
1106 * some samba versions return -ENOENT when we try to set the
1107 * file disposition here. Likely a samba bug, but work around
1108 * it for now. This means that some cifsXXX files may hang
1109 * around after they shouldn't.
1111 * BB: remove this hack after more servers have the fix
1119 cifsInode
->delete_pending
= true;
1123 CIFSSMBClose(xid
, tcon
, netfid
);
1126 cifs_put_tlink(tlink
);
1130 * reset everything back to the original state. Don't bother
1131 * dealing with errors here since we can't do anything about
1135 CIFSSMBRenameOpenFile(xid
, tcon
, netfid
, dentry
->d_name
.name
,
1136 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1137 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1139 if (dosattr
!= origattr
) {
1140 info_buf
->Attributes
= cpu_to_le32(origattr
);
1141 if (!CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, netfid
,
1143 cifsInode
->cifsAttrs
= origattr
;
1149 /* copied from fs/nfs/dir.c with small changes */
1151 cifs_drop_nlink(struct inode
*inode
)
1153 spin_lock(&inode
->i_lock
);
1154 if (inode
->i_nlink
> 0)
1156 spin_unlock(&inode
->i_lock
);
1160 * If dentry->d_inode is null (usually meaning the cached dentry
1161 * is a negative dentry) then we would attempt a standard SMB delete, but
1162 * if that fails we can not attempt the fall back mechanisms on EACCESS
1163 * but will return the EACCESS to the caller. Note that the VFS does not call
1164 * unlink on negative dentries currently.
1166 int cifs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1170 char *full_path
= NULL
;
1171 struct inode
*inode
= dentry
->d_inode
;
1172 struct cifsInodeInfo
*cifs_inode
;
1173 struct super_block
*sb
= dir
->i_sb
;
1174 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
1175 struct tcon_link
*tlink
;
1176 struct cifs_tcon
*tcon
;
1177 struct TCP_Server_Info
*server
;
1178 struct iattr
*attrs
= NULL
;
1179 __u32 dosattr
= 0, origattr
= 0;
1181 cifs_dbg(FYI
, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir
, dentry
);
1183 tlink
= cifs_sb_tlink(cifs_sb
);
1185 return PTR_ERR(tlink
);
1186 tcon
= tlink_tcon(tlink
);
1187 server
= tcon
->ses
->server
;
1191 /* Unlink can be called from rename so we can not take the
1192 * sb->s_vfs_rename_mutex here */
1193 full_path
= build_path_from_dentry(dentry
);
1194 if (full_path
== NULL
) {
1199 if (cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1200 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1201 rc
= CIFSPOSIXDelFile(xid
, tcon
, full_path
,
1202 SMB_POSIX_UNLINK_FILE_TARGET
, cifs_sb
->local_nls
,
1203 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
1204 cifs_dbg(FYI
, "posix del rc %d\n", rc
);
1205 if ((rc
== 0) || (rc
== -ENOENT
))
1206 goto psx_del_no_retry
;
1210 if (!server
->ops
->unlink
) {
1212 goto psx_del_no_retry
;
1215 rc
= server
->ops
->unlink(xid
, tcon
, full_path
, cifs_sb
);
1220 cifs_drop_nlink(inode
);
1221 } else if (rc
== -ENOENT
) {
1223 } else if (rc
== -EBUSY
) {
1224 if (server
->ops
->rename_pending_delete
) {
1225 rc
= server
->ops
->rename_pending_delete(full_path
,
1228 cifs_drop_nlink(inode
);
1230 } else if ((rc
== -EACCES
) && (dosattr
== 0) && inode
) {
1231 attrs
= kzalloc(sizeof(*attrs
), GFP_KERNEL
);
1232 if (attrs
== NULL
) {
1237 /* try to reset dos attributes */
1238 cifs_inode
= CIFS_I(inode
);
1239 origattr
= cifs_inode
->cifsAttrs
;
1241 origattr
|= ATTR_NORMAL
;
1242 dosattr
= origattr
& ~ATTR_READONLY
;
1244 dosattr
|= ATTR_NORMAL
;
1245 dosattr
|= ATTR_HIDDEN
;
1247 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
1251 goto retry_std_delete
;
1254 /* undo the setattr if we errored out and it's needed */
1255 if (rc
!= 0 && dosattr
!= 0)
1256 cifs_set_file_info(inode
, attrs
, xid
, full_path
, origattr
);
1260 cifs_inode
= CIFS_I(inode
);
1261 cifs_inode
->time
= 0; /* will force revalidate to get info
1263 inode
->i_ctime
= current_fs_time(sb
);
1265 dir
->i_ctime
= dir
->i_mtime
= current_fs_time(sb
);
1266 cifs_inode
= CIFS_I(dir
);
1267 CIFS_I(dir
)->time
= 0; /* force revalidate of dir as well */
1272 cifs_put_tlink(tlink
);
1277 cifs_mkdir_qinfo(struct inode
*parent
, struct dentry
*dentry
, umode_t mode
,
1278 const char *full_path
, struct cifs_sb_info
*cifs_sb
,
1279 struct cifs_tcon
*tcon
, const unsigned int xid
)
1282 struct inode
*inode
= NULL
;
1285 rc
= cifs_get_inode_info_unix(&inode
, full_path
, parent
->i_sb
,
1288 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, parent
->i_sb
,
1295 * setting nlink not necessary except in cases where we failed to get it
1296 * from the server or was set bogus. Also, since this is a brand new
1297 * inode, no need to grab the i_lock before setting the i_nlink.
1299 if (inode
->i_nlink
< 2)
1300 set_nlink(inode
, 2);
1301 mode
&= ~current_umask();
1302 /* must turn on setgid bit if parent dir has it */
1303 if (parent
->i_mode
& S_ISGID
)
1306 if (tcon
->unix_ext
) {
1307 struct cifs_unix_set_info_args args
= {
1309 .ctime
= NO_CHANGE_64
,
1310 .atime
= NO_CHANGE_64
,
1311 .mtime
= NO_CHANGE_64
,
1314 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1315 args
.uid
= current_fsuid();
1316 if (parent
->i_mode
& S_ISGID
)
1317 args
.gid
= parent
->i_gid
;
1319 args
.gid
= current_fsgid();
1321 args
.uid
= INVALID_UID
; /* no change */
1322 args
.gid
= INVALID_GID
; /* no change */
1324 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
1326 cifs_sb
->mnt_cifs_flags
&
1327 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1329 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1330 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
1331 (mode
& S_IWUGO
) == 0 && server
->ops
->mkdir_setinfo
)
1332 server
->ops
->mkdir_setinfo(inode
, full_path
, cifs_sb
,
1334 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
1335 inode
->i_mode
= (mode
| S_IFDIR
);
1337 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1338 inode
->i_uid
= current_fsuid();
1339 if (inode
->i_mode
& S_ISGID
)
1340 inode
->i_gid
= parent
->i_gid
;
1342 inode
->i_gid
= current_fsgid();
1345 d_instantiate(dentry
, inode
);
1350 cifs_posix_mkdir(struct inode
*inode
, struct dentry
*dentry
, umode_t mode
,
1351 const char *full_path
, struct cifs_sb_info
*cifs_sb
,
1352 struct cifs_tcon
*tcon
, const unsigned int xid
)
1356 FILE_UNIX_BASIC_INFO
*info
= NULL
;
1357 struct inode
*newinode
= NULL
;
1358 struct cifs_fattr fattr
;
1360 info
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
1363 goto posix_mkdir_out
;
1366 mode
&= ~current_umask();
1367 rc
= CIFSPOSIXCreate(xid
, tcon
, SMB_O_DIRECTORY
| SMB_O_CREAT
, mode
,
1368 NULL
/* netfid */, info
, &oplock
, full_path
,
1369 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1370 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1371 if (rc
== -EOPNOTSUPP
)
1372 goto posix_mkdir_out
;
1374 cifs_dbg(FYI
, "posix mkdir returned 0x%x\n", rc
);
1376 goto posix_mkdir_out
;
1379 if (info
->Type
== cpu_to_le32(-1))
1380 /* no return info, go query for it */
1381 goto posix_mkdir_get_info
;
1383 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1384 * need to set uid/gid.
1387 cifs_unix_basic_to_fattr(&fattr
, info
, cifs_sb
);
1388 cifs_fill_uniqueid(inode
->i_sb
, &fattr
);
1389 newinode
= cifs_iget(inode
->i_sb
, &fattr
);
1391 goto posix_mkdir_get_info
;
1393 d_instantiate(dentry
, newinode
);
1395 #ifdef CONFIG_CIFS_DEBUG2
1396 cifs_dbg(FYI
, "instantiated dentry %p %s to inode %p\n",
1397 dentry
, dentry
->d_name
.name
, newinode
);
1399 if (newinode
->i_nlink
!= 2)
1400 cifs_dbg(FYI
, "unexpected number of links %d\n",
1407 posix_mkdir_get_info
:
1408 rc
= cifs_mkdir_qinfo(inode
, dentry
, mode
, full_path
, cifs_sb
, tcon
,
1410 goto posix_mkdir_out
;
1413 int cifs_mkdir(struct inode
*inode
, struct dentry
*direntry
, umode_t mode
)
1417 struct cifs_sb_info
*cifs_sb
;
1418 struct tcon_link
*tlink
;
1419 struct cifs_tcon
*tcon
;
1420 struct TCP_Server_Info
*server
;
1423 cifs_dbg(FYI
, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1426 cifs_sb
= CIFS_SB(inode
->i_sb
);
1427 tlink
= cifs_sb_tlink(cifs_sb
);
1429 return PTR_ERR(tlink
);
1430 tcon
= tlink_tcon(tlink
);
1434 full_path
= build_path_from_dentry(direntry
);
1435 if (full_path
== NULL
) {
1440 if (cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1441 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1442 rc
= cifs_posix_mkdir(inode
, direntry
, mode
, full_path
, cifs_sb
,
1444 if (rc
!= -EOPNOTSUPP
)
1448 server
= tcon
->ses
->server
;
1450 if (!server
->ops
->mkdir
) {
1455 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1456 rc
= server
->ops
->mkdir(xid
, tcon
, full_path
, cifs_sb
);
1458 cifs_dbg(FYI
, "cifs_mkdir returned 0x%x\n", rc
);
1463 rc
= cifs_mkdir_qinfo(inode
, direntry
, mode
, full_path
, cifs_sb
, tcon
,
1467 * Force revalidate to get parent dir info when needed since cached
1468 * attributes are invalid now.
1470 CIFS_I(inode
)->time
= 0;
1473 cifs_put_tlink(tlink
);
1477 int cifs_rmdir(struct inode
*inode
, struct dentry
*direntry
)
1481 struct cifs_sb_info
*cifs_sb
;
1482 struct tcon_link
*tlink
;
1483 struct cifs_tcon
*tcon
;
1484 struct TCP_Server_Info
*server
;
1485 char *full_path
= NULL
;
1486 struct cifsInodeInfo
*cifsInode
;
1488 cifs_dbg(FYI
, "cifs_rmdir, inode = 0x%p\n", inode
);
1492 full_path
= build_path_from_dentry(direntry
);
1493 if (full_path
== NULL
) {
1498 cifs_sb
= CIFS_SB(inode
->i_sb
);
1499 tlink
= cifs_sb_tlink(cifs_sb
);
1500 if (IS_ERR(tlink
)) {
1501 rc
= PTR_ERR(tlink
);
1504 tcon
= tlink_tcon(tlink
);
1505 server
= tcon
->ses
->server
;
1507 if (!server
->ops
->rmdir
) {
1509 cifs_put_tlink(tlink
);
1513 rc
= server
->ops
->rmdir(xid
, tcon
, full_path
, cifs_sb
);
1514 cifs_put_tlink(tlink
);
1517 spin_lock(&direntry
->d_inode
->i_lock
);
1518 i_size_write(direntry
->d_inode
, 0);
1519 clear_nlink(direntry
->d_inode
);
1520 spin_unlock(&direntry
->d_inode
->i_lock
);
1523 cifsInode
= CIFS_I(direntry
->d_inode
);
1524 /* force revalidate to go get info when needed */
1525 cifsInode
->time
= 0;
1527 cifsInode
= CIFS_I(inode
);
1529 * Force revalidate to get parent dir info when needed since cached
1530 * attributes are invalid now.
1532 cifsInode
->time
= 0;
1534 direntry
->d_inode
->i_ctime
= inode
->i_ctime
= inode
->i_mtime
=
1535 current_fs_time(inode
->i_sb
);
1544 cifs_do_rename(const unsigned int xid
, struct dentry
*from_dentry
,
1545 const char *from_path
, struct dentry
*to_dentry
,
1546 const char *to_path
)
1548 struct cifs_sb_info
*cifs_sb
= CIFS_SB(from_dentry
->d_sb
);
1549 struct tcon_link
*tlink
;
1550 struct cifs_tcon
*tcon
;
1551 struct TCP_Server_Info
*server
;
1555 tlink
= cifs_sb_tlink(cifs_sb
);
1557 return PTR_ERR(tlink
);
1558 tcon
= tlink_tcon(tlink
);
1559 server
= tcon
->ses
->server
;
1561 if (!server
->ops
->rename
)
1564 /* try path-based rename first */
1565 rc
= server
->ops
->rename(xid
, tcon
, from_path
, to_path
, cifs_sb
);
1568 * Don't bother with rename by filehandle unless file is busy and
1569 * source. Note that cross directory moves do not work with
1570 * rename by filehandle to various Windows servers.
1572 if (rc
== 0 || rc
!= -EBUSY
)
1573 goto do_rename_exit
;
1575 /* open-file renames don't work across directories */
1576 if (to_dentry
->d_parent
!= from_dentry
->d_parent
)
1577 goto do_rename_exit
;
1579 /* open the file to be renamed -- we need DELETE perms */
1580 rc
= CIFSSMBOpen(xid
, tcon
, from_path
, FILE_OPEN
, DELETE
,
1581 CREATE_NOT_DIR
, &srcfid
, &oplock
, NULL
,
1582 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1583 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1585 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, srcfid
,
1586 (const char *) to_dentry
->d_name
.name
,
1587 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1588 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1589 CIFSSMBClose(xid
, tcon
, srcfid
);
1592 cifs_put_tlink(tlink
);
1597 cifs_rename(struct inode
*source_dir
, struct dentry
*source_dentry
,
1598 struct inode
*target_dir
, struct dentry
*target_dentry
)
1600 char *from_name
= NULL
;
1601 char *to_name
= NULL
;
1602 struct cifs_sb_info
*cifs_sb
;
1603 struct tcon_link
*tlink
;
1604 struct cifs_tcon
*tcon
;
1605 FILE_UNIX_BASIC_INFO
*info_buf_source
= NULL
;
1606 FILE_UNIX_BASIC_INFO
*info_buf_target
;
1610 cifs_sb
= CIFS_SB(source_dir
->i_sb
);
1611 tlink
= cifs_sb_tlink(cifs_sb
);
1613 return PTR_ERR(tlink
);
1614 tcon
= tlink_tcon(tlink
);
1619 * we already have the rename sem so we do not need to
1620 * grab it again here to protect the path integrity
1622 from_name
= build_path_from_dentry(source_dentry
);
1623 if (from_name
== NULL
) {
1625 goto cifs_rename_exit
;
1628 to_name
= build_path_from_dentry(target_dentry
);
1629 if (to_name
== NULL
) {
1631 goto cifs_rename_exit
;
1634 rc
= cifs_do_rename(xid
, source_dentry
, from_name
, target_dentry
,
1637 if (rc
== -EEXIST
&& tcon
->unix_ext
) {
1639 * Are src and dst hardlinks of same inode? We can only tell
1640 * with unix extensions enabled.
1643 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO
),
1645 if (info_buf_source
== NULL
) {
1647 goto cifs_rename_exit
;
1650 info_buf_target
= info_buf_source
+ 1;
1651 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, from_name
,
1654 cifs_sb
->mnt_cifs_flags
&
1655 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1659 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, to_name
,
1662 cifs_sb
->mnt_cifs_flags
&
1663 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1665 if (tmprc
== 0 && (info_buf_source
->UniqueId
==
1666 info_buf_target
->UniqueId
)) {
1667 /* same file, POSIX says that this is a noop */
1669 goto cifs_rename_exit
;
1673 * else ... BB we could add the same check for Windows by
1674 * checking the UniqueId via FILE_INTERNAL_INFO
1678 /* Try unlinking the target dentry if it's not negative */
1679 if (target_dentry
->d_inode
&& (rc
== -EACCES
|| rc
== -EEXIST
)) {
1680 tmprc
= cifs_unlink(target_dir
, target_dentry
);
1682 goto cifs_rename_exit
;
1683 rc
= cifs_do_rename(xid
, source_dentry
, from_name
,
1684 target_dentry
, to_name
);
1688 kfree(info_buf_source
);
1692 cifs_put_tlink(tlink
);
1697 cifs_inode_needs_reval(struct inode
*inode
)
1699 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
1700 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1702 if (CIFS_CACHE_READ(cifs_i
))
1705 if (!lookupCacheEnabled
)
1708 if (cifs_i
->time
== 0)
1711 if (!time_in_range(jiffies
, cifs_i
->time
,
1712 cifs_i
->time
+ cifs_sb
->actimeo
))
1715 /* hardlinked files w/ noserverino get "special" treatment */
1716 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) &&
1717 S_ISREG(inode
->i_mode
) && inode
->i_nlink
!= 1)
1724 * Zap the cache. Called when invalid_mapping flag is set.
1727 cifs_invalidate_mapping(struct inode
*inode
)
1730 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
1732 cifs_i
->invalid_mapping
= false;
1734 if (inode
->i_mapping
&& inode
->i_mapping
->nrpages
!= 0) {
1735 rc
= invalidate_inode_pages2(inode
->i_mapping
);
1737 cifs_dbg(VFS
, "%s: could not invalidate inode %p\n",
1739 cifs_i
->invalid_mapping
= true;
1743 cifs_fscache_reset_inode_cookie(inode
);
1747 int cifs_revalidate_file_attr(struct file
*filp
)
1750 struct inode
*inode
= file_inode(filp
);
1751 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*) filp
->private_data
;
1753 if (!cifs_inode_needs_reval(inode
))
1756 if (tlink_tcon(cfile
->tlink
)->unix_ext
)
1757 rc
= cifs_get_file_info_unix(filp
);
1759 rc
= cifs_get_file_info(filp
);
1764 int cifs_revalidate_dentry_attr(struct dentry
*dentry
)
1768 struct inode
*inode
= dentry
->d_inode
;
1769 struct super_block
*sb
= dentry
->d_sb
;
1770 char *full_path
= NULL
;
1775 if (!cifs_inode_needs_reval(inode
))
1780 /* can not safely grab the rename sem here if rename calls revalidate
1781 since that would deadlock */
1782 full_path
= build_path_from_dentry(dentry
);
1783 if (full_path
== NULL
) {
1788 cifs_dbg(FYI
, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1789 full_path
, inode
, inode
->i_count
.counter
,
1790 dentry
, dentry
->d_time
, jiffies
);
1792 if (cifs_sb_master_tcon(CIFS_SB(sb
))->unix_ext
)
1793 rc
= cifs_get_inode_info_unix(&inode
, full_path
, sb
, xid
);
1795 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, sb
,
1804 int cifs_revalidate_file(struct file
*filp
)
1807 struct inode
*inode
= file_inode(filp
);
1809 rc
= cifs_revalidate_file_attr(filp
);
1813 if (CIFS_I(inode
)->invalid_mapping
)
1814 rc
= cifs_invalidate_mapping(inode
);
1818 /* revalidate a dentry's inode attributes */
1819 int cifs_revalidate_dentry(struct dentry
*dentry
)
1822 struct inode
*inode
= dentry
->d_inode
;
1824 rc
= cifs_revalidate_dentry_attr(dentry
);
1828 if (CIFS_I(inode
)->invalid_mapping
)
1829 rc
= cifs_invalidate_mapping(inode
);
1833 int cifs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
1836 struct cifs_sb_info
*cifs_sb
= CIFS_SB(dentry
->d_sb
);
1837 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
1838 struct inode
*inode
= dentry
->d_inode
;
1842 * We need to be sure that all dirty pages are written and the server
1843 * has actual ctime, mtime and file length.
1845 if (!CIFS_CACHE_READ(CIFS_I(inode
)) && inode
->i_mapping
&&
1846 inode
->i_mapping
->nrpages
!= 0) {
1847 rc
= filemap_fdatawait(inode
->i_mapping
);
1849 mapping_set_error(inode
->i_mapping
, rc
);
1854 rc
= cifs_revalidate_dentry_attr(dentry
);
1858 generic_fillattr(inode
, stat
);
1859 stat
->blksize
= CIFS_MAX_MSGSIZE
;
1860 stat
->ino
= CIFS_I(inode
)->uniqueid
;
1863 * If on a multiuser mount without unix extensions or cifsacl being
1864 * enabled, and the admin hasn't overridden them, set the ownership
1865 * to the fsuid/fsgid of the current process.
1867 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
) &&
1868 !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
1870 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
))
1871 stat
->uid
= current_fsuid();
1872 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
))
1873 stat
->gid
= current_fsgid();
1878 static int cifs_truncate_page(struct address_space
*mapping
, loff_t from
)
1880 pgoff_t index
= from
>> PAGE_CACHE_SHIFT
;
1881 unsigned offset
= from
& (PAGE_CACHE_SIZE
- 1);
1885 page
= grab_cache_page(mapping
, index
);
1889 zero_user_segment(page
, offset
, PAGE_CACHE_SIZE
);
1891 page_cache_release(page
);
1895 static void cifs_setsize(struct inode
*inode
, loff_t offset
)
1897 spin_lock(&inode
->i_lock
);
1898 i_size_write(inode
, offset
);
1899 spin_unlock(&inode
->i_lock
);
1901 truncate_pagecache(inode
, offset
);
1905 cifs_set_file_size(struct inode
*inode
, struct iattr
*attrs
,
1906 unsigned int xid
, char *full_path
)
1909 struct cifsFileInfo
*open_file
;
1910 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1911 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1912 struct tcon_link
*tlink
= NULL
;
1913 struct cifs_tcon
*tcon
= NULL
;
1914 struct TCP_Server_Info
*server
;
1915 struct cifs_io_parms io_parms
;
1918 * To avoid spurious oplock breaks from server, in the case of
1919 * inodes that we already have open, avoid doing path based
1920 * setting of file size if we can do it by handle.
1921 * This keeps our caching token (oplock) and avoids timeouts
1922 * when the local oplock break takes longer to flush
1923 * writebehind data than the SMB timeout for the SetPathInfo
1924 * request would allow
1926 open_file
= find_writable_file(cifsInode
, true);
1928 tcon
= tlink_tcon(open_file
->tlink
);
1929 server
= tcon
->ses
->server
;
1930 if (server
->ops
->set_file_size
)
1931 rc
= server
->ops
->set_file_size(xid
, tcon
, open_file
,
1932 attrs
->ia_size
, false);
1935 cifsFileInfo_put(open_file
);
1936 cifs_dbg(FYI
, "SetFSize for attrs rc = %d\n", rc
);
1937 if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
1938 unsigned int bytes_written
;
1940 io_parms
.netfid
= open_file
->fid
.netfid
;
1941 io_parms
.pid
= open_file
->pid
;
1942 io_parms
.tcon
= tcon
;
1943 io_parms
.offset
= 0;
1944 io_parms
.length
= attrs
->ia_size
;
1945 rc
= CIFSSMBWrite(xid
, &io_parms
, &bytes_written
,
1947 cifs_dbg(FYI
, "Wrt seteof rc %d\n", rc
);
1956 tlink
= cifs_sb_tlink(cifs_sb
);
1958 return PTR_ERR(tlink
);
1959 tcon
= tlink_tcon(tlink
);
1960 server
= tcon
->ses
->server
;
1964 * Set file size by pathname rather than by handle either because no
1965 * valid, writeable file handle for it was found or because there was
1966 * an error setting it by handle.
1968 if (server
->ops
->set_path_size
)
1969 rc
= server
->ops
->set_path_size(xid
, tcon
, full_path
,
1970 attrs
->ia_size
, cifs_sb
, false);
1973 cifs_dbg(FYI
, "SetEOF by path (setattrs) rc = %d\n", rc
);
1974 if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
1978 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, FILE_OPEN
,
1979 GENERIC_WRITE
, CREATE_NOT_DIR
, &netfid
,
1980 &oplock
, NULL
, cifs_sb
->local_nls
,
1981 cifs_sb
->mnt_cifs_flags
&
1982 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1984 unsigned int bytes_written
;
1986 io_parms
.netfid
= netfid
;
1987 io_parms
.pid
= current
->tgid
;
1988 io_parms
.tcon
= tcon
;
1989 io_parms
.offset
= 0;
1990 io_parms
.length
= attrs
->ia_size
;
1991 rc
= CIFSSMBWrite(xid
, &io_parms
, &bytes_written
, NULL
,
1993 cifs_dbg(FYI
, "wrt seteof rc %d\n", rc
);
1994 CIFSSMBClose(xid
, tcon
, netfid
);
1998 cifs_put_tlink(tlink
);
2002 cifsInode
->server_eof
= attrs
->ia_size
;
2003 cifs_setsize(inode
, attrs
->ia_size
);
2004 cifs_truncate_page(inode
->i_mapping
, inode
->i_size
);
2011 cifs_setattr_unix(struct dentry
*direntry
, struct iattr
*attrs
)
2015 char *full_path
= NULL
;
2016 struct inode
*inode
= direntry
->d_inode
;
2017 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2018 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2019 struct tcon_link
*tlink
;
2020 struct cifs_tcon
*pTcon
;
2021 struct cifs_unix_set_info_args
*args
= NULL
;
2022 struct cifsFileInfo
*open_file
;
2024 cifs_dbg(FYI
, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
2025 direntry
->d_name
.name
, attrs
->ia_valid
);
2029 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
2030 attrs
->ia_valid
|= ATTR_FORCE
;
2032 rc
= inode_change_ok(inode
, attrs
);
2036 full_path
= build_path_from_dentry(direntry
);
2037 if (full_path
== NULL
) {
2043 * Attempt to flush data before changing attributes. We need to do
2044 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2045 * ownership or mode then we may also need to do this. Here, we take
2046 * the safe way out and just do the flush on all setattr requests. If
2047 * the flush returns error, store it to report later and continue.
2049 * BB: This should be smarter. Why bother flushing pages that
2050 * will be truncated anyway? Also, should we error out here if
2051 * the flush returns error?
2053 rc
= filemap_write_and_wait(inode
->i_mapping
);
2054 mapping_set_error(inode
->i_mapping
, rc
);
2057 if (attrs
->ia_valid
& ATTR_SIZE
) {
2058 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
2063 /* skip mode change if it's just for clearing setuid/setgid */
2064 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
2065 attrs
->ia_valid
&= ~ATTR_MODE
;
2067 args
= kmalloc(sizeof(*args
), GFP_KERNEL
);
2073 /* set up the struct */
2074 if (attrs
->ia_valid
& ATTR_MODE
)
2075 args
->mode
= attrs
->ia_mode
;
2077 args
->mode
= NO_CHANGE_64
;
2079 if (attrs
->ia_valid
& ATTR_UID
)
2080 args
->uid
= attrs
->ia_uid
;
2082 args
->uid
= INVALID_UID
; /* no change */
2084 if (attrs
->ia_valid
& ATTR_GID
)
2085 args
->gid
= attrs
->ia_gid
;
2087 args
->gid
= INVALID_GID
; /* no change */
2089 if (attrs
->ia_valid
& ATTR_ATIME
)
2090 args
->atime
= cifs_UnixTimeToNT(attrs
->ia_atime
);
2092 args
->atime
= NO_CHANGE_64
;
2094 if (attrs
->ia_valid
& ATTR_MTIME
)
2095 args
->mtime
= cifs_UnixTimeToNT(attrs
->ia_mtime
);
2097 args
->mtime
= NO_CHANGE_64
;
2099 if (attrs
->ia_valid
& ATTR_CTIME
)
2100 args
->ctime
= cifs_UnixTimeToNT(attrs
->ia_ctime
);
2102 args
->ctime
= NO_CHANGE_64
;
2105 open_file
= find_writable_file(cifsInode
, true);
2107 u16 nfid
= open_file
->fid
.netfid
;
2108 u32 npid
= open_file
->pid
;
2109 pTcon
= tlink_tcon(open_file
->tlink
);
2110 rc
= CIFSSMBUnixSetFileInfo(xid
, pTcon
, args
, nfid
, npid
);
2111 cifsFileInfo_put(open_file
);
2113 tlink
= cifs_sb_tlink(cifs_sb
);
2114 if (IS_ERR(tlink
)) {
2115 rc
= PTR_ERR(tlink
);
2118 pTcon
= tlink_tcon(tlink
);
2119 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, args
,
2121 cifs_sb
->mnt_cifs_flags
&
2122 CIFS_MOUNT_MAP_SPECIAL_CHR
);
2123 cifs_put_tlink(tlink
);
2129 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
2130 attrs
->ia_size
!= i_size_read(inode
))
2131 truncate_setsize(inode
, attrs
->ia_size
);
2133 setattr_copy(inode
, attrs
);
2134 mark_inode_dirty(inode
);
2136 /* force revalidate when any of these times are set since some
2137 of the fs types (eg ext3, fat) do not have fine enough
2138 time granularity to match protocol, and we do not have a
2139 a way (yet) to query the server fs's time granularity (and
2140 whether it rounds times down).
2142 if (attrs
->ia_valid
& (ATTR_MTIME
| ATTR_CTIME
))
2143 cifsInode
->time
= 0;
2152 cifs_setattr_nounix(struct dentry
*direntry
, struct iattr
*attrs
)
2155 kuid_t uid
= INVALID_UID
;
2156 kgid_t gid
= INVALID_GID
;
2157 struct inode
*inode
= direntry
->d_inode
;
2158 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2159 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2160 char *full_path
= NULL
;
2163 __u64 mode
= NO_CHANGE_64
;
2167 cifs_dbg(FYI
, "setattr on file %s attrs->iavalid 0x%x\n",
2168 direntry
->d_name
.name
, attrs
->ia_valid
);
2170 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
2171 attrs
->ia_valid
|= ATTR_FORCE
;
2173 rc
= inode_change_ok(inode
, attrs
);
2179 full_path
= build_path_from_dentry(direntry
);
2180 if (full_path
== NULL
) {
2187 * Attempt to flush data before changing attributes. We need to do
2188 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2189 * ownership or mode then we may also need to do this. Here, we take
2190 * the safe way out and just do the flush on all setattr requests. If
2191 * the flush returns error, store it to report later and continue.
2193 * BB: This should be smarter. Why bother flushing pages that
2194 * will be truncated anyway? Also, should we error out here if
2195 * the flush returns error?
2197 rc
= filemap_write_and_wait(inode
->i_mapping
);
2198 mapping_set_error(inode
->i_mapping
, rc
);
2201 if (attrs
->ia_valid
& ATTR_SIZE
) {
2202 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
2204 goto cifs_setattr_exit
;
2207 if (attrs
->ia_valid
& ATTR_UID
)
2208 uid
= attrs
->ia_uid
;
2210 if (attrs
->ia_valid
& ATTR_GID
)
2211 gid
= attrs
->ia_gid
;
2213 #ifdef CONFIG_CIFS_ACL
2214 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
2215 if (uid_valid(uid
) || gid_valid(gid
)) {
2216 rc
= id_mode_to_cifs_acl(inode
, full_path
, NO_CHANGE_64
,
2219 cifs_dbg(FYI
, "%s: Setting id failed with error: %d\n",
2221 goto cifs_setattr_exit
;
2225 #endif /* CONFIG_CIFS_ACL */
2226 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
))
2227 attrs
->ia_valid
&= ~(ATTR_UID
| ATTR_GID
);
2229 /* skip mode change if it's just for clearing setuid/setgid */
2230 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
2231 attrs
->ia_valid
&= ~ATTR_MODE
;
2233 if (attrs
->ia_valid
& ATTR_MODE
) {
2234 mode
= attrs
->ia_mode
;
2236 #ifdef CONFIG_CIFS_ACL
2237 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
2238 rc
= id_mode_to_cifs_acl(inode
, full_path
, mode
,
2239 INVALID_UID
, INVALID_GID
);
2241 cifs_dbg(FYI
, "%s: Setting ACL failed with error: %d\n",
2243 goto cifs_setattr_exit
;
2246 #endif /* CONFIG_CIFS_ACL */
2247 if (((mode
& S_IWUGO
) == 0) &&
2248 (cifsInode
->cifsAttrs
& ATTR_READONLY
) == 0) {
2250 dosattr
= cifsInode
->cifsAttrs
| ATTR_READONLY
;
2252 /* fix up mode if we're not using dynperm */
2253 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
) == 0)
2254 attrs
->ia_mode
= inode
->i_mode
& ~S_IWUGO
;
2255 } else if ((mode
& S_IWUGO
) &&
2256 (cifsInode
->cifsAttrs
& ATTR_READONLY
)) {
2258 dosattr
= cifsInode
->cifsAttrs
& ~ATTR_READONLY
;
2259 /* Attributes of 0 are ignored */
2261 dosattr
|= ATTR_NORMAL
;
2263 /* reset local inode permissions to normal */
2264 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2265 attrs
->ia_mode
&= ~(S_IALLUGO
);
2266 if (S_ISDIR(inode
->i_mode
))
2268 cifs_sb
->mnt_dir_mode
;
2271 cifs_sb
->mnt_file_mode
;
2273 } else if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2274 /* ignore mode change - ATTR_READONLY hasn't changed */
2275 attrs
->ia_valid
&= ~ATTR_MODE
;
2279 if (attrs
->ia_valid
& (ATTR_MTIME
|ATTR_ATIME
|ATTR_CTIME
) ||
2280 ((attrs
->ia_valid
& ATTR_MODE
) && dosattr
)) {
2281 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
2282 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2284 /* Even if error on time set, no sense failing the call if
2285 the server would set the time to a reasonable value anyway,
2286 and this check ensures that we are not being called from
2287 sys_utimes in which case we ought to fail the call back to
2288 the user when the server rejects the call */
2289 if ((rc
) && (attrs
->ia_valid
&
2290 (ATTR_MODE
| ATTR_GID
| ATTR_UID
| ATTR_SIZE
)))
2294 /* do not need local check to inode_check_ok since the server does
2297 goto cifs_setattr_exit
;
2299 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
2300 attrs
->ia_size
!= i_size_read(inode
))
2301 truncate_setsize(inode
, attrs
->ia_size
);
2303 setattr_copy(inode
, attrs
);
2304 mark_inode_dirty(inode
);
2313 cifs_setattr(struct dentry
*direntry
, struct iattr
*attrs
)
2315 struct inode
*inode
= direntry
->d_inode
;
2316 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2317 struct cifs_tcon
*pTcon
= cifs_sb_master_tcon(cifs_sb
);
2319 if (pTcon
->unix_ext
)
2320 return cifs_setattr_unix(direntry
, attrs
);
2322 return cifs_setattr_nounix(direntry
, attrs
);
2324 /* BB: add cifs_setattr_legacy for really old servers */
2328 void cifs_delete_inode(struct inode
*inode
)
2330 cifs_dbg(FYI
, "In cifs_delete_inode, inode = 0x%p\n", inode
);
2331 /* may have to add back in if and when safe distributed caching of
2332 directories added e.g. via FindNotify */