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 <linux/freezer.h>
26 #include <asm/div64.h>
30 #include "cifsproto.h"
31 #include "cifs_debug.h"
32 #include "cifs_fs_sb.h"
33 #include "cifs_unicode.h"
37 static void cifs_set_ops(struct inode
*inode
)
39 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
41 switch (inode
->i_mode
& S_IFMT
) {
43 inode
->i_op
= &cifs_file_inode_ops
;
44 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
45 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
46 inode
->i_fop
= &cifs_file_direct_nobrl_ops
;
48 inode
->i_fop
= &cifs_file_direct_ops
;
49 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_STRICT_IO
) {
50 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
51 inode
->i_fop
= &cifs_file_strict_nobrl_ops
;
53 inode
->i_fop
= &cifs_file_strict_ops
;
54 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
55 inode
->i_fop
= &cifs_file_nobrl_ops
;
56 else { /* not direct, send byte range locks */
57 inode
->i_fop
= &cifs_file_ops
;
60 /* check if server can support readpages */
61 if (cifs_sb_master_tcon(cifs_sb
)->ses
->server
->maxBuf
<
62 PAGE_CACHE_SIZE
+ MAX_CIFS_HDR_SIZE
)
63 inode
->i_data
.a_ops
= &cifs_addr_ops_smallbuf
;
65 inode
->i_data
.a_ops
= &cifs_addr_ops
;
68 #ifdef CONFIG_CIFS_DFS_UPCALL
69 if (IS_AUTOMOUNT(inode
)) {
70 inode
->i_op
= &cifs_dfs_referral_inode_operations
;
72 #else /* NO DFS support, treat as a directory */
75 inode
->i_op
= &cifs_dir_inode_ops
;
76 inode
->i_fop
= &cifs_dir_ops
;
80 inode
->i_op
= &cifs_symlink_inode_ops
;
83 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
88 /* check inode attributes against fattr. If they don't match, tag the
89 * inode for cache invalidation
92 cifs_revalidate_cache(struct inode
*inode
, struct cifs_fattr
*fattr
)
94 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
96 cifs_dbg(FYI
, "%s: revalidating inode %llu\n",
97 __func__
, cifs_i
->uniqueid
);
99 if (inode
->i_state
& I_NEW
) {
100 cifs_dbg(FYI
, "%s: inode %llu is new\n",
101 __func__
, cifs_i
->uniqueid
);
105 /* don't bother with revalidation if we have an oplock */
106 if (CIFS_CACHE_READ(cifs_i
)) {
107 cifs_dbg(FYI
, "%s: inode %llu is oplocked\n",
108 __func__
, cifs_i
->uniqueid
);
112 /* revalidate if mtime or size have changed */
113 if (timespec_equal(&inode
->i_mtime
, &fattr
->cf_mtime
) &&
114 cifs_i
->server_eof
== fattr
->cf_eof
) {
115 cifs_dbg(FYI
, "%s: inode %llu is unchanged\n",
116 __func__
, cifs_i
->uniqueid
);
120 cifs_dbg(FYI
, "%s: invalidating inode %llu mapping\n",
121 __func__
, cifs_i
->uniqueid
);
122 set_bit(CIFS_INO_INVALID_MAPPING
, &cifs_i
->flags
);
126 * copy nlink to the inode, unless it wasn't provided. Provide
127 * sane values if we don't have an existing one and none was provided
130 cifs_nlink_fattr_to_inode(struct inode
*inode
, struct cifs_fattr
*fattr
)
133 * if we're in a situation where we can't trust what we
134 * got from the server (readdir, some non-unix cases)
135 * fake reasonable values
137 if (fattr
->cf_flags
& CIFS_FATTR_UNKNOWN_NLINK
) {
138 /* only provide fake values on a new inode */
139 if (inode
->i_state
& I_NEW
) {
140 if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
)
148 /* we trust the server, so update it */
149 set_nlink(inode
, fattr
->cf_nlink
);
152 /* populate an inode with info from a cifs_fattr struct */
154 cifs_fattr_to_inode(struct inode
*inode
, struct cifs_fattr
*fattr
)
156 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
157 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
159 cifs_revalidate_cache(inode
, fattr
);
161 spin_lock(&inode
->i_lock
);
162 inode
->i_atime
= fattr
->cf_atime
;
163 inode
->i_mtime
= fattr
->cf_mtime
;
164 inode
->i_ctime
= fattr
->cf_ctime
;
165 inode
->i_rdev
= fattr
->cf_rdev
;
166 cifs_nlink_fattr_to_inode(inode
, fattr
);
167 inode
->i_uid
= fattr
->cf_uid
;
168 inode
->i_gid
= fattr
->cf_gid
;
170 /* if dynperm is set, don't clobber existing mode */
171 if (inode
->i_state
& I_NEW
||
172 !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
))
173 inode
->i_mode
= fattr
->cf_mode
;
175 cifs_i
->cifsAttrs
= fattr
->cf_cifsattrs
;
177 if (fattr
->cf_flags
& CIFS_FATTR_NEED_REVAL
)
180 cifs_i
->time
= jiffies
;
182 if (fattr
->cf_flags
& CIFS_FATTR_DELETE_PENDING
)
183 set_bit(CIFS_INO_DELETE_PENDING
, &cifs_i
->flags
);
185 clear_bit(CIFS_INO_DELETE_PENDING
, &cifs_i
->flags
);
187 cifs_i
->server_eof
= fattr
->cf_eof
;
189 * Can't safely change the file size here if the client is writing to
190 * it due to potential races.
192 if (is_size_safe_to_change(cifs_i
, fattr
->cf_eof
)) {
193 i_size_write(inode
, fattr
->cf_eof
);
196 * i_blocks is not related to (i_size / i_blksize),
197 * but instead 512 byte (2**9) size is required for
198 * calculating num blocks.
200 inode
->i_blocks
= (512 - 1 + fattr
->cf_bytes
) >> 9;
202 spin_unlock(&inode
->i_lock
);
204 if (fattr
->cf_flags
& CIFS_FATTR_DFS_REFERRAL
)
205 inode
->i_flags
|= S_AUTOMOUNT
;
206 if (inode
->i_state
& I_NEW
)
211 cifs_fill_uniqueid(struct super_block
*sb
, struct cifs_fattr
*fattr
)
213 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
215 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)
218 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
221 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
223 cifs_unix_basic_to_fattr(struct cifs_fattr
*fattr
, FILE_UNIX_BASIC_INFO
*info
,
224 struct cifs_sb_info
*cifs_sb
)
226 memset(fattr
, 0, sizeof(*fattr
));
227 fattr
->cf_uniqueid
= le64_to_cpu(info
->UniqueId
);
228 fattr
->cf_bytes
= le64_to_cpu(info
->NumOfBytes
);
229 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
231 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
232 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastModificationTime
);
233 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->LastStatusChange
);
234 fattr
->cf_mode
= le64_to_cpu(info
->Permissions
);
237 * Since we set the inode type below we need to mask off
238 * to avoid strange results if bits set above.
240 fattr
->cf_mode
&= ~S_IFMT
;
241 switch (le32_to_cpu(info
->Type
)) {
243 fattr
->cf_mode
|= S_IFREG
;
244 fattr
->cf_dtype
= DT_REG
;
247 fattr
->cf_mode
|= S_IFLNK
;
248 fattr
->cf_dtype
= DT_LNK
;
251 fattr
->cf_mode
|= S_IFDIR
;
252 fattr
->cf_dtype
= DT_DIR
;
255 fattr
->cf_mode
|= S_IFCHR
;
256 fattr
->cf_dtype
= DT_CHR
;
257 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
258 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
261 fattr
->cf_mode
|= S_IFBLK
;
262 fattr
->cf_dtype
= DT_BLK
;
263 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
264 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
267 fattr
->cf_mode
|= S_IFIFO
;
268 fattr
->cf_dtype
= DT_FIFO
;
271 fattr
->cf_mode
|= S_IFSOCK
;
272 fattr
->cf_dtype
= DT_SOCK
;
275 /* safest to call it a file if we do not know */
276 fattr
->cf_mode
|= S_IFREG
;
277 fattr
->cf_dtype
= DT_REG
;
278 cifs_dbg(FYI
, "unknown type %d\n", le32_to_cpu(info
->Type
));
282 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
283 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
)) {
284 u64 id
= le64_to_cpu(info
->Uid
);
285 if (id
< ((uid_t
)-1)) {
286 kuid_t uid
= make_kuid(&init_user_ns
, id
);
292 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
293 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
)) {
294 u64 id
= le64_to_cpu(info
->Gid
);
295 if (id
< ((gid_t
)-1)) {
296 kgid_t gid
= make_kgid(&init_user_ns
, id
);
302 fattr
->cf_nlink
= le64_to_cpu(info
->Nlinks
);
306 * Fill a cifs_fattr struct with fake inode info.
308 * Needed to setup cifs_fattr data for the directory which is the
309 * junction to the new submount (ie to setup the fake directory
310 * which represents a DFS referral).
313 cifs_create_dfs_fattr(struct cifs_fattr
*fattr
, struct super_block
*sb
)
315 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
317 cifs_dbg(FYI
, "creating fake fattr for DFS referral\n");
319 memset(fattr
, 0, sizeof(*fattr
));
320 fattr
->cf_mode
= S_IFDIR
| S_IXUGO
| S_IRWXU
;
321 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
322 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
323 fattr
->cf_atime
= CURRENT_TIME
;
324 fattr
->cf_ctime
= CURRENT_TIME
;
325 fattr
->cf_mtime
= CURRENT_TIME
;
327 fattr
->cf_flags
|= CIFS_FATTR_DFS_REFERRAL
;
331 cifs_get_file_info_unix(struct file
*filp
)
335 FILE_UNIX_BASIC_INFO find_data
;
336 struct cifs_fattr fattr
;
337 struct inode
*inode
= file_inode(filp
);
338 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
339 struct cifsFileInfo
*cfile
= filp
->private_data
;
340 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
343 rc
= CIFSSMBUnixQFileInfo(xid
, tcon
, cfile
->fid
.netfid
, &find_data
);
345 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
346 } else if (rc
== -EREMOTE
) {
347 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
351 cifs_fattr_to_inode(inode
, &fattr
);
356 int cifs_get_inode_info_unix(struct inode
**pinode
,
357 const unsigned char *full_path
,
358 struct super_block
*sb
, unsigned int xid
)
361 FILE_UNIX_BASIC_INFO find_data
;
362 struct cifs_fattr fattr
;
363 struct cifs_tcon
*tcon
;
364 struct tcon_link
*tlink
;
365 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
367 cifs_dbg(FYI
, "Getting info on %s\n", full_path
);
369 tlink
= cifs_sb_tlink(cifs_sb
);
371 return PTR_ERR(tlink
);
372 tcon
= tlink_tcon(tlink
);
374 /* could have done a find first instead but this returns more info */
375 rc
= CIFSSMBUnixQPathInfo(xid
, tcon
, full_path
, &find_data
,
376 cifs_sb
->local_nls
, cifs_remap(cifs_sb
));
377 cifs_put_tlink(tlink
);
380 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
381 } else if (rc
== -EREMOTE
) {
382 cifs_create_dfs_fattr(&fattr
, sb
);
388 /* check for Minshall+French symlinks */
389 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) {
390 int tmprc
= check_mf_symlink(xid
, tcon
, cifs_sb
, &fattr
,
393 cifs_dbg(FYI
, "check_mf_symlink: %d\n", tmprc
);
396 if (*pinode
== NULL
) {
398 cifs_fill_uniqueid(sb
, &fattr
);
399 *pinode
= cifs_iget(sb
, &fattr
);
403 /* we already have inode, update it */
405 /* if uniqueid is different, return error */
406 if (unlikely(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
&&
407 CIFS_I(*pinode
)->uniqueid
!= fattr
.cf_uniqueid
)) {
412 /* if filetype is different, return error */
413 if (unlikely(((*pinode
)->i_mode
& S_IFMT
) !=
414 (fattr
.cf_mode
& S_IFMT
))) {
419 cifs_fattr_to_inode(*pinode
, &fattr
);
427 cifs_sfu_type(struct cifs_fattr
*fattr
, const char *path
,
428 struct cifs_sb_info
*cifs_sb
, unsigned int xid
)
432 struct tcon_link
*tlink
;
433 struct cifs_tcon
*tcon
;
435 struct cifs_open_parms oparms
;
436 struct cifs_io_parms io_parms
;
438 unsigned int bytes_read
;
440 int buf_type
= CIFS_NO_BUFFER
;
444 fattr
->cf_mode
&= ~S_IFMT
;
446 if (fattr
->cf_eof
== 0) {
447 fattr
->cf_mode
|= S_IFIFO
;
448 fattr
->cf_dtype
= DT_FIFO
;
450 } else if (fattr
->cf_eof
< 8) {
451 fattr
->cf_mode
|= S_IFREG
;
452 fattr
->cf_dtype
= DT_REG
;
453 return -EINVAL
; /* EOPNOTSUPP? */
456 tlink
= cifs_sb_tlink(cifs_sb
);
458 return PTR_ERR(tlink
);
459 tcon
= tlink_tcon(tlink
);
462 oparms
.cifs_sb
= cifs_sb
;
463 oparms
.desired_access
= GENERIC_READ
;
464 oparms
.create_options
= CREATE_NOT_DIR
;
465 oparms
.disposition
= FILE_OPEN
;
468 oparms
.reconnect
= false;
470 if (tcon
->ses
->server
->oplocks
)
474 rc
= tcon
->ses
->server
->ops
->open(xid
, &oparms
, &oplock
, NULL
);
476 cifs_dbg(FYI
, "check sfu type of %s, open rc = %d\n", path
, rc
);
477 cifs_put_tlink(tlink
);
482 io_parms
.netfid
= fid
.netfid
;
483 io_parms
.pid
= current
->tgid
;
484 io_parms
.tcon
= tcon
;
486 io_parms
.length
= 24;
488 rc
= tcon
->ses
->server
->ops
->sync_read(xid
, &fid
, &io_parms
,
489 &bytes_read
, &pbuf
, &buf_type
);
490 if ((rc
== 0) && (bytes_read
>= 8)) {
491 if (memcmp("IntxBLK", pbuf
, 8) == 0) {
492 cifs_dbg(FYI
, "Block device\n");
493 fattr
->cf_mode
|= S_IFBLK
;
494 fattr
->cf_dtype
= DT_BLK
;
495 if (bytes_read
== 24) {
496 /* we have enough to decode dev num */
497 __u64 mjr
; /* major */
498 __u64 mnr
; /* minor */
499 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
500 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
501 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
503 } else if (memcmp("IntxCHR", pbuf
, 8) == 0) {
504 cifs_dbg(FYI
, "Char device\n");
505 fattr
->cf_mode
|= S_IFCHR
;
506 fattr
->cf_dtype
= DT_CHR
;
507 if (bytes_read
== 24) {
508 /* we have enough to decode dev num */
509 __u64 mjr
; /* major */
510 __u64 mnr
; /* minor */
511 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
512 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
513 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
515 } else if (memcmp("IntxLNK", pbuf
, 7) == 0) {
516 cifs_dbg(FYI
, "Symlink\n");
517 fattr
->cf_mode
|= S_IFLNK
;
518 fattr
->cf_dtype
= DT_LNK
;
520 fattr
->cf_mode
|= S_IFREG
; /* file? */
521 fattr
->cf_dtype
= DT_REG
;
525 fattr
->cf_mode
|= S_IFREG
; /* then it is a file */
526 fattr
->cf_dtype
= DT_REG
;
527 rc
= -EOPNOTSUPP
; /* or some unknown SFU type */
530 tcon
->ses
->server
->ops
->close(xid
, tcon
, &fid
);
531 cifs_put_tlink(tlink
);
535 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
538 * Fetch mode bits as provided by SFU.
540 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
542 static int cifs_sfu_mode(struct cifs_fattr
*fattr
, const unsigned char *path
,
543 struct cifs_sb_info
*cifs_sb
, unsigned int xid
)
545 #ifdef CONFIG_CIFS_XATTR
549 struct tcon_link
*tlink
;
550 struct cifs_tcon
*tcon
;
552 tlink
= cifs_sb_tlink(cifs_sb
);
554 return PTR_ERR(tlink
);
555 tcon
= tlink_tcon(tlink
);
557 if (tcon
->ses
->server
->ops
->query_all_EAs
== NULL
) {
558 cifs_put_tlink(tlink
);
562 rc
= tcon
->ses
->server
->ops
->query_all_EAs(xid
, tcon
, path
,
563 "SETFILEBITS", ea_value
, 4 /* size of buf */,
565 cifs_remap(cifs_sb
));
566 cifs_put_tlink(tlink
);
570 mode
= le32_to_cpu(*((__le32
*)ea_value
));
571 fattr
->cf_mode
&= ~SFBITS_MASK
;
572 cifs_dbg(FYI
, "special bits 0%o org mode 0%o\n",
573 mode
, fattr
->cf_mode
);
574 fattr
->cf_mode
= (mode
& SFBITS_MASK
) | fattr
->cf_mode
;
575 cifs_dbg(FYI
, "special mode bits 0%o\n", mode
);
584 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
586 cifs_all_info_to_fattr(struct cifs_fattr
*fattr
, FILE_ALL_INFO
*info
,
587 struct cifs_sb_info
*cifs_sb
, bool adjust_tz
,
590 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
592 memset(fattr
, 0, sizeof(*fattr
));
593 fattr
->cf_cifsattrs
= le32_to_cpu(info
->Attributes
);
594 if (info
->DeletePending
)
595 fattr
->cf_flags
|= CIFS_FATTR_DELETE_PENDING
;
597 if (info
->LastAccessTime
)
598 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
600 fattr
->cf_atime
= CURRENT_TIME
;
602 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->ChangeTime
);
603 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastWriteTime
);
606 fattr
->cf_ctime
.tv_sec
+= tcon
->ses
->server
->timeAdj
;
607 fattr
->cf_mtime
.tv_sec
+= tcon
->ses
->server
->timeAdj
;
610 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
611 fattr
->cf_bytes
= le64_to_cpu(info
->AllocationSize
);
612 fattr
->cf_createtime
= le64_to_cpu(info
->CreationTime
);
614 fattr
->cf_nlink
= le32_to_cpu(info
->NumberOfLinks
);
617 fattr
->cf_mode
= S_IFLNK
;
618 fattr
->cf_dtype
= DT_LNK
;
619 } else if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
) {
620 fattr
->cf_mode
= S_IFDIR
| cifs_sb
->mnt_dir_mode
;
621 fattr
->cf_dtype
= DT_DIR
;
623 * Server can return wrong NumberOfLinks value for directories
624 * when Unix extensions are disabled - fake it.
627 fattr
->cf_flags
|= CIFS_FATTR_UNKNOWN_NLINK
;
629 fattr
->cf_mode
= S_IFREG
| cifs_sb
->mnt_file_mode
;
630 fattr
->cf_dtype
= DT_REG
;
632 /* clear write bits if ATTR_READONLY is set */
633 if (fattr
->cf_cifsattrs
& ATTR_READONLY
)
634 fattr
->cf_mode
&= ~(S_IWUGO
);
637 * Don't accept zero nlink from non-unix servers unless
638 * delete is pending. Instead mark it as unknown.
640 if ((fattr
->cf_nlink
< 1) && !tcon
->unix_ext
&&
641 !info
->DeletePending
) {
642 cifs_dbg(1, "bogus file nlink value %u\n",
644 fattr
->cf_flags
|= CIFS_FATTR_UNKNOWN_NLINK
;
648 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
649 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
653 cifs_get_file_info(struct file
*filp
)
657 FILE_ALL_INFO find_data
;
658 struct cifs_fattr fattr
;
659 struct inode
*inode
= file_inode(filp
);
660 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
661 struct cifsFileInfo
*cfile
= filp
->private_data
;
662 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
663 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
665 if (!server
->ops
->query_file_info
)
669 rc
= server
->ops
->query_file_info(xid
, tcon
, &cfile
->fid
, &find_data
);
672 cifs_all_info_to_fattr(&fattr
, &find_data
, cifs_sb
, false,
676 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
682 * FIXME: legacy server -- fall back to path-based call?
683 * for now, just skip revalidating and mark inode for
687 CIFS_I(inode
)->time
= 0;
693 * don't bother with SFU junk here -- just mark inode as needing
696 fattr
.cf_uniqueid
= CIFS_I(inode
)->uniqueid
;
697 fattr
.cf_flags
|= CIFS_FATTR_NEED_REVAL
;
698 cifs_fattr_to_inode(inode
, &fattr
);
705 cifs_get_inode_info(struct inode
**inode
, const char *full_path
,
706 FILE_ALL_INFO
*data
, struct super_block
*sb
, int xid
,
707 const struct cifs_fid
*fid
)
709 bool validinum
= false;
711 int rc
= 0, tmprc
= ENOSYS
;
712 struct cifs_tcon
*tcon
;
713 struct TCP_Server_Info
*server
;
714 struct tcon_link
*tlink
;
715 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
717 bool adjust_tz
= false;
718 struct cifs_fattr fattr
;
719 struct cifs_search_info
*srchinf
= NULL
;
720 bool symlink
= false;
722 tlink
= cifs_sb_tlink(cifs_sb
);
724 return PTR_ERR(tlink
);
725 tcon
= tlink_tcon(tlink
);
726 server
= tcon
->ses
->server
;
728 cifs_dbg(FYI
, "Getting info on %s\n", full_path
);
730 if ((data
== NULL
) && (*inode
!= NULL
)) {
731 if (CIFS_CACHE_READ(CIFS_I(*inode
))) {
732 cifs_dbg(FYI
, "No need to revalidate cached inode sizes\n");
737 /* if inode info is not passed, get it from server */
739 if (!server
->ops
->query_path_info
) {
743 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
748 data
= (FILE_ALL_INFO
*)buf
;
749 rc
= server
->ops
->query_path_info(xid
, tcon
, cifs_sb
, full_path
,
750 data
, &adjust_tz
, &symlink
);
754 cifs_all_info_to_fattr(&fattr
, data
, cifs_sb
, adjust_tz
,
756 } else if (rc
== -EREMOTE
) {
757 cifs_create_dfs_fattr(&fattr
, sb
);
759 } else if (rc
== -EACCES
&& backup_cred(cifs_sb
)) {
760 srchinf
= kzalloc(sizeof(struct cifs_search_info
),
762 if (srchinf
== NULL
) {
767 srchinf
->endOfSearch
= false;
768 srchinf
->info_level
= SMB_FIND_FILE_ID_FULL_DIR_INFO
;
770 srchflgs
= CIFS_SEARCH_CLOSE_ALWAYS
|
771 CIFS_SEARCH_CLOSE_AT_END
|
772 CIFS_SEARCH_BACKUP_SEARCH
;
774 rc
= CIFSFindFirst(xid
, tcon
, full_path
,
775 cifs_sb
, NULL
, srchflgs
, srchinf
, false);
778 (FILE_ALL_INFO
*)srchinf
->srch_entries_start
;
780 cifs_dir_info_to_fattr(&fattr
,
781 (FILE_DIRECTORY_INFO
*)data
, cifs_sb
);
782 fattr
.cf_uniqueid
= le64_to_cpu(
783 ((SEARCH_ID_FULL_DIR_INFO
*)data
)->UniqueId
);
786 cifs_buf_release(srchinf
->ntwrk_buf_start
);
795 * If an inode wasn't passed in, then get the inode number
797 * Is an i_ino of zero legal? Can we use that to check if the server
798 * supports returning inode numbers? Are there other sanity checks we
799 * can use to ensure that the server is really filling in that field?
801 if (*inode
== NULL
) {
802 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) {
803 if (validinum
== false) {
804 if (server
->ops
->get_srv_inum
)
805 tmprc
= server
->ops
->get_srv_inum(xid
,
806 tcon
, cifs_sb
, full_path
,
807 &fattr
.cf_uniqueid
, data
);
809 cifs_dbg(FYI
, "GetSrvInodeNum rc %d\n",
811 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
812 cifs_autodisable_serverino(cifs_sb
);
816 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
818 fattr
.cf_uniqueid
= CIFS_I(*inode
)->uniqueid
;
820 /* query for SFU type info if supported and needed */
821 if (fattr
.cf_cifsattrs
& ATTR_SYSTEM
&&
822 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
) {
823 tmprc
= cifs_sfu_type(&fattr
, full_path
, cifs_sb
, xid
);
825 cifs_dbg(FYI
, "cifs_sfu_type failed: %d\n", tmprc
);
828 #ifdef CONFIG_CIFS_ACL
829 /* fill in 0777 bits from ACL */
830 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
831 rc
= cifs_acl_to_fattr(cifs_sb
, &fattr
, *inode
, full_path
, fid
);
833 cifs_dbg(FYI
, "%s: Getting ACL failed with error: %d\n",
838 #endif /* CONFIG_CIFS_ACL */
840 /* fill in remaining high mode bits e.g. SUID, VTX */
841 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
)
842 cifs_sfu_mode(&fattr
, full_path
, cifs_sb
, xid
);
844 /* check for Minshall+French symlinks */
845 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) {
846 tmprc
= check_mf_symlink(xid
, tcon
, cifs_sb
, &fattr
,
849 cifs_dbg(FYI
, "check_mf_symlink: %d\n", tmprc
);
853 *inode
= cifs_iget(sb
, &fattr
);
857 /* we already have inode, update it */
859 /* if filetype is different, return error */
860 if (unlikely(((*inode
)->i_mode
& S_IFMT
) !=
861 (fattr
.cf_mode
& S_IFMT
))) {
866 cifs_fattr_to_inode(*inode
, &fattr
);
871 cifs_put_tlink(tlink
);
875 static const struct inode_operations cifs_ipc_inode_ops
= {
876 .lookup
= cifs_lookup
,
880 cifs_find_inode(struct inode
*inode
, void *opaque
)
882 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
884 /* don't match inode with different uniqueid */
885 if (CIFS_I(inode
)->uniqueid
!= fattr
->cf_uniqueid
)
888 /* use createtime like an i_generation field */
889 if (CIFS_I(inode
)->createtime
!= fattr
->cf_createtime
)
892 /* don't match inode of different type */
893 if ((inode
->i_mode
& S_IFMT
) != (fattr
->cf_mode
& S_IFMT
))
896 /* if it's not a directory or has no dentries, then flag it */
897 if (S_ISDIR(inode
->i_mode
) && !hlist_empty(&inode
->i_dentry
))
898 fattr
->cf_flags
|= CIFS_FATTR_INO_COLLISION
;
904 cifs_init_inode(struct inode
*inode
, void *opaque
)
906 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
908 CIFS_I(inode
)->uniqueid
= fattr
->cf_uniqueid
;
909 CIFS_I(inode
)->createtime
= fattr
->cf_createtime
;
914 * walk dentry list for an inode and report whether it has aliases that
915 * are hashed. We use this to determine if a directory inode can actually
919 inode_has_hashed_dentries(struct inode
*inode
)
921 struct dentry
*dentry
;
923 spin_lock(&inode
->i_lock
);
924 hlist_for_each_entry(dentry
, &inode
->i_dentry
, d_u
.d_alias
) {
925 if (!d_unhashed(dentry
) || IS_ROOT(dentry
)) {
926 spin_unlock(&inode
->i_lock
);
930 spin_unlock(&inode
->i_lock
);
934 /* Given fattrs, get a corresponding inode */
936 cifs_iget(struct super_block
*sb
, struct cifs_fattr
*fattr
)
942 cifs_dbg(FYI
, "looking for uniqueid=%llu\n", fattr
->cf_uniqueid
);
944 /* hash down to 32-bits on 32-bit arch */
945 hash
= cifs_uniqueid_to_ino_t(fattr
->cf_uniqueid
);
947 inode
= iget5_locked(sb
, hash
, cifs_find_inode
, cifs_init_inode
, fattr
);
949 /* was there a potentially problematic inode collision? */
950 if (fattr
->cf_flags
& CIFS_FATTR_INO_COLLISION
) {
951 fattr
->cf_flags
&= ~CIFS_FATTR_INO_COLLISION
;
953 if (inode_has_hashed_dentries(inode
)) {
954 cifs_autodisable_serverino(CIFS_SB(sb
));
956 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
957 goto retry_iget5_locked
;
961 cifs_fattr_to_inode(inode
, fattr
);
962 if (sb
->s_flags
& MS_NOATIME
)
963 inode
->i_flags
|= S_NOATIME
| S_NOCMTIME
;
964 if (inode
->i_state
& I_NEW
) {
966 #ifdef CONFIG_CIFS_FSCACHE
967 /* initialize per-inode cache cookie pointer */
968 CIFS_I(inode
)->fscache
= NULL
;
970 unlock_new_inode(inode
);
977 /* gets root inode */
978 struct inode
*cifs_root_iget(struct super_block
*sb
)
981 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
982 struct inode
*inode
= NULL
;
984 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
988 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
)
989 && cifs_sb
->prepath
) {
990 len
= strlen(cifs_sb
->prepath
);
991 path
= kzalloc(len
+ 2 /* leading sep + null */, GFP_KERNEL
);
993 return ERR_PTR(-ENOMEM
);
995 memcpy(path
+1, cifs_sb
->prepath
, len
);
997 path
= kstrdup("", GFP_KERNEL
);
999 return ERR_PTR(-ENOMEM
);
1003 if (tcon
->unix_ext
) {
1004 rc
= cifs_get_inode_info_unix(&inode
, path
, sb
, xid
);
1005 /* some servers mistakenly claim POSIX support */
1006 if (rc
!= -EOPNOTSUPP
)
1008 cifs_dbg(VFS
, "server does not support POSIX extensions");
1009 tcon
->unix_ext
= false;
1012 convert_delimiter(path
, CIFS_DIR_SEP(cifs_sb
));
1013 rc
= cifs_get_inode_info(&inode
, path
, NULL
, sb
, xid
, NULL
);
1017 inode
= ERR_PTR(rc
);
1021 #ifdef CONFIG_CIFS_FSCACHE
1022 /* populate tcon->resource_id */
1023 tcon
->resource_id
= CIFS_I(inode
)->uniqueid
;
1026 if (rc
&& tcon
->ipc
) {
1027 cifs_dbg(FYI
, "ipc connection - fake read inode\n");
1028 spin_lock(&inode
->i_lock
);
1029 inode
->i_mode
|= S_IFDIR
;
1030 set_nlink(inode
, 2);
1031 inode
->i_op
= &cifs_ipc_inode_ops
;
1032 inode
->i_fop
= &simple_dir_operations
;
1033 inode
->i_uid
= cifs_sb
->mnt_uid
;
1034 inode
->i_gid
= cifs_sb
->mnt_gid
;
1035 spin_unlock(&inode
->i_lock
);
1038 inode
= ERR_PTR(rc
);
1043 /* can not call macro free_xid here since in a void func
1044 * TODO: This is no longer true
1051 cifs_set_file_info(struct inode
*inode
, struct iattr
*attrs
, unsigned int xid
,
1052 char *full_path
, __u32 dosattr
)
1054 bool set_time
= false;
1055 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1056 struct TCP_Server_Info
*server
;
1057 FILE_BASIC_INFO info_buf
;
1062 server
= cifs_sb_master_tcon(cifs_sb
)->ses
->server
;
1063 if (!server
->ops
->set_file_info
)
1068 if (attrs
->ia_valid
& ATTR_ATIME
) {
1070 info_buf
.LastAccessTime
=
1071 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_atime
));
1073 info_buf
.LastAccessTime
= 0;
1075 if (attrs
->ia_valid
& ATTR_MTIME
) {
1077 info_buf
.LastWriteTime
=
1078 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_mtime
));
1080 info_buf
.LastWriteTime
= 0;
1083 * Samba throws this field away, but windows may actually use it.
1084 * Do not set ctime unless other time stamps are changed explicitly
1085 * (i.e. by utimes()) since we would then have a mix of client and
1088 if (set_time
&& (attrs
->ia_valid
& ATTR_CTIME
)) {
1089 cifs_dbg(FYI
, "CIFS - CTIME changed\n");
1090 info_buf
.ChangeTime
=
1091 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_ctime
));
1093 info_buf
.ChangeTime
= 0;
1095 info_buf
.CreationTime
= 0; /* don't change */
1096 info_buf
.Attributes
= cpu_to_le32(dosattr
);
1098 return server
->ops
->set_file_info(inode
, full_path
, &info_buf
, xid
);
1102 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1103 * and rename it to a random name that hopefully won't conflict with
1107 cifs_rename_pending_delete(const char *full_path
, struct dentry
*dentry
,
1108 const unsigned int xid
)
1112 struct cifs_fid fid
;
1113 struct cifs_open_parms oparms
;
1114 struct inode
*inode
= d_inode(dentry
);
1115 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1116 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1117 struct tcon_link
*tlink
;
1118 struct cifs_tcon
*tcon
;
1119 __u32 dosattr
, origattr
;
1120 FILE_BASIC_INFO
*info_buf
= NULL
;
1122 tlink
= cifs_sb_tlink(cifs_sb
);
1124 return PTR_ERR(tlink
);
1125 tcon
= tlink_tcon(tlink
);
1128 * We cannot rename the file if the server doesn't support
1129 * CAP_INFOLEVEL_PASSTHRU
1131 if (!(tcon
->ses
->capabilities
& CAP_INFOLEVEL_PASSTHRU
)) {
1137 oparms
.cifs_sb
= cifs_sb
;
1138 oparms
.desired_access
= DELETE
| FILE_WRITE_ATTRIBUTES
;
1139 oparms
.create_options
= CREATE_NOT_DIR
;
1140 oparms
.disposition
= FILE_OPEN
;
1141 oparms
.path
= full_path
;
1143 oparms
.reconnect
= false;
1145 rc
= CIFS_open(xid
, &oparms
, &oplock
, NULL
);
1149 origattr
= cifsInode
->cifsAttrs
;
1151 origattr
|= ATTR_NORMAL
;
1153 dosattr
= origattr
& ~ATTR_READONLY
;
1155 dosattr
|= ATTR_NORMAL
;
1156 dosattr
|= ATTR_HIDDEN
;
1158 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1159 if (dosattr
!= origattr
) {
1160 info_buf
= kzalloc(sizeof(*info_buf
), GFP_KERNEL
);
1161 if (info_buf
== NULL
) {
1165 info_buf
->Attributes
= cpu_to_le32(dosattr
);
1166 rc
= CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, fid
.netfid
,
1168 /* although we would like to mark the file hidden
1169 if that fails we will still try to rename it */
1171 cifsInode
->cifsAttrs
= dosattr
;
1173 dosattr
= origattr
; /* since not able to change them */
1176 /* rename the file */
1177 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, fid
.netfid
, NULL
,
1179 cifs_remap(cifs_sb
));
1185 /* try to set DELETE_ON_CLOSE */
1186 if (!test_bit(CIFS_INO_DELETE_PENDING
, &cifsInode
->flags
)) {
1187 rc
= CIFSSMBSetFileDisposition(xid
, tcon
, true, fid
.netfid
,
1190 * some samba versions return -ENOENT when we try to set the
1191 * file disposition here. Likely a samba bug, but work around
1192 * it for now. This means that some cifsXXX files may hang
1193 * around after they shouldn't.
1195 * BB: remove this hack after more servers have the fix
1203 set_bit(CIFS_INO_DELETE_PENDING
, &cifsInode
->flags
);
1207 CIFSSMBClose(xid
, tcon
, fid
.netfid
);
1210 cifs_put_tlink(tlink
);
1214 * reset everything back to the original state. Don't bother
1215 * dealing with errors here since we can't do anything about
1219 CIFSSMBRenameOpenFile(xid
, tcon
, fid
.netfid
, dentry
->d_name
.name
,
1220 cifs_sb
->local_nls
, cifs_remap(cifs_sb
));
1222 if (dosattr
!= origattr
) {
1223 info_buf
->Attributes
= cpu_to_le32(origattr
);
1224 if (!CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, fid
.netfid
,
1226 cifsInode
->cifsAttrs
= origattr
;
1232 /* copied from fs/nfs/dir.c with small changes */
1234 cifs_drop_nlink(struct inode
*inode
)
1236 spin_lock(&inode
->i_lock
);
1237 if (inode
->i_nlink
> 0)
1239 spin_unlock(&inode
->i_lock
);
1243 * If d_inode(dentry) is null (usually meaning the cached dentry
1244 * is a negative dentry) then we would attempt a standard SMB delete, but
1245 * if that fails we can not attempt the fall back mechanisms on EACCESS
1246 * but will return the EACCESS to the caller. Note that the VFS does not call
1247 * unlink on negative dentries currently.
1249 int cifs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1253 char *full_path
= NULL
;
1254 struct inode
*inode
= d_inode(dentry
);
1255 struct cifsInodeInfo
*cifs_inode
;
1256 struct super_block
*sb
= dir
->i_sb
;
1257 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
1258 struct tcon_link
*tlink
;
1259 struct cifs_tcon
*tcon
;
1260 struct TCP_Server_Info
*server
;
1261 struct iattr
*attrs
= NULL
;
1262 __u32 dosattr
= 0, origattr
= 0;
1264 cifs_dbg(FYI
, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir
, dentry
);
1266 tlink
= cifs_sb_tlink(cifs_sb
);
1268 return PTR_ERR(tlink
);
1269 tcon
= tlink_tcon(tlink
);
1270 server
= tcon
->ses
->server
;
1274 /* Unlink can be called from rename so we can not take the
1275 * sb->s_vfs_rename_mutex here */
1276 full_path
= build_path_from_dentry(dentry
);
1277 if (full_path
== NULL
) {
1282 if (cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1283 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1284 rc
= CIFSPOSIXDelFile(xid
, tcon
, full_path
,
1285 SMB_POSIX_UNLINK_FILE_TARGET
, cifs_sb
->local_nls
,
1286 cifs_remap(cifs_sb
));
1287 cifs_dbg(FYI
, "posix del rc %d\n", rc
);
1288 if ((rc
== 0) || (rc
== -ENOENT
))
1289 goto psx_del_no_retry
;
1293 if (!server
->ops
->unlink
) {
1295 goto psx_del_no_retry
;
1298 rc
= server
->ops
->unlink(xid
, tcon
, full_path
, cifs_sb
);
1303 cifs_drop_nlink(inode
);
1304 } else if (rc
== -ENOENT
) {
1306 } else if (rc
== -EBUSY
) {
1307 if (server
->ops
->rename_pending_delete
) {
1308 rc
= server
->ops
->rename_pending_delete(full_path
,
1311 cifs_drop_nlink(inode
);
1313 } else if ((rc
== -EACCES
) && (dosattr
== 0) && inode
) {
1314 attrs
= kzalloc(sizeof(*attrs
), GFP_KERNEL
);
1315 if (attrs
== NULL
) {
1320 /* try to reset dos attributes */
1321 cifs_inode
= CIFS_I(inode
);
1322 origattr
= cifs_inode
->cifsAttrs
;
1324 origattr
|= ATTR_NORMAL
;
1325 dosattr
= origattr
& ~ATTR_READONLY
;
1327 dosattr
|= ATTR_NORMAL
;
1328 dosattr
|= ATTR_HIDDEN
;
1330 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
1334 goto retry_std_delete
;
1337 /* undo the setattr if we errored out and it's needed */
1338 if (rc
!= 0 && dosattr
!= 0)
1339 cifs_set_file_info(inode
, attrs
, xid
, full_path
, origattr
);
1343 cifs_inode
= CIFS_I(inode
);
1344 cifs_inode
->time
= 0; /* will force revalidate to get info
1346 inode
->i_ctime
= current_fs_time(sb
);
1348 dir
->i_ctime
= dir
->i_mtime
= current_fs_time(sb
);
1349 cifs_inode
= CIFS_I(dir
);
1350 CIFS_I(dir
)->time
= 0; /* force revalidate of dir as well */
1355 cifs_put_tlink(tlink
);
1360 cifs_mkdir_qinfo(struct inode
*parent
, struct dentry
*dentry
, umode_t mode
,
1361 const char *full_path
, struct cifs_sb_info
*cifs_sb
,
1362 struct cifs_tcon
*tcon
, const unsigned int xid
)
1365 struct inode
*inode
= NULL
;
1368 rc
= cifs_get_inode_info_unix(&inode
, full_path
, parent
->i_sb
,
1371 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, parent
->i_sb
,
1378 * setting nlink not necessary except in cases where we failed to get it
1379 * from the server or was set bogus. Also, since this is a brand new
1380 * inode, no need to grab the i_lock before setting the i_nlink.
1382 if (inode
->i_nlink
< 2)
1383 set_nlink(inode
, 2);
1384 mode
&= ~current_umask();
1385 /* must turn on setgid bit if parent dir has it */
1386 if (parent
->i_mode
& S_ISGID
)
1389 if (tcon
->unix_ext
) {
1390 struct cifs_unix_set_info_args args
= {
1392 .ctime
= NO_CHANGE_64
,
1393 .atime
= NO_CHANGE_64
,
1394 .mtime
= NO_CHANGE_64
,
1397 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1398 args
.uid
= current_fsuid();
1399 if (parent
->i_mode
& S_ISGID
)
1400 args
.gid
= parent
->i_gid
;
1402 args
.gid
= current_fsgid();
1404 args
.uid
= INVALID_UID
; /* no change */
1405 args
.gid
= INVALID_GID
; /* no change */
1407 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
1409 cifs_remap(cifs_sb
));
1411 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1412 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
1413 (mode
& S_IWUGO
) == 0 && server
->ops
->mkdir_setinfo
)
1414 server
->ops
->mkdir_setinfo(inode
, full_path
, cifs_sb
,
1416 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
1417 inode
->i_mode
= (mode
| S_IFDIR
);
1419 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1420 inode
->i_uid
= current_fsuid();
1421 if (inode
->i_mode
& S_ISGID
)
1422 inode
->i_gid
= parent
->i_gid
;
1424 inode
->i_gid
= current_fsgid();
1427 d_instantiate(dentry
, inode
);
1432 cifs_posix_mkdir(struct inode
*inode
, struct dentry
*dentry
, umode_t mode
,
1433 const char *full_path
, struct cifs_sb_info
*cifs_sb
,
1434 struct cifs_tcon
*tcon
, const unsigned int xid
)
1438 FILE_UNIX_BASIC_INFO
*info
= NULL
;
1439 struct inode
*newinode
= NULL
;
1440 struct cifs_fattr fattr
;
1442 info
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
1445 goto posix_mkdir_out
;
1448 mode
&= ~current_umask();
1449 rc
= CIFSPOSIXCreate(xid
, tcon
, SMB_O_DIRECTORY
| SMB_O_CREAT
, mode
,
1450 NULL
/* netfid */, info
, &oplock
, full_path
,
1451 cifs_sb
->local_nls
, cifs_remap(cifs_sb
));
1452 if (rc
== -EOPNOTSUPP
)
1453 goto posix_mkdir_out
;
1455 cifs_dbg(FYI
, "posix mkdir returned 0x%x\n", rc
);
1457 goto posix_mkdir_out
;
1460 if (info
->Type
== cpu_to_le32(-1))
1461 /* no return info, go query for it */
1462 goto posix_mkdir_get_info
;
1464 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1465 * need to set uid/gid.
1468 cifs_unix_basic_to_fattr(&fattr
, info
, cifs_sb
);
1469 cifs_fill_uniqueid(inode
->i_sb
, &fattr
);
1470 newinode
= cifs_iget(inode
->i_sb
, &fattr
);
1472 goto posix_mkdir_get_info
;
1474 d_instantiate(dentry
, newinode
);
1476 #ifdef CONFIG_CIFS_DEBUG2
1477 cifs_dbg(FYI
, "instantiated dentry %p %pd to inode %p\n",
1478 dentry
, dentry
, newinode
);
1480 if (newinode
->i_nlink
!= 2)
1481 cifs_dbg(FYI
, "unexpected number of links %d\n",
1488 posix_mkdir_get_info
:
1489 rc
= cifs_mkdir_qinfo(inode
, dentry
, mode
, full_path
, cifs_sb
, tcon
,
1491 goto posix_mkdir_out
;
1494 int cifs_mkdir(struct inode
*inode
, struct dentry
*direntry
, umode_t mode
)
1498 struct cifs_sb_info
*cifs_sb
;
1499 struct tcon_link
*tlink
;
1500 struct cifs_tcon
*tcon
;
1501 struct TCP_Server_Info
*server
;
1504 cifs_dbg(FYI
, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1507 cifs_sb
= CIFS_SB(inode
->i_sb
);
1508 tlink
= cifs_sb_tlink(cifs_sb
);
1510 return PTR_ERR(tlink
);
1511 tcon
= tlink_tcon(tlink
);
1515 full_path
= build_path_from_dentry(direntry
);
1516 if (full_path
== NULL
) {
1521 if (cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1522 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1523 rc
= cifs_posix_mkdir(inode
, direntry
, mode
, full_path
, cifs_sb
,
1525 if (rc
!= -EOPNOTSUPP
)
1529 server
= tcon
->ses
->server
;
1531 if (!server
->ops
->mkdir
) {
1536 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1537 rc
= server
->ops
->mkdir(xid
, tcon
, full_path
, cifs_sb
);
1539 cifs_dbg(FYI
, "cifs_mkdir returned 0x%x\n", rc
);
1544 rc
= cifs_mkdir_qinfo(inode
, direntry
, mode
, full_path
, cifs_sb
, tcon
,
1548 * Force revalidate to get parent dir info when needed since cached
1549 * attributes are invalid now.
1551 CIFS_I(inode
)->time
= 0;
1554 cifs_put_tlink(tlink
);
1558 int cifs_rmdir(struct inode
*inode
, struct dentry
*direntry
)
1562 struct cifs_sb_info
*cifs_sb
;
1563 struct tcon_link
*tlink
;
1564 struct cifs_tcon
*tcon
;
1565 struct TCP_Server_Info
*server
;
1566 char *full_path
= NULL
;
1567 struct cifsInodeInfo
*cifsInode
;
1569 cifs_dbg(FYI
, "cifs_rmdir, inode = 0x%p\n", inode
);
1573 full_path
= build_path_from_dentry(direntry
);
1574 if (full_path
== NULL
) {
1579 cifs_sb
= CIFS_SB(inode
->i_sb
);
1580 tlink
= cifs_sb_tlink(cifs_sb
);
1581 if (IS_ERR(tlink
)) {
1582 rc
= PTR_ERR(tlink
);
1585 tcon
= tlink_tcon(tlink
);
1586 server
= tcon
->ses
->server
;
1588 if (!server
->ops
->rmdir
) {
1590 cifs_put_tlink(tlink
);
1594 rc
= server
->ops
->rmdir(xid
, tcon
, full_path
, cifs_sb
);
1595 cifs_put_tlink(tlink
);
1598 spin_lock(&d_inode(direntry
)->i_lock
);
1599 i_size_write(d_inode(direntry
), 0);
1600 clear_nlink(d_inode(direntry
));
1601 spin_unlock(&d_inode(direntry
)->i_lock
);
1604 cifsInode
= CIFS_I(d_inode(direntry
));
1605 /* force revalidate to go get info when needed */
1606 cifsInode
->time
= 0;
1608 cifsInode
= CIFS_I(inode
);
1610 * Force revalidate to get parent dir info when needed since cached
1611 * attributes are invalid now.
1613 cifsInode
->time
= 0;
1615 d_inode(direntry
)->i_ctime
= inode
->i_ctime
= inode
->i_mtime
=
1616 current_fs_time(inode
->i_sb
);
1625 cifs_do_rename(const unsigned int xid
, struct dentry
*from_dentry
,
1626 const char *from_path
, struct dentry
*to_dentry
,
1627 const char *to_path
)
1629 struct cifs_sb_info
*cifs_sb
= CIFS_SB(from_dentry
->d_sb
);
1630 struct tcon_link
*tlink
;
1631 struct cifs_tcon
*tcon
;
1632 struct TCP_Server_Info
*server
;
1633 struct cifs_fid fid
;
1634 struct cifs_open_parms oparms
;
1637 tlink
= cifs_sb_tlink(cifs_sb
);
1639 return PTR_ERR(tlink
);
1640 tcon
= tlink_tcon(tlink
);
1641 server
= tcon
->ses
->server
;
1643 if (!server
->ops
->rename
)
1646 /* try path-based rename first */
1647 rc
= server
->ops
->rename(xid
, tcon
, from_path
, to_path
, cifs_sb
);
1650 * Don't bother with rename by filehandle unless file is busy and
1651 * source. Note that cross directory moves do not work with
1652 * rename by filehandle to various Windows servers.
1654 if (rc
== 0 || rc
!= -EBUSY
)
1655 goto do_rename_exit
;
1657 /* open-file renames don't work across directories */
1658 if (to_dentry
->d_parent
!= from_dentry
->d_parent
)
1659 goto do_rename_exit
;
1662 oparms
.cifs_sb
= cifs_sb
;
1663 /* open the file to be renamed -- we need DELETE perms */
1664 oparms
.desired_access
= DELETE
;
1665 oparms
.create_options
= CREATE_NOT_DIR
;
1666 oparms
.disposition
= FILE_OPEN
;
1667 oparms
.path
= from_path
;
1669 oparms
.reconnect
= false;
1671 rc
= CIFS_open(xid
, &oparms
, &oplock
, NULL
);
1673 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, fid
.netfid
,
1674 (const char *) to_dentry
->d_name
.name
,
1675 cifs_sb
->local_nls
, cifs_remap(cifs_sb
));
1676 CIFSSMBClose(xid
, tcon
, fid
.netfid
);
1679 cifs_put_tlink(tlink
);
1684 cifs_rename2(struct inode
*source_dir
, struct dentry
*source_dentry
,
1685 struct inode
*target_dir
, struct dentry
*target_dentry
,
1688 char *from_name
= NULL
;
1689 char *to_name
= NULL
;
1690 struct cifs_sb_info
*cifs_sb
;
1691 struct tcon_link
*tlink
;
1692 struct cifs_tcon
*tcon
;
1693 FILE_UNIX_BASIC_INFO
*info_buf_source
= NULL
;
1694 FILE_UNIX_BASIC_INFO
*info_buf_target
;
1698 if (flags
& ~RENAME_NOREPLACE
)
1701 cifs_sb
= CIFS_SB(source_dir
->i_sb
);
1702 tlink
= cifs_sb_tlink(cifs_sb
);
1704 return PTR_ERR(tlink
);
1705 tcon
= tlink_tcon(tlink
);
1710 * we already have the rename sem so we do not need to
1711 * grab it again here to protect the path integrity
1713 from_name
= build_path_from_dentry(source_dentry
);
1714 if (from_name
== NULL
) {
1716 goto cifs_rename_exit
;
1719 to_name
= build_path_from_dentry(target_dentry
);
1720 if (to_name
== NULL
) {
1722 goto cifs_rename_exit
;
1725 rc
= cifs_do_rename(xid
, source_dentry
, from_name
, target_dentry
,
1729 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1731 if (flags
& RENAME_NOREPLACE
)
1732 goto cifs_rename_exit
;
1734 if (rc
== -EEXIST
&& tcon
->unix_ext
) {
1736 * Are src and dst hardlinks of same inode? We can only tell
1737 * with unix extensions enabled.
1740 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO
),
1742 if (info_buf_source
== NULL
) {
1744 goto cifs_rename_exit
;
1747 info_buf_target
= info_buf_source
+ 1;
1748 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, from_name
,
1751 cifs_remap(cifs_sb
));
1755 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, to_name
,
1758 cifs_remap(cifs_sb
));
1760 if (tmprc
== 0 && (info_buf_source
->UniqueId
==
1761 info_buf_target
->UniqueId
)) {
1762 /* same file, POSIX says that this is a noop */
1764 goto cifs_rename_exit
;
1768 * else ... BB we could add the same check for Windows by
1769 * checking the UniqueId via FILE_INTERNAL_INFO
1773 /* Try unlinking the target dentry if it's not negative */
1774 if (d_really_is_positive(target_dentry
) && (rc
== -EACCES
|| rc
== -EEXIST
)) {
1775 if (d_is_dir(target_dentry
))
1776 tmprc
= cifs_rmdir(target_dir
, target_dentry
);
1778 tmprc
= cifs_unlink(target_dir
, target_dentry
);
1780 goto cifs_rename_exit
;
1781 rc
= cifs_do_rename(xid
, source_dentry
, from_name
,
1782 target_dentry
, to_name
);
1785 /* force revalidate to go get info when needed */
1786 CIFS_I(source_dir
)->time
= CIFS_I(target_dir
)->time
= 0;
1788 source_dir
->i_ctime
= source_dir
->i_mtime
= target_dir
->i_ctime
=
1789 target_dir
->i_mtime
= current_fs_time(source_dir
->i_sb
);
1792 kfree(info_buf_source
);
1796 cifs_put_tlink(tlink
);
1801 cifs_inode_needs_reval(struct inode
*inode
)
1803 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
1804 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1806 if (CIFS_CACHE_READ(cifs_i
))
1809 if (!lookupCacheEnabled
)
1812 if (cifs_i
->time
== 0)
1815 if (!cifs_sb
->actimeo
)
1818 if (!time_in_range(jiffies
, cifs_i
->time
,
1819 cifs_i
->time
+ cifs_sb
->actimeo
))
1822 /* hardlinked files w/ noserverino get "special" treatment */
1823 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) &&
1824 S_ISREG(inode
->i_mode
) && inode
->i_nlink
!= 1)
1831 * Zap the cache. Called when invalid_mapping flag is set.
1834 cifs_invalidate_mapping(struct inode
*inode
)
1838 if (inode
->i_mapping
&& inode
->i_mapping
->nrpages
!= 0) {
1839 rc
= invalidate_inode_pages2(inode
->i_mapping
);
1841 cifs_dbg(VFS
, "%s: could not invalidate inode %p\n",
1845 cifs_fscache_reset_inode_cookie(inode
);
1850 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1851 * @word: long word containing the bit lock
1854 cifs_wait_bit_killable(struct wait_bit_key
*key
, int mode
)
1856 freezable_schedule_unsafe();
1857 if (signal_pending_state(mode
, current
))
1858 return -ERESTARTSYS
;
1863 cifs_revalidate_mapping(struct inode
*inode
)
1866 unsigned long *flags
= &CIFS_I(inode
)->flags
;
1868 rc
= wait_on_bit_lock_action(flags
, CIFS_INO_LOCK
, cifs_wait_bit_killable
,
1873 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING
, flags
)) {
1874 rc
= cifs_invalidate_mapping(inode
);
1876 set_bit(CIFS_INO_INVALID_MAPPING
, flags
);
1879 clear_bit_unlock(CIFS_INO_LOCK
, flags
);
1880 smp_mb__after_atomic();
1881 wake_up_bit(flags
, CIFS_INO_LOCK
);
1887 cifs_zap_mapping(struct inode
*inode
)
1889 set_bit(CIFS_INO_INVALID_MAPPING
, &CIFS_I(inode
)->flags
);
1890 return cifs_revalidate_mapping(inode
);
1893 int cifs_revalidate_file_attr(struct file
*filp
)
1896 struct inode
*inode
= file_inode(filp
);
1897 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*) filp
->private_data
;
1899 if (!cifs_inode_needs_reval(inode
))
1902 if (tlink_tcon(cfile
->tlink
)->unix_ext
)
1903 rc
= cifs_get_file_info_unix(filp
);
1905 rc
= cifs_get_file_info(filp
);
1910 int cifs_revalidate_dentry_attr(struct dentry
*dentry
)
1914 struct inode
*inode
= d_inode(dentry
);
1915 struct super_block
*sb
= dentry
->d_sb
;
1916 char *full_path
= NULL
;
1921 if (!cifs_inode_needs_reval(inode
))
1926 /* can not safely grab the rename sem here if rename calls revalidate
1927 since that would deadlock */
1928 full_path
= build_path_from_dentry(dentry
);
1929 if (full_path
== NULL
) {
1934 cifs_dbg(FYI
, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1935 full_path
, inode
, inode
->i_count
.counter
,
1936 dentry
, dentry
->d_time
, jiffies
);
1938 if (cifs_sb_master_tcon(CIFS_SB(sb
))->unix_ext
)
1939 rc
= cifs_get_inode_info_unix(&inode
, full_path
, sb
, xid
);
1941 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, sb
,
1950 int cifs_revalidate_file(struct file
*filp
)
1953 struct inode
*inode
= file_inode(filp
);
1955 rc
= cifs_revalidate_file_attr(filp
);
1959 return cifs_revalidate_mapping(inode
);
1962 /* revalidate a dentry's inode attributes */
1963 int cifs_revalidate_dentry(struct dentry
*dentry
)
1966 struct inode
*inode
= d_inode(dentry
);
1968 rc
= cifs_revalidate_dentry_attr(dentry
);
1972 return cifs_revalidate_mapping(inode
);
1975 int cifs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
1978 struct cifs_sb_info
*cifs_sb
= CIFS_SB(dentry
->d_sb
);
1979 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
1980 struct inode
*inode
= d_inode(dentry
);
1984 * We need to be sure that all dirty pages are written and the server
1985 * has actual ctime, mtime and file length.
1987 if (!CIFS_CACHE_READ(CIFS_I(inode
)) && inode
->i_mapping
&&
1988 inode
->i_mapping
->nrpages
!= 0) {
1989 rc
= filemap_fdatawait(inode
->i_mapping
);
1991 mapping_set_error(inode
->i_mapping
, rc
);
1996 rc
= cifs_revalidate_dentry_attr(dentry
);
2000 generic_fillattr(inode
, stat
);
2001 stat
->blksize
= CIFS_MAX_MSGSIZE
;
2002 stat
->ino
= CIFS_I(inode
)->uniqueid
;
2005 * If on a multiuser mount without unix extensions or cifsacl being
2006 * enabled, and the admin hasn't overridden them, set the ownership
2007 * to the fsuid/fsgid of the current process.
2009 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
) &&
2010 !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
2012 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
))
2013 stat
->uid
= current_fsuid();
2014 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
))
2015 stat
->gid
= current_fsgid();
2020 static int cifs_truncate_page(struct address_space
*mapping
, loff_t from
)
2022 pgoff_t index
= from
>> PAGE_CACHE_SHIFT
;
2023 unsigned offset
= from
& (PAGE_CACHE_SIZE
- 1);
2027 page
= grab_cache_page(mapping
, index
);
2031 zero_user_segment(page
, offset
, PAGE_CACHE_SIZE
);
2033 page_cache_release(page
);
2037 static void cifs_setsize(struct inode
*inode
, loff_t offset
)
2039 spin_lock(&inode
->i_lock
);
2040 i_size_write(inode
, offset
);
2041 spin_unlock(&inode
->i_lock
);
2043 truncate_pagecache(inode
, offset
);
2047 cifs_set_file_size(struct inode
*inode
, struct iattr
*attrs
,
2048 unsigned int xid
, char *full_path
)
2051 struct cifsFileInfo
*open_file
;
2052 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2053 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2054 struct tcon_link
*tlink
= NULL
;
2055 struct cifs_tcon
*tcon
= NULL
;
2056 struct TCP_Server_Info
*server
;
2059 * To avoid spurious oplock breaks from server, in the case of
2060 * inodes that we already have open, avoid doing path based
2061 * setting of file size if we can do it by handle.
2062 * This keeps our caching token (oplock) and avoids timeouts
2063 * when the local oplock break takes longer to flush
2064 * writebehind data than the SMB timeout for the SetPathInfo
2065 * request would allow
2067 open_file
= find_writable_file(cifsInode
, true);
2069 tcon
= tlink_tcon(open_file
->tlink
);
2070 server
= tcon
->ses
->server
;
2071 if (server
->ops
->set_file_size
)
2072 rc
= server
->ops
->set_file_size(xid
, tcon
, open_file
,
2073 attrs
->ia_size
, false);
2076 cifsFileInfo_put(open_file
);
2077 cifs_dbg(FYI
, "SetFSize for attrs rc = %d\n", rc
);
2085 tlink
= cifs_sb_tlink(cifs_sb
);
2087 return PTR_ERR(tlink
);
2088 tcon
= tlink_tcon(tlink
);
2089 server
= tcon
->ses
->server
;
2093 * Set file size by pathname rather than by handle either because no
2094 * valid, writeable file handle for it was found or because there was
2095 * an error setting it by handle.
2097 if (server
->ops
->set_path_size
)
2098 rc
= server
->ops
->set_path_size(xid
, tcon
, full_path
,
2099 attrs
->ia_size
, cifs_sb
, false);
2102 cifs_dbg(FYI
, "SetEOF by path (setattrs) rc = %d\n", rc
);
2105 cifs_put_tlink(tlink
);
2109 cifsInode
->server_eof
= attrs
->ia_size
;
2110 cifs_setsize(inode
, attrs
->ia_size
);
2111 cifs_truncate_page(inode
->i_mapping
, inode
->i_size
);
2118 cifs_setattr_unix(struct dentry
*direntry
, struct iattr
*attrs
)
2122 char *full_path
= NULL
;
2123 struct inode
*inode
= d_inode(direntry
);
2124 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2125 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2126 struct tcon_link
*tlink
;
2127 struct cifs_tcon
*pTcon
;
2128 struct cifs_unix_set_info_args
*args
= NULL
;
2129 struct cifsFileInfo
*open_file
;
2131 cifs_dbg(FYI
, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2132 direntry
, attrs
->ia_valid
);
2136 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
2137 attrs
->ia_valid
|= ATTR_FORCE
;
2139 rc
= inode_change_ok(inode
, attrs
);
2143 full_path
= build_path_from_dentry(direntry
);
2144 if (full_path
== NULL
) {
2150 * Attempt to flush data before changing attributes. We need to do
2151 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2152 * ownership or mode then we may also need to do this. Here, we take
2153 * the safe way out and just do the flush on all setattr requests. If
2154 * the flush returns error, store it to report later and continue.
2156 * BB: This should be smarter. Why bother flushing pages that
2157 * will be truncated anyway? Also, should we error out here if
2158 * the flush returns error?
2160 rc
= filemap_write_and_wait(inode
->i_mapping
);
2161 mapping_set_error(inode
->i_mapping
, rc
);
2164 if (attrs
->ia_valid
& ATTR_SIZE
) {
2165 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
2170 /* skip mode change if it's just for clearing setuid/setgid */
2171 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
2172 attrs
->ia_valid
&= ~ATTR_MODE
;
2174 args
= kmalloc(sizeof(*args
), GFP_KERNEL
);
2180 /* set up the struct */
2181 if (attrs
->ia_valid
& ATTR_MODE
)
2182 args
->mode
= attrs
->ia_mode
;
2184 args
->mode
= NO_CHANGE_64
;
2186 if (attrs
->ia_valid
& ATTR_UID
)
2187 args
->uid
= attrs
->ia_uid
;
2189 args
->uid
= INVALID_UID
; /* no change */
2191 if (attrs
->ia_valid
& ATTR_GID
)
2192 args
->gid
= attrs
->ia_gid
;
2194 args
->gid
= INVALID_GID
; /* no change */
2196 if (attrs
->ia_valid
& ATTR_ATIME
)
2197 args
->atime
= cifs_UnixTimeToNT(attrs
->ia_atime
);
2199 args
->atime
= NO_CHANGE_64
;
2201 if (attrs
->ia_valid
& ATTR_MTIME
)
2202 args
->mtime
= cifs_UnixTimeToNT(attrs
->ia_mtime
);
2204 args
->mtime
= NO_CHANGE_64
;
2206 if (attrs
->ia_valid
& ATTR_CTIME
)
2207 args
->ctime
= cifs_UnixTimeToNT(attrs
->ia_ctime
);
2209 args
->ctime
= NO_CHANGE_64
;
2212 open_file
= find_writable_file(cifsInode
, true);
2214 u16 nfid
= open_file
->fid
.netfid
;
2215 u32 npid
= open_file
->pid
;
2216 pTcon
= tlink_tcon(open_file
->tlink
);
2217 rc
= CIFSSMBUnixSetFileInfo(xid
, pTcon
, args
, nfid
, npid
);
2218 cifsFileInfo_put(open_file
);
2220 tlink
= cifs_sb_tlink(cifs_sb
);
2221 if (IS_ERR(tlink
)) {
2222 rc
= PTR_ERR(tlink
);
2225 pTcon
= tlink_tcon(tlink
);
2226 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, args
,
2228 cifs_remap(cifs_sb
));
2229 cifs_put_tlink(tlink
);
2235 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
2236 attrs
->ia_size
!= i_size_read(inode
))
2237 truncate_setsize(inode
, attrs
->ia_size
);
2239 setattr_copy(inode
, attrs
);
2240 mark_inode_dirty(inode
);
2242 /* force revalidate when any of these times are set since some
2243 of the fs types (eg ext3, fat) do not have fine enough
2244 time granularity to match protocol, and we do not have a
2245 a way (yet) to query the server fs's time granularity (and
2246 whether it rounds times down).
2248 if (attrs
->ia_valid
& (ATTR_MTIME
| ATTR_CTIME
))
2249 cifsInode
->time
= 0;
2258 cifs_setattr_nounix(struct dentry
*direntry
, struct iattr
*attrs
)
2261 kuid_t uid
= INVALID_UID
;
2262 kgid_t gid
= INVALID_GID
;
2263 struct inode
*inode
= d_inode(direntry
);
2264 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2265 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2266 char *full_path
= NULL
;
2269 __u64 mode
= NO_CHANGE_64
;
2273 cifs_dbg(FYI
, "setattr on file %pd attrs->iavalid 0x%x\n",
2274 direntry
, attrs
->ia_valid
);
2276 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
2277 attrs
->ia_valid
|= ATTR_FORCE
;
2279 rc
= inode_change_ok(inode
, attrs
);
2285 full_path
= build_path_from_dentry(direntry
);
2286 if (full_path
== NULL
) {
2293 * Attempt to flush data before changing attributes. We need to do
2294 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2295 * ownership or mode then we may also need to do this. Here, we take
2296 * the safe way out and just do the flush on all setattr requests. If
2297 * the flush returns error, store it to report later and continue.
2299 * BB: This should be smarter. Why bother flushing pages that
2300 * will be truncated anyway? Also, should we error out here if
2301 * the flush returns error?
2303 rc
= filemap_write_and_wait(inode
->i_mapping
);
2304 mapping_set_error(inode
->i_mapping
, rc
);
2307 if (attrs
->ia_valid
& ATTR_SIZE
) {
2308 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
2310 goto cifs_setattr_exit
;
2313 if (attrs
->ia_valid
& ATTR_UID
)
2314 uid
= attrs
->ia_uid
;
2316 if (attrs
->ia_valid
& ATTR_GID
)
2317 gid
= attrs
->ia_gid
;
2319 #ifdef CONFIG_CIFS_ACL
2320 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
2321 if (uid_valid(uid
) || gid_valid(gid
)) {
2322 rc
= id_mode_to_cifs_acl(inode
, full_path
, NO_CHANGE_64
,
2325 cifs_dbg(FYI
, "%s: Setting id failed with error: %d\n",
2327 goto cifs_setattr_exit
;
2331 #endif /* CONFIG_CIFS_ACL */
2332 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
))
2333 attrs
->ia_valid
&= ~(ATTR_UID
| ATTR_GID
);
2335 /* skip mode change if it's just for clearing setuid/setgid */
2336 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
2337 attrs
->ia_valid
&= ~ATTR_MODE
;
2339 if (attrs
->ia_valid
& ATTR_MODE
) {
2340 mode
= attrs
->ia_mode
;
2342 #ifdef CONFIG_CIFS_ACL
2343 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
2344 rc
= id_mode_to_cifs_acl(inode
, full_path
, mode
,
2345 INVALID_UID
, INVALID_GID
);
2347 cifs_dbg(FYI
, "%s: Setting ACL failed with error: %d\n",
2349 goto cifs_setattr_exit
;
2352 #endif /* CONFIG_CIFS_ACL */
2353 if (((mode
& S_IWUGO
) == 0) &&
2354 (cifsInode
->cifsAttrs
& ATTR_READONLY
) == 0) {
2356 dosattr
= cifsInode
->cifsAttrs
| ATTR_READONLY
;
2358 /* fix up mode if we're not using dynperm */
2359 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
) == 0)
2360 attrs
->ia_mode
= inode
->i_mode
& ~S_IWUGO
;
2361 } else if ((mode
& S_IWUGO
) &&
2362 (cifsInode
->cifsAttrs
& ATTR_READONLY
)) {
2364 dosattr
= cifsInode
->cifsAttrs
& ~ATTR_READONLY
;
2365 /* Attributes of 0 are ignored */
2367 dosattr
|= ATTR_NORMAL
;
2369 /* reset local inode permissions to normal */
2370 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2371 attrs
->ia_mode
&= ~(S_IALLUGO
);
2372 if (S_ISDIR(inode
->i_mode
))
2374 cifs_sb
->mnt_dir_mode
;
2377 cifs_sb
->mnt_file_mode
;
2379 } else if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2380 /* ignore mode change - ATTR_READONLY hasn't changed */
2381 attrs
->ia_valid
&= ~ATTR_MODE
;
2385 if (attrs
->ia_valid
& (ATTR_MTIME
|ATTR_ATIME
|ATTR_CTIME
) ||
2386 ((attrs
->ia_valid
& ATTR_MODE
) && dosattr
)) {
2387 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
2388 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2390 /* Even if error on time set, no sense failing the call if
2391 the server would set the time to a reasonable value anyway,
2392 and this check ensures that we are not being called from
2393 sys_utimes in which case we ought to fail the call back to
2394 the user when the server rejects the call */
2395 if ((rc
) && (attrs
->ia_valid
&
2396 (ATTR_MODE
| ATTR_GID
| ATTR_UID
| ATTR_SIZE
)))
2400 /* do not need local check to inode_check_ok since the server does
2403 goto cifs_setattr_exit
;
2405 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
2406 attrs
->ia_size
!= i_size_read(inode
))
2407 truncate_setsize(inode
, attrs
->ia_size
);
2409 setattr_copy(inode
, attrs
);
2410 mark_inode_dirty(inode
);
2419 cifs_setattr(struct dentry
*direntry
, struct iattr
*attrs
)
2421 struct inode
*inode
= d_inode(direntry
);
2422 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2423 struct cifs_tcon
*pTcon
= cifs_sb_master_tcon(cifs_sb
);
2425 if (pTcon
->unix_ext
)
2426 return cifs_setattr_unix(direntry
, attrs
);
2428 return cifs_setattr_nounix(direntry
, attrs
);
2430 /* BB: add cifs_setattr_legacy for really old servers */
2434 void cifs_delete_inode(struct inode
*inode
)
2436 cifs_dbg(FYI
, "In cifs_delete_inode, inode = 0x%p\n", inode
);
2437 /* may have to add back in if and when safe distributed caching of
2438 directories added e.g. via FindNotify */