1 // SPDX-License-Identifier: LGPL-2.1
5 * vfs operations that deal with dentries
7 * Copyright (C) International Business Machines Corp., 2002,2009
8 * Author(s): Steve French (sfrench@us.ibm.com)
12 #include <linux/stat.h>
13 #include <linux/slab.h>
14 #include <linux/namei.h>
15 #include <linux/mount.h>
16 #include <linux/file.h>
20 #include "cifsproto.h"
21 #include "cifs_debug.h"
22 #include "cifs_fs_sb.h"
23 #include "cifs_unicode.h"
24 #include "fs_context.h"
25 #include "cifs_ioctl.h"
28 renew_parental_timestamps(struct dentry
*direntry
)
30 /* BB check if there is a way to get the kernel to do this or if we
33 cifs_set_time(direntry
, jiffies
);
34 direntry
= direntry
->d_parent
;
35 } while (!IS_ROOT(direntry
));
39 cifs_build_path_to_root(struct smb3_fs_context
*ctx
, struct cifs_sb_info
*cifs_sb
,
40 struct cifs_tcon
*tcon
, int add_treename
)
42 int pplen
= ctx
->prepath
? strlen(ctx
->prepath
) + 1 : 0;
44 char *full_path
= NULL
;
46 /* if no prefix path, simply set path to the root of share to "" */
48 full_path
= kzalloc(1, GFP_KERNEL
);
53 dfsplen
= strnlen(tcon
->treeName
, MAX_TREE_SIZE
+ 1);
57 full_path
= kmalloc(dfsplen
+ pplen
+ 1, GFP_KERNEL
);
58 if (full_path
== NULL
)
62 memcpy(full_path
, tcon
->treeName
, dfsplen
);
63 full_path
[dfsplen
] = CIFS_DIR_SEP(cifs_sb
);
64 memcpy(full_path
+ dfsplen
+ 1, ctx
->prepath
, pplen
);
65 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
69 /* Note: caller must free return buffer */
71 build_path_from_dentry(struct dentry
*direntry
, void *page
)
73 struct cifs_sb_info
*cifs_sb
= CIFS_SB(direntry
->d_sb
);
74 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
75 bool prefix
= tcon
->Flags
& SMB_SHARE_IS_IN_DFS
;
77 return build_path_from_dentry_optional_prefix(direntry
, page
,
82 build_path_from_dentry_optional_prefix(struct dentry
*direntry
, void *page
,
87 struct cifs_sb_info
*cifs_sb
= CIFS_SB(direntry
->d_sb
);
88 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
89 char dirsep
= CIFS_DIR_SEP(cifs_sb
);
93 return ERR_PTR(-ENOMEM
);
96 dfsplen
= strnlen(tcon
->treeName
, MAX_TREE_SIZE
+ 1);
100 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
)
101 pplen
= cifs_sb
->prepath
? strlen(cifs_sb
->prepath
) + 1 : 0;
103 s
= dentry_path_raw(direntry
, page
, PATH_MAX
);
106 if (!s
[1]) // for root we want "", not "/"
108 if (s
< (char *)page
+ pplen
+ dfsplen
)
109 return ERR_PTR(-ENAMETOOLONG
);
111 cifs_dbg(FYI
, "using cifs_sb prepath <%s>\n", cifs_sb
->prepath
);
113 memcpy(s
+ 1, cifs_sb
->prepath
, pplen
- 1);
117 /* BB test paths to Windows with '/' in the midst of prepath */
126 memcpy(s
, tcon
->treeName
, dfsplen
);
127 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
) {
129 for (i
= 0; i
< dfsplen
; i
++) {
139 * Don't allow path components longer than the server max.
140 * Don't allow the separator character in a path component.
141 * The VFS will not allow "/", but "\" is allowed by posix.
144 check_name(struct dentry
*direntry
, struct cifs_tcon
*tcon
)
146 struct cifs_sb_info
*cifs_sb
= CIFS_SB(direntry
->d_sb
);
149 if (unlikely(tcon
->fsAttrInfo
.MaxPathNameComponentLength
&&
150 direntry
->d_name
.len
>
151 le32_to_cpu(tcon
->fsAttrInfo
.MaxPathNameComponentLength
)))
152 return -ENAMETOOLONG
;
154 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
)) {
155 for (i
= 0; i
< direntry
->d_name
.len
; i
++) {
156 if (direntry
->d_name
.name
[i
] == '\\') {
157 cifs_dbg(FYI
, "Invalid file name\n");
166 /* Inode operations in similar order to how they appear in Linux file fs.h */
169 cifs_do_create(struct inode
*inode
, struct dentry
*direntry
, unsigned int xid
,
170 struct tcon_link
*tlink
, unsigned oflags
, umode_t mode
,
171 __u32
*oplock
, struct cifs_fid
*fid
)
174 int create_options
= CREATE_NOT_DIR
;
176 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
177 struct cifs_tcon
*tcon
= tlink_tcon(tlink
);
178 const char *full_path
;
179 void *page
= alloc_dentry_path();
180 FILE_ALL_INFO
*buf
= NULL
;
181 struct inode
*newinode
= NULL
;
183 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
184 struct cifs_open_parms oparms
;
187 if (tcon
->ses
->server
->oplocks
)
188 *oplock
= REQ_OPLOCK
;
190 full_path
= build_path_from_dentry(direntry
, page
);
191 if (IS_ERR(full_path
)) {
192 free_dentry_path(page
);
193 return PTR_ERR(full_path
);
196 if (tcon
->unix_ext
&& cap_unix(tcon
->ses
) && !tcon
->broken_posix_open
&&
197 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
198 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
199 rc
= cifs_posix_open(full_path
, &newinode
, inode
->i_sb
, mode
,
200 oflags
, oplock
, &fid
->netfid
, xid
);
203 if (newinode
== NULL
) {
204 /* query inode info */
205 goto cifs_create_get_file_info
;
208 if (S_ISDIR(newinode
->i_mode
)) {
209 CIFSSMBClose(xid
, tcon
, fid
->netfid
);
215 if (!S_ISREG(newinode
->i_mode
)) {
217 * The server may allow us to open things like
218 * FIFOs, but the client isn't set up to deal
219 * with that. If it's not a regular file, just
220 * close it and proceed as if it were a normal
223 CIFSSMBClose(xid
, tcon
, fid
->netfid
);
224 goto cifs_create_get_file_info
;
226 /* success, no need to query */
227 goto cifs_create_set_dentry
;
230 goto cifs_create_get_file_info
;
235 * EIO could indicate that (posix open) operation is not
236 * supported, despite what server claimed in capability
239 * POSIX open in samba versions 3.3.1 and earlier could
240 * incorrectly fail with invalid parameter.
242 tcon
->broken_posix_open
= true;
248 * EREMOTE indicates DFS junction, which is not handled
249 * in posix open. If either that or op not supported
250 * returned, follow the normal lookup.
258 * fallthrough to retry, using older open call, this is case
259 * where server does not support this SMB level, and falsely
260 * claims capability (also get here for DFS case which should be
261 * rare for path not covered on files)
266 if (OPEN_FMODE(oflags
) & FMODE_READ
)
267 desired_access
|= GENERIC_READ
; /* is this too little? */
268 if (OPEN_FMODE(oflags
) & FMODE_WRITE
)
269 desired_access
|= GENERIC_WRITE
;
271 disposition
= FILE_OVERWRITE_IF
;
272 if ((oflags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
273 disposition
= FILE_CREATE
;
274 else if ((oflags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
275 disposition
= FILE_OVERWRITE_IF
;
276 else if ((oflags
& O_CREAT
) == O_CREAT
)
277 disposition
= FILE_OPEN_IF
;
279 cifs_dbg(FYI
, "Create flag not set in create function\n");
282 * BB add processing to set equivalent of mode - e.g. via CreateX with
286 if (!server
->ops
->open
) {
291 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
298 * if we're not using unix extensions, see if we need to set
299 * ATTR_READONLY on the create call
301 if (!tcon
->unix_ext
&& (mode
& S_IWUGO
) == 0)
302 create_options
|= CREATE_OPTION_READONLY
;
305 oparms
.cifs_sb
= cifs_sb
;
306 oparms
.desired_access
= desired_access
;
307 oparms
.create_options
= cifs_create_options(cifs_sb
, create_options
);
308 oparms
.disposition
= disposition
;
309 oparms
.path
= full_path
;
311 oparms
.reconnect
= false;
313 rc
= server
->ops
->open(xid
, &oparms
, oplock
, buf
);
315 cifs_dbg(FYI
, "cifs_create returned 0x%x\n", rc
);
320 * If Open reported that we actually created a file then we now have to
321 * set the mode if possible.
323 if ((tcon
->unix_ext
) && (*oplock
& CIFS_CREATE_ACTION
)) {
324 struct cifs_unix_set_info_args args
= {
326 .ctime
= NO_CHANGE_64
,
327 .atime
= NO_CHANGE_64
,
328 .mtime
= NO_CHANGE_64
,
332 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
333 args
.uid
= current_fsuid();
334 if (inode
->i_mode
& S_ISGID
)
335 args
.gid
= inode
->i_gid
;
337 args
.gid
= current_fsgid();
339 args
.uid
= INVALID_UID
; /* no change */
340 args
.gid
= INVALID_GID
; /* no change */
342 CIFSSMBUnixSetFileInfo(xid
, tcon
, &args
, fid
->netfid
,
346 * BB implement mode setting via Windows security
349 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
351 /* Could set r/o dos attribute if mode & 0222 == 0 */
354 cifs_create_get_file_info
:
355 /* server might mask mode so we have to query for it */
357 rc
= cifs_get_inode_info_unix(&newinode
, full_path
, inode
->i_sb
,
360 /* TODO: Add support for calling POSIX query info here, but passing in fid */
361 rc
= cifs_get_inode_info(&newinode
, full_path
, buf
, inode
->i_sb
,
364 if (server
->ops
->set_lease_key
)
365 server
->ops
->set_lease_key(newinode
, fid
);
366 if ((*oplock
& CIFS_CREATE_ACTION
) && S_ISREG(newinode
->i_mode
)) {
367 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
368 newinode
->i_mode
= mode
;
369 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
370 newinode
->i_uid
= current_fsuid();
371 if (inode
->i_mode
& S_ISGID
)
372 newinode
->i_gid
= inode
->i_gid
;
374 newinode
->i_gid
= current_fsgid();
380 cifs_create_set_dentry
:
382 cifs_dbg(FYI
, "Create worked, get_inode_info failed rc = %d\n",
388 if (S_ISDIR(newinode
->i_mode
)) {
394 d_add(direntry
, newinode
);
398 free_dentry_path(page
);
402 if (server
->ops
->close
)
403 server
->ops
->close(xid
, tcon
, fid
);
410 cifs_atomic_open(struct inode
*inode
, struct dentry
*direntry
,
411 struct file
*file
, unsigned oflags
, umode_t mode
)
415 struct tcon_link
*tlink
;
416 struct cifs_tcon
*tcon
;
417 struct TCP_Server_Info
*server
;
419 struct cifs_pending_open open
;
421 struct cifsFileInfo
*file_info
;
423 if (unlikely(cifs_forced_shutdown(CIFS_SB(inode
->i_sb
))))
427 * Posix open is only called (at lookup time) for file create now. For
428 * opens (rather than creates), because we do not know if it is a file
429 * or directory yet, and current Samba no longer allows us to do posix
430 * open on dirs, we could end up wasting an open call on what turns out
431 * to be a dir. For file opens, we wait to call posix open till
432 * cifs_open. It could be added to atomic_open in the future but the
433 * performance tradeoff of the extra network request when EISDIR or
434 * EACCES is returned would have to be weighed against the 50% reduction
435 * in network traffic in the other paths.
437 if (!(oflags
& O_CREAT
)) {
441 * Check for hashed negative dentry. We have already revalidated
442 * the dentry and it is fine. No need to perform another lookup.
444 if (!d_in_lookup(direntry
))
447 res
= cifs_lookup(inode
, direntry
, 0);
451 return finish_no_open(file
, res
);
456 cifs_dbg(FYI
, "parent inode = 0x%p name is: %pd and dentry = 0x%p\n",
457 inode
, direntry
, direntry
);
459 tlink
= cifs_sb_tlink(CIFS_SB(inode
->i_sb
));
465 tcon
= tlink_tcon(tlink
);
467 rc
= check_name(direntry
, tcon
);
471 server
= tcon
->ses
->server
;
473 if (server
->ops
->new_lease_key
)
474 server
->ops
->new_lease_key(&fid
);
476 cifs_add_pending_open(&fid
, tlink
, &open
);
478 rc
= cifs_do_create(inode
, direntry
, xid
, tlink
, oflags
, mode
,
482 cifs_del_pending_open(&open
);
486 if ((oflags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
487 file
->f_mode
|= FMODE_CREATED
;
489 rc
= finish_open(file
, direntry
, generic_file_open
);
491 if (server
->ops
->close
)
492 server
->ops
->close(xid
, tcon
, &fid
);
493 cifs_del_pending_open(&open
);
497 if (file
->f_flags
& O_DIRECT
&&
498 CIFS_SB(inode
->i_sb
)->mnt_cifs_flags
& CIFS_MOUNT_STRICT_IO
) {
499 if (CIFS_SB(inode
->i_sb
)->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
500 file
->f_op
= &cifs_file_direct_nobrl_ops
;
502 file
->f_op
= &cifs_file_direct_ops
;
505 file_info
= cifs_new_fileinfo(&fid
, file
, tlink
, oplock
);
506 if (file_info
== NULL
) {
507 if (server
->ops
->close
)
508 server
->ops
->close(xid
, tcon
, &fid
);
509 cifs_del_pending_open(&open
);
514 cifs_put_tlink(tlink
);
520 int cifs_create(struct user_namespace
*mnt_userns
, struct inode
*inode
,
521 struct dentry
*direntry
, umode_t mode
, bool excl
)
524 unsigned int xid
= get_xid();
526 * BB below access is probably too much for mknod to request
527 * but we have to do query and setpathinfo so requesting
528 * less could fail (unless we want to request getatr and setatr
529 * permissions (only). At least for POSIX we do not have to
532 unsigned oflags
= O_EXCL
| O_CREAT
| O_RDWR
;
533 struct tcon_link
*tlink
;
534 struct cifs_tcon
*tcon
;
535 struct TCP_Server_Info
*server
;
539 cifs_dbg(FYI
, "cifs_create parent inode = 0x%p name is: %pd and dentry = 0x%p\n",
540 inode
, direntry
, direntry
);
542 if (unlikely(cifs_forced_shutdown(CIFS_SB(inode
->i_sb
))))
545 tlink
= cifs_sb_tlink(CIFS_SB(inode
->i_sb
));
550 tcon
= tlink_tcon(tlink
);
551 server
= tcon
->ses
->server
;
553 if (server
->ops
->new_lease_key
)
554 server
->ops
->new_lease_key(&fid
);
556 rc
= cifs_do_create(inode
, direntry
, xid
, tlink
, oflags
, mode
,
558 if (!rc
&& server
->ops
->close
)
559 server
->ops
->close(xid
, tcon
, &fid
);
561 cifs_put_tlink(tlink
);
567 int cifs_mknod(struct user_namespace
*mnt_userns
, struct inode
*inode
,
568 struct dentry
*direntry
, umode_t mode
, dev_t device_number
)
572 struct cifs_sb_info
*cifs_sb
;
573 struct tcon_link
*tlink
;
574 struct cifs_tcon
*tcon
;
575 const char *full_path
;
578 if (!old_valid_dev(device_number
))
581 cifs_sb
= CIFS_SB(inode
->i_sb
);
582 if (unlikely(cifs_forced_shutdown(cifs_sb
)))
585 tlink
= cifs_sb_tlink(cifs_sb
);
587 return PTR_ERR(tlink
);
589 page
= alloc_dentry_path();
590 tcon
= tlink_tcon(tlink
);
593 full_path
= build_path_from_dentry(direntry
, page
);
594 if (IS_ERR(full_path
)) {
595 rc
= PTR_ERR(full_path
);
599 rc
= tcon
->ses
->server
->ops
->make_node(xid
, inode
, direntry
, tcon
,
604 free_dentry_path(page
);
606 cifs_put_tlink(tlink
);
611 cifs_lookup(struct inode
*parent_dir_inode
, struct dentry
*direntry
,
615 int rc
= 0; /* to get around spurious gcc warning, set to zero here */
616 struct cifs_sb_info
*cifs_sb
;
617 struct tcon_link
*tlink
;
618 struct cifs_tcon
*pTcon
;
619 struct inode
*newInode
= NULL
;
620 const char *full_path
;
626 cifs_dbg(FYI
, "parent inode = 0x%p name is: %pd and dentry = 0x%p\n",
627 parent_dir_inode
, direntry
, direntry
);
629 /* check whether path exists */
631 cifs_sb
= CIFS_SB(parent_dir_inode
->i_sb
);
632 tlink
= cifs_sb_tlink(cifs_sb
);
635 return ERR_CAST(tlink
);
637 pTcon
= tlink_tcon(tlink
);
639 rc
= check_name(direntry
, pTcon
);
641 cifs_put_tlink(tlink
);
646 /* can not grab the rename sem here since it would
647 deadlock in the cases (beginning of sys_rename itself)
648 in which we already have the sb rename sem */
649 page
= alloc_dentry_path();
650 full_path
= build_path_from_dentry(direntry
, page
);
651 if (IS_ERR(full_path
)) {
652 cifs_put_tlink(tlink
);
654 free_dentry_path(page
);
655 return ERR_CAST(full_path
);
658 if (d_really_is_positive(direntry
)) {
659 cifs_dbg(FYI
, "non-NULL inode in lookup\n");
661 cifs_dbg(FYI
, "NULL inode in lookup\n");
663 cifs_dbg(FYI
, "Full path: %s inode = 0x%p\n",
664 full_path
, d_inode(direntry
));
667 if (pTcon
->posix_extensions
)
668 rc
= smb311_posix_get_inode_info(&newInode
, full_path
, parent_dir_inode
->i_sb
, xid
);
669 else if (pTcon
->unix_ext
) {
670 rc
= cifs_get_inode_info_unix(&newInode
, full_path
,
671 parent_dir_inode
->i_sb
, xid
);
673 rc
= cifs_get_inode_info(&newInode
, full_path
, NULL
,
674 parent_dir_inode
->i_sb
, xid
, NULL
);
678 /* since paths are not looked up by component - the parent
679 directories are presumed to be good here */
680 renew_parental_timestamps(direntry
);
681 } else if (rc
== -EAGAIN
&& retry_count
++ < 10) {
683 } else if (rc
== -ENOENT
) {
684 cifs_set_time(direntry
, jiffies
);
688 cifs_dbg(FYI
, "Unexpected lookup error %d\n", rc
);
689 /* We special case check for Access Denied - since that
690 is a common return code */
692 newInode
= ERR_PTR(rc
);
694 free_dentry_path(page
);
695 cifs_put_tlink(tlink
);
697 return d_splice_alias(newInode
, direntry
);
701 cifs_d_revalidate(struct dentry
*direntry
, unsigned int flags
)
706 if (flags
& LOOKUP_RCU
)
709 if (d_really_is_positive(direntry
)) {
710 inode
= d_inode(direntry
);
711 if ((flags
& LOOKUP_REVAL
) && !CIFS_CACHE_READ(CIFS_I(inode
)))
712 CIFS_I(inode
)->time
= 0; /* force reval */
714 rc
= cifs_revalidate_dentry(direntry
);
716 cifs_dbg(FYI
, "cifs_revalidate_dentry failed with rc=%d", rc
);
721 * Those errors mean the dentry is invalid
722 * (file was deleted or recreated)
727 * Otherwise some unexpected error happened
728 * report it as-is to VFS layer
735 * If the inode wasn't known to be a dfs entry when
736 * the dentry was instantiated, such as when created
737 * via ->readdir(), it needs to be set now since the
738 * attributes will have been updated by
739 * cifs_revalidate_dentry().
741 if (IS_AUTOMOUNT(inode
) &&
742 !(direntry
->d_flags
& DCACHE_NEED_AUTOMOUNT
)) {
743 spin_lock(&direntry
->d_lock
);
744 direntry
->d_flags
|= DCACHE_NEED_AUTOMOUNT
;
745 spin_unlock(&direntry
->d_lock
);
753 * This may be nfsd (or something), anyway, we can't see the
754 * intent of this. So, since this can be for creation, drop it.
760 * Drop the negative dentry, in order to make sure to use the
761 * case sensitive name which is specified by user if this is
764 if (flags
& (LOOKUP_CREATE
| LOOKUP_RENAME_TARGET
))
767 if (time_after(jiffies
, cifs_get_time(direntry
) + HZ
) || !lookupCacheEnabled
)
773 /* static int cifs_d_delete(struct dentry *direntry)
777 cifs_dbg(FYI, "In cifs d_delete, name = %pd\n", direntry);
782 const struct dentry_operations cifs_dentry_ops
= {
783 .d_revalidate
= cifs_d_revalidate
,
784 .d_automount
= cifs_dfs_d_automount
,
785 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
788 static int cifs_ci_hash(const struct dentry
*dentry
, struct qstr
*q
)
790 struct nls_table
*codepage
= CIFS_SB(dentry
->d_sb
)->local_nls
;
795 hash
= init_name_hash(dentry
);
796 for (i
= 0; i
< q
->len
; i
+= charlen
) {
797 charlen
= codepage
->char2uni(&q
->name
[i
], q
->len
- i
, &c
);
798 /* error out if we can't convert the character */
799 if (unlikely(charlen
< 0))
801 hash
= partial_name_hash(cifs_toupper(c
), hash
);
803 q
->hash
= end_name_hash(hash
);
808 static int cifs_ci_compare(const struct dentry
*dentry
,
809 unsigned int len
, const char *str
, const struct qstr
*name
)
811 struct nls_table
*codepage
= CIFS_SB(dentry
->d_sb
)->local_nls
;
816 * We make the assumption here that uppercase characters in the local
817 * codepage are always the same length as their lowercase counterparts.
819 * If that's ever not the case, then this will fail to match it.
821 if (name
->len
!= len
)
824 for (i
= 0; i
< len
; i
+= l1
) {
825 /* Convert characters in both strings to UTF-16. */
826 l1
= codepage
->char2uni(&str
[i
], len
- i
, &c1
);
827 l2
= codepage
->char2uni(&name
->name
[i
], name
->len
- i
, &c2
);
830 * If we can't convert either character, just declare it to
831 * be 1 byte long and compare the original byte.
833 if (unlikely(l1
< 0 && l2
< 0)) {
834 if (str
[i
] != name
->name
[i
])
841 * Here, we again ass|u|me that upper/lowercase versions of
842 * a character are the same length in the local NLS.
847 /* Now compare uppercase versions of these characters */
848 if (cifs_toupper(c1
) != cifs_toupper(c2
))
855 const struct dentry_operations cifs_ci_dentry_ops
= {
856 .d_revalidate
= cifs_d_revalidate
,
857 .d_hash
= cifs_ci_hash
,
858 .d_compare
= cifs_ci_compare
,
859 .d_automount
= cifs_dfs_d_automount
,