Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *   Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org>
0004  *   Copyright (C) 2018 Samsung Electronics Co., Ltd.
0005  */
0006 
0007 #include <linux/kernel.h>
0008 #include <linux/fs.h>
0009 #include <linux/uaccess.h>
0010 #include <linux/backing-dev.h>
0011 #include <linux/writeback.h>
0012 #include <linux/xattr.h>
0013 #include <linux/falloc.h>
0014 #include <linux/fsnotify.h>
0015 #include <linux/dcache.h>
0016 #include <linux/slab.h>
0017 #include <linux/vmalloc.h>
0018 #include <linux/sched/xacct.h>
0019 #include <linux/crc32c.h>
0020 
0021 #include "../internal.h"    /* for vfs_path_lookup */
0022 
0023 #include "glob.h"
0024 #include "oplock.h"
0025 #include "connection.h"
0026 #include "vfs.h"
0027 #include "vfs_cache.h"
0028 #include "smbacl.h"
0029 #include "ndr.h"
0030 #include "auth.h"
0031 #include "misc.h"
0032 
0033 #include "smb_common.h"
0034 #include "mgmt/share_config.h"
0035 #include "mgmt/tree_connect.h"
0036 #include "mgmt/user_session.h"
0037 #include "mgmt/user_config.h"
0038 
0039 static char *extract_last_component(char *path)
0040 {
0041     char *p = strrchr(path, '/');
0042 
0043     if (p && p[1] != '\0') {
0044         *p = '\0';
0045         p++;
0046     } else {
0047         p = NULL;
0048     }
0049     return p;
0050 }
0051 
0052 static void ksmbd_vfs_inherit_owner(struct ksmbd_work *work,
0053                     struct inode *parent_inode,
0054                     struct inode *inode)
0055 {
0056     if (!test_share_config_flag(work->tcon->share_conf,
0057                     KSMBD_SHARE_FLAG_INHERIT_OWNER))
0058         return;
0059 
0060     i_uid_write(inode, i_uid_read(parent_inode));
0061 }
0062 
0063 /**
0064  * ksmbd_vfs_lock_parent() - lock parent dentry if it is stable
0065  *
0066  * the parent dentry got by dget_parent or @parent could be
0067  * unstable, we try to lock a parent inode and lookup the
0068  * child dentry again.
0069  *
0070  * the reference count of @parent isn't incremented.
0071  */
0072 int ksmbd_vfs_lock_parent(struct user_namespace *user_ns, struct dentry *parent,
0073               struct dentry *child)
0074 {
0075     struct dentry *dentry;
0076     int ret = 0;
0077 
0078     inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);
0079     dentry = lookup_one(user_ns, child->d_name.name, parent,
0080                 child->d_name.len);
0081     if (IS_ERR(dentry)) {
0082         ret = PTR_ERR(dentry);
0083         goto out_err;
0084     }
0085 
0086     if (dentry != child) {
0087         ret = -ESTALE;
0088         dput(dentry);
0089         goto out_err;
0090     }
0091 
0092     dput(dentry);
0093     return 0;
0094 out_err:
0095     inode_unlock(d_inode(parent));
0096     return ret;
0097 }
0098 
0099 int ksmbd_vfs_may_delete(struct user_namespace *user_ns,
0100              struct dentry *dentry)
0101 {
0102     struct dentry *parent;
0103     int ret;
0104 
0105     parent = dget_parent(dentry);
0106     ret = ksmbd_vfs_lock_parent(user_ns, parent, dentry);
0107     if (ret) {
0108         dput(parent);
0109         return ret;
0110     }
0111 
0112     ret = inode_permission(user_ns, d_inode(parent),
0113                    MAY_EXEC | MAY_WRITE);
0114 
0115     inode_unlock(d_inode(parent));
0116     dput(parent);
0117     return ret;
0118 }
0119 
0120 int ksmbd_vfs_query_maximal_access(struct user_namespace *user_ns,
0121                    struct dentry *dentry, __le32 *daccess)
0122 {
0123     struct dentry *parent;
0124     int ret = 0;
0125 
0126     *daccess = cpu_to_le32(FILE_READ_ATTRIBUTES | READ_CONTROL);
0127 
0128     if (!inode_permission(user_ns, d_inode(dentry), MAY_OPEN | MAY_WRITE))
0129         *daccess |= cpu_to_le32(WRITE_DAC | WRITE_OWNER | SYNCHRONIZE |
0130                 FILE_WRITE_DATA | FILE_APPEND_DATA |
0131                 FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES |
0132                 FILE_DELETE_CHILD);
0133 
0134     if (!inode_permission(user_ns, d_inode(dentry), MAY_OPEN | MAY_READ))
0135         *daccess |= FILE_READ_DATA_LE | FILE_READ_EA_LE;
0136 
0137     if (!inode_permission(user_ns, d_inode(dentry), MAY_OPEN | MAY_EXEC))
0138         *daccess |= FILE_EXECUTE_LE;
0139 
0140     parent = dget_parent(dentry);
0141     ret = ksmbd_vfs_lock_parent(user_ns, parent, dentry);
0142     if (ret) {
0143         dput(parent);
0144         return ret;
0145     }
0146 
0147     if (!inode_permission(user_ns, d_inode(parent), MAY_EXEC | MAY_WRITE))
0148         *daccess |= FILE_DELETE_LE;
0149 
0150     inode_unlock(d_inode(parent));
0151     dput(parent);
0152     return ret;
0153 }
0154 
0155 /**
0156  * ksmbd_vfs_create() - vfs helper for smb create file
0157  * @work:   work
0158  * @name:   file name that is relative to share
0159  * @mode:   file create mode
0160  *
0161  * Return:  0 on success, otherwise error
0162  */
0163 int ksmbd_vfs_create(struct ksmbd_work *work, const char *name, umode_t mode)
0164 {
0165     struct path path;
0166     struct dentry *dentry;
0167     int err;
0168 
0169     dentry = ksmbd_vfs_kern_path_create(work, name,
0170                         LOOKUP_NO_SYMLINKS, &path);
0171     if (IS_ERR(dentry)) {
0172         err = PTR_ERR(dentry);
0173         if (err != -ENOENT)
0174             pr_err("path create failed for %s, err %d\n",
0175                    name, err);
0176         return err;
0177     }
0178 
0179     mode |= S_IFREG;
0180     err = vfs_create(mnt_user_ns(path.mnt), d_inode(path.dentry),
0181              dentry, mode, true);
0182     if (!err) {
0183         ksmbd_vfs_inherit_owner(work, d_inode(path.dentry),
0184                     d_inode(dentry));
0185     } else {
0186         pr_err("File(%s): creation failed (err:%d)\n", name, err);
0187     }
0188     done_path_create(&path, dentry);
0189     return err;
0190 }
0191 
0192 /**
0193  * ksmbd_vfs_mkdir() - vfs helper for smb create directory
0194  * @work:   work
0195  * @name:   directory name that is relative to share
0196  * @mode:   directory create mode
0197  *
0198  * Return:  0 on success, otherwise error
0199  */
0200 int ksmbd_vfs_mkdir(struct ksmbd_work *work, const char *name, umode_t mode)
0201 {
0202     struct user_namespace *user_ns;
0203     struct path path;
0204     struct dentry *dentry;
0205     int err;
0206 
0207     dentry = ksmbd_vfs_kern_path_create(work, name,
0208                         LOOKUP_NO_SYMLINKS | LOOKUP_DIRECTORY,
0209                         &path);
0210     if (IS_ERR(dentry)) {
0211         err = PTR_ERR(dentry);
0212         if (err != -EEXIST)
0213             ksmbd_debug(VFS, "path create failed for %s, err %d\n",
0214                     name, err);
0215         return err;
0216     }
0217 
0218     user_ns = mnt_user_ns(path.mnt);
0219     mode |= S_IFDIR;
0220     err = vfs_mkdir(user_ns, d_inode(path.dentry), dentry, mode);
0221     if (err) {
0222         goto out;
0223     } else if (d_unhashed(dentry)) {
0224         struct dentry *d;
0225 
0226         d = lookup_one(user_ns, dentry->d_name.name, dentry->d_parent,
0227                    dentry->d_name.len);
0228         if (IS_ERR(d)) {
0229             err = PTR_ERR(d);
0230             goto out;
0231         }
0232         if (unlikely(d_is_negative(d))) {
0233             dput(d);
0234             err = -ENOENT;
0235             goto out;
0236         }
0237 
0238         ksmbd_vfs_inherit_owner(work, d_inode(path.dentry), d_inode(d));
0239         dput(d);
0240     }
0241 out:
0242     done_path_create(&path, dentry);
0243     if (err)
0244         pr_err("mkdir(%s): creation failed (err:%d)\n", name, err);
0245     return err;
0246 }
0247 
0248 static ssize_t ksmbd_vfs_getcasexattr(struct user_namespace *user_ns,
0249                       struct dentry *dentry, char *attr_name,
0250                       int attr_name_len, char **attr_value)
0251 {
0252     char *name, *xattr_list = NULL;
0253     ssize_t value_len = -ENOENT, xattr_list_len;
0254 
0255     xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list);
0256     if (xattr_list_len <= 0)
0257         goto out;
0258 
0259     for (name = xattr_list; name - xattr_list < xattr_list_len;
0260             name += strlen(name) + 1) {
0261         ksmbd_debug(VFS, "%s, len %zd\n", name, strlen(name));
0262         if (strncasecmp(attr_name, name, attr_name_len))
0263             continue;
0264 
0265         value_len = ksmbd_vfs_getxattr(user_ns,
0266                            dentry,
0267                            name,
0268                            attr_value);
0269         if (value_len < 0)
0270             pr_err("failed to get xattr in file\n");
0271         break;
0272     }
0273 
0274 out:
0275     kvfree(xattr_list);
0276     return value_len;
0277 }
0278 
0279 static int ksmbd_vfs_stream_read(struct ksmbd_file *fp, char *buf, loff_t *pos,
0280                  size_t count)
0281 {
0282     ssize_t v_len;
0283     char *stream_buf = NULL;
0284 
0285     ksmbd_debug(VFS, "read stream data pos : %llu, count : %zd\n",
0286             *pos, count);
0287 
0288     v_len = ksmbd_vfs_getcasexattr(file_mnt_user_ns(fp->filp),
0289                        fp->filp->f_path.dentry,
0290                        fp->stream.name,
0291                        fp->stream.size,
0292                        &stream_buf);
0293     if ((int)v_len <= 0)
0294         return (int)v_len;
0295 
0296     if (v_len <= *pos) {
0297         count = -EINVAL;
0298         goto free_buf;
0299     }
0300 
0301     if (v_len - *pos < count)
0302         count = v_len - *pos;
0303 
0304     memcpy(buf, &stream_buf[*pos], count);
0305 
0306 free_buf:
0307     kvfree(stream_buf);
0308     return count;
0309 }
0310 
0311 /**
0312  * check_lock_range() - vfs helper for smb byte range file locking
0313  * @filp:   the file to apply the lock to
0314  * @start:  lock start byte offset
0315  * @end:    lock end byte offset
0316  * @type:   byte range type read/write
0317  *
0318  * Return:  0 on success, otherwise error
0319  */
0320 static int check_lock_range(struct file *filp, loff_t start, loff_t end,
0321                 unsigned char type)
0322 {
0323     struct file_lock *flock;
0324     struct file_lock_context *ctx = file_inode(filp)->i_flctx;
0325     int error = 0;
0326 
0327     if (!ctx || list_empty_careful(&ctx->flc_posix))
0328         return 0;
0329 
0330     spin_lock(&ctx->flc_lock);
0331     list_for_each_entry(flock, &ctx->flc_posix, fl_list) {
0332         /* check conflict locks */
0333         if (flock->fl_end >= start && end >= flock->fl_start) {
0334             if (flock->fl_type == F_RDLCK) {
0335                 if (type == WRITE) {
0336                     pr_err("not allow write by shared lock\n");
0337                     error = 1;
0338                     goto out;
0339                 }
0340             } else if (flock->fl_type == F_WRLCK) {
0341                 /* check owner in lock */
0342                 if (flock->fl_file != filp) {
0343                     error = 1;
0344                     pr_err("not allow rw access by exclusive lock from other opens\n");
0345                     goto out;
0346                 }
0347             }
0348         }
0349     }
0350 out:
0351     spin_unlock(&ctx->flc_lock);
0352     return error;
0353 }
0354 
0355 /**
0356  * ksmbd_vfs_read() - vfs helper for smb file read
0357  * @work:   smb work
0358  * @fid:    file id of open file
0359  * @count:  read byte count
0360  * @pos:    file pos
0361  *
0362  * Return:  number of read bytes on success, otherwise error
0363  */
0364 int ksmbd_vfs_read(struct ksmbd_work *work, struct ksmbd_file *fp, size_t count,
0365            loff_t *pos)
0366 {
0367     struct file *filp = fp->filp;
0368     ssize_t nbytes = 0;
0369     char *rbuf = work->aux_payload_buf;
0370     struct inode *inode = file_inode(filp);
0371 
0372     if (S_ISDIR(inode->i_mode))
0373         return -EISDIR;
0374 
0375     if (unlikely(count == 0))
0376         return 0;
0377 
0378     if (work->conn->connection_type) {
0379         if (!(fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) {
0380             pr_err("no right to read(%pd)\n",
0381                    fp->filp->f_path.dentry);
0382             return -EACCES;
0383         }
0384     }
0385 
0386     if (ksmbd_stream_fd(fp))
0387         return ksmbd_vfs_stream_read(fp, rbuf, pos, count);
0388 
0389     if (!work->tcon->posix_extensions) {
0390         int ret;
0391 
0392         ret = check_lock_range(filp, *pos, *pos + count - 1, READ);
0393         if (ret) {
0394             pr_err("unable to read due to lock\n");
0395             return -EAGAIN;
0396         }
0397     }
0398 
0399     nbytes = kernel_read(filp, rbuf, count, pos);
0400     if (nbytes < 0) {
0401         pr_err("smb read failed, err = %zd\n", nbytes);
0402         return nbytes;
0403     }
0404 
0405     filp->f_pos = *pos;
0406     return nbytes;
0407 }
0408 
0409 static int ksmbd_vfs_stream_write(struct ksmbd_file *fp, char *buf, loff_t *pos,
0410                   size_t count)
0411 {
0412     char *stream_buf = NULL, *wbuf;
0413     struct user_namespace *user_ns = file_mnt_user_ns(fp->filp);
0414     size_t size, v_len;
0415     int err = 0;
0416 
0417     ksmbd_debug(VFS, "write stream data pos : %llu, count : %zd\n",
0418             *pos, count);
0419 
0420     size = *pos + count;
0421     if (size > XATTR_SIZE_MAX) {
0422         size = XATTR_SIZE_MAX;
0423         count = (*pos + count) - XATTR_SIZE_MAX;
0424     }
0425 
0426     v_len = ksmbd_vfs_getcasexattr(user_ns,
0427                        fp->filp->f_path.dentry,
0428                        fp->stream.name,
0429                        fp->stream.size,
0430                        &stream_buf);
0431     if ((int)v_len < 0) {
0432         pr_err("not found stream in xattr : %zd\n", v_len);
0433         err = (int)v_len;
0434         goto out;
0435     }
0436 
0437     if (v_len < size) {
0438         wbuf = kvmalloc(size, GFP_KERNEL | __GFP_ZERO);
0439         if (!wbuf) {
0440             err = -ENOMEM;
0441             goto out;
0442         }
0443 
0444         if (v_len > 0)
0445             memcpy(wbuf, stream_buf, v_len);
0446         kvfree(stream_buf);
0447         stream_buf = wbuf;
0448     }
0449 
0450     memcpy(&stream_buf[*pos], buf, count);
0451 
0452     err = ksmbd_vfs_setxattr(user_ns,
0453                  fp->filp->f_path.dentry,
0454                  fp->stream.name,
0455                  (void *)stream_buf,
0456                  size,
0457                  0);
0458     if (err < 0)
0459         goto out;
0460 
0461     fp->filp->f_pos = *pos;
0462     err = 0;
0463 out:
0464     kvfree(stream_buf);
0465     return err;
0466 }
0467 
0468 /**
0469  * ksmbd_vfs_write() - vfs helper for smb file write
0470  * @work:   work
0471  * @fid:    file id of open file
0472  * @buf:    buf containing data for writing
0473  * @count:  read byte count
0474  * @pos:    file pos
0475  * @sync:   fsync after write
0476  * @written:    number of bytes written
0477  *
0478  * Return:  0 on success, otherwise error
0479  */
0480 int ksmbd_vfs_write(struct ksmbd_work *work, struct ksmbd_file *fp,
0481             char *buf, size_t count, loff_t *pos, bool sync,
0482             ssize_t *written)
0483 {
0484     struct file *filp;
0485     loff_t  offset = *pos;
0486     int err = 0;
0487 
0488     if (work->conn->connection_type) {
0489         if (!(fp->daccess & FILE_WRITE_DATA_LE)) {
0490             pr_err("no right to write(%pd)\n",
0491                    fp->filp->f_path.dentry);
0492             err = -EACCES;
0493             goto out;
0494         }
0495     }
0496 
0497     filp = fp->filp;
0498 
0499     if (ksmbd_stream_fd(fp)) {
0500         err = ksmbd_vfs_stream_write(fp, buf, pos, count);
0501         if (!err)
0502             *written = count;
0503         goto out;
0504     }
0505 
0506     if (!work->tcon->posix_extensions) {
0507         err = check_lock_range(filp, *pos, *pos + count - 1, WRITE);
0508         if (err) {
0509             pr_err("unable to write due to lock\n");
0510             err = -EAGAIN;
0511             goto out;
0512         }
0513     }
0514 
0515     /* Do we need to break any of a levelII oplock? */
0516     smb_break_all_levII_oplock(work, fp, 1);
0517 
0518     err = kernel_write(filp, buf, count, pos);
0519     if (err < 0) {
0520         ksmbd_debug(VFS, "smb write failed, err = %d\n", err);
0521         goto out;
0522     }
0523 
0524     filp->f_pos = *pos;
0525     *written = err;
0526     err = 0;
0527     if (sync) {
0528         err = vfs_fsync_range(filp, offset, offset + *written, 0);
0529         if (err < 0)
0530             pr_err("fsync failed for filename = %pd, err = %d\n",
0531                    fp->filp->f_path.dentry, err);
0532     }
0533 
0534 out:
0535     return err;
0536 }
0537 
0538 /**
0539  * ksmbd_vfs_getattr() - vfs helper for smb getattr
0540  * @work:   work
0541  * @fid:    file id of open file
0542  * @attrs:  inode attributes
0543  *
0544  * Return:  0 on success, otherwise error
0545  */
0546 int ksmbd_vfs_getattr(struct path *path, struct kstat *stat)
0547 {
0548     int err;
0549 
0550     err = vfs_getattr(path, stat, STATX_BTIME, AT_STATX_SYNC_AS_STAT);
0551     if (err)
0552         pr_err("getattr failed, err %d\n", err);
0553     return err;
0554 }
0555 
0556 /**
0557  * ksmbd_vfs_fsync() - vfs helper for smb fsync
0558  * @work:   work
0559  * @fid:    file id of open file
0560  *
0561  * Return:  0 on success, otherwise error
0562  */
0563 int ksmbd_vfs_fsync(struct ksmbd_work *work, u64 fid, u64 p_id)
0564 {
0565     struct ksmbd_file *fp;
0566     int err;
0567 
0568     fp = ksmbd_lookup_fd_slow(work, fid, p_id);
0569     if (!fp) {
0570         pr_err("failed to get filp for fid %llu\n", fid);
0571         return -ENOENT;
0572     }
0573     err = vfs_fsync(fp->filp, 0);
0574     if (err < 0)
0575         pr_err("smb fsync failed, err = %d\n", err);
0576     ksmbd_fd_put(work, fp);
0577     return err;
0578 }
0579 
0580 /**
0581  * ksmbd_vfs_remove_file() - vfs helper for smb rmdir or unlink
0582  * @name:   directory or file name that is relative to share
0583  *
0584  * Return:  0 on success, otherwise error
0585  */
0586 int ksmbd_vfs_remove_file(struct ksmbd_work *work, char *name)
0587 {
0588     struct user_namespace *user_ns;
0589     struct path path;
0590     struct dentry *parent;
0591     int err;
0592 
0593     if (ksmbd_override_fsids(work))
0594         return -ENOMEM;
0595 
0596     err = ksmbd_vfs_kern_path(work, name, LOOKUP_NO_SYMLINKS, &path, false);
0597     if (err) {
0598         ksmbd_debug(VFS, "can't get %s, err %d\n", name, err);
0599         ksmbd_revert_fsids(work);
0600         return err;
0601     }
0602 
0603     user_ns = mnt_user_ns(path.mnt);
0604     parent = dget_parent(path.dentry);
0605     err = ksmbd_vfs_lock_parent(user_ns, parent, path.dentry);
0606     if (err) {
0607         dput(parent);
0608         path_put(&path);
0609         ksmbd_revert_fsids(work);
0610         return err;
0611     }
0612 
0613     if (!d_inode(path.dentry)->i_nlink) {
0614         err = -ENOENT;
0615         goto out_err;
0616     }
0617 
0618     if (S_ISDIR(d_inode(path.dentry)->i_mode)) {
0619         err = vfs_rmdir(user_ns, d_inode(parent), path.dentry);
0620         if (err && err != -ENOTEMPTY)
0621             ksmbd_debug(VFS, "%s: rmdir failed, err %d\n", name,
0622                     err);
0623     } else {
0624         err = vfs_unlink(user_ns, d_inode(parent), path.dentry, NULL);
0625         if (err)
0626             ksmbd_debug(VFS, "%s: unlink failed, err %d\n", name,
0627                     err);
0628     }
0629 
0630 out_err:
0631     inode_unlock(d_inode(parent));
0632     dput(parent);
0633     path_put(&path);
0634     ksmbd_revert_fsids(work);
0635     return err;
0636 }
0637 
0638 /**
0639  * ksmbd_vfs_link() - vfs helper for creating smb hardlink
0640  * @oldname:    source file name
0641  * @newname:    hardlink name that is relative to share
0642  *
0643  * Return:  0 on success, otherwise error
0644  */
0645 int ksmbd_vfs_link(struct ksmbd_work *work, const char *oldname,
0646            const char *newname)
0647 {
0648     struct path oldpath, newpath;
0649     struct dentry *dentry;
0650     int err;
0651 
0652     if (ksmbd_override_fsids(work))
0653         return -ENOMEM;
0654 
0655     err = kern_path(oldname, LOOKUP_NO_SYMLINKS, &oldpath);
0656     if (err) {
0657         pr_err("cannot get linux path for %s, err = %d\n",
0658                oldname, err);
0659         goto out1;
0660     }
0661 
0662     dentry = ksmbd_vfs_kern_path_create(work, newname,
0663                         LOOKUP_NO_SYMLINKS | LOOKUP_REVAL,
0664                         &newpath);
0665     if (IS_ERR(dentry)) {
0666         err = PTR_ERR(dentry);
0667         pr_err("path create err for %s, err %d\n", newname, err);
0668         goto out2;
0669     }
0670 
0671     err = -EXDEV;
0672     if (oldpath.mnt != newpath.mnt) {
0673         pr_err("vfs_link failed err %d\n", err);
0674         goto out3;
0675     }
0676 
0677     err = vfs_link(oldpath.dentry, mnt_user_ns(newpath.mnt),
0678                d_inode(newpath.dentry),
0679                dentry, NULL);
0680     if (err)
0681         ksmbd_debug(VFS, "vfs_link failed err %d\n", err);
0682 
0683 out3:
0684     done_path_create(&newpath, dentry);
0685 out2:
0686     path_put(&oldpath);
0687 out1:
0688     ksmbd_revert_fsids(work);
0689     return err;
0690 }
0691 
0692 static int ksmbd_validate_entry_in_use(struct dentry *src_dent)
0693 {
0694     struct dentry *dst_dent;
0695 
0696     spin_lock(&src_dent->d_lock);
0697     list_for_each_entry(dst_dent, &src_dent->d_subdirs, d_child) {
0698         struct ksmbd_file *child_fp;
0699 
0700         if (d_really_is_negative(dst_dent))
0701             continue;
0702 
0703         child_fp = ksmbd_lookup_fd_inode(d_inode(dst_dent));
0704         if (child_fp) {
0705             spin_unlock(&src_dent->d_lock);
0706             ksmbd_debug(VFS, "Forbid rename, sub file/dir is in use\n");
0707             return -EACCES;
0708         }
0709     }
0710     spin_unlock(&src_dent->d_lock);
0711 
0712     return 0;
0713 }
0714 
0715 static int __ksmbd_vfs_rename(struct ksmbd_work *work,
0716                   struct user_namespace *src_user_ns,
0717                   struct dentry *src_dent_parent,
0718                   struct dentry *src_dent,
0719                   struct user_namespace *dst_user_ns,
0720                   struct dentry *dst_dent_parent,
0721                   struct dentry *trap_dent,
0722                   char *dst_name)
0723 {
0724     struct dentry *dst_dent;
0725     int err;
0726 
0727     if (!work->tcon->posix_extensions) {
0728         err = ksmbd_validate_entry_in_use(src_dent);
0729         if (err)
0730             return err;
0731     }
0732 
0733     if (d_really_is_negative(src_dent_parent))
0734         return -ENOENT;
0735     if (d_really_is_negative(dst_dent_parent))
0736         return -ENOENT;
0737     if (d_really_is_negative(src_dent))
0738         return -ENOENT;
0739     if (src_dent == trap_dent)
0740         return -EINVAL;
0741 
0742     if (ksmbd_override_fsids(work))
0743         return -ENOMEM;
0744 
0745     dst_dent = lookup_one(dst_user_ns, dst_name, dst_dent_parent,
0746                   strlen(dst_name));
0747     err = PTR_ERR(dst_dent);
0748     if (IS_ERR(dst_dent)) {
0749         pr_err("lookup failed %s [%d]\n", dst_name, err);
0750         goto out;
0751     }
0752 
0753     err = -ENOTEMPTY;
0754     if (dst_dent != trap_dent && !d_really_is_positive(dst_dent)) {
0755         struct renamedata rd = {
0756             .old_mnt_userns = src_user_ns,
0757             .old_dir    = d_inode(src_dent_parent),
0758             .old_dentry = src_dent,
0759             .new_mnt_userns = dst_user_ns,
0760             .new_dir    = d_inode(dst_dent_parent),
0761             .new_dentry = dst_dent,
0762         };
0763         err = vfs_rename(&rd);
0764     }
0765     if (err)
0766         pr_err("vfs_rename failed err %d\n", err);
0767     if (dst_dent)
0768         dput(dst_dent);
0769 out:
0770     ksmbd_revert_fsids(work);
0771     return err;
0772 }
0773 
0774 int ksmbd_vfs_fp_rename(struct ksmbd_work *work, struct ksmbd_file *fp,
0775             char *newname)
0776 {
0777     struct user_namespace *user_ns;
0778     struct path dst_path;
0779     struct dentry *src_dent_parent, *dst_dent_parent;
0780     struct dentry *src_dent, *trap_dent, *src_child;
0781     char *dst_name;
0782     int err;
0783 
0784     dst_name = extract_last_component(newname);
0785     if (!dst_name) {
0786         dst_name = newname;
0787         newname = "";
0788     }
0789 
0790     src_dent_parent = dget_parent(fp->filp->f_path.dentry);
0791     src_dent = fp->filp->f_path.dentry;
0792 
0793     err = ksmbd_vfs_kern_path(work, newname,
0794                   LOOKUP_NO_SYMLINKS | LOOKUP_DIRECTORY,
0795                   &dst_path, false);
0796     if (err) {
0797         ksmbd_debug(VFS, "Cannot get path for %s [%d]\n", newname, err);
0798         goto out;
0799     }
0800     dst_dent_parent = dst_path.dentry;
0801 
0802     trap_dent = lock_rename(src_dent_parent, dst_dent_parent);
0803     dget(src_dent);
0804     dget(dst_dent_parent);
0805     user_ns = file_mnt_user_ns(fp->filp);
0806     src_child = lookup_one(user_ns, src_dent->d_name.name, src_dent_parent,
0807                    src_dent->d_name.len);
0808     if (IS_ERR(src_child)) {
0809         err = PTR_ERR(src_child);
0810         goto out_lock;
0811     }
0812 
0813     if (src_child != src_dent) {
0814         err = -ESTALE;
0815         dput(src_child);
0816         goto out_lock;
0817     }
0818     dput(src_child);
0819 
0820     err = __ksmbd_vfs_rename(work,
0821                  user_ns,
0822                  src_dent_parent,
0823                  src_dent,
0824                  mnt_user_ns(dst_path.mnt),
0825                  dst_dent_parent,
0826                  trap_dent,
0827                  dst_name);
0828 out_lock:
0829     dput(src_dent);
0830     dput(dst_dent_parent);
0831     unlock_rename(src_dent_parent, dst_dent_parent);
0832     path_put(&dst_path);
0833 out:
0834     dput(src_dent_parent);
0835     return err;
0836 }
0837 
0838 /**
0839  * ksmbd_vfs_truncate() - vfs helper for smb file truncate
0840  * @work:   work
0841  * @fid:    file id of old file
0842  * @size:   truncate to given size
0843  *
0844  * Return:  0 on success, otherwise error
0845  */
0846 int ksmbd_vfs_truncate(struct ksmbd_work *work,
0847                struct ksmbd_file *fp, loff_t size)
0848 {
0849     int err = 0;
0850     struct file *filp;
0851 
0852     filp = fp->filp;
0853 
0854     /* Do we need to break any of a levelII oplock? */
0855     smb_break_all_levII_oplock(work, fp, 1);
0856 
0857     if (!work->tcon->posix_extensions) {
0858         struct inode *inode = file_inode(filp);
0859 
0860         if (size < inode->i_size) {
0861             err = check_lock_range(filp, size,
0862                            inode->i_size - 1, WRITE);
0863         } else {
0864             err = check_lock_range(filp, inode->i_size,
0865                            size - 1, WRITE);
0866         }
0867 
0868         if (err) {
0869             pr_err("failed due to lock\n");
0870             return -EAGAIN;
0871         }
0872     }
0873 
0874     err = vfs_truncate(&filp->f_path, size);
0875     if (err)
0876         pr_err("truncate failed, err %d\n", err);
0877     return err;
0878 }
0879 
0880 /**
0881  * ksmbd_vfs_listxattr() - vfs helper for smb list extended attributes
0882  * @dentry: dentry of file for listing xattrs
0883  * @list:   destination buffer
0884  * @size:   destination buffer length
0885  *
0886  * Return:  xattr list length on success, otherwise error
0887  */
0888 ssize_t ksmbd_vfs_listxattr(struct dentry *dentry, char **list)
0889 {
0890     ssize_t size;
0891     char *vlist = NULL;
0892 
0893     size = vfs_listxattr(dentry, NULL, 0);
0894     if (size <= 0)
0895         return size;
0896 
0897     vlist = kvmalloc(size, GFP_KERNEL | __GFP_ZERO);
0898     if (!vlist)
0899         return -ENOMEM;
0900 
0901     *list = vlist;
0902     size = vfs_listxattr(dentry, vlist, size);
0903     if (size < 0) {
0904         ksmbd_debug(VFS, "listxattr failed\n");
0905         kvfree(vlist);
0906         *list = NULL;
0907     }
0908 
0909     return size;
0910 }
0911 
0912 static ssize_t ksmbd_vfs_xattr_len(struct user_namespace *user_ns,
0913                    struct dentry *dentry, char *xattr_name)
0914 {
0915     return vfs_getxattr(user_ns, dentry, xattr_name, NULL, 0);
0916 }
0917 
0918 /**
0919  * ksmbd_vfs_getxattr() - vfs helper for smb get extended attributes value
0920  * @user_ns:    user namespace
0921  * @dentry: dentry of file for getting xattrs
0922  * @xattr_name: name of xattr name to query
0923  * @xattr_buf:  destination buffer xattr value
0924  *
0925  * Return:  read xattr value length on success, otherwise error
0926  */
0927 ssize_t ksmbd_vfs_getxattr(struct user_namespace *user_ns,
0928                struct dentry *dentry,
0929                char *xattr_name, char **xattr_buf)
0930 {
0931     ssize_t xattr_len;
0932     char *buf;
0933 
0934     *xattr_buf = NULL;
0935     xattr_len = ksmbd_vfs_xattr_len(user_ns, dentry, xattr_name);
0936     if (xattr_len < 0)
0937         return xattr_len;
0938 
0939     buf = kmalloc(xattr_len + 1, GFP_KERNEL);
0940     if (!buf)
0941         return -ENOMEM;
0942 
0943     xattr_len = vfs_getxattr(user_ns, dentry, xattr_name,
0944                  (void *)buf, xattr_len);
0945     if (xattr_len > 0)
0946         *xattr_buf = buf;
0947     else
0948         kfree(buf);
0949     return xattr_len;
0950 }
0951 
0952 /**
0953  * ksmbd_vfs_setxattr() - vfs helper for smb set extended attributes value
0954  * @user_ns:    user namespace
0955  * @dentry: dentry to set XATTR at
0956  * @name:   xattr name for setxattr
0957  * @value:  xattr value to set
0958  * @size:   size of xattr value
0959  * @flags:  destination buffer length
0960  *
0961  * Return:  0 on success, otherwise error
0962  */
0963 int ksmbd_vfs_setxattr(struct user_namespace *user_ns,
0964                struct dentry *dentry, const char *attr_name,
0965                void *attr_value, size_t attr_size, int flags)
0966 {
0967     int err;
0968 
0969     err = vfs_setxattr(user_ns,
0970                dentry,
0971                attr_name,
0972                attr_value,
0973                attr_size,
0974                flags);
0975     if (err)
0976         ksmbd_debug(VFS, "setxattr failed, err %d\n", err);
0977     return err;
0978 }
0979 
0980 /**
0981  * ksmbd_vfs_set_fadvise() - convert smb IO caching options to linux options
0982  * @filp:   file pointer for IO
0983  * @options:    smb IO options
0984  */
0985 void ksmbd_vfs_set_fadvise(struct file *filp, __le32 option)
0986 {
0987     struct address_space *mapping;
0988 
0989     mapping = filp->f_mapping;
0990 
0991     if (!option || !mapping)
0992         return;
0993 
0994     if (option & FILE_WRITE_THROUGH_LE) {
0995         filp->f_flags |= O_SYNC;
0996     } else if (option & FILE_SEQUENTIAL_ONLY_LE) {
0997         filp->f_ra.ra_pages = inode_to_bdi(mapping->host)->ra_pages * 2;
0998         spin_lock(&filp->f_lock);
0999         filp->f_mode &= ~FMODE_RANDOM;
1000         spin_unlock(&filp->f_lock);
1001     } else if (option & FILE_RANDOM_ACCESS_LE) {
1002         spin_lock(&filp->f_lock);
1003         filp->f_mode |= FMODE_RANDOM;
1004         spin_unlock(&filp->f_lock);
1005     }
1006 }
1007 
1008 int ksmbd_vfs_zero_data(struct ksmbd_work *work, struct ksmbd_file *fp,
1009             loff_t off, loff_t len)
1010 {
1011     smb_break_all_levII_oplock(work, fp, 1);
1012     if (fp->f_ci->m_fattr & FILE_ATTRIBUTE_SPARSE_FILE_LE)
1013         return vfs_fallocate(fp->filp,
1014                      FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1015                      off, len);
1016 
1017     return vfs_fallocate(fp->filp,
1018                  FALLOC_FL_ZERO_RANGE | FALLOC_FL_KEEP_SIZE,
1019                  off, len);
1020 }
1021 
1022 int ksmbd_vfs_fqar_lseek(struct ksmbd_file *fp, loff_t start, loff_t length,
1023              struct file_allocated_range_buffer *ranges,
1024              unsigned int in_count, unsigned int *out_count)
1025 {
1026     struct file *f = fp->filp;
1027     struct inode *inode = file_inode(fp->filp);
1028     loff_t maxbytes = (u64)inode->i_sb->s_maxbytes, end;
1029     loff_t extent_start, extent_end;
1030     int ret = 0;
1031 
1032     if (start > maxbytes)
1033         return -EFBIG;
1034 
1035     if (!in_count)
1036         return 0;
1037 
1038     /*
1039      * Shrink request scope to what the fs can actually handle.
1040      */
1041     if (length > maxbytes || (maxbytes - length) < start)
1042         length = maxbytes - start;
1043 
1044     if (start + length > inode->i_size)
1045         length = inode->i_size - start;
1046 
1047     *out_count = 0;
1048     end = start + length;
1049     while (start < end && *out_count < in_count) {
1050         extent_start = vfs_llseek(f, start, SEEK_DATA);
1051         if (extent_start < 0) {
1052             if (extent_start != -ENXIO)
1053                 ret = (int)extent_start;
1054             break;
1055         }
1056 
1057         if (extent_start >= end)
1058             break;
1059 
1060         extent_end = vfs_llseek(f, extent_start, SEEK_HOLE);
1061         if (extent_end < 0) {
1062             if (extent_end != -ENXIO)
1063                 ret = (int)extent_end;
1064             break;
1065         } else if (extent_start >= extent_end) {
1066             break;
1067         }
1068 
1069         ranges[*out_count].file_offset = cpu_to_le64(extent_start);
1070         ranges[(*out_count)++].length =
1071             cpu_to_le64(min(extent_end, end) - extent_start);
1072 
1073         start = extent_end;
1074     }
1075 
1076     return ret;
1077 }
1078 
1079 int ksmbd_vfs_remove_xattr(struct user_namespace *user_ns,
1080                struct dentry *dentry, char *attr_name)
1081 {
1082     return vfs_removexattr(user_ns, dentry, attr_name);
1083 }
1084 
1085 int ksmbd_vfs_unlink(struct user_namespace *user_ns,
1086              struct dentry *dir, struct dentry *dentry)
1087 {
1088     int err = 0;
1089 
1090     err = ksmbd_vfs_lock_parent(user_ns, dir, dentry);
1091     if (err)
1092         return err;
1093     dget(dentry);
1094 
1095     if (S_ISDIR(d_inode(dentry)->i_mode))
1096         err = vfs_rmdir(user_ns, d_inode(dir), dentry);
1097     else
1098         err = vfs_unlink(user_ns, d_inode(dir), dentry, NULL);
1099 
1100     dput(dentry);
1101     inode_unlock(d_inode(dir));
1102     if (err)
1103         ksmbd_debug(VFS, "failed to delete, err %d\n", err);
1104 
1105     return err;
1106 }
1107 
1108 static int __dir_empty(struct dir_context *ctx, const char *name, int namlen,
1109                loff_t offset, u64 ino, unsigned int d_type)
1110 {
1111     struct ksmbd_readdir_data *buf;
1112 
1113     buf = container_of(ctx, struct ksmbd_readdir_data, ctx);
1114     buf->dirent_count++;
1115 
1116     if (buf->dirent_count > 2)
1117         return -ENOTEMPTY;
1118     return 0;
1119 }
1120 
1121 /**
1122  * ksmbd_vfs_empty_dir() - check for empty directory
1123  * @fp: ksmbd file pointer
1124  *
1125  * Return:  true if directory empty, otherwise false
1126  */
1127 int ksmbd_vfs_empty_dir(struct ksmbd_file *fp)
1128 {
1129     int err;
1130     struct ksmbd_readdir_data readdir_data;
1131 
1132     memset(&readdir_data, 0, sizeof(struct ksmbd_readdir_data));
1133 
1134     set_ctx_actor(&readdir_data.ctx, __dir_empty);
1135     readdir_data.dirent_count = 0;
1136 
1137     err = iterate_dir(fp->filp, &readdir_data.ctx);
1138     if (readdir_data.dirent_count > 2)
1139         err = -ENOTEMPTY;
1140     else
1141         err = 0;
1142     return err;
1143 }
1144 
1145 static int __caseless_lookup(struct dir_context *ctx, const char *name,
1146                  int namlen, loff_t offset, u64 ino,
1147                  unsigned int d_type)
1148 {
1149     struct ksmbd_readdir_data *buf;
1150 
1151     buf = container_of(ctx, struct ksmbd_readdir_data, ctx);
1152 
1153     if (buf->used != namlen)
1154         return 0;
1155     if (!strncasecmp((char *)buf->private, name, namlen)) {
1156         memcpy((char *)buf->private, name, namlen);
1157         buf->dirent_count = 1;
1158         return -EEXIST;
1159     }
1160     return 0;
1161 }
1162 
1163 /**
1164  * ksmbd_vfs_lookup_in_dir() - lookup a file in a directory
1165  * @dir:    path info
1166  * @name:   filename to lookup
1167  * @namelen:    filename length
1168  *
1169  * Return:  0 on success, otherwise error
1170  */
1171 static int ksmbd_vfs_lookup_in_dir(struct path *dir, char *name, size_t namelen)
1172 {
1173     int ret;
1174     struct file *dfilp;
1175     int flags = O_RDONLY | O_LARGEFILE;
1176     struct ksmbd_readdir_data readdir_data = {
1177         .ctx.actor  = __caseless_lookup,
1178         .private    = name,
1179         .used       = namelen,
1180         .dirent_count   = 0,
1181     };
1182 
1183     dfilp = dentry_open(dir, flags, current_cred());
1184     if (IS_ERR(dfilp))
1185         return PTR_ERR(dfilp);
1186 
1187     ret = iterate_dir(dfilp, &readdir_data.ctx);
1188     if (readdir_data.dirent_count > 0)
1189         ret = 0;
1190     fput(dfilp);
1191     return ret;
1192 }
1193 
1194 /**
1195  * ksmbd_vfs_kern_path() - lookup a file and get path info
1196  * @name:   file path that is relative to share
1197  * @flags:  lookup flags
1198  * @path:   if lookup succeed, return path info
1199  * @caseless:   caseless filename lookup
1200  *
1201  * Return:  0 on success, otherwise error
1202  */
1203 int ksmbd_vfs_kern_path(struct ksmbd_work *work, char *name,
1204             unsigned int flags, struct path *path, bool caseless)
1205 {
1206     struct ksmbd_share_config *share_conf = work->tcon->share_conf;
1207     int err;
1208 
1209     flags |= LOOKUP_BENEATH;
1210     err = vfs_path_lookup(share_conf->vfs_path.dentry,
1211                   share_conf->vfs_path.mnt,
1212                   name,
1213                   flags,
1214                   path);
1215     if (!err)
1216         return 0;
1217 
1218     if (caseless) {
1219         char *filepath;
1220         struct path parent;
1221         size_t path_len, remain_len;
1222 
1223         filepath = kstrdup(name, GFP_KERNEL);
1224         if (!filepath)
1225             return -ENOMEM;
1226 
1227         path_len = strlen(filepath);
1228         remain_len = path_len;
1229 
1230         parent = share_conf->vfs_path;
1231         path_get(&parent);
1232 
1233         while (d_can_lookup(parent.dentry)) {
1234             char *filename = filepath + path_len - remain_len;
1235             char *next = strchrnul(filename, '/');
1236             size_t filename_len = next - filename;
1237             bool is_last = !next[0];
1238 
1239             if (filename_len == 0)
1240                 break;
1241 
1242             err = ksmbd_vfs_lookup_in_dir(&parent, filename,
1243                               filename_len);
1244             path_put(&parent);
1245             if (err)
1246                 goto out;
1247 
1248             next[0] = '\0';
1249 
1250             err = vfs_path_lookup(share_conf->vfs_path.dentry,
1251                           share_conf->vfs_path.mnt,
1252                           filepath,
1253                           flags,
1254                           &parent);
1255             if (err)
1256                 goto out;
1257             else if (is_last) {
1258                 *path = parent;
1259                 goto out;
1260             }
1261 
1262             next[0] = '/';
1263             remain_len -= filename_len + 1;
1264         }
1265 
1266         path_put(&parent);
1267         err = -EINVAL;
1268 out:
1269         kfree(filepath);
1270     }
1271     return err;
1272 }
1273 
1274 struct dentry *ksmbd_vfs_kern_path_create(struct ksmbd_work *work,
1275                       const char *name,
1276                       unsigned int flags,
1277                       struct path *path)
1278 {
1279     char *abs_name;
1280     struct dentry *dent;
1281 
1282     abs_name = convert_to_unix_name(work->tcon->share_conf, name);
1283     if (!abs_name)
1284         return ERR_PTR(-ENOMEM);
1285 
1286     dent = kern_path_create(AT_FDCWD, abs_name, path, flags);
1287     kfree(abs_name);
1288     return dent;
1289 }
1290 
1291 int ksmbd_vfs_remove_acl_xattrs(struct user_namespace *user_ns,
1292                 struct dentry *dentry)
1293 {
1294     char *name, *xattr_list = NULL;
1295     ssize_t xattr_list_len;
1296     int err = 0;
1297 
1298     xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list);
1299     if (xattr_list_len < 0) {
1300         goto out;
1301     } else if (!xattr_list_len) {
1302         ksmbd_debug(SMB, "empty xattr in the file\n");
1303         goto out;
1304     }
1305 
1306     for (name = xattr_list; name - xattr_list < xattr_list_len;
1307          name += strlen(name) + 1) {
1308         ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name));
1309 
1310         if (!strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS,
1311                  sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1) ||
1312             !strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT,
1313                  sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1)) {
1314             err = ksmbd_vfs_remove_xattr(user_ns, dentry, name);
1315             if (err)
1316                 ksmbd_debug(SMB,
1317                         "remove acl xattr failed : %s\n", name);
1318         }
1319     }
1320 out:
1321     kvfree(xattr_list);
1322     return err;
1323 }
1324 
1325 int ksmbd_vfs_remove_sd_xattrs(struct user_namespace *user_ns,
1326                    struct dentry *dentry)
1327 {
1328     char *name, *xattr_list = NULL;
1329     ssize_t xattr_list_len;
1330     int err = 0;
1331 
1332     xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list);
1333     if (xattr_list_len < 0) {
1334         goto out;
1335     } else if (!xattr_list_len) {
1336         ksmbd_debug(SMB, "empty xattr in the file\n");
1337         goto out;
1338     }
1339 
1340     for (name = xattr_list; name - xattr_list < xattr_list_len;
1341             name += strlen(name) + 1) {
1342         ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name));
1343 
1344         if (!strncmp(name, XATTR_NAME_SD, XATTR_NAME_SD_LEN)) {
1345             err = ksmbd_vfs_remove_xattr(user_ns, dentry, name);
1346             if (err)
1347                 ksmbd_debug(SMB, "remove xattr failed : %s\n", name);
1348         }
1349     }
1350 out:
1351     kvfree(xattr_list);
1352     return err;
1353 }
1354 
1355 static struct xattr_smb_acl *ksmbd_vfs_make_xattr_posix_acl(struct user_namespace *user_ns,
1356                                 struct inode *inode,
1357                                 int acl_type)
1358 {
1359     struct xattr_smb_acl *smb_acl = NULL;
1360     struct posix_acl *posix_acls;
1361     struct posix_acl_entry *pa_entry;
1362     struct xattr_acl_entry *xa_entry;
1363     int i;
1364 
1365     if (!IS_ENABLED(CONFIG_FS_POSIX_ACL))
1366         return NULL;
1367 
1368     posix_acls = get_acl(inode, acl_type);
1369     if (!posix_acls)
1370         return NULL;
1371 
1372     smb_acl = kzalloc(sizeof(struct xattr_smb_acl) +
1373               sizeof(struct xattr_acl_entry) * posix_acls->a_count,
1374               GFP_KERNEL);
1375     if (!smb_acl)
1376         goto out;
1377 
1378     smb_acl->count = posix_acls->a_count;
1379     pa_entry = posix_acls->a_entries;
1380     xa_entry = smb_acl->entries;
1381     for (i = 0; i < posix_acls->a_count; i++, pa_entry++, xa_entry++) {
1382         switch (pa_entry->e_tag) {
1383         case ACL_USER:
1384             xa_entry->type = SMB_ACL_USER;
1385             xa_entry->uid = posix_acl_uid_translate(user_ns, pa_entry);
1386             break;
1387         case ACL_USER_OBJ:
1388             xa_entry->type = SMB_ACL_USER_OBJ;
1389             break;
1390         case ACL_GROUP:
1391             xa_entry->type = SMB_ACL_GROUP;
1392             xa_entry->gid = posix_acl_gid_translate(user_ns, pa_entry);
1393             break;
1394         case ACL_GROUP_OBJ:
1395             xa_entry->type = SMB_ACL_GROUP_OBJ;
1396             break;
1397         case ACL_OTHER:
1398             xa_entry->type = SMB_ACL_OTHER;
1399             break;
1400         case ACL_MASK:
1401             xa_entry->type = SMB_ACL_MASK;
1402             break;
1403         default:
1404             pr_err("unknown type : 0x%x\n", pa_entry->e_tag);
1405             goto out;
1406         }
1407 
1408         if (pa_entry->e_perm & ACL_READ)
1409             xa_entry->perm |= SMB_ACL_READ;
1410         if (pa_entry->e_perm & ACL_WRITE)
1411             xa_entry->perm |= SMB_ACL_WRITE;
1412         if (pa_entry->e_perm & ACL_EXECUTE)
1413             xa_entry->perm |= SMB_ACL_EXECUTE;
1414     }
1415 out:
1416     posix_acl_release(posix_acls);
1417     return smb_acl;
1418 }
1419 
1420 int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn *conn,
1421                struct user_namespace *user_ns,
1422                struct dentry *dentry,
1423                struct smb_ntsd *pntsd, int len)
1424 {
1425     int rc;
1426     struct ndr sd_ndr = {0}, acl_ndr = {0};
1427     struct xattr_ntacl acl = {0};
1428     struct xattr_smb_acl *smb_acl, *def_smb_acl = NULL;
1429     struct inode *inode = d_inode(dentry);
1430 
1431     acl.version = 4;
1432     acl.hash_type = XATTR_SD_HASH_TYPE_SHA256;
1433     acl.current_time = ksmbd_UnixTimeToNT(current_time(inode));
1434 
1435     memcpy(acl.desc, "posix_acl", 9);
1436     acl.desc_len = 10;
1437 
1438     pntsd->osidoffset =
1439         cpu_to_le32(le32_to_cpu(pntsd->osidoffset) + NDR_NTSD_OFFSETOF);
1440     pntsd->gsidoffset =
1441         cpu_to_le32(le32_to_cpu(pntsd->gsidoffset) + NDR_NTSD_OFFSETOF);
1442     pntsd->dacloffset =
1443         cpu_to_le32(le32_to_cpu(pntsd->dacloffset) + NDR_NTSD_OFFSETOF);
1444 
1445     acl.sd_buf = (char *)pntsd;
1446     acl.sd_size = len;
1447 
1448     rc = ksmbd_gen_sd_hash(conn, acl.sd_buf, acl.sd_size, acl.hash);
1449     if (rc) {
1450         pr_err("failed to generate hash for ndr acl\n");
1451         return rc;
1452     }
1453 
1454     smb_acl = ksmbd_vfs_make_xattr_posix_acl(user_ns, inode,
1455                          ACL_TYPE_ACCESS);
1456     if (S_ISDIR(inode->i_mode))
1457         def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(user_ns, inode,
1458                                  ACL_TYPE_DEFAULT);
1459 
1460     rc = ndr_encode_posix_acl(&acl_ndr, user_ns, inode,
1461                   smb_acl, def_smb_acl);
1462     if (rc) {
1463         pr_err("failed to encode ndr to posix acl\n");
1464         goto out;
1465     }
1466 
1467     rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset,
1468                    acl.posix_acl_hash);
1469     if (rc) {
1470         pr_err("failed to generate hash for ndr acl\n");
1471         goto out;
1472     }
1473 
1474     rc = ndr_encode_v4_ntacl(&sd_ndr, &acl);
1475     if (rc) {
1476         pr_err("failed to encode ndr to posix acl\n");
1477         goto out;
1478     }
1479 
1480     rc = ksmbd_vfs_setxattr(user_ns, dentry,
1481                 XATTR_NAME_SD, sd_ndr.data,
1482                 sd_ndr.offset, 0);
1483     if (rc < 0)
1484         pr_err("Failed to store XATTR ntacl :%d\n", rc);
1485 
1486     kfree(sd_ndr.data);
1487 out:
1488     kfree(acl_ndr.data);
1489     kfree(smb_acl);
1490     kfree(def_smb_acl);
1491     return rc;
1492 }
1493 
1494 int ksmbd_vfs_get_sd_xattr(struct ksmbd_conn *conn,
1495                struct user_namespace *user_ns,
1496                struct dentry *dentry,
1497                struct smb_ntsd **pntsd)
1498 {
1499     int rc;
1500     struct ndr n;
1501     struct inode *inode = d_inode(dentry);
1502     struct ndr acl_ndr = {0};
1503     struct xattr_ntacl acl;
1504     struct xattr_smb_acl *smb_acl = NULL, *def_smb_acl = NULL;
1505     __u8 cmp_hash[XATTR_SD_HASH_SIZE] = {0};
1506 
1507     rc = ksmbd_vfs_getxattr(user_ns, dentry, XATTR_NAME_SD, &n.data);
1508     if (rc <= 0)
1509         return rc;
1510 
1511     n.length = rc;
1512     rc = ndr_decode_v4_ntacl(&n, &acl);
1513     if (rc)
1514         goto free_n_data;
1515 
1516     smb_acl = ksmbd_vfs_make_xattr_posix_acl(user_ns, inode,
1517                          ACL_TYPE_ACCESS);
1518     if (S_ISDIR(inode->i_mode))
1519         def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(user_ns, inode,
1520                                  ACL_TYPE_DEFAULT);
1521 
1522     rc = ndr_encode_posix_acl(&acl_ndr, user_ns, inode, smb_acl,
1523                   def_smb_acl);
1524     if (rc) {
1525         pr_err("failed to encode ndr to posix acl\n");
1526         goto out_free;
1527     }
1528 
1529     rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset, cmp_hash);
1530     if (rc) {
1531         pr_err("failed to generate hash for ndr acl\n");
1532         goto out_free;
1533     }
1534 
1535     if (memcmp(cmp_hash, acl.posix_acl_hash, XATTR_SD_HASH_SIZE)) {
1536         pr_err("hash value diff\n");
1537         rc = -EINVAL;
1538         goto out_free;
1539     }
1540 
1541     *pntsd = acl.sd_buf;
1542     if (acl.sd_size < sizeof(struct smb_ntsd)) {
1543         pr_err("sd size is invalid\n");
1544         goto out_free;
1545     }
1546 
1547     (*pntsd)->osidoffset = cpu_to_le32(le32_to_cpu((*pntsd)->osidoffset) -
1548                        NDR_NTSD_OFFSETOF);
1549     (*pntsd)->gsidoffset = cpu_to_le32(le32_to_cpu((*pntsd)->gsidoffset) -
1550                        NDR_NTSD_OFFSETOF);
1551     (*pntsd)->dacloffset = cpu_to_le32(le32_to_cpu((*pntsd)->dacloffset) -
1552                        NDR_NTSD_OFFSETOF);
1553 
1554     rc = acl.sd_size;
1555 out_free:
1556     kfree(acl_ndr.data);
1557     kfree(smb_acl);
1558     kfree(def_smb_acl);
1559     if (rc < 0) {
1560         kfree(acl.sd_buf);
1561         *pntsd = NULL;
1562     }
1563 
1564 free_n_data:
1565     kfree(n.data);
1566     return rc;
1567 }
1568 
1569 int ksmbd_vfs_set_dos_attrib_xattr(struct user_namespace *user_ns,
1570                    struct dentry *dentry,
1571                    struct xattr_dos_attrib *da)
1572 {
1573     struct ndr n;
1574     int err;
1575 
1576     err = ndr_encode_dos_attr(&n, da);
1577     if (err)
1578         return err;
1579 
1580     err = ksmbd_vfs_setxattr(user_ns, dentry, XATTR_NAME_DOS_ATTRIBUTE,
1581                  (void *)n.data, n.offset, 0);
1582     if (err)
1583         ksmbd_debug(SMB, "failed to store dos attribute in xattr\n");
1584     kfree(n.data);
1585 
1586     return err;
1587 }
1588 
1589 int ksmbd_vfs_get_dos_attrib_xattr(struct user_namespace *user_ns,
1590                    struct dentry *dentry,
1591                    struct xattr_dos_attrib *da)
1592 {
1593     struct ndr n;
1594     int err;
1595 
1596     err = ksmbd_vfs_getxattr(user_ns, dentry, XATTR_NAME_DOS_ATTRIBUTE,
1597                  (char **)&n.data);
1598     if (err > 0) {
1599         n.length = err;
1600         if (ndr_decode_dos_attr(&n, da))
1601             err = -EINVAL;
1602         kfree(n.data);
1603     } else {
1604         ksmbd_debug(SMB, "failed to load dos attribute in xattr\n");
1605     }
1606 
1607     return err;
1608 }
1609 
1610 /**
1611  * ksmbd_vfs_init_kstat() - convert unix stat information to smb stat format
1612  * @p:          destination buffer
1613  * @ksmbd_kstat:      ksmbd kstat wrapper
1614  */
1615 void *ksmbd_vfs_init_kstat(char **p, struct ksmbd_kstat *ksmbd_kstat)
1616 {
1617     struct file_directory_info *info = (struct file_directory_info *)(*p);
1618     struct kstat *kstat = ksmbd_kstat->kstat;
1619     u64 time;
1620 
1621     info->FileIndex = 0;
1622     info->CreationTime = cpu_to_le64(ksmbd_kstat->create_time);
1623     time = ksmbd_UnixTimeToNT(kstat->atime);
1624     info->LastAccessTime = cpu_to_le64(time);
1625     time = ksmbd_UnixTimeToNT(kstat->mtime);
1626     info->LastWriteTime = cpu_to_le64(time);
1627     time = ksmbd_UnixTimeToNT(kstat->ctime);
1628     info->ChangeTime = cpu_to_le64(time);
1629 
1630     if (ksmbd_kstat->file_attributes & FILE_ATTRIBUTE_DIRECTORY_LE) {
1631         info->EndOfFile = 0;
1632         info->AllocationSize = 0;
1633     } else {
1634         info->EndOfFile = cpu_to_le64(kstat->size);
1635         info->AllocationSize = cpu_to_le64(kstat->blocks << 9);
1636     }
1637     info->ExtFileAttributes = ksmbd_kstat->file_attributes;
1638 
1639     return info;
1640 }
1641 
1642 int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work,
1643                 struct user_namespace *user_ns,
1644                 struct dentry *dentry,
1645                 struct ksmbd_kstat *ksmbd_kstat)
1646 {
1647     u64 time;
1648     int rc;
1649 
1650     generic_fillattr(user_ns, d_inode(dentry), ksmbd_kstat->kstat);
1651 
1652     time = ksmbd_UnixTimeToNT(ksmbd_kstat->kstat->ctime);
1653     ksmbd_kstat->create_time = time;
1654 
1655     /*
1656      * set default value for the case that store dos attributes is not yes
1657      * or that acl is disable in server's filesystem and the config is yes.
1658      */
1659     if (S_ISDIR(ksmbd_kstat->kstat->mode))
1660         ksmbd_kstat->file_attributes = FILE_ATTRIBUTE_DIRECTORY_LE;
1661     else
1662         ksmbd_kstat->file_attributes = FILE_ATTRIBUTE_ARCHIVE_LE;
1663 
1664     if (test_share_config_flag(work->tcon->share_conf,
1665                    KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) {
1666         struct xattr_dos_attrib da;
1667 
1668         rc = ksmbd_vfs_get_dos_attrib_xattr(user_ns, dentry, &da);
1669         if (rc > 0) {
1670             ksmbd_kstat->file_attributes = cpu_to_le32(da.attr);
1671             ksmbd_kstat->create_time = da.create_time;
1672         } else {
1673             ksmbd_debug(VFS, "fail to load dos attribute.\n");
1674         }
1675     }
1676 
1677     return 0;
1678 }
1679 
1680 ssize_t ksmbd_vfs_casexattr_len(struct user_namespace *user_ns,
1681                 struct dentry *dentry, char *attr_name,
1682                 int attr_name_len)
1683 {
1684     char *name, *xattr_list = NULL;
1685     ssize_t value_len = -ENOENT, xattr_list_len;
1686 
1687     xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list);
1688     if (xattr_list_len <= 0)
1689         goto out;
1690 
1691     for (name = xattr_list; name - xattr_list < xattr_list_len;
1692             name += strlen(name) + 1) {
1693         ksmbd_debug(VFS, "%s, len %zd\n", name, strlen(name));
1694         if (strncasecmp(attr_name, name, attr_name_len))
1695             continue;
1696 
1697         value_len = ksmbd_vfs_xattr_len(user_ns, dentry, name);
1698         break;
1699     }
1700 
1701 out:
1702     kvfree(xattr_list);
1703     return value_len;
1704 }
1705 
1706 int ksmbd_vfs_xattr_stream_name(char *stream_name, char **xattr_stream_name,
1707                 size_t *xattr_stream_name_size, int s_type)
1708 {
1709     char *type, *buf;
1710 
1711     if (s_type == DIR_STREAM)
1712         type = ":$INDEX_ALLOCATION";
1713     else
1714         type = ":$DATA";
1715 
1716     buf = kasprintf(GFP_KERNEL, "%s%s%s",
1717             XATTR_NAME_STREAM, stream_name, type);
1718     if (!buf)
1719         return -ENOMEM;
1720 
1721     *xattr_stream_name = buf;
1722     *xattr_stream_name_size = strlen(buf) + 1;
1723 
1724     return 0;
1725 }
1726 
1727 int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work,
1728                    struct ksmbd_file *src_fp,
1729                    struct ksmbd_file *dst_fp,
1730                    struct srv_copychunk *chunks,
1731                    unsigned int chunk_count,
1732                    unsigned int *chunk_count_written,
1733                    unsigned int *chunk_size_written,
1734                    loff_t *total_size_written)
1735 {
1736     unsigned int i;
1737     loff_t src_off, dst_off, src_file_size;
1738     size_t len;
1739     int ret;
1740 
1741     *chunk_count_written = 0;
1742     *chunk_size_written = 0;
1743     *total_size_written = 0;
1744 
1745     if (!(src_fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) {
1746         pr_err("no right to read(%pd)\n", src_fp->filp->f_path.dentry);
1747         return -EACCES;
1748     }
1749     if (!(dst_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE))) {
1750         pr_err("no right to write(%pd)\n", dst_fp->filp->f_path.dentry);
1751         return -EACCES;
1752     }
1753 
1754     if (ksmbd_stream_fd(src_fp) || ksmbd_stream_fd(dst_fp))
1755         return -EBADF;
1756 
1757     smb_break_all_levII_oplock(work, dst_fp, 1);
1758 
1759     if (!work->tcon->posix_extensions) {
1760         for (i = 0; i < chunk_count; i++) {
1761             src_off = le64_to_cpu(chunks[i].SourceOffset);
1762             dst_off = le64_to_cpu(chunks[i].TargetOffset);
1763             len = le32_to_cpu(chunks[i].Length);
1764 
1765             if (check_lock_range(src_fp->filp, src_off,
1766                          src_off + len - 1, READ))
1767                 return -EAGAIN;
1768             if (check_lock_range(dst_fp->filp, dst_off,
1769                          dst_off + len - 1, WRITE))
1770                 return -EAGAIN;
1771         }
1772     }
1773 
1774     src_file_size = i_size_read(file_inode(src_fp->filp));
1775 
1776     for (i = 0; i < chunk_count; i++) {
1777         src_off = le64_to_cpu(chunks[i].SourceOffset);
1778         dst_off = le64_to_cpu(chunks[i].TargetOffset);
1779         len = le32_to_cpu(chunks[i].Length);
1780 
1781         if (src_off + len > src_file_size)
1782             return -E2BIG;
1783 
1784         ret = vfs_copy_file_range(src_fp->filp, src_off,
1785                       dst_fp->filp, dst_off, len, 0);
1786         if (ret == -EOPNOTSUPP || ret == -EXDEV)
1787             ret = generic_copy_file_range(src_fp->filp, src_off,
1788                               dst_fp->filp, dst_off,
1789                               len, 0);
1790         if (ret < 0)
1791             return ret;
1792 
1793         *chunk_count_written += 1;
1794         *total_size_written += ret;
1795     }
1796     return 0;
1797 }
1798 
1799 void ksmbd_vfs_posix_lock_wait(struct file_lock *flock)
1800 {
1801     wait_event(flock->fl_wait, !flock->fl_blocker);
1802 }
1803 
1804 int ksmbd_vfs_posix_lock_wait_timeout(struct file_lock *flock, long timeout)
1805 {
1806     return wait_event_interruptible_timeout(flock->fl_wait,
1807                         !flock->fl_blocker,
1808                         timeout);
1809 }
1810 
1811 void ksmbd_vfs_posix_lock_unblock(struct file_lock *flock)
1812 {
1813     locks_delete_block(flock);
1814 }
1815 
1816 int ksmbd_vfs_set_init_posix_acl(struct user_namespace *user_ns,
1817                  struct inode *inode)
1818 {
1819     struct posix_acl_state acl_state;
1820     struct posix_acl *acls;
1821     int rc;
1822 
1823     if (!IS_ENABLED(CONFIG_FS_POSIX_ACL))
1824         return -EOPNOTSUPP;
1825 
1826     ksmbd_debug(SMB, "Set posix acls\n");
1827     rc = init_acl_state(&acl_state, 1);
1828     if (rc)
1829         return rc;
1830 
1831     /* Set default owner group */
1832     acl_state.owner.allow = (inode->i_mode & 0700) >> 6;
1833     acl_state.group.allow = (inode->i_mode & 0070) >> 3;
1834     acl_state.other.allow = inode->i_mode & 0007;
1835     acl_state.users->aces[acl_state.users->n].uid = inode->i_uid;
1836     acl_state.users->aces[acl_state.users->n++].perms.allow =
1837         acl_state.owner.allow;
1838     acl_state.groups->aces[acl_state.groups->n].gid = inode->i_gid;
1839     acl_state.groups->aces[acl_state.groups->n++].perms.allow =
1840         acl_state.group.allow;
1841     acl_state.mask.allow = 0x07;
1842 
1843     acls = posix_acl_alloc(6, GFP_KERNEL);
1844     if (!acls) {
1845         free_acl_state(&acl_state);
1846         return -ENOMEM;
1847     }
1848     posix_state_to_acl(&acl_state, acls->a_entries);
1849     rc = set_posix_acl(user_ns, inode, ACL_TYPE_ACCESS, acls);
1850     if (rc < 0)
1851         ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n",
1852                 rc);
1853     else if (S_ISDIR(inode->i_mode)) {
1854         posix_state_to_acl(&acl_state, acls->a_entries);
1855         rc = set_posix_acl(user_ns, inode, ACL_TYPE_DEFAULT,
1856                    acls);
1857         if (rc < 0)
1858             ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n",
1859                     rc);
1860     }
1861     free_acl_state(&acl_state);
1862     posix_acl_release(acls);
1863     return rc;
1864 }
1865 
1866 int ksmbd_vfs_inherit_posix_acl(struct user_namespace *user_ns,
1867                 struct inode *inode, struct inode *parent_inode)
1868 {
1869     struct posix_acl *acls;
1870     struct posix_acl_entry *pace;
1871     int rc, i;
1872 
1873     if (!IS_ENABLED(CONFIG_FS_POSIX_ACL))
1874         return -EOPNOTSUPP;
1875 
1876     acls = get_acl(parent_inode, ACL_TYPE_DEFAULT);
1877     if (!acls)
1878         return -ENOENT;
1879     pace = acls->a_entries;
1880 
1881     for (i = 0; i < acls->a_count; i++, pace++) {
1882         if (pace->e_tag == ACL_MASK) {
1883             pace->e_perm = 0x07;
1884             break;
1885         }
1886     }
1887 
1888     rc = set_posix_acl(user_ns, inode, ACL_TYPE_ACCESS, acls);
1889     if (rc < 0)
1890         ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n",
1891                 rc);
1892     if (S_ISDIR(inode->i_mode)) {
1893         rc = set_posix_acl(user_ns, inode, ACL_TYPE_DEFAULT,
1894                    acls);
1895         if (rc < 0)
1896             ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n",
1897                     rc);
1898     }
1899     posix_acl_release(acls);
1900     return rc;
1901 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!