return 0;
 }
 
-static int smb2_remove_smb_xattrs(struct dentry *dentry)
+static int smb2_remove_smb_xattrs(struct path *path)
 {
        char *name, *xattr_list = NULL;
        ssize_t xattr_list_len;
        int err = 0;
 
-       xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list);
+       xattr_list_len = ksmbd_vfs_listxattr(path->dentry, &xattr_list);
        if (xattr_list_len < 0) {
                goto out;
        } else if (!xattr_list_len) {
                    strncmp(&name[XATTR_USER_PREFIX_LEN], STREAM_PREFIX, STREAM_PREFIX_LEN))
                        continue;
 
-               err = ksmbd_vfs_remove_xattr(dentry, name);
+               err = ksmbd_vfs_remove_xattr(path->dentry, name);
                if (err)
                        ksmbd_debug(SMB, "remove xattr failed : %s\n", name);
        }
                return rc;
        }
 
-       rc = smb2_remove_smb_xattrs(path->dentry);
+       rc = smb2_remove_smb_xattrs(path);
        if (rc == -EOPNOTSUPP)
                rc = 0;
        if (rc)
 
 static int smb2_create_sd_buffer(struct ksmbd_work *work,
                                 struct smb2_create_req *req,
-                                struct dentry *dentry)
+                                struct path *path)
 {
        struct create_context *context;
        int rc = -ENOENT;
                ksmbd_debug(SMB,
                            "Set ACLs using SMB2_CREATE_SD_BUFFER context\n");
                sd_buf = (struct create_sd_buf_req *)context;
-               rc = set_info_sec(work->conn, work->tcon, dentry, &sd_buf->ntsd,
+               rc = set_info_sec(work->conn, work->tcon,
+                                 path, &sd_buf->ntsd,
                                  le32_to_cpu(sd_buf->ccontext.DataLength), true);
        }
 
        daccess = smb_map_generic_desired_access(req->DesiredAccess);
 
        if (file_present && !(req->CreateOptions & FILE_DELETE_ON_CLOSE_LE)) {
-               rc = smb_check_perm_dacl(conn, path.dentry, &daccess,
+               rc = smb_check_perm_dacl(conn, &path, &daccess,
                                         sess->user->uid);
                if (rc)
                        goto err_out;
 
                if (test_share_config_flag(work->tcon->share_conf,
                                           KSMBD_SHARE_FLAG_ACL_XATTR)) {
-                       rc = smb_inherit_dacl(conn, path.dentry, sess->user->uid,
+                       rc = smb_inherit_dacl(conn, &path, sess->user->uid,
                                              sess->user->gid);
                }
 
                if (rc) {
-                       rc = smb2_create_sd_buffer(work, req, path.dentry);
+                       rc = smb2_create_sd_buffer(work, req, &path);
                        if (rc) {
                                if (posix_acl_rc)
                                        ksmbd_vfs_set_init_posix_acl(inode);
 
        fp->saccess |= FILE_SHARE_DELETE_LE;
 
-       return set_info_sec(fp->conn, fp->tcon, fp->filp->f_path.dentry, pntsd,
+       return set_info_sec(fp->conn, fp->tcon, &fp->filp->f_path, pntsd,
                        buf_len, false);
 }
 
 
        ace->size = cpu_to_le16(1 + 1 + 2 + 4 + 1 + 1 + 6 + (sid->num_subauth * 4));
 }
 
-int smb_inherit_dacl(struct ksmbd_conn *conn, struct dentry *dentry,
+int smb_inherit_dacl(struct ksmbd_conn *conn,
+                    struct path *path,
                     unsigned int uid, unsigned int gid)
 {
        const struct smb_sid *psid, *creator = NULL;
        struct smb_acl *parent_pdacl;
        struct smb_ntsd *parent_pntsd = NULL;
        struct smb_sid owner_sid, group_sid;
-       struct dentry *parent = dentry->d_parent;
+       struct dentry *parent = path->dentry->d_parent;
        int inherited_flags = 0, flags = 0, i, ace_cnt = 0, nt_size = 0;
        int rc = -ENOENT, num_aces, dacloffset, pntsd_type, acl_len;
        char *aces_base;
-       bool is_dir = S_ISDIR(d_inode(dentry)->i_mode);
+       bool is_dir = S_ISDIR(d_inode(path->dentry)->i_mode);
 
        acl_len = ksmbd_vfs_get_sd_xattr(conn, parent, &parent_pntsd);
        if (acl_len <= 0)
                        pntsd_size += sizeof(struct smb_acl) + nt_size;
                }
 
-               ksmbd_vfs_set_sd_xattr(conn, dentry, pntsd, pntsd_size);
+               ksmbd_vfs_set_sd_xattr(conn, path->dentry, pntsd, pntsd_size);
                kfree(pntsd);
                rc = 0;
        }
        return false;
 }
 
-int smb_check_perm_dacl(struct ksmbd_conn *conn, struct dentry *dentry,
+int smb_check_perm_dacl(struct ksmbd_conn *conn, struct path *path,
                        __le32 *pdaccess, int uid)
 {
        struct smb_ntsd *pntsd = NULL;
        char *end_of_acl;
 
        ksmbd_debug(SMB, "check permission using windows acl\n");
-       acl_size = ksmbd_vfs_get_sd_xattr(conn, dentry, &pntsd);
+       acl_size = ksmbd_vfs_get_sd_xattr(conn, path->dentry, &pntsd);
        if (acl_size <= 0 || !pntsd || !pntsd->dacloffset) {
                kfree(pntsd);
                return 0;
                        granted = GENERIC_ALL_FLAGS;
        }
 
-       posix_acls = get_acl(d_inode(dentry), ACL_TYPE_ACCESS);
+       posix_acls = get_acl(d_inode(path->dentry), ACL_TYPE_ACCESS);
        if (posix_acls && !found) {
                unsigned int id = -1;
 
 }
 
 int set_info_sec(struct ksmbd_conn *conn, struct ksmbd_tree_connect *tcon,
-                struct dentry *dentry, struct smb_ntsd *pntsd, int ntsd_len,
+                struct path *path, struct smb_ntsd *pntsd, int ntsd_len,
                 bool type_check)
 {
        int rc;
        struct smb_fattr fattr = {{0}};
-       struct inode *inode = d_inode(dentry);
+       struct inode *inode = d_inode(path->dentry);
 
        fattr.cf_uid = INVALID_UID;
        fattr.cf_gid = INVALID_GID;
                inode->i_gid = fattr.cf_gid;
        mark_inode_dirty(inode);
 
-       ksmbd_vfs_remove_acl_xattrs(dentry);
+       ksmbd_vfs_remove_acl_xattrs(path->dentry);
        /* Update posix acls */
        if (fattr.cf_dacls) {
                rc = set_posix_acl(&init_user_ns, inode, ACL_TYPE_ACCESS,
 
        if (test_share_config_flag(tcon->share_conf, KSMBD_SHARE_FLAG_ACL_XATTR)) {
                /* Update WinACL in xattr */
-               ksmbd_vfs_remove_sd_xattrs(dentry);
-               ksmbd_vfs_set_sd_xattr(conn, dentry, pntsd, ntsd_len);
+               ksmbd_vfs_remove_sd_xattrs(path->dentry);
+               ksmbd_vfs_set_sd_xattr(conn, path->dentry, pntsd, ntsd_len);
        }
 
 out:
 
                        struct posix_acl_entry *pace);
 int compare_sids(const struct smb_sid *ctsid, const struct smb_sid *cwsid);
 bool smb_inherit_flags(int flags, bool is_dir);
-int smb_inherit_dacl(struct ksmbd_conn *conn, struct dentry *dentry,
+int smb_inherit_dacl(struct ksmbd_conn *conn, struct path *path,
                     unsigned int uid, unsigned int gid);
-int smb_check_perm_dacl(struct ksmbd_conn *conn, struct dentry *dentry,
+int smb_check_perm_dacl(struct ksmbd_conn *conn, struct path *path,
                        __le32 *pdaccess, int uid);
 int set_info_sec(struct ksmbd_conn *conn, struct ksmbd_tree_connect *tcon,
-                struct dentry *dentry, struct smb_ntsd *pntsd, int ntsd_len,
+                struct path *path, struct smb_ntsd *pntsd, int ntsd_len,
                 bool type_check);
 void id_to_sid(unsigned int cid, uint sidtype, struct smb_sid *ssid);
 void ksmbd_init_domain(u32 *sub_auth);