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 #ifdef CONFIG_CIFS_ACL
896 /* fill in 0777 bits from ACL */
897 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
898 rc
= cifs_acl_to_fattr(cifs_sb
, &fattr
, *inode
, full_path
, fid
);
900 cifs_dbg(FYI
, "%s: Getting ACL failed with error: %d\n",
905 #endif /* CONFIG_CIFS_ACL */
907 /* fill in remaining high mode bits e.g. SUID, VTX */
908 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
)
909 cifs_sfu_mode(&fattr
, full_path
, cifs_sb
, xid
);
911 /* check for Minshall+French symlinks */
912 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) {
913 tmprc
= check_mf_symlink(xid
, tcon
, cifs_sb
, &fattr
,
916 cifs_dbg(FYI
, "check_mf_symlink: %d\n", tmprc
);
920 *inode
= cifs_iget(sb
, &fattr
);
924 /* we already have inode, update it */
926 /* if uniqueid is different, return error */
927 if (unlikely(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
&&
928 CIFS_I(*inode
)->uniqueid
!= fattr
.cf_uniqueid
)) {
933 /* if filetype is different, return error */
934 if (unlikely(((*inode
)->i_mode
& S_IFMT
) !=
935 (fattr
.cf_mode
& S_IFMT
))) {
940 cifs_fattr_to_inode(*inode
, &fattr
);
944 if ((*inode
) && ((*inode
)->i_ino
== 0))
945 cifs_dbg(FYI
, "inode number of zero returned\n");
948 cifs_put_tlink(tlink
);
952 static const struct inode_operations cifs_ipc_inode_ops
= {
953 .lookup
= cifs_lookup
,
957 cifs_find_inode(struct inode
*inode
, void *opaque
)
959 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
961 /* don't match inode with different uniqueid */
962 if (CIFS_I(inode
)->uniqueid
!= fattr
->cf_uniqueid
)
965 /* use createtime like an i_generation field */
966 if (CIFS_I(inode
)->createtime
!= fattr
->cf_createtime
)
969 /* don't match inode of different type */
970 if ((inode
->i_mode
& S_IFMT
) != (fattr
->cf_mode
& S_IFMT
))
973 /* if it's not a directory or has no dentries, then flag it */
974 if (S_ISDIR(inode
->i_mode
) && !hlist_empty(&inode
->i_dentry
))
975 fattr
->cf_flags
|= CIFS_FATTR_INO_COLLISION
;
981 cifs_init_inode(struct inode
*inode
, void *opaque
)
983 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
985 CIFS_I(inode
)->uniqueid
= fattr
->cf_uniqueid
;
986 CIFS_I(inode
)->createtime
= fattr
->cf_createtime
;
991 * walk dentry list for an inode and report whether it has aliases that
992 * are hashed. We use this to determine if a directory inode can actually
996 inode_has_hashed_dentries(struct inode
*inode
)
998 struct dentry
*dentry
;
1000 spin_lock(&inode
->i_lock
);
1001 hlist_for_each_entry(dentry
, &inode
->i_dentry
, d_u
.d_alias
) {
1002 if (!d_unhashed(dentry
) || IS_ROOT(dentry
)) {
1003 spin_unlock(&inode
->i_lock
);
1007 spin_unlock(&inode
->i_lock
);
1011 /* Given fattrs, get a corresponding inode */
1013 cifs_iget(struct super_block
*sb
, struct cifs_fattr
*fattr
)
1016 struct inode
*inode
;
1019 cifs_dbg(FYI
, "looking for uniqueid=%llu\n", fattr
->cf_uniqueid
);
1021 /* hash down to 32-bits on 32-bit arch */
1022 hash
= cifs_uniqueid_to_ino_t(fattr
->cf_uniqueid
);
1024 inode
= iget5_locked(sb
, hash
, cifs_find_inode
, cifs_init_inode
, fattr
);
1026 /* was there a potentially problematic inode collision? */
1027 if (fattr
->cf_flags
& CIFS_FATTR_INO_COLLISION
) {
1028 fattr
->cf_flags
&= ~CIFS_FATTR_INO_COLLISION
;
1030 if (inode_has_hashed_dentries(inode
)) {
1031 cifs_autodisable_serverino(CIFS_SB(sb
));
1033 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
1034 goto retry_iget5_locked
;
1038 cifs_fattr_to_inode(inode
, fattr
);
1039 if (sb
->s_flags
& SB_NOATIME
)
1040 inode
->i_flags
|= S_NOATIME
| S_NOCMTIME
;
1041 if (inode
->i_state
& I_NEW
) {
1042 inode
->i_ino
= hash
;
1043 #ifdef CONFIG_CIFS_FSCACHE
1044 /* initialize per-inode cache cookie pointer */
1045 CIFS_I(inode
)->fscache
= NULL
;
1047 unlock_new_inode(inode
);
1054 /* gets root inode */
1055 struct inode
*cifs_root_iget(struct super_block
*sb
)
1058 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
1059 struct inode
*inode
= NULL
;
1061 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
1065 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
)
1066 && cifs_sb
->prepath
) {
1067 len
= strlen(cifs_sb
->prepath
);
1068 path
= kzalloc(len
+ 2 /* leading sep + null */, GFP_KERNEL
);
1070 return ERR_PTR(-ENOMEM
);
1072 memcpy(path
+1, cifs_sb
->prepath
, len
);
1074 path
= kstrdup("", GFP_KERNEL
);
1076 return ERR_PTR(-ENOMEM
);
1080 if (tcon
->unix_ext
) {
1081 rc
= cifs_get_inode_info_unix(&inode
, path
, sb
, xid
);
1082 /* some servers mistakenly claim POSIX support */
1083 if (rc
!= -EOPNOTSUPP
)
1085 cifs_dbg(VFS
, "server does not support POSIX extensions");
1086 tcon
->unix_ext
= false;
1089 convert_delimiter(path
, CIFS_DIR_SEP(cifs_sb
));
1090 rc
= cifs_get_inode_info(&inode
, path
, NULL
, sb
, xid
, NULL
);
1094 inode
= ERR_PTR(rc
);
1098 #ifdef CONFIG_CIFS_FSCACHE
1099 /* populate tcon->resource_id */
1100 tcon
->resource_id
= CIFS_I(inode
)->uniqueid
;
1103 if (rc
&& tcon
->pipe
) {
1104 cifs_dbg(FYI
, "ipc connection - fake read inode\n");
1105 spin_lock(&inode
->i_lock
);
1106 inode
->i_mode
|= S_IFDIR
;
1107 set_nlink(inode
, 2);
1108 inode
->i_op
= &cifs_ipc_inode_ops
;
1109 inode
->i_fop
= &simple_dir_operations
;
1110 inode
->i_uid
= cifs_sb
->mnt_uid
;
1111 inode
->i_gid
= cifs_sb
->mnt_gid
;
1112 spin_unlock(&inode
->i_lock
);
1115 inode
= ERR_PTR(rc
);
1125 cifs_set_file_info(struct inode
*inode
, struct iattr
*attrs
, unsigned int xid
,
1126 char *full_path
, __u32 dosattr
)
1128 bool set_time
= false;
1129 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1130 struct TCP_Server_Info
*server
;
1131 FILE_BASIC_INFO info_buf
;
1136 server
= cifs_sb_master_tcon(cifs_sb
)->ses
->server
;
1137 if (!server
->ops
->set_file_info
)
1142 if (attrs
->ia_valid
& ATTR_ATIME
) {
1144 info_buf
.LastAccessTime
=
1145 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_atime
));
1147 info_buf
.LastAccessTime
= 0;
1149 if (attrs
->ia_valid
& ATTR_MTIME
) {
1151 info_buf
.LastWriteTime
=
1152 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_mtime
));
1154 info_buf
.LastWriteTime
= 0;
1157 * Samba throws this field away, but windows may actually use it.
1158 * Do not set ctime unless other time stamps are changed explicitly
1159 * (i.e. by utimes()) since we would then have a mix of client and
1162 if (set_time
&& (attrs
->ia_valid
& ATTR_CTIME
)) {
1163 cifs_dbg(FYI
, "CIFS - CTIME changed\n");
1164 info_buf
.ChangeTime
=
1165 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_ctime
));
1167 info_buf
.ChangeTime
= 0;
1169 info_buf
.CreationTime
= 0; /* don't change */
1170 info_buf
.Attributes
= cpu_to_le32(dosattr
);
1172 return server
->ops
->set_file_info(inode
, full_path
, &info_buf
, xid
);
1176 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1177 * and rename it to a random name that hopefully won't conflict with
1181 cifs_rename_pending_delete(const char *full_path
, struct dentry
*dentry
,
1182 const unsigned int xid
)
1186 struct cifs_fid fid
;
1187 struct cifs_open_parms oparms
;
1188 struct inode
*inode
= d_inode(dentry
);
1189 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1190 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1191 struct tcon_link
*tlink
;
1192 struct cifs_tcon
*tcon
;
1193 __u32 dosattr
, origattr
;
1194 FILE_BASIC_INFO
*info_buf
= NULL
;
1196 tlink
= cifs_sb_tlink(cifs_sb
);
1198 return PTR_ERR(tlink
);
1199 tcon
= tlink_tcon(tlink
);
1202 * We cannot rename the file if the server doesn't support
1203 * CAP_INFOLEVEL_PASSTHRU
1205 if (!(tcon
->ses
->capabilities
& CAP_INFOLEVEL_PASSTHRU
)) {
1211 oparms
.cifs_sb
= cifs_sb
;
1212 oparms
.desired_access
= DELETE
| FILE_WRITE_ATTRIBUTES
;
1213 oparms
.create_options
= CREATE_NOT_DIR
;
1214 oparms
.disposition
= FILE_OPEN
;
1215 oparms
.path
= full_path
;
1217 oparms
.reconnect
= false;
1219 rc
= CIFS_open(xid
, &oparms
, &oplock
, NULL
);
1223 origattr
= cifsInode
->cifsAttrs
;
1225 origattr
|= ATTR_NORMAL
;
1227 dosattr
= origattr
& ~ATTR_READONLY
;
1229 dosattr
|= ATTR_NORMAL
;
1230 dosattr
|= ATTR_HIDDEN
;
1232 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1233 if (dosattr
!= origattr
) {
1234 info_buf
= kzalloc(sizeof(*info_buf
), GFP_KERNEL
);
1235 if (info_buf
== NULL
) {
1239 info_buf
->Attributes
= cpu_to_le32(dosattr
);
1240 rc
= CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, fid
.netfid
,
1242 /* although we would like to mark the file hidden
1243 if that fails we will still try to rename it */
1245 cifsInode
->cifsAttrs
= dosattr
;
1247 dosattr
= origattr
; /* since not able to change them */
1250 /* rename the file */
1251 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, fid
.netfid
, NULL
,
1253 cifs_remap(cifs_sb
));
1259 /* try to set DELETE_ON_CLOSE */
1260 if (!test_bit(CIFS_INO_DELETE_PENDING
, &cifsInode
->flags
)) {
1261 rc
= CIFSSMBSetFileDisposition(xid
, tcon
, true, fid
.netfid
,
1264 * some samba versions return -ENOENT when we try to set the
1265 * file disposition here. Likely a samba bug, but work around
1266 * it for now. This means that some cifsXXX files may hang
1267 * around after they shouldn't.
1269 * BB: remove this hack after more servers have the fix
1277 set_bit(CIFS_INO_DELETE_PENDING
, &cifsInode
->flags
);
1281 CIFSSMBClose(xid
, tcon
, fid
.netfid
);
1284 cifs_put_tlink(tlink
);
1288 * reset everything back to the original state. Don't bother
1289 * dealing with errors here since we can't do anything about
1293 CIFSSMBRenameOpenFile(xid
, tcon
, fid
.netfid
, dentry
->d_name
.name
,
1294 cifs_sb
->local_nls
, cifs_remap(cifs_sb
));
1296 if (dosattr
!= origattr
) {
1297 info_buf
->Attributes
= cpu_to_le32(origattr
);
1298 if (!CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, fid
.netfid
,
1300 cifsInode
->cifsAttrs
= origattr
;
1306 /* copied from fs/nfs/dir.c with small changes */
1308 cifs_drop_nlink(struct inode
*inode
)
1310 spin_lock(&inode
->i_lock
);
1311 if (inode
->i_nlink
> 0)
1313 spin_unlock(&inode
->i_lock
);
1317 * If d_inode(dentry) is null (usually meaning the cached dentry
1318 * is a negative dentry) then we would attempt a standard SMB delete, but
1319 * if that fails we can not attempt the fall back mechanisms on EACCES
1320 * but will return the EACCES to the caller. Note that the VFS does not call
1321 * unlink on negative dentries currently.
1323 int cifs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1327 char *full_path
= NULL
;
1328 struct inode
*inode
= d_inode(dentry
);
1329 struct cifsInodeInfo
*cifs_inode
;
1330 struct super_block
*sb
= dir
->i_sb
;
1331 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
1332 struct tcon_link
*tlink
;
1333 struct cifs_tcon
*tcon
;
1334 struct TCP_Server_Info
*server
;
1335 struct iattr
*attrs
= NULL
;
1336 __u32 dosattr
= 0, origattr
= 0;
1338 cifs_dbg(FYI
, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir
, dentry
);
1340 tlink
= cifs_sb_tlink(cifs_sb
);
1342 return PTR_ERR(tlink
);
1343 tcon
= tlink_tcon(tlink
);
1344 server
= tcon
->ses
->server
;
1348 /* Unlink can be called from rename so we can not take the
1349 * sb->s_vfs_rename_mutex here */
1350 full_path
= build_path_from_dentry(dentry
);
1351 if (full_path
== NULL
) {
1356 if (cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1357 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1358 rc
= CIFSPOSIXDelFile(xid
, tcon
, full_path
,
1359 SMB_POSIX_UNLINK_FILE_TARGET
, cifs_sb
->local_nls
,
1360 cifs_remap(cifs_sb
));
1361 cifs_dbg(FYI
, "posix del rc %d\n", rc
);
1362 if ((rc
== 0) || (rc
== -ENOENT
))
1363 goto psx_del_no_retry
;
1367 if (!server
->ops
->unlink
) {
1369 goto psx_del_no_retry
;
1372 rc
= server
->ops
->unlink(xid
, tcon
, full_path
, cifs_sb
);
1377 cifs_drop_nlink(inode
);
1378 } else if (rc
== -ENOENT
) {
1380 } else if (rc
== -EBUSY
) {
1381 if (server
->ops
->rename_pending_delete
) {
1382 rc
= server
->ops
->rename_pending_delete(full_path
,
1385 cifs_drop_nlink(inode
);
1387 } else if ((rc
== -EACCES
) && (dosattr
== 0) && inode
) {
1388 attrs
= kzalloc(sizeof(*attrs
), GFP_KERNEL
);
1389 if (attrs
== NULL
) {
1394 /* try to reset dos attributes */
1395 cifs_inode
= CIFS_I(inode
);
1396 origattr
= cifs_inode
->cifsAttrs
;
1398 origattr
|= ATTR_NORMAL
;
1399 dosattr
= origattr
& ~ATTR_READONLY
;
1401 dosattr
|= ATTR_NORMAL
;
1402 dosattr
|= ATTR_HIDDEN
;
1404 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
1408 goto retry_std_delete
;
1411 /* undo the setattr if we errored out and it's needed */
1412 if (rc
!= 0 && dosattr
!= 0)
1413 cifs_set_file_info(inode
, attrs
, xid
, full_path
, origattr
);
1417 cifs_inode
= CIFS_I(inode
);
1418 cifs_inode
->time
= 0; /* will force revalidate to get info
1420 inode
->i_ctime
= current_time(inode
);
1422 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
1423 cifs_inode
= CIFS_I(dir
);
1424 CIFS_I(dir
)->time
= 0; /* force revalidate of dir as well */
1429 cifs_put_tlink(tlink
);
1434 cifs_mkdir_qinfo(struct inode
*parent
, struct dentry
*dentry
, umode_t mode
,
1435 const char *full_path
, struct cifs_sb_info
*cifs_sb
,
1436 struct cifs_tcon
*tcon
, const unsigned int xid
)
1439 struct inode
*inode
= NULL
;
1442 rc
= cifs_get_inode_info_unix(&inode
, full_path
, parent
->i_sb
,
1445 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, parent
->i_sb
,
1452 * setting nlink not necessary except in cases where we failed to get it
1453 * from the server or was set bogus. Also, since this is a brand new
1454 * inode, no need to grab the i_lock before setting the i_nlink.
1456 if (inode
->i_nlink
< 2)
1457 set_nlink(inode
, 2);
1458 mode
&= ~current_umask();
1459 /* must turn on setgid bit if parent dir has it */
1460 if (parent
->i_mode
& S_ISGID
)
1463 if (tcon
->unix_ext
) {
1464 struct cifs_unix_set_info_args args
= {
1466 .ctime
= NO_CHANGE_64
,
1467 .atime
= NO_CHANGE_64
,
1468 .mtime
= NO_CHANGE_64
,
1471 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1472 args
.uid
= current_fsuid();
1473 if (parent
->i_mode
& S_ISGID
)
1474 args
.gid
= parent
->i_gid
;
1476 args
.gid
= current_fsgid();
1478 args
.uid
= INVALID_UID
; /* no change */
1479 args
.gid
= INVALID_GID
; /* no change */
1481 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
1483 cifs_remap(cifs_sb
));
1485 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1486 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
1487 (mode
& S_IWUGO
) == 0 && server
->ops
->mkdir_setinfo
)
1488 server
->ops
->mkdir_setinfo(inode
, full_path
, cifs_sb
,
1490 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
1491 inode
->i_mode
= (mode
| S_IFDIR
);
1493 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1494 inode
->i_uid
= current_fsuid();
1495 if (inode
->i_mode
& S_ISGID
)
1496 inode
->i_gid
= parent
->i_gid
;
1498 inode
->i_gid
= current_fsgid();
1501 d_instantiate(dentry
, inode
);
1506 cifs_posix_mkdir(struct inode
*inode
, struct dentry
*dentry
, umode_t mode
,
1507 const char *full_path
, struct cifs_sb_info
*cifs_sb
,
1508 struct cifs_tcon
*tcon
, const unsigned int xid
)
1512 FILE_UNIX_BASIC_INFO
*info
= NULL
;
1513 struct inode
*newinode
= NULL
;
1514 struct cifs_fattr fattr
;
1516 info
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
1519 goto posix_mkdir_out
;
1522 mode
&= ~current_umask();
1523 rc
= CIFSPOSIXCreate(xid
, tcon
, SMB_O_DIRECTORY
| SMB_O_CREAT
, mode
,
1524 NULL
/* netfid */, info
, &oplock
, full_path
,
1525 cifs_sb
->local_nls
, cifs_remap(cifs_sb
));
1526 if (rc
== -EOPNOTSUPP
)
1527 goto posix_mkdir_out
;
1529 cifs_dbg(FYI
, "posix mkdir returned 0x%x\n", rc
);
1531 goto posix_mkdir_out
;
1534 if (info
->Type
== cpu_to_le32(-1))
1535 /* no return info, go query for it */
1536 goto posix_mkdir_get_info
;
1538 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1539 * need to set uid/gid.
1542 cifs_unix_basic_to_fattr(&fattr
, info
, cifs_sb
);
1543 cifs_fill_uniqueid(inode
->i_sb
, &fattr
);
1544 newinode
= cifs_iget(inode
->i_sb
, &fattr
);
1546 goto posix_mkdir_get_info
;
1548 d_instantiate(dentry
, newinode
);
1550 #ifdef CONFIG_CIFS_DEBUG2
1551 cifs_dbg(FYI
, "instantiated dentry %p %pd to inode %p\n",
1552 dentry
, dentry
, newinode
);
1554 if (newinode
->i_nlink
!= 2)
1555 cifs_dbg(FYI
, "unexpected number of links %d\n",
1562 posix_mkdir_get_info
:
1563 rc
= cifs_mkdir_qinfo(inode
, dentry
, mode
, full_path
, cifs_sb
, tcon
,
1565 goto posix_mkdir_out
;
1568 int cifs_mkdir(struct inode
*inode
, struct dentry
*direntry
, umode_t mode
)
1572 struct cifs_sb_info
*cifs_sb
;
1573 struct tcon_link
*tlink
;
1574 struct cifs_tcon
*tcon
;
1575 struct TCP_Server_Info
*server
;
1578 cifs_dbg(FYI
, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1581 cifs_sb
= CIFS_SB(inode
->i_sb
);
1582 tlink
= cifs_sb_tlink(cifs_sb
);
1584 return PTR_ERR(tlink
);
1585 tcon
= tlink_tcon(tlink
);
1589 full_path
= build_path_from_dentry(direntry
);
1590 if (full_path
== NULL
) {
1595 server
= tcon
->ses
->server
;
1597 if ((server
->ops
->posix_mkdir
) && (tcon
->posix_extensions
)) {
1598 rc
= server
->ops
->posix_mkdir(xid
, inode
, mode
, tcon
, full_path
,
1600 d_drop(direntry
); /* for time being always refresh inode info */
1604 if (cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1605 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1606 rc
= cifs_posix_mkdir(inode
, direntry
, mode
, full_path
, cifs_sb
,
1608 if (rc
!= -EOPNOTSUPP
)
1612 if (!server
->ops
->mkdir
) {
1617 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1618 rc
= server
->ops
->mkdir(xid
, tcon
, full_path
, cifs_sb
);
1620 cifs_dbg(FYI
, "cifs_mkdir returned 0x%x\n", rc
);
1625 rc
= cifs_mkdir_qinfo(inode
, direntry
, mode
, full_path
, cifs_sb
, tcon
,
1629 * Force revalidate to get parent dir info when needed since cached
1630 * attributes are invalid now.
1632 CIFS_I(inode
)->time
= 0;
1635 cifs_put_tlink(tlink
);
1639 int cifs_rmdir(struct inode
*inode
, struct dentry
*direntry
)
1643 struct cifs_sb_info
*cifs_sb
;
1644 struct tcon_link
*tlink
;
1645 struct cifs_tcon
*tcon
;
1646 struct TCP_Server_Info
*server
;
1647 char *full_path
= NULL
;
1648 struct cifsInodeInfo
*cifsInode
;
1650 cifs_dbg(FYI
, "cifs_rmdir, inode = 0x%p\n", inode
);
1654 full_path
= build_path_from_dentry(direntry
);
1655 if (full_path
== NULL
) {
1660 cifs_sb
= CIFS_SB(inode
->i_sb
);
1661 tlink
= cifs_sb_tlink(cifs_sb
);
1662 if (IS_ERR(tlink
)) {
1663 rc
= PTR_ERR(tlink
);
1666 tcon
= tlink_tcon(tlink
);
1667 server
= tcon
->ses
->server
;
1669 if (!server
->ops
->rmdir
) {
1671 cifs_put_tlink(tlink
);
1675 rc
= server
->ops
->rmdir(xid
, tcon
, full_path
, cifs_sb
);
1676 cifs_put_tlink(tlink
);
1679 spin_lock(&d_inode(direntry
)->i_lock
);
1680 i_size_write(d_inode(direntry
), 0);
1681 clear_nlink(d_inode(direntry
));
1682 spin_unlock(&d_inode(direntry
)->i_lock
);
1685 cifsInode
= CIFS_I(d_inode(direntry
));
1686 /* force revalidate to go get info when needed */
1687 cifsInode
->time
= 0;
1689 cifsInode
= CIFS_I(inode
);
1691 * Force revalidate to get parent dir info when needed since cached
1692 * attributes are invalid now.
1694 cifsInode
->time
= 0;
1696 d_inode(direntry
)->i_ctime
= inode
->i_ctime
= inode
->i_mtime
=
1697 current_time(inode
);
1706 cifs_do_rename(const unsigned int xid
, struct dentry
*from_dentry
,
1707 const char *from_path
, struct dentry
*to_dentry
,
1708 const char *to_path
)
1710 struct cifs_sb_info
*cifs_sb
= CIFS_SB(from_dentry
->d_sb
);
1711 struct tcon_link
*tlink
;
1712 struct cifs_tcon
*tcon
;
1713 struct TCP_Server_Info
*server
;
1714 struct cifs_fid fid
;
1715 struct cifs_open_parms oparms
;
1718 tlink
= cifs_sb_tlink(cifs_sb
);
1720 return PTR_ERR(tlink
);
1721 tcon
= tlink_tcon(tlink
);
1722 server
= tcon
->ses
->server
;
1724 if (!server
->ops
->rename
)
1727 /* try path-based rename first */
1728 rc
= server
->ops
->rename(xid
, tcon
, from_path
, to_path
, cifs_sb
);
1731 * Don't bother with rename by filehandle unless file is busy and
1732 * source. Note that cross directory moves do not work with
1733 * rename by filehandle to various Windows servers.
1735 if (rc
== 0 || rc
!= -EBUSY
)
1736 goto do_rename_exit
;
1738 /* open-file renames don't work across directories */
1739 if (to_dentry
->d_parent
!= from_dentry
->d_parent
)
1740 goto do_rename_exit
;
1743 oparms
.cifs_sb
= cifs_sb
;
1744 /* open the file to be renamed -- we need DELETE perms */
1745 oparms
.desired_access
= DELETE
;
1746 oparms
.create_options
= CREATE_NOT_DIR
;
1747 oparms
.disposition
= FILE_OPEN
;
1748 oparms
.path
= from_path
;
1750 oparms
.reconnect
= false;
1752 rc
= CIFS_open(xid
, &oparms
, &oplock
, NULL
);
1754 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, fid
.netfid
,
1755 (const char *) to_dentry
->d_name
.name
,
1756 cifs_sb
->local_nls
, cifs_remap(cifs_sb
));
1757 CIFSSMBClose(xid
, tcon
, fid
.netfid
);
1760 cifs_put_tlink(tlink
);
1765 cifs_rename2(struct inode
*source_dir
, struct dentry
*source_dentry
,
1766 struct inode
*target_dir
, struct dentry
*target_dentry
,
1769 char *from_name
= NULL
;
1770 char *to_name
= NULL
;
1771 struct cifs_sb_info
*cifs_sb
;
1772 struct tcon_link
*tlink
;
1773 struct cifs_tcon
*tcon
;
1774 FILE_UNIX_BASIC_INFO
*info_buf_source
= NULL
;
1775 FILE_UNIX_BASIC_INFO
*info_buf_target
;
1779 if (flags
& ~RENAME_NOREPLACE
)
1782 cifs_sb
= CIFS_SB(source_dir
->i_sb
);
1783 tlink
= cifs_sb_tlink(cifs_sb
);
1785 return PTR_ERR(tlink
);
1786 tcon
= tlink_tcon(tlink
);
1791 * we already have the rename sem so we do not need to
1792 * grab it again here to protect the path integrity
1794 from_name
= build_path_from_dentry(source_dentry
);
1795 if (from_name
== NULL
) {
1797 goto cifs_rename_exit
;
1800 to_name
= build_path_from_dentry(target_dentry
);
1801 if (to_name
== NULL
) {
1803 goto cifs_rename_exit
;
1806 rc
= cifs_do_rename(xid
, source_dentry
, from_name
, target_dentry
,
1810 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1812 if (flags
& RENAME_NOREPLACE
)
1813 goto cifs_rename_exit
;
1815 if (rc
== -EEXIST
&& tcon
->unix_ext
) {
1817 * Are src and dst hardlinks of same inode? We can only tell
1818 * with unix extensions enabled.
1821 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO
),
1823 if (info_buf_source
== NULL
) {
1825 goto cifs_rename_exit
;
1828 info_buf_target
= info_buf_source
+ 1;
1829 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, from_name
,
1832 cifs_remap(cifs_sb
));
1836 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, to_name
,
1839 cifs_remap(cifs_sb
));
1841 if (tmprc
== 0 && (info_buf_source
->UniqueId
==
1842 info_buf_target
->UniqueId
)) {
1843 /* same file, POSIX says that this is a noop */
1845 goto cifs_rename_exit
;
1849 * else ... BB we could add the same check for Windows by
1850 * checking the UniqueId via FILE_INTERNAL_INFO
1854 /* Try unlinking the target dentry if it's not negative */
1855 if (d_really_is_positive(target_dentry
) && (rc
== -EACCES
|| rc
== -EEXIST
)) {
1856 if (d_is_dir(target_dentry
))
1857 tmprc
= cifs_rmdir(target_dir
, target_dentry
);
1859 tmprc
= cifs_unlink(target_dir
, target_dentry
);
1861 goto cifs_rename_exit
;
1862 rc
= cifs_do_rename(xid
, source_dentry
, from_name
,
1863 target_dentry
, to_name
);
1866 /* force revalidate to go get info when needed */
1867 CIFS_I(source_dir
)->time
= CIFS_I(target_dir
)->time
= 0;
1869 source_dir
->i_ctime
= source_dir
->i_mtime
= target_dir
->i_ctime
=
1870 target_dir
->i_mtime
= current_time(source_dir
);
1873 kfree(info_buf_source
);
1877 cifs_put_tlink(tlink
);
1882 cifs_inode_needs_reval(struct inode
*inode
)
1884 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
1885 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1887 if (cifs_i
->time
== 0)
1890 if (CIFS_CACHE_READ(cifs_i
))
1893 if (!lookupCacheEnabled
)
1896 if (!cifs_sb
->actimeo
)
1899 if (!time_in_range(jiffies
, cifs_i
->time
,
1900 cifs_i
->time
+ cifs_sb
->actimeo
))
1903 /* hardlinked files w/ noserverino get "special" treatment */
1904 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) &&
1905 S_ISREG(inode
->i_mode
) && inode
->i_nlink
!= 1)
1912 * Zap the cache. Called when invalid_mapping flag is set.
1915 cifs_invalidate_mapping(struct inode
*inode
)
1919 if (inode
->i_mapping
&& inode
->i_mapping
->nrpages
!= 0) {
1920 rc
= invalidate_inode_pages2(inode
->i_mapping
);
1922 cifs_dbg(VFS
, "%s: could not invalidate inode %p\n",
1926 cifs_fscache_reset_inode_cookie(inode
);
1931 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1932 * @word: long word containing the bit lock
1935 cifs_wait_bit_killable(struct wait_bit_key
*key
, int mode
)
1937 freezable_schedule_unsafe();
1938 if (signal_pending_state(mode
, current
))
1939 return -ERESTARTSYS
;
1944 cifs_revalidate_mapping(struct inode
*inode
)
1947 unsigned long *flags
= &CIFS_I(inode
)->flags
;
1949 rc
= wait_on_bit_lock_action(flags
, CIFS_INO_LOCK
, cifs_wait_bit_killable
,
1954 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING
, flags
)) {
1955 rc
= cifs_invalidate_mapping(inode
);
1957 set_bit(CIFS_INO_INVALID_MAPPING
, flags
);
1960 clear_bit_unlock(CIFS_INO_LOCK
, flags
);
1961 smp_mb__after_atomic();
1962 wake_up_bit(flags
, CIFS_INO_LOCK
);
1968 cifs_zap_mapping(struct inode
*inode
)
1970 set_bit(CIFS_INO_INVALID_MAPPING
, &CIFS_I(inode
)->flags
);
1971 return cifs_revalidate_mapping(inode
);
1974 int cifs_revalidate_file_attr(struct file
*filp
)
1977 struct inode
*inode
= file_inode(filp
);
1978 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*) filp
->private_data
;
1980 if (!cifs_inode_needs_reval(inode
))
1983 if (tlink_tcon(cfile
->tlink
)->unix_ext
)
1984 rc
= cifs_get_file_info_unix(filp
);
1986 rc
= cifs_get_file_info(filp
);
1991 int cifs_revalidate_dentry_attr(struct dentry
*dentry
)
1995 struct inode
*inode
= d_inode(dentry
);
1996 struct super_block
*sb
= dentry
->d_sb
;
1997 char *full_path
= NULL
;
2002 if (!cifs_inode_needs_reval(inode
))
2007 /* can not safely grab the rename sem here if rename calls revalidate
2008 since that would deadlock */
2009 full_path
= build_path_from_dentry(dentry
);
2010 if (full_path
== NULL
) {
2015 cifs_dbg(FYI
, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2016 full_path
, inode
, inode
->i_count
.counter
,
2017 dentry
, cifs_get_time(dentry
), jiffies
);
2019 if (cifs_sb_master_tcon(CIFS_SB(sb
))->unix_ext
)
2020 rc
= cifs_get_inode_info_unix(&inode
, full_path
, sb
, xid
);
2022 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, sb
,
2031 int cifs_revalidate_file(struct file
*filp
)
2034 struct inode
*inode
= file_inode(filp
);
2036 rc
= cifs_revalidate_file_attr(filp
);
2040 return cifs_revalidate_mapping(inode
);
2043 /* revalidate a dentry's inode attributes */
2044 int cifs_revalidate_dentry(struct dentry
*dentry
)
2047 struct inode
*inode
= d_inode(dentry
);
2049 rc
= cifs_revalidate_dentry_attr(dentry
);
2053 return cifs_revalidate_mapping(inode
);
2056 int cifs_getattr(const struct path
*path
, struct kstat
*stat
,
2057 u32 request_mask
, unsigned int flags
)
2059 struct dentry
*dentry
= path
->dentry
;
2060 struct cifs_sb_info
*cifs_sb
= CIFS_SB(dentry
->d_sb
);
2061 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
2062 struct inode
*inode
= d_inode(dentry
);
2066 * We need to be sure that all dirty pages are written and the server
2067 * has actual ctime, mtime and file length.
2069 if (!CIFS_CACHE_READ(CIFS_I(inode
)) && inode
->i_mapping
&&
2070 inode
->i_mapping
->nrpages
!= 0) {
2071 rc
= filemap_fdatawait(inode
->i_mapping
);
2073 mapping_set_error(inode
->i_mapping
, rc
);
2078 rc
= cifs_revalidate_dentry_attr(dentry
);
2082 generic_fillattr(inode
, stat
);
2083 stat
->blksize
= cifs_sb
->bsize
;
2084 stat
->ino
= CIFS_I(inode
)->uniqueid
;
2086 /* old CIFS Unix Extensions doesn't return create time */
2087 if (CIFS_I(inode
)->createtime
) {
2088 stat
->result_mask
|= STATX_BTIME
;
2090 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode
)->createtime
));
2093 stat
->attributes_mask
|= (STATX_ATTR_COMPRESSED
| STATX_ATTR_ENCRYPTED
);
2094 if (CIFS_I(inode
)->cifsAttrs
& FILE_ATTRIBUTE_COMPRESSED
)
2095 stat
->attributes
|= STATX_ATTR_COMPRESSED
;
2096 if (CIFS_I(inode
)->cifsAttrs
& FILE_ATTRIBUTE_ENCRYPTED
)
2097 stat
->attributes
|= STATX_ATTR_ENCRYPTED
;
2100 * If on a multiuser mount without unix extensions or cifsacl being
2101 * enabled, and the admin hasn't overridden them, set the ownership
2102 * to the fsuid/fsgid of the current process.
2104 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
) &&
2105 !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
2107 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
))
2108 stat
->uid
= current_fsuid();
2109 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
))
2110 stat
->gid
= current_fsgid();
2115 static int cifs_truncate_page(struct address_space
*mapping
, loff_t from
)
2117 pgoff_t index
= from
>> PAGE_SHIFT
;
2118 unsigned offset
= from
& (PAGE_SIZE
- 1);
2122 page
= grab_cache_page(mapping
, index
);
2126 zero_user_segment(page
, offset
, PAGE_SIZE
);
2132 static void cifs_setsize(struct inode
*inode
, loff_t offset
)
2134 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
2136 spin_lock(&inode
->i_lock
);
2137 i_size_write(inode
, offset
);
2138 spin_unlock(&inode
->i_lock
);
2140 /* Cached inode must be refreshed on truncate */
2142 truncate_pagecache(inode
, offset
);
2146 cifs_set_file_size(struct inode
*inode
, struct iattr
*attrs
,
2147 unsigned int xid
, char *full_path
)
2150 struct cifsFileInfo
*open_file
;
2151 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2152 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2153 struct tcon_link
*tlink
= NULL
;
2154 struct cifs_tcon
*tcon
= NULL
;
2155 struct TCP_Server_Info
*server
;
2158 * To avoid spurious oplock breaks from server, in the case of
2159 * inodes that we already have open, avoid doing path based
2160 * setting of file size if we can do it by handle.
2161 * This keeps our caching token (oplock) and avoids timeouts
2162 * when the local oplock break takes longer to flush
2163 * writebehind data than the SMB timeout for the SetPathInfo
2164 * request would allow
2166 open_file
= find_writable_file(cifsInode
, true);
2168 tcon
= tlink_tcon(open_file
->tlink
);
2169 server
= tcon
->ses
->server
;
2170 if (server
->ops
->set_file_size
)
2171 rc
= server
->ops
->set_file_size(xid
, tcon
, open_file
,
2172 attrs
->ia_size
, false);
2175 cifsFileInfo_put(open_file
);
2176 cifs_dbg(FYI
, "SetFSize for attrs rc = %d\n", rc
);
2184 tlink
= cifs_sb_tlink(cifs_sb
);
2186 return PTR_ERR(tlink
);
2187 tcon
= tlink_tcon(tlink
);
2188 server
= tcon
->ses
->server
;
2192 * Set file size by pathname rather than by handle either because no
2193 * valid, writeable file handle for it was found or because there was
2194 * an error setting it by handle.
2196 if (server
->ops
->set_path_size
)
2197 rc
= server
->ops
->set_path_size(xid
, tcon
, full_path
,
2198 attrs
->ia_size
, cifs_sb
, false);
2201 cifs_dbg(FYI
, "SetEOF by path (setattrs) rc = %d\n", rc
);
2204 cifs_put_tlink(tlink
);
2208 cifsInode
->server_eof
= attrs
->ia_size
;
2209 cifs_setsize(inode
, attrs
->ia_size
);
2210 cifs_truncate_page(inode
->i_mapping
, inode
->i_size
);
2217 cifs_setattr_unix(struct dentry
*direntry
, struct iattr
*attrs
)
2221 char *full_path
= NULL
;
2222 struct inode
*inode
= d_inode(direntry
);
2223 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2224 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2225 struct tcon_link
*tlink
;
2226 struct cifs_tcon
*pTcon
;
2227 struct cifs_unix_set_info_args
*args
= NULL
;
2228 struct cifsFileInfo
*open_file
;
2230 cifs_dbg(FYI
, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2231 direntry
, attrs
->ia_valid
);
2235 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
2236 attrs
->ia_valid
|= ATTR_FORCE
;
2238 rc
= setattr_prepare(direntry
, attrs
);
2242 full_path
= build_path_from_dentry(direntry
);
2243 if (full_path
== NULL
) {
2249 * Attempt to flush data before changing attributes. We need to do
2250 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2251 * ownership or mode then we may also need to do this. Here, we take
2252 * the safe way out and just do the flush on all setattr requests. If
2253 * the flush returns error, store it to report later and continue.
2255 * BB: This should be smarter. Why bother flushing pages that
2256 * will be truncated anyway? Also, should we error out here if
2257 * the flush returns error?
2259 rc
= filemap_write_and_wait(inode
->i_mapping
);
2260 if (is_interrupt_error(rc
)) {
2265 mapping_set_error(inode
->i_mapping
, rc
);
2268 if (attrs
->ia_valid
& ATTR_SIZE
) {
2269 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
2274 /* skip mode change if it's just for clearing setuid/setgid */
2275 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
2276 attrs
->ia_valid
&= ~ATTR_MODE
;
2278 args
= kmalloc(sizeof(*args
), GFP_KERNEL
);
2284 /* set up the struct */
2285 if (attrs
->ia_valid
& ATTR_MODE
)
2286 args
->mode
= attrs
->ia_mode
;
2288 args
->mode
= NO_CHANGE_64
;
2290 if (attrs
->ia_valid
& ATTR_UID
)
2291 args
->uid
= attrs
->ia_uid
;
2293 args
->uid
= INVALID_UID
; /* no change */
2295 if (attrs
->ia_valid
& ATTR_GID
)
2296 args
->gid
= attrs
->ia_gid
;
2298 args
->gid
= INVALID_GID
; /* no change */
2300 if (attrs
->ia_valid
& ATTR_ATIME
)
2301 args
->atime
= cifs_UnixTimeToNT(attrs
->ia_atime
);
2303 args
->atime
= NO_CHANGE_64
;
2305 if (attrs
->ia_valid
& ATTR_MTIME
)
2306 args
->mtime
= cifs_UnixTimeToNT(attrs
->ia_mtime
);
2308 args
->mtime
= NO_CHANGE_64
;
2310 if (attrs
->ia_valid
& ATTR_CTIME
)
2311 args
->ctime
= cifs_UnixTimeToNT(attrs
->ia_ctime
);
2313 args
->ctime
= NO_CHANGE_64
;
2316 open_file
= find_writable_file(cifsInode
, true);
2318 u16 nfid
= open_file
->fid
.netfid
;
2319 u32 npid
= open_file
->pid
;
2320 pTcon
= tlink_tcon(open_file
->tlink
);
2321 rc
= CIFSSMBUnixSetFileInfo(xid
, pTcon
, args
, nfid
, npid
);
2322 cifsFileInfo_put(open_file
);
2324 tlink
= cifs_sb_tlink(cifs_sb
);
2325 if (IS_ERR(tlink
)) {
2326 rc
= PTR_ERR(tlink
);
2329 pTcon
= tlink_tcon(tlink
);
2330 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, args
,
2332 cifs_remap(cifs_sb
));
2333 cifs_put_tlink(tlink
);
2339 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
2340 attrs
->ia_size
!= i_size_read(inode
))
2341 truncate_setsize(inode
, attrs
->ia_size
);
2343 setattr_copy(inode
, attrs
);
2344 mark_inode_dirty(inode
);
2346 /* force revalidate when any of these times are set since some
2347 of the fs types (eg ext3, fat) do not have fine enough
2348 time granularity to match protocol, and we do not have a
2349 a way (yet) to query the server fs's time granularity (and
2350 whether it rounds times down).
2352 if (attrs
->ia_valid
& (ATTR_MTIME
| ATTR_CTIME
))
2353 cifsInode
->time
= 0;
2362 cifs_setattr_nounix(struct dentry
*direntry
, struct iattr
*attrs
)
2365 kuid_t uid
= INVALID_UID
;
2366 kgid_t gid
= INVALID_GID
;
2367 struct inode
*inode
= d_inode(direntry
);
2368 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2369 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2370 char *full_path
= NULL
;
2373 __u64 mode
= NO_CHANGE_64
;
2377 cifs_dbg(FYI
, "setattr on file %pd attrs->iavalid 0x%x\n",
2378 direntry
, attrs
->ia_valid
);
2380 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
2381 attrs
->ia_valid
|= ATTR_FORCE
;
2383 rc
= setattr_prepare(direntry
, attrs
);
2389 full_path
= build_path_from_dentry(direntry
);
2390 if (full_path
== NULL
) {
2397 * Attempt to flush data before changing attributes. We need to do
2398 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2399 * ownership or mode then we may also need to do this. Here, we take
2400 * the safe way out and just do the flush on all setattr requests. If
2401 * the flush returns error, store it to report later and continue.
2403 * BB: This should be smarter. Why bother flushing pages that
2404 * will be truncated anyway? Also, should we error out here if
2405 * the flush returns error?
2407 rc
= filemap_write_and_wait(inode
->i_mapping
);
2408 if (is_interrupt_error(rc
)) {
2410 goto cifs_setattr_exit
;
2413 mapping_set_error(inode
->i_mapping
, rc
);
2416 if (attrs
->ia_valid
& ATTR_SIZE
) {
2417 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
2419 goto cifs_setattr_exit
;
2422 if (attrs
->ia_valid
& ATTR_UID
)
2423 uid
= attrs
->ia_uid
;
2425 if (attrs
->ia_valid
& ATTR_GID
)
2426 gid
= attrs
->ia_gid
;
2428 #ifdef CONFIG_CIFS_ACL
2429 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
2430 if (uid_valid(uid
) || gid_valid(gid
)) {
2431 rc
= id_mode_to_cifs_acl(inode
, full_path
, NO_CHANGE_64
,
2434 cifs_dbg(FYI
, "%s: Setting id failed with error: %d\n",
2436 goto cifs_setattr_exit
;
2440 #endif /* CONFIG_CIFS_ACL */
2441 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
))
2442 attrs
->ia_valid
&= ~(ATTR_UID
| ATTR_GID
);
2444 /* skip mode change if it's just for clearing setuid/setgid */
2445 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
2446 attrs
->ia_valid
&= ~ATTR_MODE
;
2448 if (attrs
->ia_valid
& ATTR_MODE
) {
2449 mode
= attrs
->ia_mode
;
2451 #ifdef CONFIG_CIFS_ACL
2452 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
2453 rc
= id_mode_to_cifs_acl(inode
, full_path
, mode
,
2454 INVALID_UID
, INVALID_GID
);
2456 cifs_dbg(FYI
, "%s: Setting ACL failed with error: %d\n",
2458 goto cifs_setattr_exit
;
2461 #endif /* CONFIG_CIFS_ACL */
2462 if (((mode
& S_IWUGO
) == 0) &&
2463 (cifsInode
->cifsAttrs
& ATTR_READONLY
) == 0) {
2465 dosattr
= cifsInode
->cifsAttrs
| ATTR_READONLY
;
2467 /* fix up mode if we're not using dynperm */
2468 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
) == 0)
2469 attrs
->ia_mode
= inode
->i_mode
& ~S_IWUGO
;
2470 } else if ((mode
& S_IWUGO
) &&
2471 (cifsInode
->cifsAttrs
& ATTR_READONLY
)) {
2473 dosattr
= cifsInode
->cifsAttrs
& ~ATTR_READONLY
;
2474 /* Attributes of 0 are ignored */
2476 dosattr
|= ATTR_NORMAL
;
2478 /* reset local inode permissions to normal */
2479 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2480 attrs
->ia_mode
&= ~(S_IALLUGO
);
2481 if (S_ISDIR(inode
->i_mode
))
2483 cifs_sb
->mnt_dir_mode
;
2486 cifs_sb
->mnt_file_mode
;
2488 } else if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2489 /* ignore mode change - ATTR_READONLY hasn't changed */
2490 attrs
->ia_valid
&= ~ATTR_MODE
;
2494 if (attrs
->ia_valid
& (ATTR_MTIME
|ATTR_ATIME
|ATTR_CTIME
) ||
2495 ((attrs
->ia_valid
& ATTR_MODE
) && dosattr
)) {
2496 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
2497 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2499 /* Even if error on time set, no sense failing the call if
2500 the server would set the time to a reasonable value anyway,
2501 and this check ensures that we are not being called from
2502 sys_utimes in which case we ought to fail the call back to
2503 the user when the server rejects the call */
2504 if ((rc
) && (attrs
->ia_valid
&
2505 (ATTR_MODE
| ATTR_GID
| ATTR_UID
| ATTR_SIZE
)))
2509 /* do not need local check to inode_check_ok since the server does
2512 goto cifs_setattr_exit
;
2514 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
2515 attrs
->ia_size
!= i_size_read(inode
))
2516 truncate_setsize(inode
, attrs
->ia_size
);
2518 setattr_copy(inode
, attrs
);
2519 mark_inode_dirty(inode
);
2528 cifs_setattr(struct dentry
*direntry
, struct iattr
*attrs
)
2530 struct cifs_sb_info
*cifs_sb
= CIFS_SB(direntry
->d_sb
);
2531 struct cifs_tcon
*pTcon
= cifs_sb_master_tcon(cifs_sb
);
2533 if (pTcon
->unix_ext
)
2534 return cifs_setattr_unix(direntry
, attrs
);
2536 return cifs_setattr_nounix(direntry
, attrs
);
2538 /* BB: add cifs_setattr_legacy for really old servers */
2542 void cifs_delete_inode(struct inode
*inode
)
2544 cifs_dbg(FYI
, "In cifs_delete_inode, inode = 0x%p\n", inode
);
2545 /* may have to add back in if and when safe distributed caching of
2546 directories added e.g. via FindNotify */