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 <linux/sched/signal.h>
27 #include <linux/wait_bit.h>
29 #include <asm/div64.h>
33 #include "cifsproto.h"
34 #include "cifs_debug.h"
35 #include "cifs_fs_sb.h"
36 #include "cifs_unicode.h"
40 static void cifs_set_ops(struct inode
*inode
)
42 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
44 switch (inode
->i_mode
& S_IFMT
) {
46 inode
->i_op
= &cifs_file_inode_ops
;
47 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
48 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
49 inode
->i_fop
= &cifs_file_direct_nobrl_ops
;
51 inode
->i_fop
= &cifs_file_direct_ops
;
52 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_STRICT_IO
) {
53 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
54 inode
->i_fop
= &cifs_file_strict_nobrl_ops
;
56 inode
->i_fop
= &cifs_file_strict_ops
;
57 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
58 inode
->i_fop
= &cifs_file_nobrl_ops
;
59 else { /* not direct, send byte range locks */
60 inode
->i_fop
= &cifs_file_ops
;
63 /* check if server can support readpages */
64 if (cifs_sb_master_tcon(cifs_sb
)->ses
->server
->maxBuf
<
65 PAGE_SIZE
+ MAX_CIFS_HDR_SIZE
)
66 inode
->i_data
.a_ops
= &cifs_addr_ops_smallbuf
;
68 inode
->i_data
.a_ops
= &cifs_addr_ops
;
71 #ifdef CONFIG_CIFS_DFS_UPCALL
72 if (IS_AUTOMOUNT(inode
)) {
73 inode
->i_op
= &cifs_dfs_referral_inode_operations
;
75 #else /* NO DFS support, treat as a directory */
78 inode
->i_op
= &cifs_dir_inode_ops
;
79 inode
->i_fop
= &cifs_dir_ops
;
83 inode
->i_op
= &cifs_symlink_inode_ops
;
86 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
91 /* check inode attributes against fattr. If they don't match, tag the
92 * inode for cache invalidation
95 cifs_revalidate_cache(struct inode
*inode
, struct cifs_fattr
*fattr
)
97 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
99 cifs_dbg(FYI
, "%s: revalidating inode %llu\n",
100 __func__
, cifs_i
->uniqueid
);
102 if (inode
->i_state
& I_NEW
) {
103 cifs_dbg(FYI
, "%s: inode %llu is new\n",
104 __func__
, cifs_i
->uniqueid
);
108 /* don't bother with revalidation if we have an oplock */
109 if (CIFS_CACHE_READ(cifs_i
)) {
110 cifs_dbg(FYI
, "%s: inode %llu is oplocked\n",
111 __func__
, cifs_i
->uniqueid
);
115 /* revalidate if mtime or size have changed */
116 if (timespec64_equal(&inode
->i_mtime
, &fattr
->cf_mtime
) &&
117 cifs_i
->server_eof
== fattr
->cf_eof
) {
118 cifs_dbg(FYI
, "%s: inode %llu is unchanged\n",
119 __func__
, cifs_i
->uniqueid
);
123 cifs_dbg(FYI
, "%s: invalidating inode %llu mapping\n",
124 __func__
, cifs_i
->uniqueid
);
125 set_bit(CIFS_INO_INVALID_MAPPING
, &cifs_i
->flags
);
129 * copy nlink to the inode, unless it wasn't provided. Provide
130 * sane values if we don't have an existing one and none was provided
133 cifs_nlink_fattr_to_inode(struct inode
*inode
, struct cifs_fattr
*fattr
)
136 * if we're in a situation where we can't trust what we
137 * got from the server (readdir, some non-unix cases)
138 * fake reasonable values
140 if (fattr
->cf_flags
& CIFS_FATTR_UNKNOWN_NLINK
) {
141 /* only provide fake values on a new inode */
142 if (inode
->i_state
& I_NEW
) {
143 if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
)
151 /* we trust the server, so update it */
152 set_nlink(inode
, fattr
->cf_nlink
);
155 /* populate an inode with info from a cifs_fattr struct */
157 cifs_fattr_to_inode(struct inode
*inode
, struct cifs_fattr
*fattr
)
159 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
160 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
162 cifs_revalidate_cache(inode
, fattr
);
164 spin_lock(&inode
->i_lock
);
165 /* we do not want atime to be less than mtime, it broke some apps */
166 if (timespec64_compare(&fattr
->cf_atime
, &fattr
->cf_mtime
))
167 inode
->i_atime
= fattr
->cf_mtime
;
169 inode
->i_atime
= fattr
->cf_atime
;
170 inode
->i_mtime
= fattr
->cf_mtime
;
171 inode
->i_ctime
= fattr
->cf_ctime
;
172 inode
->i_rdev
= fattr
->cf_rdev
;
173 cifs_nlink_fattr_to_inode(inode
, fattr
);
174 inode
->i_uid
= fattr
->cf_uid
;
175 inode
->i_gid
= fattr
->cf_gid
;
177 /* if dynperm is set, don't clobber existing mode */
178 if (inode
->i_state
& I_NEW
||
179 !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
))
180 inode
->i_mode
= fattr
->cf_mode
;
182 cifs_i
->cifsAttrs
= fattr
->cf_cifsattrs
;
184 if (fattr
->cf_flags
& CIFS_FATTR_NEED_REVAL
)
187 cifs_i
->time
= jiffies
;
189 if (fattr
->cf_flags
& CIFS_FATTR_DELETE_PENDING
)
190 set_bit(CIFS_INO_DELETE_PENDING
, &cifs_i
->flags
);
192 clear_bit(CIFS_INO_DELETE_PENDING
, &cifs_i
->flags
);
194 cifs_i
->server_eof
= fattr
->cf_eof
;
196 * Can't safely change the file size here if the client is writing to
197 * it due to potential races.
199 if (is_size_safe_to_change(cifs_i
, fattr
->cf_eof
)) {
200 i_size_write(inode
, fattr
->cf_eof
);
203 * i_blocks is not related to (i_size / i_blksize),
204 * but instead 512 byte (2**9) size is required for
205 * calculating num blocks.
207 inode
->i_blocks
= (512 - 1 + fattr
->cf_bytes
) >> 9;
209 spin_unlock(&inode
->i_lock
);
211 if (fattr
->cf_flags
& CIFS_FATTR_DFS_REFERRAL
)
212 inode
->i_flags
|= S_AUTOMOUNT
;
213 if (inode
->i_state
& I_NEW
)
218 cifs_fill_uniqueid(struct super_block
*sb
, struct cifs_fattr
*fattr
)
220 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
222 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)
225 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
228 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
230 cifs_unix_basic_to_fattr(struct cifs_fattr
*fattr
, FILE_UNIX_BASIC_INFO
*info
,
231 struct cifs_sb_info
*cifs_sb
)
233 memset(fattr
, 0, sizeof(*fattr
));
234 fattr
->cf_uniqueid
= le64_to_cpu(info
->UniqueId
);
235 fattr
->cf_bytes
= le64_to_cpu(info
->NumOfBytes
);
236 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
238 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
239 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastModificationTime
);
240 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->LastStatusChange
);
241 /* old POSIX extensions don't get create time */
243 fattr
->cf_mode
= le64_to_cpu(info
->Permissions
);
246 * Since we set the inode type below we need to mask off
247 * to avoid strange results if bits set above.
249 fattr
->cf_mode
&= ~S_IFMT
;
250 switch (le32_to_cpu(info
->Type
)) {
252 fattr
->cf_mode
|= S_IFREG
;
253 fattr
->cf_dtype
= DT_REG
;
256 fattr
->cf_mode
|= S_IFLNK
;
257 fattr
->cf_dtype
= DT_LNK
;
260 fattr
->cf_mode
|= S_IFDIR
;
261 fattr
->cf_dtype
= DT_DIR
;
264 fattr
->cf_mode
|= S_IFCHR
;
265 fattr
->cf_dtype
= DT_CHR
;
266 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
267 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
270 fattr
->cf_mode
|= S_IFBLK
;
271 fattr
->cf_dtype
= DT_BLK
;
272 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
273 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
276 fattr
->cf_mode
|= S_IFIFO
;
277 fattr
->cf_dtype
= DT_FIFO
;
280 fattr
->cf_mode
|= S_IFSOCK
;
281 fattr
->cf_dtype
= DT_SOCK
;
284 /* safest to call it a file if we do not know */
285 fattr
->cf_mode
|= S_IFREG
;
286 fattr
->cf_dtype
= DT_REG
;
287 cifs_dbg(FYI
, "unknown type %d\n", le32_to_cpu(info
->Type
));
291 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
292 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
)) {
293 u64 id
= le64_to_cpu(info
->Uid
);
294 if (id
< ((uid_t
)-1)) {
295 kuid_t uid
= make_kuid(&init_user_ns
, id
);
301 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
302 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
)) {
303 u64 id
= le64_to_cpu(info
->Gid
);
304 if (id
< ((gid_t
)-1)) {
305 kgid_t gid
= make_kgid(&init_user_ns
, id
);
311 fattr
->cf_nlink
= le64_to_cpu(info
->Nlinks
);
315 * Fill a cifs_fattr struct with fake inode info.
317 * Needed to setup cifs_fattr data for the directory which is the
318 * junction to the new submount (ie to setup the fake directory
319 * which represents a DFS referral).
322 cifs_create_dfs_fattr(struct cifs_fattr
*fattr
, struct super_block
*sb
)
324 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
326 cifs_dbg(FYI
, "creating fake fattr for DFS referral\n");
328 memset(fattr
, 0, sizeof(*fattr
));
329 fattr
->cf_mode
= S_IFDIR
| S_IXUGO
| S_IRWXU
;
330 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
331 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
332 ktime_get_real_ts64(&fattr
->cf_mtime
);
333 fattr
->cf_mtime
= timespec64_trunc(fattr
->cf_mtime
, sb
->s_time_gran
);
334 fattr
->cf_atime
= fattr
->cf_ctime
= fattr
->cf_mtime
;
336 fattr
->cf_flags
= CIFS_FATTR_DFS_REFERRAL
;
340 cifs_get_file_info_unix(struct file
*filp
)
344 FILE_UNIX_BASIC_INFO find_data
;
345 struct cifs_fattr fattr
;
346 struct inode
*inode
= file_inode(filp
);
347 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
348 struct cifsFileInfo
*cfile
= filp
->private_data
;
349 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
352 rc
= CIFSSMBUnixQFileInfo(xid
, tcon
, cfile
->fid
.netfid
, &find_data
);
354 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
355 } else if (rc
== -EREMOTE
) {
356 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
360 cifs_fattr_to_inode(inode
, &fattr
);
365 int cifs_get_inode_info_unix(struct inode
**pinode
,
366 const unsigned char *full_path
,
367 struct super_block
*sb
, unsigned int xid
)
370 FILE_UNIX_BASIC_INFO find_data
;
371 struct cifs_fattr fattr
;
372 struct cifs_tcon
*tcon
;
373 struct tcon_link
*tlink
;
374 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
376 cifs_dbg(FYI
, "Getting info on %s\n", full_path
);
378 tlink
= cifs_sb_tlink(cifs_sb
);
380 return PTR_ERR(tlink
);
381 tcon
= tlink_tcon(tlink
);
383 /* could have done a find first instead but this returns more info */
384 rc
= CIFSSMBUnixQPathInfo(xid
, tcon
, full_path
, &find_data
,
385 cifs_sb
->local_nls
, cifs_remap(cifs_sb
));
386 cifs_put_tlink(tlink
);
389 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
390 } else if (rc
== -EREMOTE
) {
391 cifs_create_dfs_fattr(&fattr
, sb
);
397 /* check for Minshall+French symlinks */
398 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) {
399 int tmprc
= check_mf_symlink(xid
, tcon
, cifs_sb
, &fattr
,
402 cifs_dbg(FYI
, "check_mf_symlink: %d\n", tmprc
);
405 if (*pinode
== NULL
) {
407 cifs_fill_uniqueid(sb
, &fattr
);
408 *pinode
= cifs_iget(sb
, &fattr
);
412 /* we already have inode, update it */
414 /* if uniqueid is different, return error */
415 if (unlikely(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
&&
416 CIFS_I(*pinode
)->uniqueid
!= fattr
.cf_uniqueid
)) {
421 /* if filetype is different, return error */
422 if (unlikely(((*pinode
)->i_mode
& S_IFMT
) !=
423 (fattr
.cf_mode
& S_IFMT
))) {
428 cifs_fattr_to_inode(*pinode
, &fattr
);
436 cifs_sfu_type(struct cifs_fattr
*fattr
, const char *path
,
437 struct cifs_sb_info
*cifs_sb
, unsigned int xid
)
441 struct tcon_link
*tlink
;
442 struct cifs_tcon
*tcon
;
444 struct cifs_open_parms oparms
;
445 struct cifs_io_parms io_parms
;
447 unsigned int bytes_read
;
449 int buf_type
= CIFS_NO_BUFFER
;
453 fattr
->cf_mode
&= ~S_IFMT
;
455 if (fattr
->cf_eof
== 0) {
456 fattr
->cf_mode
|= S_IFIFO
;
457 fattr
->cf_dtype
= DT_FIFO
;
459 } else if (fattr
->cf_eof
< 8) {
460 fattr
->cf_mode
|= S_IFREG
;
461 fattr
->cf_dtype
= DT_REG
;
462 return -EINVAL
; /* EOPNOTSUPP? */
465 tlink
= cifs_sb_tlink(cifs_sb
);
467 return PTR_ERR(tlink
);
468 tcon
= tlink_tcon(tlink
);
471 oparms
.cifs_sb
= cifs_sb
;
472 oparms
.desired_access
= GENERIC_READ
;
473 oparms
.create_options
= CREATE_NOT_DIR
;
474 if (backup_cred(cifs_sb
))
475 oparms
.create_options
|= CREATE_OPEN_BACKUP_INTENT
;
476 oparms
.disposition
= FILE_OPEN
;
479 oparms
.reconnect
= false;
481 if (tcon
->ses
->server
->oplocks
)
485 rc
= tcon
->ses
->server
->ops
->open(xid
, &oparms
, &oplock
, NULL
);
487 cifs_dbg(FYI
, "check sfu type of %s, open rc = %d\n", path
, rc
);
488 cifs_put_tlink(tlink
);
493 io_parms
.netfid
= fid
.netfid
;
494 io_parms
.pid
= current
->tgid
;
495 io_parms
.tcon
= tcon
;
497 io_parms
.length
= 24;
499 rc
= tcon
->ses
->server
->ops
->sync_read(xid
, &fid
, &io_parms
,
500 &bytes_read
, &pbuf
, &buf_type
);
501 if ((rc
== 0) && (bytes_read
>= 8)) {
502 if (memcmp("IntxBLK", pbuf
, 8) == 0) {
503 cifs_dbg(FYI
, "Block device\n");
504 fattr
->cf_mode
|= S_IFBLK
;
505 fattr
->cf_dtype
= DT_BLK
;
506 if (bytes_read
== 24) {
507 /* we have enough to decode dev num */
508 __u64 mjr
; /* major */
509 __u64 mnr
; /* minor */
510 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
511 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
512 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
514 } else if (memcmp("IntxCHR", pbuf
, 8) == 0) {
515 cifs_dbg(FYI
, "Char device\n");
516 fattr
->cf_mode
|= S_IFCHR
;
517 fattr
->cf_dtype
= DT_CHR
;
518 if (bytes_read
== 24) {
519 /* we have enough to decode dev num */
520 __u64 mjr
; /* major */
521 __u64 mnr
; /* minor */
522 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
523 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
524 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
526 } else if (memcmp("IntxLNK", pbuf
, 7) == 0) {
527 cifs_dbg(FYI
, "Symlink\n");
528 fattr
->cf_mode
|= S_IFLNK
;
529 fattr
->cf_dtype
= DT_LNK
;
531 fattr
->cf_mode
|= S_IFREG
; /* file? */
532 fattr
->cf_dtype
= DT_REG
;
536 fattr
->cf_mode
|= S_IFREG
; /* then it is a file */
537 fattr
->cf_dtype
= DT_REG
;
538 rc
= -EOPNOTSUPP
; /* or some unknown SFU type */
541 tcon
->ses
->server
->ops
->close(xid
, tcon
, &fid
);
542 cifs_put_tlink(tlink
);
546 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
549 * Fetch mode bits as provided by SFU.
551 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
553 static int cifs_sfu_mode(struct cifs_fattr
*fattr
, const unsigned char *path
,
554 struct cifs_sb_info
*cifs_sb
, unsigned int xid
)
556 #ifdef CONFIG_CIFS_XATTR
560 struct tcon_link
*tlink
;
561 struct cifs_tcon
*tcon
;
563 tlink
= cifs_sb_tlink(cifs_sb
);
565 return PTR_ERR(tlink
);
566 tcon
= tlink_tcon(tlink
);
568 if (tcon
->ses
->server
->ops
->query_all_EAs
== NULL
) {
569 cifs_put_tlink(tlink
);
573 rc
= tcon
->ses
->server
->ops
->query_all_EAs(xid
, tcon
, path
,
574 "SETFILEBITS", ea_value
, 4 /* size of buf */,
576 cifs_put_tlink(tlink
);
580 mode
= le32_to_cpu(*((__le32
*)ea_value
));
581 fattr
->cf_mode
&= ~SFBITS_MASK
;
582 cifs_dbg(FYI
, "special bits 0%o org mode 0%o\n",
583 mode
, fattr
->cf_mode
);
584 fattr
->cf_mode
= (mode
& SFBITS_MASK
) | fattr
->cf_mode
;
585 cifs_dbg(FYI
, "special mode bits 0%o\n", mode
);
594 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
596 cifs_all_info_to_fattr(struct cifs_fattr
*fattr
, FILE_ALL_INFO
*info
,
597 struct super_block
*sb
, bool adjust_tz
,
600 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
601 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
603 memset(fattr
, 0, sizeof(*fattr
));
604 fattr
->cf_cifsattrs
= le32_to_cpu(info
->Attributes
);
605 if (info
->DeletePending
)
606 fattr
->cf_flags
|= CIFS_FATTR_DELETE_PENDING
;
608 if (info
->LastAccessTime
)
609 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
611 ktime_get_real_ts64(&fattr
->cf_atime
);
612 fattr
->cf_atime
= timespec64_trunc(fattr
->cf_atime
, sb
->s_time_gran
);
615 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->ChangeTime
);
616 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastWriteTime
);
619 fattr
->cf_ctime
.tv_sec
+= tcon
->ses
->server
->timeAdj
;
620 fattr
->cf_mtime
.tv_sec
+= tcon
->ses
->server
->timeAdj
;
623 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
624 fattr
->cf_bytes
= le64_to_cpu(info
->AllocationSize
);
625 fattr
->cf_createtime
= le64_to_cpu(info
->CreationTime
);
627 fattr
->cf_nlink
= le32_to_cpu(info
->NumberOfLinks
);
630 fattr
->cf_mode
= S_IFLNK
;
631 fattr
->cf_dtype
= DT_LNK
;
632 } else if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
) {
633 fattr
->cf_mode
= S_IFDIR
| cifs_sb
->mnt_dir_mode
;
634 fattr
->cf_dtype
= DT_DIR
;
636 * Server can return wrong NumberOfLinks value for directories
637 * when Unix extensions are disabled - fake it.
640 fattr
->cf_flags
|= CIFS_FATTR_UNKNOWN_NLINK
;
642 fattr
->cf_mode
= S_IFREG
| cifs_sb
->mnt_file_mode
;
643 fattr
->cf_dtype
= DT_REG
;
645 /* clear write bits if ATTR_READONLY is set */
646 if (fattr
->cf_cifsattrs
& ATTR_READONLY
)
647 fattr
->cf_mode
&= ~(S_IWUGO
);
650 * Don't accept zero nlink from non-unix servers unless
651 * delete is pending. Instead mark it as unknown.
653 if ((fattr
->cf_nlink
< 1) && !tcon
->unix_ext
&&
654 !info
->DeletePending
) {
655 cifs_dbg(1, "bogus file nlink value %u\n",
657 fattr
->cf_flags
|= CIFS_FATTR_UNKNOWN_NLINK
;
661 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
662 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
666 cifs_get_file_info(struct file
*filp
)
670 FILE_ALL_INFO find_data
;
671 struct cifs_fattr fattr
;
672 struct inode
*inode
= file_inode(filp
);
673 struct cifsFileInfo
*cfile
= filp
->private_data
;
674 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
675 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
677 if (!server
->ops
->query_file_info
)
681 rc
= server
->ops
->query_file_info(xid
, tcon
, &cfile
->fid
, &find_data
);
684 cifs_all_info_to_fattr(&fattr
, &find_data
, inode
->i_sb
, false,
688 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
694 * FIXME: legacy server -- fall back to path-based call?
695 * for now, just skip revalidating and mark inode for
699 CIFS_I(inode
)->time
= 0;
705 * don't bother with SFU junk here -- just mark inode as needing
708 fattr
.cf_uniqueid
= CIFS_I(inode
)->uniqueid
;
709 fattr
.cf_flags
|= CIFS_FATTR_NEED_REVAL
;
710 cifs_fattr_to_inode(inode
, &fattr
);
716 /* Simple function to return a 64 bit hash of string. Rarely called */
717 static __u64
simple_hashstr(const char *str
)
719 const __u64 hash_mult
= 1125899906842597ULL; /* a big enough prime */
723 hash
= (hash
+ (__u64
) *str
++) * hash_mult
;
729 cifs_get_inode_info(struct inode
**inode
, const char *full_path
,
730 FILE_ALL_INFO
*data
, struct super_block
*sb
, int xid
,
731 const struct cifs_fid
*fid
)
734 int rc
= 0, tmprc
= ENOSYS
;
735 struct cifs_tcon
*tcon
;
736 struct TCP_Server_Info
*server
;
737 struct tcon_link
*tlink
;
738 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
740 bool adjust_tz
= false;
741 struct cifs_fattr fattr
;
742 struct cifs_search_info
*srchinf
= NULL
;
743 bool symlink
= false;
745 tlink
= cifs_sb_tlink(cifs_sb
);
747 return PTR_ERR(tlink
);
748 tcon
= tlink_tcon(tlink
);
749 server
= tcon
->ses
->server
;
751 cifs_dbg(FYI
, "Getting info on %s\n", full_path
);
753 if ((data
== NULL
) && (*inode
!= NULL
)) {
754 if (CIFS_CACHE_READ(CIFS_I(*inode
)) &&
755 CIFS_I(*inode
)->time
!= 0) {
756 cifs_dbg(FYI
, "No need to revalidate cached inode sizes\n");
761 /* if inode info is not passed, get it from server */
763 if (!server
->ops
->query_path_info
) {
767 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
772 data
= (FILE_ALL_INFO
*)buf
;
773 rc
= server
->ops
->query_path_info(xid
, tcon
, cifs_sb
, full_path
,
774 data
, &adjust_tz
, &symlink
);
778 cifs_all_info_to_fattr(&fattr
, data
, sb
, adjust_tz
,
780 } else if (rc
== -EREMOTE
) {
781 cifs_create_dfs_fattr(&fattr
, sb
);
783 } else if ((rc
== -EACCES
) && backup_cred(cifs_sb
) &&
784 (strcmp(server
->vals
->version_string
, SMB1_VERSION_STRING
)
787 * For SMB2 and later the backup intent flag is already
788 * sent if needed on open and there is no path based
789 * FindFirst operation to use to retry with
792 srchinf
= kzalloc(sizeof(struct cifs_search_info
),
794 if (srchinf
== NULL
) {
799 srchinf
->endOfSearch
= false;
801 srchinf
->info_level
= SMB_FIND_FILE_UNIX
;
802 else if ((tcon
->ses
->capabilities
&
803 tcon
->ses
->server
->vals
->cap_nt_find
) == 0)
804 srchinf
->info_level
= SMB_FIND_FILE_INFO_STANDARD
;
805 else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)
806 srchinf
->info_level
= SMB_FIND_FILE_ID_FULL_DIR_INFO
;
807 else /* no srvino useful for fallback to some netapp */
808 srchinf
->info_level
= SMB_FIND_FILE_DIRECTORY_INFO
;
810 srchflgs
= CIFS_SEARCH_CLOSE_ALWAYS
|
811 CIFS_SEARCH_CLOSE_AT_END
|
812 CIFS_SEARCH_BACKUP_SEARCH
;
814 rc
= CIFSFindFirst(xid
, tcon
, full_path
,
815 cifs_sb
, NULL
, srchflgs
, srchinf
, false);
817 data
= (FILE_ALL_INFO
*)srchinf
->srch_entries_start
;
819 cifs_dir_info_to_fattr(&fattr
,
820 (FILE_DIRECTORY_INFO
*)data
, cifs_sb
);
821 fattr
.cf_uniqueid
= le64_to_cpu(
822 ((SEARCH_ID_FULL_DIR_INFO
*)data
)->UniqueId
);
824 cifs_buf_release(srchinf
->ntwrk_buf_start
);
833 * If an inode wasn't passed in, then get the inode number
835 * Is an i_ino of zero legal? Can we use that to check if the server
836 * supports returning inode numbers? Are there other sanity checks we
837 * can use to ensure that the server is really filling in that field?
839 if (*inode
== NULL
) {
840 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) {
841 if (server
->ops
->get_srv_inum
)
842 tmprc
= server
->ops
->get_srv_inum(xid
,
843 tcon
, cifs_sb
, full_path
,
844 &fattr
.cf_uniqueid
, data
);
846 cifs_dbg(FYI
, "GetSrvInodeNum rc %d\n",
848 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
849 cifs_autodisable_serverino(cifs_sb
);
850 } else if ((fattr
.cf_uniqueid
== 0) &&
851 strlen(full_path
) == 0) {
852 /* some servers ret bad root ino ie 0 */
853 cifs_dbg(FYI
, "Invalid (0) inodenum\n");
855 CIFS_FATTR_FAKE_ROOT_INO
;
857 simple_hashstr(tcon
->treeName
);
860 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
862 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)
863 && server
->ops
->get_srv_inum
) {
865 * Pass a NULL tcon to ensure we don't make a round
866 * trip to the server. This only works for SMB2+.
868 tmprc
= server
->ops
->get_srv_inum(xid
,
869 NULL
, cifs_sb
, full_path
,
870 &fattr
.cf_uniqueid
, data
);
872 fattr
.cf_uniqueid
= CIFS_I(*inode
)->uniqueid
;
873 else if ((fattr
.cf_uniqueid
== 0) &&
874 strlen(full_path
) == 0) {
876 * Reuse existing root inode num since
877 * inum zero for root causes ls of . and .. to
880 cifs_dbg(FYI
, "Srv ret 0 inode num for root\n");
881 fattr
.cf_uniqueid
= CIFS_I(*inode
)->uniqueid
;
884 fattr
.cf_uniqueid
= CIFS_I(*inode
)->uniqueid
;
887 /* query for SFU type info if supported and needed */
888 if (fattr
.cf_cifsattrs
& ATTR_SYSTEM
&&
889 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
) {
890 tmprc
= cifs_sfu_type(&fattr
, full_path
, cifs_sb
, xid
);
892 cifs_dbg(FYI
, "cifs_sfu_type failed: %d\n", tmprc
);
895 /* fill in 0777 bits from ACL */
896 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MODE_FROM_SID
) {
897 rc
= cifs_acl_to_fattr(cifs_sb
, &fattr
, *inode
, true,
900 cifs_dbg(FYI
, "%s: Get mode from SID failed. rc=%d\n",
904 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
905 rc
= cifs_acl_to_fattr(cifs_sb
, &fattr
, *inode
, false,
908 cifs_dbg(FYI
, "%s: Getting ACL failed with error: %d\n",
914 /* fill in remaining high mode bits e.g. SUID, VTX */
915 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
)
916 cifs_sfu_mode(&fattr
, full_path
, cifs_sb
, xid
);
918 /* check for Minshall+French symlinks */
919 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) {
920 tmprc
= check_mf_symlink(xid
, tcon
, cifs_sb
, &fattr
,
923 cifs_dbg(FYI
, "check_mf_symlink: %d\n", tmprc
);
927 *inode
= cifs_iget(sb
, &fattr
);
931 /* we already have inode, update it */
933 /* if uniqueid is different, return error */
934 if (unlikely(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
&&
935 CIFS_I(*inode
)->uniqueid
!= fattr
.cf_uniqueid
)) {
940 /* if filetype is different, return error */
941 if (unlikely(((*inode
)->i_mode
& S_IFMT
) !=
942 (fattr
.cf_mode
& S_IFMT
))) {
947 cifs_fattr_to_inode(*inode
, &fattr
);
951 if ((*inode
) && ((*inode
)->i_ino
== 0))
952 cifs_dbg(FYI
, "inode number of zero returned\n");
955 cifs_put_tlink(tlink
);
959 static const struct inode_operations cifs_ipc_inode_ops
= {
960 .lookup
= cifs_lookup
,
964 cifs_find_inode(struct inode
*inode
, void *opaque
)
966 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
968 /* don't match inode with different uniqueid */
969 if (CIFS_I(inode
)->uniqueid
!= fattr
->cf_uniqueid
)
972 /* use createtime like an i_generation field */
973 if (CIFS_I(inode
)->createtime
!= fattr
->cf_createtime
)
976 /* don't match inode of different type */
977 if ((inode
->i_mode
& S_IFMT
) != (fattr
->cf_mode
& S_IFMT
))
980 /* if it's not a directory or has no dentries, then flag it */
981 if (S_ISDIR(inode
->i_mode
) && !hlist_empty(&inode
->i_dentry
))
982 fattr
->cf_flags
|= CIFS_FATTR_INO_COLLISION
;
988 cifs_init_inode(struct inode
*inode
, void *opaque
)
990 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
992 CIFS_I(inode
)->uniqueid
= fattr
->cf_uniqueid
;
993 CIFS_I(inode
)->createtime
= fattr
->cf_createtime
;
998 * walk dentry list for an inode and report whether it has aliases that
999 * are hashed. We use this to determine if a directory inode can actually
1003 inode_has_hashed_dentries(struct inode
*inode
)
1005 struct dentry
*dentry
;
1007 spin_lock(&inode
->i_lock
);
1008 hlist_for_each_entry(dentry
, &inode
->i_dentry
, d_u
.d_alias
) {
1009 if (!d_unhashed(dentry
) || IS_ROOT(dentry
)) {
1010 spin_unlock(&inode
->i_lock
);
1014 spin_unlock(&inode
->i_lock
);
1018 /* Given fattrs, get a corresponding inode */
1020 cifs_iget(struct super_block
*sb
, struct cifs_fattr
*fattr
)
1023 struct inode
*inode
;
1026 cifs_dbg(FYI
, "looking for uniqueid=%llu\n", fattr
->cf_uniqueid
);
1028 /* hash down to 32-bits on 32-bit arch */
1029 hash
= cifs_uniqueid_to_ino_t(fattr
->cf_uniqueid
);
1031 inode
= iget5_locked(sb
, hash
, cifs_find_inode
, cifs_init_inode
, fattr
);
1033 /* was there a potentially problematic inode collision? */
1034 if (fattr
->cf_flags
& CIFS_FATTR_INO_COLLISION
) {
1035 fattr
->cf_flags
&= ~CIFS_FATTR_INO_COLLISION
;
1037 if (inode_has_hashed_dentries(inode
)) {
1038 cifs_autodisable_serverino(CIFS_SB(sb
));
1040 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
1041 goto retry_iget5_locked
;
1045 cifs_fattr_to_inode(inode
, fattr
);
1046 if (sb
->s_flags
& SB_NOATIME
)
1047 inode
->i_flags
|= S_NOATIME
| S_NOCMTIME
;
1048 if (inode
->i_state
& I_NEW
) {
1049 inode
->i_ino
= hash
;
1050 #ifdef CONFIG_CIFS_FSCACHE
1051 /* initialize per-inode cache cookie pointer */
1052 CIFS_I(inode
)->fscache
= NULL
;
1054 unlock_new_inode(inode
);
1061 /* gets root inode */
1062 struct inode
*cifs_root_iget(struct super_block
*sb
)
1065 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
1066 struct inode
*inode
= NULL
;
1068 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
1072 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
)
1073 && cifs_sb
->prepath
) {
1074 len
= strlen(cifs_sb
->prepath
);
1075 path
= kzalloc(len
+ 2 /* leading sep + null */, GFP_KERNEL
);
1077 return ERR_PTR(-ENOMEM
);
1079 memcpy(path
+1, cifs_sb
->prepath
, len
);
1081 path
= kstrdup("", GFP_KERNEL
);
1083 return ERR_PTR(-ENOMEM
);
1087 if (tcon
->unix_ext
) {
1088 rc
= cifs_get_inode_info_unix(&inode
, path
, sb
, xid
);
1089 /* some servers mistakenly claim POSIX support */
1090 if (rc
!= -EOPNOTSUPP
)
1092 cifs_dbg(VFS
, "server does not support POSIX extensions");
1093 tcon
->unix_ext
= false;
1096 convert_delimiter(path
, CIFS_DIR_SEP(cifs_sb
));
1097 rc
= cifs_get_inode_info(&inode
, path
, NULL
, sb
, xid
, NULL
);
1101 inode
= ERR_PTR(rc
);
1105 #ifdef CONFIG_CIFS_FSCACHE
1106 /* populate tcon->resource_id */
1107 tcon
->resource_id
= CIFS_I(inode
)->uniqueid
;
1110 if (rc
&& tcon
->pipe
) {
1111 cifs_dbg(FYI
, "ipc connection - fake read inode\n");
1112 spin_lock(&inode
->i_lock
);
1113 inode
->i_mode
|= S_IFDIR
;
1114 set_nlink(inode
, 2);
1115 inode
->i_op
= &cifs_ipc_inode_ops
;
1116 inode
->i_fop
= &simple_dir_operations
;
1117 inode
->i_uid
= cifs_sb
->mnt_uid
;
1118 inode
->i_gid
= cifs_sb
->mnt_gid
;
1119 spin_unlock(&inode
->i_lock
);
1122 inode
= ERR_PTR(rc
);
1132 cifs_set_file_info(struct inode
*inode
, struct iattr
*attrs
, unsigned int xid
,
1133 char *full_path
, __u32 dosattr
)
1135 bool set_time
= false;
1136 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1137 struct TCP_Server_Info
*server
;
1138 FILE_BASIC_INFO info_buf
;
1143 server
= cifs_sb_master_tcon(cifs_sb
)->ses
->server
;
1144 if (!server
->ops
->set_file_info
)
1149 if (attrs
->ia_valid
& ATTR_ATIME
) {
1151 info_buf
.LastAccessTime
=
1152 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_atime
));
1154 info_buf
.LastAccessTime
= 0;
1156 if (attrs
->ia_valid
& ATTR_MTIME
) {
1158 info_buf
.LastWriteTime
=
1159 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_mtime
));
1161 info_buf
.LastWriteTime
= 0;
1164 * Samba throws this field away, but windows may actually use it.
1165 * Do not set ctime unless other time stamps are changed explicitly
1166 * (i.e. by utimes()) since we would then have a mix of client and
1169 if (set_time
&& (attrs
->ia_valid
& ATTR_CTIME
)) {
1170 cifs_dbg(FYI
, "CIFS - CTIME changed\n");
1171 info_buf
.ChangeTime
=
1172 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_ctime
));
1174 info_buf
.ChangeTime
= 0;
1176 info_buf
.CreationTime
= 0; /* don't change */
1177 info_buf
.Attributes
= cpu_to_le32(dosattr
);
1179 return server
->ops
->set_file_info(inode
, full_path
, &info_buf
, xid
);
1183 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1184 * and rename it to a random name that hopefully won't conflict with
1188 cifs_rename_pending_delete(const char *full_path
, struct dentry
*dentry
,
1189 const unsigned int xid
)
1193 struct cifs_fid fid
;
1194 struct cifs_open_parms oparms
;
1195 struct inode
*inode
= d_inode(dentry
);
1196 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1197 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1198 struct tcon_link
*tlink
;
1199 struct cifs_tcon
*tcon
;
1200 __u32 dosattr
, origattr
;
1201 FILE_BASIC_INFO
*info_buf
= NULL
;
1203 tlink
= cifs_sb_tlink(cifs_sb
);
1205 return PTR_ERR(tlink
);
1206 tcon
= tlink_tcon(tlink
);
1209 * We cannot rename the file if the server doesn't support
1210 * CAP_INFOLEVEL_PASSTHRU
1212 if (!(tcon
->ses
->capabilities
& CAP_INFOLEVEL_PASSTHRU
)) {
1218 oparms
.cifs_sb
= cifs_sb
;
1219 oparms
.desired_access
= DELETE
| FILE_WRITE_ATTRIBUTES
;
1220 oparms
.create_options
= CREATE_NOT_DIR
;
1221 oparms
.disposition
= FILE_OPEN
;
1222 oparms
.path
= full_path
;
1224 oparms
.reconnect
= false;
1226 rc
= CIFS_open(xid
, &oparms
, &oplock
, NULL
);
1230 origattr
= cifsInode
->cifsAttrs
;
1232 origattr
|= ATTR_NORMAL
;
1234 dosattr
= origattr
& ~ATTR_READONLY
;
1236 dosattr
|= ATTR_NORMAL
;
1237 dosattr
|= ATTR_HIDDEN
;
1239 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1240 if (dosattr
!= origattr
) {
1241 info_buf
= kzalloc(sizeof(*info_buf
), GFP_KERNEL
);
1242 if (info_buf
== NULL
) {
1246 info_buf
->Attributes
= cpu_to_le32(dosattr
);
1247 rc
= CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, fid
.netfid
,
1249 /* although we would like to mark the file hidden
1250 if that fails we will still try to rename it */
1252 cifsInode
->cifsAttrs
= dosattr
;
1254 dosattr
= origattr
; /* since not able to change them */
1257 /* rename the file */
1258 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, fid
.netfid
, NULL
,
1260 cifs_remap(cifs_sb
));
1266 /* try to set DELETE_ON_CLOSE */
1267 if (!test_bit(CIFS_INO_DELETE_PENDING
, &cifsInode
->flags
)) {
1268 rc
= CIFSSMBSetFileDisposition(xid
, tcon
, true, fid
.netfid
,
1271 * some samba versions return -ENOENT when we try to set the
1272 * file disposition here. Likely a samba bug, but work around
1273 * it for now. This means that some cifsXXX files may hang
1274 * around after they shouldn't.
1276 * BB: remove this hack after more servers have the fix
1284 set_bit(CIFS_INO_DELETE_PENDING
, &cifsInode
->flags
);
1288 CIFSSMBClose(xid
, tcon
, fid
.netfid
);
1291 cifs_put_tlink(tlink
);
1295 * reset everything back to the original state. Don't bother
1296 * dealing with errors here since we can't do anything about
1300 CIFSSMBRenameOpenFile(xid
, tcon
, fid
.netfid
, dentry
->d_name
.name
,
1301 cifs_sb
->local_nls
, cifs_remap(cifs_sb
));
1303 if (dosattr
!= origattr
) {
1304 info_buf
->Attributes
= cpu_to_le32(origattr
);
1305 if (!CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, fid
.netfid
,
1307 cifsInode
->cifsAttrs
= origattr
;
1313 /* copied from fs/nfs/dir.c with small changes */
1315 cifs_drop_nlink(struct inode
*inode
)
1317 spin_lock(&inode
->i_lock
);
1318 if (inode
->i_nlink
> 0)
1320 spin_unlock(&inode
->i_lock
);
1324 * If d_inode(dentry) is null (usually meaning the cached dentry
1325 * is a negative dentry) then we would attempt a standard SMB delete, but
1326 * if that fails we can not attempt the fall back mechanisms on EACCES
1327 * but will return the EACCES to the caller. Note that the VFS does not call
1328 * unlink on negative dentries currently.
1330 int cifs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1334 char *full_path
= NULL
;
1335 struct inode
*inode
= d_inode(dentry
);
1336 struct cifsInodeInfo
*cifs_inode
;
1337 struct super_block
*sb
= dir
->i_sb
;
1338 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
1339 struct tcon_link
*tlink
;
1340 struct cifs_tcon
*tcon
;
1341 struct TCP_Server_Info
*server
;
1342 struct iattr
*attrs
= NULL
;
1343 __u32 dosattr
= 0, origattr
= 0;
1345 cifs_dbg(FYI
, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir
, dentry
);
1347 tlink
= cifs_sb_tlink(cifs_sb
);
1349 return PTR_ERR(tlink
);
1350 tcon
= tlink_tcon(tlink
);
1351 server
= tcon
->ses
->server
;
1355 /* Unlink can be called from rename so we can not take the
1356 * sb->s_vfs_rename_mutex here */
1357 full_path
= build_path_from_dentry(dentry
);
1358 if (full_path
== NULL
) {
1363 if (cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1364 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1365 rc
= CIFSPOSIXDelFile(xid
, tcon
, full_path
,
1366 SMB_POSIX_UNLINK_FILE_TARGET
, cifs_sb
->local_nls
,
1367 cifs_remap(cifs_sb
));
1368 cifs_dbg(FYI
, "posix del rc %d\n", rc
);
1369 if ((rc
== 0) || (rc
== -ENOENT
))
1370 goto psx_del_no_retry
;
1374 if (!server
->ops
->unlink
) {
1376 goto psx_del_no_retry
;
1379 rc
= server
->ops
->unlink(xid
, tcon
, full_path
, cifs_sb
);
1384 cifs_drop_nlink(inode
);
1385 } else if (rc
== -ENOENT
) {
1387 } else if (rc
== -EBUSY
) {
1388 if (server
->ops
->rename_pending_delete
) {
1389 rc
= server
->ops
->rename_pending_delete(full_path
,
1392 cifs_drop_nlink(inode
);
1394 } else if ((rc
== -EACCES
) && (dosattr
== 0) && inode
) {
1395 attrs
= kzalloc(sizeof(*attrs
), GFP_KERNEL
);
1396 if (attrs
== NULL
) {
1401 /* try to reset dos attributes */
1402 cifs_inode
= CIFS_I(inode
);
1403 origattr
= cifs_inode
->cifsAttrs
;
1405 origattr
|= ATTR_NORMAL
;
1406 dosattr
= origattr
& ~ATTR_READONLY
;
1408 dosattr
|= ATTR_NORMAL
;
1409 dosattr
|= ATTR_HIDDEN
;
1411 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
1415 goto retry_std_delete
;
1418 /* undo the setattr if we errored out and it's needed */
1419 if (rc
!= 0 && dosattr
!= 0)
1420 cifs_set_file_info(inode
, attrs
, xid
, full_path
, origattr
);
1424 cifs_inode
= CIFS_I(inode
);
1425 cifs_inode
->time
= 0; /* will force revalidate to get info
1427 inode
->i_ctime
= current_time(inode
);
1429 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
1430 cifs_inode
= CIFS_I(dir
);
1431 CIFS_I(dir
)->time
= 0; /* force revalidate of dir as well */
1436 cifs_put_tlink(tlink
);
1441 cifs_mkdir_qinfo(struct inode
*parent
, struct dentry
*dentry
, umode_t mode
,
1442 const char *full_path
, struct cifs_sb_info
*cifs_sb
,
1443 struct cifs_tcon
*tcon
, const unsigned int xid
)
1446 struct inode
*inode
= NULL
;
1449 rc
= cifs_get_inode_info_unix(&inode
, full_path
, parent
->i_sb
,
1452 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, parent
->i_sb
,
1459 * setting nlink not necessary except in cases where we failed to get it
1460 * from the server or was set bogus. Also, since this is a brand new
1461 * inode, no need to grab the i_lock before setting the i_nlink.
1463 if (inode
->i_nlink
< 2)
1464 set_nlink(inode
, 2);
1465 mode
&= ~current_umask();
1466 /* must turn on setgid bit if parent dir has it */
1467 if (parent
->i_mode
& S_ISGID
)
1470 if (tcon
->unix_ext
) {
1471 struct cifs_unix_set_info_args args
= {
1473 .ctime
= NO_CHANGE_64
,
1474 .atime
= NO_CHANGE_64
,
1475 .mtime
= NO_CHANGE_64
,
1478 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1479 args
.uid
= current_fsuid();
1480 if (parent
->i_mode
& S_ISGID
)
1481 args
.gid
= parent
->i_gid
;
1483 args
.gid
= current_fsgid();
1485 args
.uid
= INVALID_UID
; /* no change */
1486 args
.gid
= INVALID_GID
; /* no change */
1488 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
1490 cifs_remap(cifs_sb
));
1492 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1493 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
1494 (mode
& S_IWUGO
) == 0 && server
->ops
->mkdir_setinfo
)
1495 server
->ops
->mkdir_setinfo(inode
, full_path
, cifs_sb
,
1497 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
1498 inode
->i_mode
= (mode
| S_IFDIR
);
1500 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1501 inode
->i_uid
= current_fsuid();
1502 if (inode
->i_mode
& S_ISGID
)
1503 inode
->i_gid
= parent
->i_gid
;
1505 inode
->i_gid
= current_fsgid();
1508 d_instantiate(dentry
, inode
);
1513 cifs_posix_mkdir(struct inode
*inode
, struct dentry
*dentry
, umode_t mode
,
1514 const char *full_path
, struct cifs_sb_info
*cifs_sb
,
1515 struct cifs_tcon
*tcon
, const unsigned int xid
)
1519 FILE_UNIX_BASIC_INFO
*info
= NULL
;
1520 struct inode
*newinode
= NULL
;
1521 struct cifs_fattr fattr
;
1523 info
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
1526 goto posix_mkdir_out
;
1529 mode
&= ~current_umask();
1530 rc
= CIFSPOSIXCreate(xid
, tcon
, SMB_O_DIRECTORY
| SMB_O_CREAT
, mode
,
1531 NULL
/* netfid */, info
, &oplock
, full_path
,
1532 cifs_sb
->local_nls
, cifs_remap(cifs_sb
));
1533 if (rc
== -EOPNOTSUPP
)
1534 goto posix_mkdir_out
;
1536 cifs_dbg(FYI
, "posix mkdir returned 0x%x\n", rc
);
1538 goto posix_mkdir_out
;
1541 if (info
->Type
== cpu_to_le32(-1))
1542 /* no return info, go query for it */
1543 goto posix_mkdir_get_info
;
1545 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1546 * need to set uid/gid.
1549 cifs_unix_basic_to_fattr(&fattr
, info
, cifs_sb
);
1550 cifs_fill_uniqueid(inode
->i_sb
, &fattr
);
1551 newinode
= cifs_iget(inode
->i_sb
, &fattr
);
1553 goto posix_mkdir_get_info
;
1555 d_instantiate(dentry
, newinode
);
1557 #ifdef CONFIG_CIFS_DEBUG2
1558 cifs_dbg(FYI
, "instantiated dentry %p %pd to inode %p\n",
1559 dentry
, dentry
, newinode
);
1561 if (newinode
->i_nlink
!= 2)
1562 cifs_dbg(FYI
, "unexpected number of links %d\n",
1569 posix_mkdir_get_info
:
1570 rc
= cifs_mkdir_qinfo(inode
, dentry
, mode
, full_path
, cifs_sb
, tcon
,
1572 goto posix_mkdir_out
;
1575 int cifs_mkdir(struct inode
*inode
, struct dentry
*direntry
, umode_t mode
)
1579 struct cifs_sb_info
*cifs_sb
;
1580 struct tcon_link
*tlink
;
1581 struct cifs_tcon
*tcon
;
1582 struct TCP_Server_Info
*server
;
1585 cifs_dbg(FYI
, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1588 cifs_sb
= CIFS_SB(inode
->i_sb
);
1589 tlink
= cifs_sb_tlink(cifs_sb
);
1591 return PTR_ERR(tlink
);
1592 tcon
= tlink_tcon(tlink
);
1596 full_path
= build_path_from_dentry(direntry
);
1597 if (full_path
== NULL
) {
1602 server
= tcon
->ses
->server
;
1604 if ((server
->ops
->posix_mkdir
) && (tcon
->posix_extensions
)) {
1605 rc
= server
->ops
->posix_mkdir(xid
, inode
, mode
, tcon
, full_path
,
1607 d_drop(direntry
); /* for time being always refresh inode info */
1611 if (cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1612 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1613 rc
= cifs_posix_mkdir(inode
, direntry
, mode
, full_path
, cifs_sb
,
1615 if (rc
!= -EOPNOTSUPP
)
1619 if (!server
->ops
->mkdir
) {
1624 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1625 rc
= server
->ops
->mkdir(xid
, inode
, mode
, tcon
, full_path
, cifs_sb
);
1627 cifs_dbg(FYI
, "cifs_mkdir returned 0x%x\n", rc
);
1632 /* TODO: skip this for smb2/smb3 */
1633 rc
= cifs_mkdir_qinfo(inode
, direntry
, mode
, full_path
, cifs_sb
, tcon
,
1637 * Force revalidate to get parent dir info when needed since cached
1638 * attributes are invalid now.
1640 CIFS_I(inode
)->time
= 0;
1643 cifs_put_tlink(tlink
);
1647 int cifs_rmdir(struct inode
*inode
, struct dentry
*direntry
)
1651 struct cifs_sb_info
*cifs_sb
;
1652 struct tcon_link
*tlink
;
1653 struct cifs_tcon
*tcon
;
1654 struct TCP_Server_Info
*server
;
1655 char *full_path
= NULL
;
1656 struct cifsInodeInfo
*cifsInode
;
1658 cifs_dbg(FYI
, "cifs_rmdir, inode = 0x%p\n", inode
);
1662 full_path
= build_path_from_dentry(direntry
);
1663 if (full_path
== NULL
) {
1668 cifs_sb
= CIFS_SB(inode
->i_sb
);
1669 tlink
= cifs_sb_tlink(cifs_sb
);
1670 if (IS_ERR(tlink
)) {
1671 rc
= PTR_ERR(tlink
);
1674 tcon
= tlink_tcon(tlink
);
1675 server
= tcon
->ses
->server
;
1677 if (!server
->ops
->rmdir
) {
1679 cifs_put_tlink(tlink
);
1683 rc
= server
->ops
->rmdir(xid
, tcon
, full_path
, cifs_sb
);
1684 cifs_put_tlink(tlink
);
1687 spin_lock(&d_inode(direntry
)->i_lock
);
1688 i_size_write(d_inode(direntry
), 0);
1689 clear_nlink(d_inode(direntry
));
1690 spin_unlock(&d_inode(direntry
)->i_lock
);
1693 cifsInode
= CIFS_I(d_inode(direntry
));
1694 /* force revalidate to go get info when needed */
1695 cifsInode
->time
= 0;
1697 cifsInode
= CIFS_I(inode
);
1699 * Force revalidate to get parent dir info when needed since cached
1700 * attributes are invalid now.
1702 cifsInode
->time
= 0;
1704 d_inode(direntry
)->i_ctime
= inode
->i_ctime
= inode
->i_mtime
=
1705 current_time(inode
);
1714 cifs_do_rename(const unsigned int xid
, struct dentry
*from_dentry
,
1715 const char *from_path
, struct dentry
*to_dentry
,
1716 const char *to_path
)
1718 struct cifs_sb_info
*cifs_sb
= CIFS_SB(from_dentry
->d_sb
);
1719 struct tcon_link
*tlink
;
1720 struct cifs_tcon
*tcon
;
1721 struct TCP_Server_Info
*server
;
1722 struct cifs_fid fid
;
1723 struct cifs_open_parms oparms
;
1726 tlink
= cifs_sb_tlink(cifs_sb
);
1728 return PTR_ERR(tlink
);
1729 tcon
= tlink_tcon(tlink
);
1730 server
= tcon
->ses
->server
;
1732 if (!server
->ops
->rename
)
1735 /* try path-based rename first */
1736 rc
= server
->ops
->rename(xid
, tcon
, from_path
, to_path
, cifs_sb
);
1739 * Don't bother with rename by filehandle unless file is busy and
1740 * source. Note that cross directory moves do not work with
1741 * rename by filehandle to various Windows servers.
1743 if (rc
== 0 || rc
!= -EBUSY
)
1744 goto do_rename_exit
;
1746 /* Don't fall back to using SMB on SMB 2+ mount */
1747 if (server
->vals
->protocol_id
!= 0)
1748 goto do_rename_exit
;
1750 /* open-file renames don't work across directories */
1751 if (to_dentry
->d_parent
!= from_dentry
->d_parent
)
1752 goto do_rename_exit
;
1755 oparms
.cifs_sb
= cifs_sb
;
1756 /* open the file to be renamed -- we need DELETE perms */
1757 oparms
.desired_access
= DELETE
;
1758 oparms
.create_options
= CREATE_NOT_DIR
;
1759 oparms
.disposition
= FILE_OPEN
;
1760 oparms
.path
= from_path
;
1762 oparms
.reconnect
= false;
1764 rc
= CIFS_open(xid
, &oparms
, &oplock
, NULL
);
1766 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, fid
.netfid
,
1767 (const char *) to_dentry
->d_name
.name
,
1768 cifs_sb
->local_nls
, cifs_remap(cifs_sb
));
1769 CIFSSMBClose(xid
, tcon
, fid
.netfid
);
1772 cifs_put_tlink(tlink
);
1777 cifs_rename2(struct inode
*source_dir
, struct dentry
*source_dentry
,
1778 struct inode
*target_dir
, struct dentry
*target_dentry
,
1781 char *from_name
= NULL
;
1782 char *to_name
= NULL
;
1783 struct cifs_sb_info
*cifs_sb
;
1784 struct tcon_link
*tlink
;
1785 struct cifs_tcon
*tcon
;
1786 FILE_UNIX_BASIC_INFO
*info_buf_source
= NULL
;
1787 FILE_UNIX_BASIC_INFO
*info_buf_target
;
1791 if (flags
& ~RENAME_NOREPLACE
)
1794 cifs_sb
= CIFS_SB(source_dir
->i_sb
);
1795 tlink
= cifs_sb_tlink(cifs_sb
);
1797 return PTR_ERR(tlink
);
1798 tcon
= tlink_tcon(tlink
);
1803 * we already have the rename sem so we do not need to
1804 * grab it again here to protect the path integrity
1806 from_name
= build_path_from_dentry(source_dentry
);
1807 if (from_name
== NULL
) {
1809 goto cifs_rename_exit
;
1812 to_name
= build_path_from_dentry(target_dentry
);
1813 if (to_name
== NULL
) {
1815 goto cifs_rename_exit
;
1818 rc
= cifs_do_rename(xid
, source_dentry
, from_name
, target_dentry
,
1822 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1824 if (flags
& RENAME_NOREPLACE
)
1825 goto cifs_rename_exit
;
1827 if (rc
== -EEXIST
&& tcon
->unix_ext
) {
1829 * Are src and dst hardlinks of same inode? We can only tell
1830 * with unix extensions enabled.
1833 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO
),
1835 if (info_buf_source
== NULL
) {
1837 goto cifs_rename_exit
;
1840 info_buf_target
= info_buf_source
+ 1;
1841 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, from_name
,
1844 cifs_remap(cifs_sb
));
1848 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, to_name
,
1851 cifs_remap(cifs_sb
));
1853 if (tmprc
== 0 && (info_buf_source
->UniqueId
==
1854 info_buf_target
->UniqueId
)) {
1855 /* same file, POSIX says that this is a noop */
1857 goto cifs_rename_exit
;
1861 * else ... BB we could add the same check for Windows by
1862 * checking the UniqueId via FILE_INTERNAL_INFO
1866 /* Try unlinking the target dentry if it's not negative */
1867 if (d_really_is_positive(target_dentry
) && (rc
== -EACCES
|| rc
== -EEXIST
)) {
1868 if (d_is_dir(target_dentry
))
1869 tmprc
= cifs_rmdir(target_dir
, target_dentry
);
1871 tmprc
= cifs_unlink(target_dir
, target_dentry
);
1873 goto cifs_rename_exit
;
1874 rc
= cifs_do_rename(xid
, source_dentry
, from_name
,
1875 target_dentry
, to_name
);
1878 /* force revalidate to go get info when needed */
1879 CIFS_I(source_dir
)->time
= CIFS_I(target_dir
)->time
= 0;
1881 source_dir
->i_ctime
= source_dir
->i_mtime
= target_dir
->i_ctime
=
1882 target_dir
->i_mtime
= current_time(source_dir
);
1885 kfree(info_buf_source
);
1889 cifs_put_tlink(tlink
);
1894 cifs_inode_needs_reval(struct inode
*inode
)
1896 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
1897 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1899 if (cifs_i
->time
== 0)
1902 if (CIFS_CACHE_READ(cifs_i
))
1905 if (!lookupCacheEnabled
)
1908 if (!cifs_sb
->actimeo
)
1911 if (!time_in_range(jiffies
, cifs_i
->time
,
1912 cifs_i
->time
+ cifs_sb
->actimeo
))
1915 /* hardlinked files w/ noserverino get "special" treatment */
1916 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) &&
1917 S_ISREG(inode
->i_mode
) && inode
->i_nlink
!= 1)
1924 * Zap the cache. Called when invalid_mapping flag is set.
1927 cifs_invalidate_mapping(struct inode
*inode
)
1931 if (inode
->i_mapping
&& inode
->i_mapping
->nrpages
!= 0) {
1932 rc
= invalidate_inode_pages2(inode
->i_mapping
);
1934 cifs_dbg(VFS
, "%s: could not invalidate inode %p\n",
1938 cifs_fscache_reset_inode_cookie(inode
);
1943 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1944 * @word: long word containing the bit lock
1947 cifs_wait_bit_killable(struct wait_bit_key
*key
, int mode
)
1949 freezable_schedule_unsafe();
1950 if (signal_pending_state(mode
, current
))
1951 return -ERESTARTSYS
;
1956 cifs_revalidate_mapping(struct inode
*inode
)
1959 unsigned long *flags
= &CIFS_I(inode
)->flags
;
1961 rc
= wait_on_bit_lock_action(flags
, CIFS_INO_LOCK
, cifs_wait_bit_killable
,
1966 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING
, flags
)) {
1967 rc
= cifs_invalidate_mapping(inode
);
1969 set_bit(CIFS_INO_INVALID_MAPPING
, flags
);
1972 clear_bit_unlock(CIFS_INO_LOCK
, flags
);
1973 smp_mb__after_atomic();
1974 wake_up_bit(flags
, CIFS_INO_LOCK
);
1980 cifs_zap_mapping(struct inode
*inode
)
1982 set_bit(CIFS_INO_INVALID_MAPPING
, &CIFS_I(inode
)->flags
);
1983 return cifs_revalidate_mapping(inode
);
1986 int cifs_revalidate_file_attr(struct file
*filp
)
1989 struct inode
*inode
= file_inode(filp
);
1990 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*) filp
->private_data
;
1992 if (!cifs_inode_needs_reval(inode
))
1995 if (tlink_tcon(cfile
->tlink
)->unix_ext
)
1996 rc
= cifs_get_file_info_unix(filp
);
1998 rc
= cifs_get_file_info(filp
);
2003 int cifs_revalidate_dentry_attr(struct dentry
*dentry
)
2007 struct inode
*inode
= d_inode(dentry
);
2008 struct super_block
*sb
= dentry
->d_sb
;
2009 char *full_path
= NULL
;
2014 if (!cifs_inode_needs_reval(inode
))
2019 /* can not safely grab the rename sem here if rename calls revalidate
2020 since that would deadlock */
2021 full_path
= build_path_from_dentry(dentry
);
2022 if (full_path
== NULL
) {
2027 cifs_dbg(FYI
, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2028 full_path
, inode
, inode
->i_count
.counter
,
2029 dentry
, cifs_get_time(dentry
), jiffies
);
2031 if (cifs_sb_master_tcon(CIFS_SB(sb
))->unix_ext
)
2032 rc
= cifs_get_inode_info_unix(&inode
, full_path
, sb
, xid
);
2034 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, sb
,
2043 int cifs_revalidate_file(struct file
*filp
)
2046 struct inode
*inode
= file_inode(filp
);
2048 rc
= cifs_revalidate_file_attr(filp
);
2052 return cifs_revalidate_mapping(inode
);
2055 /* revalidate a dentry's inode attributes */
2056 int cifs_revalidate_dentry(struct dentry
*dentry
)
2059 struct inode
*inode
= d_inode(dentry
);
2061 rc
= cifs_revalidate_dentry_attr(dentry
);
2065 return cifs_revalidate_mapping(inode
);
2068 int cifs_getattr(const struct path
*path
, struct kstat
*stat
,
2069 u32 request_mask
, unsigned int flags
)
2071 struct dentry
*dentry
= path
->dentry
;
2072 struct cifs_sb_info
*cifs_sb
= CIFS_SB(dentry
->d_sb
);
2073 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
2074 struct inode
*inode
= d_inode(dentry
);
2078 * We need to be sure that all dirty pages are written and the server
2079 * has actual ctime, mtime and file length.
2081 if (!CIFS_CACHE_READ(CIFS_I(inode
)) && inode
->i_mapping
&&
2082 inode
->i_mapping
->nrpages
!= 0) {
2083 rc
= filemap_fdatawait(inode
->i_mapping
);
2085 mapping_set_error(inode
->i_mapping
, rc
);
2090 rc
= cifs_revalidate_dentry_attr(dentry
);
2094 generic_fillattr(inode
, stat
);
2095 stat
->blksize
= cifs_sb
->bsize
;
2096 stat
->ino
= CIFS_I(inode
)->uniqueid
;
2098 /* old CIFS Unix Extensions doesn't return create time */
2099 if (CIFS_I(inode
)->createtime
) {
2100 stat
->result_mask
|= STATX_BTIME
;
2102 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode
)->createtime
));
2105 stat
->attributes_mask
|= (STATX_ATTR_COMPRESSED
| STATX_ATTR_ENCRYPTED
);
2106 if (CIFS_I(inode
)->cifsAttrs
& FILE_ATTRIBUTE_COMPRESSED
)
2107 stat
->attributes
|= STATX_ATTR_COMPRESSED
;
2108 if (CIFS_I(inode
)->cifsAttrs
& FILE_ATTRIBUTE_ENCRYPTED
)
2109 stat
->attributes
|= STATX_ATTR_ENCRYPTED
;
2112 * If on a multiuser mount without unix extensions or cifsacl being
2113 * enabled, and the admin hasn't overridden them, set the ownership
2114 * to the fsuid/fsgid of the current process.
2116 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
) &&
2117 !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
2119 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
))
2120 stat
->uid
= current_fsuid();
2121 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
))
2122 stat
->gid
= current_fsgid();
2127 int cifs_fiemap(struct inode
*inode
, struct fiemap_extent_info
*fei
, u64 start
,
2130 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
2131 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cifs_i
->vfs_inode
.i_sb
);
2132 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
2133 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
2134 struct cifsFileInfo
*cfile
;
2138 * We need to be sure that all dirty pages are written as they
2139 * might fill holes on the server.
2141 if (!CIFS_CACHE_READ(CIFS_I(inode
)) && inode
->i_mapping
&&
2142 inode
->i_mapping
->nrpages
!= 0) {
2143 rc
= filemap_fdatawait(inode
->i_mapping
);
2145 mapping_set_error(inode
->i_mapping
, rc
);
2150 cfile
= find_readable_file(cifs_i
, false);
2154 if (server
->ops
->fiemap
) {
2155 rc
= server
->ops
->fiemap(tcon
, cfile
, fei
, start
, len
);
2156 cifsFileInfo_put(cfile
);
2160 cifsFileInfo_put(cfile
);
2164 static int cifs_truncate_page(struct address_space
*mapping
, loff_t from
)
2166 pgoff_t index
= from
>> PAGE_SHIFT
;
2167 unsigned offset
= from
& (PAGE_SIZE
- 1);
2171 page
= grab_cache_page(mapping
, index
);
2175 zero_user_segment(page
, offset
, PAGE_SIZE
);
2181 static void cifs_setsize(struct inode
*inode
, loff_t offset
)
2183 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
2185 spin_lock(&inode
->i_lock
);
2186 i_size_write(inode
, offset
);
2187 spin_unlock(&inode
->i_lock
);
2189 /* Cached inode must be refreshed on truncate */
2191 truncate_pagecache(inode
, offset
);
2195 cifs_set_file_size(struct inode
*inode
, struct iattr
*attrs
,
2196 unsigned int xid
, char *full_path
)
2199 struct cifsFileInfo
*open_file
;
2200 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2201 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2202 struct tcon_link
*tlink
= NULL
;
2203 struct cifs_tcon
*tcon
= NULL
;
2204 struct TCP_Server_Info
*server
;
2207 * To avoid spurious oplock breaks from server, in the case of
2208 * inodes that we already have open, avoid doing path based
2209 * setting of file size if we can do it by handle.
2210 * This keeps our caching token (oplock) and avoids timeouts
2211 * when the local oplock break takes longer to flush
2212 * writebehind data than the SMB timeout for the SetPathInfo
2213 * request would allow
2215 open_file
= find_writable_file(cifsInode
, true);
2217 tcon
= tlink_tcon(open_file
->tlink
);
2218 server
= tcon
->ses
->server
;
2219 if (server
->ops
->set_file_size
)
2220 rc
= server
->ops
->set_file_size(xid
, tcon
, open_file
,
2221 attrs
->ia_size
, false);
2224 cifsFileInfo_put(open_file
);
2225 cifs_dbg(FYI
, "SetFSize for attrs rc = %d\n", rc
);
2233 tlink
= cifs_sb_tlink(cifs_sb
);
2235 return PTR_ERR(tlink
);
2236 tcon
= tlink_tcon(tlink
);
2237 server
= tcon
->ses
->server
;
2241 * Set file size by pathname rather than by handle either because no
2242 * valid, writeable file handle for it was found or because there was
2243 * an error setting it by handle.
2245 if (server
->ops
->set_path_size
)
2246 rc
= server
->ops
->set_path_size(xid
, tcon
, full_path
,
2247 attrs
->ia_size
, cifs_sb
, false);
2250 cifs_dbg(FYI
, "SetEOF by path (setattrs) rc = %d\n", rc
);
2253 cifs_put_tlink(tlink
);
2257 cifsInode
->server_eof
= attrs
->ia_size
;
2258 cifs_setsize(inode
, attrs
->ia_size
);
2259 cifs_truncate_page(inode
->i_mapping
, inode
->i_size
);
2266 cifs_setattr_unix(struct dentry
*direntry
, struct iattr
*attrs
)
2270 char *full_path
= NULL
;
2271 struct inode
*inode
= d_inode(direntry
);
2272 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2273 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2274 struct tcon_link
*tlink
;
2275 struct cifs_tcon
*pTcon
;
2276 struct cifs_unix_set_info_args
*args
= NULL
;
2277 struct cifsFileInfo
*open_file
;
2279 cifs_dbg(FYI
, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2280 direntry
, attrs
->ia_valid
);
2284 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
2285 attrs
->ia_valid
|= ATTR_FORCE
;
2287 rc
= setattr_prepare(direntry
, attrs
);
2291 full_path
= build_path_from_dentry(direntry
);
2292 if (full_path
== NULL
) {
2298 * Attempt to flush data before changing attributes. We need to do
2299 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2300 * ownership or mode then we may also need to do this. Here, we take
2301 * the safe way out and just do the flush on all setattr requests. If
2302 * the flush returns error, store it to report later and continue.
2304 * BB: This should be smarter. Why bother flushing pages that
2305 * will be truncated anyway? Also, should we error out here if
2306 * the flush returns error?
2308 rc
= filemap_write_and_wait(inode
->i_mapping
);
2309 if (is_interrupt_error(rc
)) {
2314 mapping_set_error(inode
->i_mapping
, rc
);
2317 if (attrs
->ia_valid
& ATTR_SIZE
) {
2318 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
2323 /* skip mode change if it's just for clearing setuid/setgid */
2324 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
2325 attrs
->ia_valid
&= ~ATTR_MODE
;
2327 args
= kmalloc(sizeof(*args
), GFP_KERNEL
);
2333 /* set up the struct */
2334 if (attrs
->ia_valid
& ATTR_MODE
)
2335 args
->mode
= attrs
->ia_mode
;
2337 args
->mode
= NO_CHANGE_64
;
2339 if (attrs
->ia_valid
& ATTR_UID
)
2340 args
->uid
= attrs
->ia_uid
;
2342 args
->uid
= INVALID_UID
; /* no change */
2344 if (attrs
->ia_valid
& ATTR_GID
)
2345 args
->gid
= attrs
->ia_gid
;
2347 args
->gid
= INVALID_GID
; /* no change */
2349 if (attrs
->ia_valid
& ATTR_ATIME
)
2350 args
->atime
= cifs_UnixTimeToNT(attrs
->ia_atime
);
2352 args
->atime
= NO_CHANGE_64
;
2354 if (attrs
->ia_valid
& ATTR_MTIME
)
2355 args
->mtime
= cifs_UnixTimeToNT(attrs
->ia_mtime
);
2357 args
->mtime
= NO_CHANGE_64
;
2359 if (attrs
->ia_valid
& ATTR_CTIME
)
2360 args
->ctime
= cifs_UnixTimeToNT(attrs
->ia_ctime
);
2362 args
->ctime
= NO_CHANGE_64
;
2365 open_file
= find_writable_file(cifsInode
, true);
2367 u16 nfid
= open_file
->fid
.netfid
;
2368 u32 npid
= open_file
->pid
;
2369 pTcon
= tlink_tcon(open_file
->tlink
);
2370 rc
= CIFSSMBUnixSetFileInfo(xid
, pTcon
, args
, nfid
, npid
);
2371 cifsFileInfo_put(open_file
);
2373 tlink
= cifs_sb_tlink(cifs_sb
);
2374 if (IS_ERR(tlink
)) {
2375 rc
= PTR_ERR(tlink
);
2378 pTcon
= tlink_tcon(tlink
);
2379 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, args
,
2381 cifs_remap(cifs_sb
));
2382 cifs_put_tlink(tlink
);
2388 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
2389 attrs
->ia_size
!= i_size_read(inode
))
2390 truncate_setsize(inode
, attrs
->ia_size
);
2392 setattr_copy(inode
, attrs
);
2393 mark_inode_dirty(inode
);
2395 /* force revalidate when any of these times are set since some
2396 of the fs types (eg ext3, fat) do not have fine enough
2397 time granularity to match protocol, and we do not have a
2398 a way (yet) to query the server fs's time granularity (and
2399 whether it rounds times down).
2401 if (attrs
->ia_valid
& (ATTR_MTIME
| ATTR_CTIME
))
2402 cifsInode
->time
= 0;
2411 cifs_setattr_nounix(struct dentry
*direntry
, struct iattr
*attrs
)
2414 kuid_t uid
= INVALID_UID
;
2415 kgid_t gid
= INVALID_GID
;
2416 struct inode
*inode
= d_inode(direntry
);
2417 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2418 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2419 struct cifsFileInfo
*wfile
;
2420 struct cifs_tcon
*tcon
;
2421 char *full_path
= NULL
;
2424 __u64 mode
= NO_CHANGE_64
;
2428 cifs_dbg(FYI
, "setattr on file %pd attrs->ia_valid 0x%x\n",
2429 direntry
, attrs
->ia_valid
);
2431 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
2432 attrs
->ia_valid
|= ATTR_FORCE
;
2434 rc
= setattr_prepare(direntry
, attrs
);
2440 full_path
= build_path_from_dentry(direntry
);
2441 if (full_path
== NULL
) {
2448 * Attempt to flush data before changing attributes. We need to do
2449 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2450 * ownership or mode then we may also need to do this. Here, we take
2451 * the safe way out and just do the flush on all setattr requests. If
2452 * the flush returns error, store it to report later and continue.
2454 * BB: This should be smarter. Why bother flushing pages that
2455 * will be truncated anyway? Also, should we error out here if
2456 * the flush returns error?
2458 rc
= filemap_write_and_wait(inode
->i_mapping
);
2459 if (is_interrupt_error(rc
)) {
2461 goto cifs_setattr_exit
;
2464 mapping_set_error(inode
->i_mapping
, rc
);
2467 if (attrs
->ia_valid
& ATTR_MTIME
) {
2468 rc
= cifs_get_writable_file(cifsInode
, false, &wfile
);
2470 tcon
= tlink_tcon(wfile
->tlink
);
2471 rc
= tcon
->ses
->server
->ops
->flush(xid
, tcon
, &wfile
->fid
);
2472 cifsFileInfo_put(wfile
);
2475 } else if (rc
!= -EBADF
)
2481 if (attrs
->ia_valid
& ATTR_SIZE
) {
2482 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
2484 goto cifs_setattr_exit
;
2487 if (attrs
->ia_valid
& ATTR_UID
)
2488 uid
= attrs
->ia_uid
;
2490 if (attrs
->ia_valid
& ATTR_GID
)
2491 gid
= attrs
->ia_gid
;
2493 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) ||
2494 (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MODE_FROM_SID
)) {
2495 if (uid_valid(uid
) || gid_valid(gid
)) {
2496 rc
= id_mode_to_cifs_acl(inode
, full_path
, NO_CHANGE_64
,
2499 cifs_dbg(FYI
, "%s: Setting id failed with error: %d\n",
2501 goto cifs_setattr_exit
;
2505 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
))
2506 attrs
->ia_valid
&= ~(ATTR_UID
| ATTR_GID
);
2508 /* skip mode change if it's just for clearing setuid/setgid */
2509 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
2510 attrs
->ia_valid
&= ~ATTR_MODE
;
2512 if (attrs
->ia_valid
& ATTR_MODE
) {
2513 mode
= attrs
->ia_mode
;
2515 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) ||
2516 (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MODE_FROM_SID
)) {
2517 rc
= id_mode_to_cifs_acl(inode
, full_path
, mode
,
2518 INVALID_UID
, INVALID_GID
);
2520 cifs_dbg(FYI
, "%s: Setting ACL failed with error: %d\n",
2522 goto cifs_setattr_exit
;
2525 if (((mode
& S_IWUGO
) == 0) &&
2526 (cifsInode
->cifsAttrs
& ATTR_READONLY
) == 0) {
2528 dosattr
= cifsInode
->cifsAttrs
| ATTR_READONLY
;
2530 /* fix up mode if we're not using dynperm */
2531 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
) == 0)
2532 attrs
->ia_mode
= inode
->i_mode
& ~S_IWUGO
;
2533 } else if ((mode
& S_IWUGO
) &&
2534 (cifsInode
->cifsAttrs
& ATTR_READONLY
)) {
2536 dosattr
= cifsInode
->cifsAttrs
& ~ATTR_READONLY
;
2537 /* Attributes of 0 are ignored */
2539 dosattr
|= ATTR_NORMAL
;
2541 /* reset local inode permissions to normal */
2542 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2543 attrs
->ia_mode
&= ~(S_IALLUGO
);
2544 if (S_ISDIR(inode
->i_mode
))
2546 cifs_sb
->mnt_dir_mode
;
2549 cifs_sb
->mnt_file_mode
;
2551 } else if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2552 /* ignore mode change - ATTR_READONLY hasn't changed */
2553 attrs
->ia_valid
&= ~ATTR_MODE
;
2557 if (attrs
->ia_valid
& (ATTR_MTIME
|ATTR_ATIME
|ATTR_CTIME
) ||
2558 ((attrs
->ia_valid
& ATTR_MODE
) && dosattr
)) {
2559 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
2560 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2562 /* Even if error on time set, no sense failing the call if
2563 the server would set the time to a reasonable value anyway,
2564 and this check ensures that we are not being called from
2565 sys_utimes in which case we ought to fail the call back to
2566 the user when the server rejects the call */
2567 if ((rc
) && (attrs
->ia_valid
&
2568 (ATTR_MODE
| ATTR_GID
| ATTR_UID
| ATTR_SIZE
)))
2572 /* do not need local check to inode_check_ok since the server does
2575 goto cifs_setattr_exit
;
2577 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
2578 attrs
->ia_size
!= i_size_read(inode
))
2579 truncate_setsize(inode
, attrs
->ia_size
);
2581 setattr_copy(inode
, attrs
);
2582 mark_inode_dirty(inode
);
2591 cifs_setattr(struct dentry
*direntry
, struct iattr
*attrs
)
2593 struct cifs_sb_info
*cifs_sb
= CIFS_SB(direntry
->d_sb
);
2594 struct cifs_tcon
*pTcon
= cifs_sb_master_tcon(cifs_sb
);
2596 if (pTcon
->unix_ext
)
2597 return cifs_setattr_unix(direntry
, attrs
);
2599 return cifs_setattr_nounix(direntry
, attrs
);
2601 /* BB: add cifs_setattr_legacy for really old servers */
2605 void cifs_delete_inode(struct inode
*inode
)
2607 cifs_dbg(FYI
, "In cifs_delete_inode, inode = 0x%p\n", inode
);
2608 /* may have to add back in if and when safe distributed caching of
2609 directories added e.g. via FindNotify */