fs/ksmbd/vfs.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *   Copyright (C) 2016 Namjae Jeon <[email protected]>
   4  *   Copyright (C) 2018 Samsung Electronics Co., Ltd.
   5  */
   6
   7 #include <linux/kernel.h>
   8 #include <linux/fs.h>
   9 #include <linux/filelock.h>
  10 #include <linux/uaccess.h>
  11 #include <linux/backing-dev.h>
  12 #include <linux/writeback.h>
  13 #include <linux/xattr.h>
  14 #include <linux/falloc.h>
  15 #include <linux/fsnotify.h>
  16 #include <linux/dcache.h>
  17 #include <linux/slab.h>
  18 #include <linux/vmalloc.h>
  19 #include <linux/sched/xacct.h>
  20 #include <linux/crc32c.h>
  21
  22 #include "../internal.h"        /* for vfs_path_lookup */
  23
  24 #include "glob.h"
  25 #include "oplock.h"
  26 #include "connection.h"
  27 #include "vfs.h"
  28 #include "vfs_cache.h"
  29 #include "smbacl.h"
  30 #include "ndr.h"
  31 #include "auth.h"
  32 #include "misc.h"
  33
  34 #include "smb_common.h"
  35 #include "mgmt/share_config.h"
  36 #include "mgmt/tree_connect.h"
  37 #include "mgmt/user_session.h"
  38 #include "mgmt/user_config.h"
  39
  40 static char *extract_last_component(char *path)
  41 {
  42         char *p = strrchr(path, '/');
  43
  44         if (p && p[1] != '\0') {
  45                 *p = '\0';
  46                 p++;
  47         } else {
  48                 p = NULL;
  49         }
  50         return p;
  51 }
  52
  53 static void ksmbd_vfs_inherit_owner(struct ksmbd_work *work,
  54                                     struct inode *parent_inode,
  55                                     struct inode *inode)
  56 {
  57         if (!test_share_config_flag(work->tcon->share_conf,
  58                                     KSMBD_SHARE_FLAG_INHERIT_OWNER))
  59                 return;
  60
  61         i_uid_write(inode, i_uid_read(parent_inode));
  62 }
  63
  64 /**
  65  * ksmbd_vfs_lock_parent() - lock parent dentry if it is stable
  66  *
  67  * the parent dentry got by dget_parent or @parent could be
  68  * unstable, we try to lock a parent inode and lookup the
  69  * child dentry again.
  70  *
  71  * the reference count of @parent isn't incremented.
  72  */
  73 int ksmbd_vfs_lock_parent(struct mnt_idmap *idmap, struct dentry *parent,
  74                           struct dentry *child)
  75 {
  76         struct dentry *dentry;
  77         int ret = 0;
  78
  79         inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);
  80         dentry = lookup_one(idmap, child->d_name.name, parent,
  81                             child->d_name.len);
  82         if (IS_ERR(dentry)) {
  83                 ret = PTR_ERR(dentry);
  84                 goto out_err;
  85         }
  86
  87         if (dentry != child) {
  88                 ret = -ESTALE;
  89                 dput(dentry);
  90                 goto out_err;
  91         }
  92
  93         dput(dentry);
  94         return 0;
  95 out_err:
  96         inode_unlock(d_inode(parent));
  97         return ret;
  98 }
  99
 100 int ksmbd_vfs_may_delete(struct mnt_idmap *idmap,
 101                          struct dentry *dentry)
 102 {
 103         struct dentry *parent;
 104         int ret;
 105
 106         parent = dget_parent(dentry);
 107         ret = ksmbd_vfs_lock_parent(idmap, parent, dentry);
 108         if (ret) {
 109                 dput(parent);
 110                 return ret;
 111         }
 112
 113         ret = inode_permission(idmap, d_inode(parent),
 114                                MAY_EXEC | MAY_WRITE);
 115
 116         inode_unlock(d_inode(parent));
 117         dput(parent);
 118         return ret;
 119 }
 120
 121 int ksmbd_vfs_query_maximal_access(struct mnt_idmap *idmap,
 122                                    struct dentry *dentry, __le32 *daccess)
 123 {
 124         struct dentry *parent;
 125         int ret = 0;
 126
 127         *daccess = cpu_to_le32(FILE_READ_ATTRIBUTES | READ_CONTROL);
 128
 129         if (!inode_permission(idmap, d_inode(dentry), MAY_OPEN | MAY_WRITE))
 130                 *daccess |= cpu_to_le32(WRITE_DAC | WRITE_OWNER | SYNCHRONIZE |
 131                                 FILE_WRITE_DATA | FILE_APPEND_DATA |
 132                                 FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES |
 133                                 FILE_DELETE_CHILD);
 134
 135         if (!inode_permission(idmap, d_inode(dentry), MAY_OPEN | MAY_READ))
 136                 *daccess |= FILE_READ_DATA_LE | FILE_READ_EA_LE;
 137
 138         if (!inode_permission(idmap, d_inode(dentry), MAY_OPEN | MAY_EXEC))
 139                 *daccess |= FILE_EXECUTE_LE;
 140
 141         parent = dget_parent(dentry);
 142         ret = ksmbd_vfs_lock_parent(idmap, parent, dentry);
 143         if (ret) {
 144                 dput(parent);
 145                 return ret;
 146         }
 147
 148         if (!inode_permission(idmap, d_inode(parent), MAY_EXEC | MAY_WRITE))
 149                 *daccess |= FILE_DELETE_LE;
 150
 151         inode_unlock(d_inode(parent));
 152         dput(parent);
 153         return ret;
 154 }
 155
 156 /**
 157  * ksmbd_vfs_create() - vfs helper for smb create file
 158  * @work:       work
 159  * @name:       file name that is relative to share
 160  * @mode:       file create mode
 161  *
 162  * Return:      0 on success, otherwise error
 163  */
 164 int ksmbd_vfs_create(struct ksmbd_work *work, const char *name, umode_t mode)
 165 {
 166         struct path path;
 167         struct dentry *dentry;
 168         int err;
 169
 170         dentry = ksmbd_vfs_kern_path_create(work, name,
 171                                             LOOKUP_NO_SYMLINKS, &path);
 172         if (IS_ERR(dentry)) {
 173                 err = PTR_ERR(dentry);
 174                 if (err != -ENOENT)
 175                         pr_err("path create failed for %s, err %d\n",
 176                                name, err);
 177                 return err;
 178         }
 179
 180         mode |= S_IFREG;
 181         err = vfs_create(mnt_idmap(path.mnt), d_inode(path.dentry),
 182                          dentry, mode, true);
 183         if (!err) {
 184                 ksmbd_vfs_inherit_owner(work, d_inode(path.dentry),
 185                                         d_inode(dentry));
 186         } else {
 187                 pr_err("File(%s): creation failed (err:%d)\n", name, err);
 188         }
 189         done_path_create(&path, dentry);
 190         return err;
 191 }
 192
 193 /**
 194  * ksmbd_vfs_mkdir() - vfs helper for smb create directory
 195  * @work:       work
 196  * @name:       directory name that is relative to share
 197  * @mode:       directory create mode
 198  *
 199  * Return:      0 on success, otherwise error
 200  */
 201 int ksmbd_vfs_mkdir(struct ksmbd_work *work, const char *name, umode_t mode)
 202 {
 203         struct mnt_idmap *idmap;
 204         struct path path;
 205         struct dentry *dentry;
 206         int err;
 207
 208         dentry = ksmbd_vfs_kern_path_create(work, name,
 209                                             LOOKUP_NO_SYMLINKS | LOOKUP_DIRECTORY,
 210                                             &path);
 211         if (IS_ERR(dentry)) {
 212                 err = PTR_ERR(dentry);
 213                 if (err != -EEXIST)
 214                         ksmbd_debug(VFS, "path create failed for %s, err %d\n",
 215                                     name, err);
 216                 return err;
 217         }
 218
 219         idmap = mnt_idmap(path.mnt);
 220         mode |= S_IFDIR;
 221         err = vfs_mkdir(idmap, d_inode(path.dentry), dentry, mode);
 222         if (err) {
 223                 goto out;
 224         } else if (d_unhashed(dentry)) {
 225                 struct dentry *d;
 226
 227                 d = lookup_one(idmap, dentry->d_name.name, dentry->d_parent,
 228                                dentry->d_name.len);
 229                 if (IS_ERR(d)) {
 230                         err = PTR_ERR(d);
 231                         goto out;
 232                 }
 233                 if (unlikely(d_is_negative(d))) {
 234                         dput(d);
 235                         err = -ENOENT;
 236                         goto out;
 237                 }
 238
 239                 ksmbd_vfs_inherit_owner(work, d_inode(path.dentry), d_inode(d));
 240                 dput(d);
 241         }
 242 out:
 243         done_path_create(&path, dentry);
 244         if (err)
 245                 pr_err("mkdir(%s): creation failed (err:%d)\n", name, err);
 246         return err;
 247 }
 248
 249 static ssize_t ksmbd_vfs_getcasexattr(struct mnt_idmap *idmap,
 250                                       struct dentry *dentry, char *attr_name,
 251                                       int attr_name_len, char **attr_value)
 252 {
 253         char *name, *xattr_list = NULL;
 254         ssize_t value_len = -ENOENT, xattr_list_len;
 255
 256         xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list);
 257         if (xattr_list_len <= 0)
 258                 goto out;
 259
 260         for (name = xattr_list; name - xattr_list < xattr_list_len;
 261                         name += strlen(name) + 1) {
 262                 ksmbd_debug(VFS, "%s, len %zd\n", name, strlen(name));
 263                 if (strncasecmp(attr_name, name, attr_name_len))
 264                         continue;
 265
 266                 value_len = ksmbd_vfs_getxattr(idmap,
 267                                                dentry,
 268                                                name,
 269                                                attr_value);
 270                 if (value_len < 0)
 271                         pr_err("failed to get xattr in file\n");
 272                 break;
 273         }
 274
 275 out:
 276         kvfree(xattr_list);
 277         return value_len;
 278 }
 279
 280 static int ksmbd_vfs_stream_read(struct ksmbd_file *fp, char *buf, loff_t *pos,
 281                                  size_t count)
 282 {
 283         ssize_t v_len;
 284         char *stream_buf = NULL;
 285
 286         ksmbd_debug(VFS, "read stream data pos : %llu, count : %zd\n",
 287                     *pos, count);
 288
 289         v_len = ksmbd_vfs_getcasexattr(file_mnt_idmap(fp->filp),
 290                                        fp->filp->f_path.dentry,
 291                                        fp->stream.name,
 292                                        fp->stream.size,
 293                                        &stream_buf);
 294         if ((int)v_len <= 0)
 295                 return (int)v_len;
 296
 297         if (v_len <= *pos) {
 298                 count = -EINVAL;
 299                 goto free_buf;
 300         }
 301
 302         if (v_len - *pos < count)
 303                 count = v_len - *pos;
 304
 305         memcpy(buf, &stream_buf[*pos], count);
 306
 307 free_buf:
 308         kvfree(stream_buf);
 309         return count;
 310 }
 311
 312 /**
 313  * check_lock_range() - vfs helper for smb byte range file locking
 314  * @filp:       the file to apply the lock to
 315  * @start:      lock start byte offset
 316  * @end:        lock end byte offset
 317  * @type:       byte range type read/write
 318  *
 319  * Return:      0 on success, otherwise error
 320  */
 321 static int check_lock_range(struct file *filp, loff_t start, loff_t end,
 322                             unsigned char type)
 323 {
 324         struct file_lock *flock;
 325         struct file_lock_context *ctx = locks_inode_context(file_inode(filp));
 326         int error = 0;
 327
 328         if (!ctx || list_empty_careful(&ctx->flc_posix))
 329                 return 0;
 330
 331         spin_lock(&ctx->flc_lock);
 332         list_for_each_entry(flock, &ctx->flc_posix, fl_list) {
 333                 /* check conflict locks */
 334                 if (flock->fl_end >= start && end >= flock->fl_start) {
 335                         if (flock->fl_type == F_RDLCK) {
 336                                 if (type == WRITE) {
 337                                         pr_err("not allow write by shared lock\n");
 338                                         error = 1;
 339                                         goto out;
 340                                 }
 341                         } else if (flock->fl_type == F_WRLCK) {
 342                                 /* check owner in lock */
 343                                 if (flock->fl_file != filp) {
 344                                         error = 1;
 345                                         pr_err("not allow rw access by exclusive lock from other opens\n");
 346                                         goto out;
 347                                 }
 348                         }
 349                 }
 350         }
 351 out:
 352         spin_unlock(&ctx->flc_lock);
 353         return error;
 354 }
 355
 356 /**
 357  * ksmbd_vfs_read() - vfs helper for smb file read
 358  * @work:       smb work
 359  * @fid:        file id of open file
 360  * @count:      read byte count
 361  * @pos:        file pos
 362  *
 363  * Return:      number of read bytes on success, otherwise error
 364  */
 365 int ksmbd_vfs_read(struct ksmbd_work *work, struct ksmbd_file *fp, size_t count,
 366                    loff_t *pos)
 367 {
 368         struct file *filp = fp->filp;
 369         ssize_t nbytes = 0;
 370         char *rbuf = work->aux_payload_buf;
 371         struct inode *inode = file_inode(filp);
 372
 373         if (S_ISDIR(inode->i_mode))
 374                 return -EISDIR;
 375
 376         if (unlikely(count == 0))
 377                 return 0;
 378
 379         if (work->conn->connection_type) {
 380                 if (!(fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) {
 381                         pr_err("no right to read(%pD)\n", fp->filp);
 382                         return -EACCES;
 383                 }
 384         }
 385
 386         if (ksmbd_stream_fd(fp))
 387                 return ksmbd_vfs_stream_read(fp, rbuf, pos, count);
 388
 389         if (!work->tcon->posix_extensions) {
 390                 int ret;
 391
 392                 ret = check_lock_range(filp, *pos, *pos + count - 1, READ);
 393                 if (ret) {
 394                         pr_err("unable to read due to lock\n");
 395                         return -EAGAIN;
 396                 }
 397         }
 398
 399         nbytes = kernel_read(filp, rbuf, count, pos);
 400         if (nbytes < 0) {
 401                 pr_err("smb read failed, err = %zd\n", nbytes);
 402                 return nbytes;
 403         }
 404
 405         filp->f_pos = *pos;
 406         return nbytes;
 407 }
 408
 409 static int ksmbd_vfs_stream_write(struct ksmbd_file *fp, char *buf, loff_t *pos,
 410                                   size_t count)
 411 {
 412         char *stream_buf = NULL, *wbuf;
 413         struct mnt_idmap *idmap = file_mnt_idmap(fp->filp);
 414         size_t size, v_len;
 415         int err = 0;
 416
 417         ksmbd_debug(VFS, "write stream data pos : %llu, count : %zd\n",
 418                     *pos, count);
 419
 420         size = *pos + count;
 421         if (size > XATTR_SIZE_MAX) {
 422                 size = XATTR_SIZE_MAX;
 423                 count = (*pos + count) - XATTR_SIZE_MAX;
 424         }
 425
 426         v_len = ksmbd_vfs_getcasexattr(idmap,
 427                                        fp->filp->f_path.dentry,
 428                                        fp->stream.name,
 429                                        fp->stream.size,
 430                                        &stream_buf);
 431         if ((int)v_len < 0) {
 432                 pr_err("not found stream in xattr : %zd\n", v_len);
 433                 err = (int)v_len;
 434                 goto out;
 435         }
 436
 437         if (v_len < size) {
 438                 wbuf = kvmalloc(size, GFP_KERNEL | __GFP_ZERO);
 439                 if (!wbuf) {
 440                         err = -ENOMEM;
 441                         goto out;
 442                 }
 443
 444                 if (v_len > 0)
 445                         memcpy(wbuf, stream_buf, v_len);
 446                 kvfree(stream_buf);
 447                 stream_buf = wbuf;
 448         }
 449
 450         memcpy(&stream_buf[*pos], buf, count);
 451
 452         err = ksmbd_vfs_setxattr(idmap,
 453                                  fp->filp->f_path.dentry,
 454                                  fp->stream.name,
 455                                  (void *)stream_buf,
 456                                  size,
 457                                  0);
 458         if (err < 0)
 459                 goto out;
 460
 461         fp->filp->f_pos = *pos;
 462         err = 0;
 463 out:
 464         kvfree(stream_buf);
 465         return err;
 466 }
 467
 468 /**
 469  * ksmbd_vfs_write() - vfs helper for smb file write
 470  * @work:       work
 471  * @fid:        file id of open file
 472  * @buf:        buf containing data for writing
 473  * @count:      read byte count
 474  * @pos:        file pos
 475  * @sync:       fsync after write
 476  * @written:    number of bytes written
 477  *
 478  * Return:      0 on success, otherwise error
 479  */
 480 int ksmbd_vfs_write(struct ksmbd_work *work, struct ksmbd_file *fp,
 481                     char *buf, size_t count, loff_t *pos, bool sync,
 482                     ssize_t *written)
 483 {
 484         struct file *filp;
 485         loff_t  offset = *pos;
 486         int err = 0;
 487
 488         if (work->conn->connection_type) {
 489                 if (!(fp->daccess & FILE_WRITE_DATA_LE)) {
 490                         pr_err("no right to write(%pD)\n", fp->filp);
 491                         err = -EACCES;
 492                         goto out;
 493                 }
 494         }
 495
 496         filp = fp->filp;
 497
 498         if (ksmbd_stream_fd(fp)) {
 499                 err = ksmbd_vfs_stream_write(fp, buf, pos, count);
 500                 if (!err)
 501                         *written = count;
 502                 goto out;
 503         }
 504
 505         if (!work->tcon->posix_extensions) {
 506                 err = check_lock_range(filp, *pos, *pos + count - 1, WRITE);
 507                 if (err) {
 508                         pr_err("unable to write due to lock\n");
 509                         err = -EAGAIN;
 510                         goto out;
 511                 }
 512         }
 513
 514         /* Do we need to break any of a levelII oplock? */
 515         smb_break_all_levII_oplock(work, fp, 1);
 516
 517         err = kernel_write(filp, buf, count, pos);
 518         if (err < 0) {
 519                 ksmbd_debug(VFS, "smb write failed, err = %d\n", err);
 520                 goto out;
 521         }
 522
 523         filp->f_pos = *pos;
 524         *written = err;
 525         err = 0;
 526         if (sync) {
 527                 err = vfs_fsync_range(filp, offset, offset + *written, 0);
 528                 if (err < 0)
 529                         pr_err("fsync failed for filename = %pD, err = %d\n",
 530                                fp->filp, err);
 531         }
 532
 533 out:
 534         return err;
 535 }
 536
 537 /**
 538  * ksmbd_vfs_getattr() - vfs helper for smb getattr
 539  * @work:       work
 540  * @fid:        file id of open file
 541  * @attrs:      inode attributes
 542  *
 543  * Return:      0 on success, otherwise error
 544  */
 545 int ksmbd_vfs_getattr(const struct path *path, struct kstat *stat)
 546 {
 547         int err;
 548
 549         err = vfs_getattr(path, stat, STATX_BTIME, AT_STATX_SYNC_AS_STAT);
 550         if (err)
 551                 pr_err("getattr failed, err %d\n", err);
 552         return err;
 553 }
 554
 555 /**
 556  * ksmbd_vfs_fsync() - vfs helper for smb fsync
 557  * @work:       work
 558  * @fid:        file id of open file
 559  *
 560  * Return:      0 on success, otherwise error
 561  */
 562 int ksmbd_vfs_fsync(struct ksmbd_work *work, u64 fid, u64 p_id)
 563 {
 564         struct ksmbd_file *fp;
 565         int err;
 566
 567         fp = ksmbd_lookup_fd_slow(work, fid, p_id);
 568         if (!fp) {
 569                 pr_err("failed to get filp for fid %llu\n", fid);
 570                 return -ENOENT;
 571         }
 572         err = vfs_fsync(fp->filp, 0);
 573         if (err < 0)
 574                 pr_err("smb fsync failed, err = %d\n", err);
 575         ksmbd_fd_put(work, fp);
 576         return err;
 577 }
 578
 579 /**
 580  * ksmbd_vfs_remove_file() - vfs helper for smb rmdir or unlink
 581  * @name:       directory or file name that is relative to share
 582  *
 583  * Return:      0 on success, otherwise error
 584  */
 585 int ksmbd_vfs_remove_file(struct ksmbd_work *work, char *name)
 586 {
 587         struct mnt_idmap *idmap;
 588         struct path path;
 589         struct dentry *parent;
 590         int err;
 591
 592         if (ksmbd_override_fsids(work))
 593                 return -ENOMEM;
 594
 595         err = ksmbd_vfs_kern_path(work, name, LOOKUP_NO_SYMLINKS, &path, false);
 596         if (err) {
 597                 ksmbd_debug(VFS, "can't get %s, err %d\n", name, err);
 598                 ksmbd_revert_fsids(work);
 599                 return err;
 600         }
 601
 602         idmap = mnt_idmap(path.mnt);
 603         parent = dget_parent(path.dentry);
 604         err = ksmbd_vfs_lock_parent(idmap, parent, path.dentry);
 605         if (err) {
 606                 dput(parent);
 607                 path_put(&path);
 608                 ksmbd_revert_fsids(work);
 609                 return err;
 610         }
 611
 612         if (!d_inode(path.dentry)->i_nlink) {
 613                 err = -ENOENT;
 614                 goto out_err;
 615         }
 616
 617         if (S_ISDIR(d_inode(path.dentry)->i_mode)) {
 618                 err = vfs_rmdir(idmap, d_inode(parent), path.dentry);
 619                 if (err && err != -ENOTEMPTY)
 620                         ksmbd_debug(VFS, "%s: rmdir failed, err %d\n", name,
 621                                     err);
 622         } else {
 623                 err = vfs_unlink(idmap, d_inode(parent), path.dentry, NULL);
 624                 if (err)
 625                         ksmbd_debug(VFS, "%s: unlink failed, err %d\n", name,
 626                                     err);
 627         }
 628
 629 out_err:
 630         inode_unlock(d_inode(parent));
 631         dput(parent);
 632         path_put(&path);
 633         ksmbd_revert_fsids(work);
 634         return err;
 635 }
 636
 637 /**
 638  * ksmbd_vfs_link() - vfs helper for creating smb hardlink
 639  * @oldname:    source file name
 640  * @newname:    hardlink name that is relative to share
 641  *
 642  * Return:      0 on success, otherwise error
 643  */
 644 int ksmbd_vfs_link(struct ksmbd_work *work, const char *oldname,
 645                    const char *newname)
 646 {
 647         struct path oldpath, newpath;
 648         struct dentry *dentry;
 649         int err;
 650
 651         if (ksmbd_override_fsids(work))
 652                 return -ENOMEM;
 653
 654         err = kern_path(oldname, LOOKUP_NO_SYMLINKS, &oldpath);
 655         if (err) {
 656                 pr_err("cannot get linux path for %s, err = %d\n",
 657                        oldname, err);
 658                 goto out1;
 659         }
 660
 661         dentry = ksmbd_vfs_kern_path_create(work, newname,
 662                                             LOOKUP_NO_SYMLINKS | LOOKUP_REVAL,
 663                                             &newpath);
 664         if (IS_ERR(dentry)) {
 665                 err = PTR_ERR(dentry);
 666                 pr_err("path create err for %s, err %d\n", newname, err);
 667                 goto out2;
 668         }
 669
 670         err = -EXDEV;
 671         if (oldpath.mnt != newpath.mnt) {
 672                 pr_err("vfs_link failed err %d\n", err);
 673                 goto out3;
 674         }
 675
 676         err = vfs_link(oldpath.dentry, mnt_idmap(newpath.mnt),
 677                        d_inode(newpath.dentry),
 678                        dentry, NULL);
 679         if (err)
 680                 ksmbd_debug(VFS, "vfs_link failed err %d\n", err);
 681
 682 out3:
 683         done_path_create(&newpath, dentry);
 684 out2:
 685         path_put(&oldpath);
 686 out1:
 687         ksmbd_revert_fsids(work);
 688         return err;
 689 }
 690
 691 static int ksmbd_validate_entry_in_use(struct dentry *src_dent)
 692 {
 693         struct dentry *dst_dent;
 694
 695         spin_lock(&src_dent->d_lock);
 696         list_for_each_entry(dst_dent, &src_dent->d_subdirs, d_child) {
 697                 struct ksmbd_file *child_fp;
 698
 699                 if (d_really_is_negative(dst_dent))
 700                         continue;
 701
 702                 child_fp = ksmbd_lookup_fd_inode(d_inode(dst_dent));
 703                 if (child_fp) {
 704                         spin_unlock(&src_dent->d_lock);
 705                         ksmbd_debug(VFS, "Forbid rename, sub file/dir is in use\n");
 706                         return -EACCES;
 707                 }
 708         }
 709         spin_unlock(&src_dent->d_lock);
 710
 711         return 0;
 712 }
 713
 714 static int __ksmbd_vfs_rename(struct ksmbd_work *work,
 715                               struct mnt_idmap *src_idmap,
 716                               struct dentry *src_dent_parent,
 717                               struct dentry *src_dent,
 718                               struct mnt_idmap *dst_idmap,
 719                               struct dentry *dst_dent_parent,
 720                               struct dentry *trap_dent,
 721                               char *dst_name)
 722 {
 723         struct dentry *dst_dent;
 724         int err;
 725
 726         if (!work->tcon->posix_extensions) {
 727                 err = ksmbd_validate_entry_in_use(src_dent);
 728                 if (err)
 729                         return err;
 730         }
 731
 732         if (d_really_is_negative(src_dent_parent))
 733                 return -ENOENT;
 734         if (d_really_is_negative(dst_dent_parent))
 735                 return -ENOENT;
 736         if (d_really_is_negative(src_dent))
 737                 return -ENOENT;
 738         if (src_dent == trap_dent)
 739                 return -EINVAL;
 740
 741         if (ksmbd_override_fsids(work))
 742                 return -ENOMEM;
 743
 744         dst_dent = lookup_one(dst_idmap, dst_name,
 745                               dst_dent_parent, strlen(dst_name));
 746         err = PTR_ERR(dst_dent);
 747         if (IS_ERR(dst_dent)) {
 748                 pr_err("lookup failed %s [%d]\n", dst_name, err);
 749                 goto out;
 750         }
 751
 752         err = -ENOTEMPTY;
 753         if (dst_dent != trap_dent && !d_really_is_positive(dst_dent)) {
 754                 struct renamedata rd = {
 755                         .old_mnt_idmap  = src_idmap,
 756                         .old_dir        = d_inode(src_dent_parent),
 757                         .old_dentry     = src_dent,
 758                         .new_mnt_idmap  = dst_idmap,
 759                         .new_dir        = d_inode(dst_dent_parent),
 760                         .new_dentry     = dst_dent,
 761                 };
 762                 err = vfs_rename(&rd);
 763         }
 764         if (err)
 765                 pr_err("vfs_rename failed err %d\n", err);
 766         if (dst_dent)
 767                 dput(dst_dent);
 768 out:
 769         ksmbd_revert_fsids(work);
 770         return err;
 771 }
 772
 773 int ksmbd_vfs_fp_rename(struct ksmbd_work *work, struct ksmbd_file *fp,
 774                         char *newname)
 775 {
 776         struct mnt_idmap *idmap;
 777         struct path dst_path;
 778         struct dentry *src_dent_parent, *dst_dent_parent;
 779         struct dentry *src_dent, *trap_dent, *src_child;
 780         char *dst_name;
 781         int err;
 782
 783         dst_name = extract_last_component(newname);
 784         if (!dst_name) {
 785                 dst_name = newname;
 786                 newname = "";
 787         }
 788
 789         src_dent_parent = dget_parent(fp->filp->f_path.dentry);
 790         src_dent = fp->filp->f_path.dentry;
 791
 792         err = ksmbd_vfs_kern_path(work, newname,
 793                                   LOOKUP_NO_SYMLINKS | LOOKUP_DIRECTORY,
 794                                   &dst_path, false);
 795         if (err) {
 796                 ksmbd_debug(VFS, "Cannot get path for %s [%d]\n", newname, err);
 797                 goto out;
 798         }
 799         dst_dent_parent = dst_path.dentry;
 800
 801         trap_dent = lock_rename(src_dent_parent, dst_dent_parent);
 802         dget(src_dent);
 803         dget(dst_dent_parent);
 804         idmap = file_mnt_idmap(fp->filp);
 805         src_child = lookup_one(idmap, src_dent->d_name.name, src_dent_parent,
 806                                src_dent->d_name.len);
 807         if (IS_ERR(src_child)) {
 808                 err = PTR_ERR(src_child);
 809                 goto out_lock;
 810         }
 811
 812         if (src_child != src_dent) {
 813                 err = -ESTALE;
 814                 dput(src_child);
 815                 goto out_lock;
 816         }
 817         dput(src_child);
 818
 819         err = __ksmbd_vfs_rename(work,
 820                                  idmap,
 821                                  src_dent_parent,
 822                                  src_dent,
 823                                  mnt_idmap(dst_path.mnt),
 824                                  dst_dent_parent,
 825                                  trap_dent,
 826                                  dst_name);
 827 out_lock:
 828         dput(src_dent);
 829         dput(dst_dent_parent);
 830         unlock_rename(src_dent_parent, dst_dent_parent);
 831         path_put(&dst_path);
 832 out:
 833         dput(src_dent_parent);
 834         return err;
 835 }
 836
 837 /**
 838  * ksmbd_vfs_truncate() - vfs helper for smb file truncate
 839  * @work:       work
 840  * @fid:        file id of old file
 841  * @size:       truncate to given size
 842  *
 843  * Return:      0 on success, otherwise error
 844  */
 845 int ksmbd_vfs_truncate(struct ksmbd_work *work,
 846                        struct ksmbd_file *fp, loff_t size)
 847 {
 848         int err = 0;
 849         struct file *filp;
 850
 851         filp = fp->filp;
 852
 853         /* Do we need to break any of a levelII oplock? */
 854         smb_break_all_levII_oplock(work, fp, 1);
 855
 856         if (!work->tcon->posix_extensions) {
 857                 struct inode *inode = file_inode(filp);
 858
 859                 if (size < inode->i_size) {
 860                         err = check_lock_range(filp, size,
 861                                                inode->i_size - 1, WRITE);
 862                 } else {
 863                         err = check_lock_range(filp, inode->i_size,
 864                                                size - 1, WRITE);
 865                 }
 866
 867                 if (err) {
 868                         pr_err("failed due to lock\n");
 869                         return -EAGAIN;
 870                 }
 871         }
 872
 873         err = vfs_truncate(&filp->f_path, size);
 874         if (err)
 875                 pr_err("truncate failed, err %d\n", err);
 876         return err;
 877 }
 878
 879 /**
 880  * ksmbd_vfs_listxattr() - vfs helper for smb list extended attributes
 881  * @dentry:     dentry of file for listing xattrs
 882  * @list:       destination buffer
 883  * @size:       destination buffer length
 884  *
 885  * Return:      xattr list length on success, otherwise error
 886  */
 887 ssize_t ksmbd_vfs_listxattr(struct dentry *dentry, char **list)
 888 {
 889         ssize_t size;
 890         char *vlist = NULL;
 891
 892         size = vfs_listxattr(dentry, NULL, 0);
 893         if (size <= 0)
 894                 return size;
 895
 896         vlist = kvmalloc(size, GFP_KERNEL | __GFP_ZERO);
 897         if (!vlist)
 898                 return -ENOMEM;
 899
 900         *list = vlist;
 901         size = vfs_listxattr(dentry, vlist, size);
 902         if (size < 0) {
 903                 ksmbd_debug(VFS, "listxattr failed\n");
 904                 kvfree(vlist);
 905                 *list = NULL;
 906         }
 907
 908         return size;
 909 }
 910
 911 static ssize_t ksmbd_vfs_xattr_len(struct mnt_idmap *idmap,
 912                                    struct dentry *dentry, char *xattr_name)
 913 {
 914         return vfs_getxattr(idmap, dentry, xattr_name, NULL, 0);
 915 }
 916
 917 /**
 918  * ksmbd_vfs_getxattr() - vfs helper for smb get extended attributes value
 919  * @idmap:      idmap
 920  * @dentry:     dentry of file for getting xattrs
 921  * @xattr_name: name of xattr name to query
 922  * @xattr_buf:  destination buffer xattr value
 923  *
 924  * Return:      read xattr value length on success, otherwise error
 925  */
 926 ssize_t ksmbd_vfs_getxattr(struct mnt_idmap *idmap,
 927                            struct dentry *dentry,
 928                            char *xattr_name, char **xattr_buf)
 929 {
 930         ssize_t xattr_len;
 931         char *buf;
 932
 933         *xattr_buf = NULL;
 934         xattr_len = ksmbd_vfs_xattr_len(idmap, dentry, xattr_name);
 935         if (xattr_len < 0)
 936                 return xattr_len;
 937
 938         buf = kmalloc(xattr_len + 1, GFP_KERNEL);
 939         if (!buf)
 940                 return -ENOMEM;
 941
 942         xattr_len = vfs_getxattr(idmap, dentry, xattr_name,
 943                                  (void *)buf, xattr_len);
 944         if (xattr_len > 0)
 945                 *xattr_buf = buf;
 946         else
 947                 kfree(buf);
 948         return xattr_len;
 949 }
 950
 951 /**
 952  * ksmbd_vfs_setxattr() - vfs helper for smb set extended attributes value
 953  * @idmap:      idmap of the relevant mount
 954  * @dentry:     dentry to set XATTR at
 955  * @attr_name:  xattr name for setxattr
 956  * @attr_value: xattr value to set
 957  * @attr_size:  size of xattr value
 958  * @flags:      destination buffer length
 959  *
 960  * Return:      0 on success, otherwise error
 961  */
 962 int ksmbd_vfs_setxattr(struct mnt_idmap *idmap,
 963                        struct dentry *dentry, const char *attr_name,
 964                        void *attr_value, size_t attr_size, int flags)
 965 {
 966         int err;
 967
 968         err = vfs_setxattr(idmap,
 969                            dentry,
 970                            attr_name,
 971                            attr_value,
 972                            attr_size,
 973                            flags);
 974         if (err)
 975                 ksmbd_debug(VFS, "setxattr failed, err %d\n", err);
 976         return err;
 977 }
 978
 979 /**
 980  * ksmbd_vfs_set_fadvise() - convert smb IO caching options to linux options
 981  * @filp:       file pointer for IO
 982  * @options:    smb IO options
 983  */
 984 void ksmbd_vfs_set_fadvise(struct file *filp, __le32 option)
 985 {
 986         struct address_space *mapping;
 987
 988         mapping = filp->f_mapping;
 989
 990         if (!option || !mapping)
 991                 return;
 992
 993         if (option & FILE_WRITE_THROUGH_LE) {
 994                 filp->f_flags |= O_SYNC;
 995         } else if (option & FILE_SEQUENTIAL_ONLY_LE) {
 996                 filp->f_ra.ra_pages = inode_to_bdi(mapping->host)->ra_pages * 2;
 997                 spin_lock(&filp->f_lock);
 998                 filp->f_mode &= ~FMODE_RANDOM;
 999                 spin_unlock(&filp->f_lock);
1000         } else if (option & FILE_RANDOM_ACCESS_LE) {
1001                 spin_lock(&filp->f_lock);
1002                 filp->f_mode |= FMODE_RANDOM;
1003                 spin_unlock(&filp->f_lock);
1004         }
1005 }
1006
1007 int ksmbd_vfs_zero_data(struct ksmbd_work *work, struct ksmbd_file *fp,
1008                         loff_t off, loff_t len)
1009 {
1010         smb_break_all_levII_oplock(work, fp, 1);
1011         if (fp->f_ci->m_fattr & FILE_ATTRIBUTE_SPARSE_FILE_LE)
1012                 return vfs_fallocate(fp->filp,
1013                                      FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1014                                      off, len);
1015
1016         return vfs_fallocate(fp->filp,
1017                              FALLOC_FL_ZERO_RANGE | FALLOC_FL_KEEP_SIZE,
1018                              off, len);
1019 }
1020
1021 int ksmbd_vfs_fqar_lseek(struct ksmbd_file *fp, loff_t start, loff_t length,
1022                          struct file_allocated_range_buffer *ranges,
1023                          unsigned int in_count, unsigned int *out_count)
1024 {
1025         struct file *f = fp->filp;
1026         struct inode *inode = file_inode(fp->filp);
1027         loff_t maxbytes = (u64)inode->i_sb->s_maxbytes, end;
1028         loff_t extent_start, extent_end;
1029         int ret = 0;
1030
1031         if (start > maxbytes)
1032                 return -EFBIG;
1033
1034         if (!in_count)
1035                 return 0;
1036
1037         /*
1038          * Shrink request scope to what the fs can actually handle.
1039          */
1040         if (length > maxbytes || (maxbytes - length) < start)
1041                 length = maxbytes - start;
1042
1043         if (start + length > inode->i_size)
1044                 length = inode->i_size - start;
1045
1046         *out_count = 0;
1047         end = start + length;
1048         while (start < end && *out_count < in_count) {
1049                 extent_start = vfs_llseek(f, start, SEEK_DATA);
1050                 if (extent_start < 0) {
1051                         if (extent_start != -ENXIO)
1052                                 ret = (int)extent_start;
1053                         break;
1054                 }
1055
1056                 if (extent_start >= end)
1057                         break;
1058
1059                 extent_end = vfs_llseek(f, extent_start, SEEK_HOLE);
1060                 if (extent_end < 0) {
1061                         if (extent_end != -ENXIO)
1062                                 ret = (int)extent_end;
1063                         break;
1064                 } else if (extent_start >= extent_end) {
1065                         break;
1066                 }
1067
1068                 ranges[*out_count].file_offset = cpu_to_le64(extent_start);
1069                 ranges[(*out_count)++].length =
1070                         cpu_to_le64(min(extent_end, end) - extent_start);
1071
1072                 start = extent_end;
1073         }
1074
1075         return ret;
1076 }
1077
1078 int ksmbd_vfs_remove_xattr(struct mnt_idmap *idmap,
1079                            struct dentry *dentry, char *attr_name)
1080 {
1081         return vfs_removexattr(idmap, dentry, attr_name);
1082 }
1083
1084 int ksmbd_vfs_unlink(struct mnt_idmap *idmap,
1085                      struct dentry *dir, struct dentry *dentry)
1086 {
1087         int err = 0;
1088
1089         err = ksmbd_vfs_lock_parent(idmap, dir, dentry);
1090         if (err)
1091                 return err;
1092         dget(dentry);
1093
1094         if (S_ISDIR(d_inode(dentry)->i_mode))
1095                 err = vfs_rmdir(idmap, d_inode(dir), dentry);
1096         else
1097                 err = vfs_unlink(idmap, d_inode(dir), dentry, NULL);
1098
1099         dput(dentry);
1100         inode_unlock(d_inode(dir));
1101         if (err)
1102                 ksmbd_debug(VFS, "failed to delete, err %d\n", err);
1103
1104         return err;
1105 }
1106
1107 static bool __dir_empty(struct dir_context *ctx, const char *name, int namlen,
1108                        loff_t offset, u64 ino, unsigned int d_type)
1109 {
1110         struct ksmbd_readdir_data *buf;
1111
1112         buf = container_of(ctx, struct ksmbd_readdir_data, ctx);
1113         buf->dirent_count++;
1114
1115         return buf->dirent_count <= 2;
1116 }
1117
1118 /**
1119  * ksmbd_vfs_empty_dir() - check for empty directory
1120  * @fp: ksmbd file pointer
1121  *
1122  * Return:      true if directory empty, otherwise false
1123  */
1124 int ksmbd_vfs_empty_dir(struct ksmbd_file *fp)
1125 {
1126         int err;
1127         struct ksmbd_readdir_data readdir_data;
1128
1129         memset(&readdir_data, 0, sizeof(struct ksmbd_readdir_data));
1130
1131         set_ctx_actor(&readdir_data.ctx, __dir_empty);
1132         readdir_data.dirent_count = 0;
1133
1134         err = iterate_dir(fp->filp, &readdir_data.ctx);
1135         if (readdir_data.dirent_count > 2)
1136                 err = -ENOTEMPTY;
1137         else
1138                 err = 0;
1139         return err;
1140 }
1141
1142 static bool __caseless_lookup(struct dir_context *ctx, const char *name,
1143                              int namlen, loff_t offset, u64 ino,
1144                              unsigned int d_type)
1145 {
1146         struct ksmbd_readdir_data *buf;
1147         int cmp = -EINVAL;
1148
1149         buf = container_of(ctx, struct ksmbd_readdir_data, ctx);
1150
1151         if (buf->used != namlen)
1152                 return true;
1153         if (IS_ENABLED(CONFIG_UNICODE) && buf->um) {
1154                 const struct qstr q_buf = {.name = buf->private,
1155                                            .len = buf->used};
1156                 const struct qstr q_name = {.name = name,
1157                                             .len = namlen};
1158
1159                 cmp = utf8_strncasecmp(buf->um, &q_buf, &q_name);
1160         }
1161         if (cmp < 0)
1162                 cmp = strncasecmp((char *)buf->private, name, namlen);
1163         if (!cmp) {
1164                 memcpy((char *)buf->private, name, namlen);
1165                 buf->dirent_count = 1;
1166                 return false;
1167         }
1168         return true;
1169 }
1170
1171 /**
1172  * ksmbd_vfs_lookup_in_dir() - lookup a file in a directory
1173  * @dir:        path info
1174  * @name:       filename to lookup
1175  * @namelen:    filename length
1176  *
1177  * Return:      0 on success, otherwise error
1178  */
1179 static int ksmbd_vfs_lookup_in_dir(const struct path *dir, char *name,
1180                                    size_t namelen, struct unicode_map *um)
1181 {
1182         int ret;
1183         struct file *dfilp;
1184         int flags = O_RDONLY | O_LARGEFILE;
1185         struct ksmbd_readdir_data readdir_data = {
1186                 .ctx.actor      = __caseless_lookup,
1187                 .private        = name,
1188                 .used           = namelen,
1189                 .dirent_count   = 0,
1190                 .um             = um,
1191         };
1192
1193         dfilp = dentry_open(dir, flags, current_cred());
1194         if (IS_ERR(dfilp))
1195                 return PTR_ERR(dfilp);
1196
1197         ret = iterate_dir(dfilp, &readdir_data.ctx);
1198         if (readdir_data.dirent_count > 0)
1199                 ret = 0;
1200         fput(dfilp);
1201         return ret;
1202 }
1203
1204 /**
1205  * ksmbd_vfs_kern_path() - lookup a file and get path info
1206  * @name:       file path that is relative to share
1207  * @flags:      lookup flags
1208  * @path:       if lookup succeed, return path info
1209  * @caseless:   caseless filename lookup
1210  *
1211  * Return:      0 on success, otherwise error
1212  */
1213 int ksmbd_vfs_kern_path(struct ksmbd_work *work, char *name,
1214                         unsigned int flags, struct path *path, bool caseless)
1215 {
1216         struct ksmbd_share_config *share_conf = work->tcon->share_conf;
1217         int err;
1218
1219         flags |= LOOKUP_BENEATH;
1220         err = vfs_path_lookup(share_conf->vfs_path.dentry,
1221                               share_conf->vfs_path.mnt,
1222                               name,
1223                               flags,
1224                               path);
1225         if (!err)
1226                 return 0;
1227
1228         if (caseless) {
1229                 char *filepath;
1230                 struct path parent;
1231                 size_t path_len, remain_len;
1232
1233                 filepath = kstrdup(name, GFP_KERNEL);
1234                 if (!filepath)
1235                         return -ENOMEM;
1236
1237                 path_len = strlen(filepath);
1238                 remain_len = path_len;
1239
1240                 parent = share_conf->vfs_path;
1241                 path_get(&parent);
1242
1243                 while (d_can_lookup(parent.dentry)) {
1244                         char *filename = filepath + path_len - remain_len;
1245                         char *next = strchrnul(filename, '/');
1246                         size_t filename_len = next - filename;
1247                         bool is_last = !next[0];
1248
1249                         if (filename_len == 0)
1250                                 break;
1251
1252                         err = ksmbd_vfs_lookup_in_dir(&parent, filename,
1253                                                       filename_len,
1254                                                       work->conn->um);
1255                         path_put(&parent);
1256                         if (err)
1257                                 goto out;
1258
1259                         next[0] = '\0';
1260
1261                         err = vfs_path_lookup(share_conf->vfs_path.dentry,
1262                                               share_conf->vfs_path.mnt,
1263                                               filepath,
1264                                               flags,
1265                                               &parent);
1266                         if (err)
1267                                 goto out;
1268                         else if (is_last) {
1269                                 *path = parent;
1270                                 goto out;
1271                         }
1272
1273                         next[0] = '/';
1274                         remain_len -= filename_len + 1;
1275                 }
1276
1277                 path_put(&parent);
1278                 err = -EINVAL;
1279 out:
1280                 kfree(filepath);
1281         }
1282         return err;
1283 }
1284
1285 struct dentry *ksmbd_vfs_kern_path_create(struct ksmbd_work *work,
1286                                           const char *name,
1287                                           unsigned int flags,
1288                                           struct path *path)
1289 {
1290         char *abs_name;
1291         struct dentry *dent;
1292
1293         abs_name = convert_to_unix_name(work->tcon->share_conf, name);
1294         if (!abs_name)
1295                 return ERR_PTR(-ENOMEM);
1296
1297         dent = kern_path_create(AT_FDCWD, abs_name, path, flags);
1298         kfree(abs_name);
1299         return dent;
1300 }
1301
1302 int ksmbd_vfs_remove_acl_xattrs(struct mnt_idmap *idmap,
1303                                 struct dentry *dentry)
1304 {
1305         char *name, *xattr_list = NULL;
1306         ssize_t xattr_list_len;
1307         int err = 0;
1308
1309         xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list);
1310         if (xattr_list_len < 0) {
1311                 goto out;
1312         } else if (!xattr_list_len) {
1313                 ksmbd_debug(SMB, "empty xattr in the file\n");
1314                 goto out;
1315         }
1316
1317         for (name = xattr_list; name - xattr_list < xattr_list_len;
1318              name += strlen(name) + 1) {
1319                 ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name));
1320
1321                 if (!strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS,
1322                              sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1) ||
1323                     !strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT,
1324                              sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1)) {
1325                         err = vfs_remove_acl(idmap, dentry, name);
1326                         if (err)
1327                                 ksmbd_debug(SMB,
1328                                             "remove acl xattr failed : %s\n", name);
1329                 }
1330         }
1331 out:
1332         kvfree(xattr_list);
1333         return err;
1334 }
1335
1336 int ksmbd_vfs_remove_sd_xattrs(struct mnt_idmap *idmap,
1337                                struct dentry *dentry)
1338 {
1339         char *name, *xattr_list = NULL;
1340         ssize_t xattr_list_len;
1341         int err = 0;
1342
1343         xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list);
1344         if (xattr_list_len < 0) {
1345                 goto out;
1346         } else if (!xattr_list_len) {
1347                 ksmbd_debug(SMB, "empty xattr in the file\n");
1348                 goto out;
1349         }
1350
1351         for (name = xattr_list; name - xattr_list < xattr_list_len;
1352                         name += strlen(name) + 1) {
1353                 ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name));
1354
1355                 if (!strncmp(name, XATTR_NAME_SD, XATTR_NAME_SD_LEN)) {
1356                         err = ksmbd_vfs_remove_xattr(idmap, dentry, name);
1357                         if (err)
1358                                 ksmbd_debug(SMB, "remove xattr failed : %s\n", name);
1359                 }
1360         }
1361 out:
1362         kvfree(xattr_list);
1363         return err;
1364 }
1365
1366 static struct xattr_smb_acl *ksmbd_vfs_make_xattr_posix_acl(struct mnt_idmap *idmap,
1367                                                             struct inode *inode,
1368                                                             int acl_type)
1369 {
1370         struct xattr_smb_acl *smb_acl = NULL;
1371         struct posix_acl *posix_acls;
1372         struct posix_acl_entry *pa_entry;
1373         struct xattr_acl_entry *xa_entry;
1374         int i;
1375
1376         if (!IS_ENABLED(CONFIG_FS_POSIX_ACL))
1377                 return NULL;
1378
1379         posix_acls = get_inode_acl(inode, acl_type);
1380         if (!posix_acls)
1381                 return NULL;
1382
1383         smb_acl = kzalloc(sizeof(struct xattr_smb_acl) +
1384                           sizeof(struct xattr_acl_entry) * posix_acls->a_count,
1385                           GFP_KERNEL);
1386         if (!smb_acl)
1387                 goto out;
1388
1389         smb_acl->count = posix_acls->a_count;
1390         pa_entry = posix_acls->a_entries;
1391         xa_entry = smb_acl->entries;
1392         for (i = 0; i < posix_acls->a_count; i++, pa_entry++, xa_entry++) {
1393                 switch (pa_entry->e_tag) {
1394                 case ACL_USER:
1395                         xa_entry->type = SMB_ACL_USER;
1396                         xa_entry->uid = posix_acl_uid_translate(idmap, pa_entry);
1397                         break;
1398                 case ACL_USER_OBJ:
1399                         xa_entry->type = SMB_ACL_USER_OBJ;
1400                         break;
1401                 case ACL_GROUP:
1402                         xa_entry->type = SMB_ACL_GROUP;
1403                         xa_entry->gid = posix_acl_gid_translate(idmap, pa_entry);
1404                         break;
1405                 case ACL_GROUP_OBJ:
1406                         xa_entry->type = SMB_ACL_GROUP_OBJ;
1407                         break;
1408                 case ACL_OTHER:
1409                         xa_entry->type = SMB_ACL_OTHER;
1410                         break;
1411                 case ACL_MASK:
1412                         xa_entry->type = SMB_ACL_MASK;
1413                         break;
1414                 default:
1415                         pr_err("unknown type : 0x%x\n", pa_entry->e_tag);
1416                         goto out;
1417                 }
1418
1419                 if (pa_entry->e_perm & ACL_READ)
1420                         xa_entry->perm |= SMB_ACL_READ;
1421                 if (pa_entry->e_perm & ACL_WRITE)
1422                         xa_entry->perm |= SMB_ACL_WRITE;
1423                 if (pa_entry->e_perm & ACL_EXECUTE)
1424                         xa_entry->perm |= SMB_ACL_EXECUTE;
1425         }
1426 out:
1427         posix_acl_release(posix_acls);
1428         return smb_acl;
1429 }
1430
1431 int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn *conn,
1432                            struct mnt_idmap *idmap,
1433                            struct dentry *dentry,
1434                            struct smb_ntsd *pntsd, int len)
1435 {
1436         int rc;
1437         struct ndr sd_ndr = {0}, acl_ndr = {0};
1438         struct xattr_ntacl acl = {0};
1439         struct xattr_smb_acl *smb_acl, *def_smb_acl = NULL;
1440         struct inode *inode = d_inode(dentry);
1441
1442         acl.version = 4;
1443         acl.hash_type = XATTR_SD_HASH_TYPE_SHA256;
1444         acl.current_time = ksmbd_UnixTimeToNT(current_time(inode));
1445
1446         memcpy(acl.desc, "posix_acl", 9);
1447         acl.desc_len = 10;
1448
1449         pntsd->osidoffset =
1450                 cpu_to_le32(le32_to_cpu(pntsd->osidoffset) + NDR_NTSD_OFFSETOF);
1451         pntsd->gsidoffset =
1452                 cpu_to_le32(le32_to_cpu(pntsd->gsidoffset) + NDR_NTSD_OFFSETOF);
1453         pntsd->dacloffset =
1454                 cpu_to_le32(le32_to_cpu(pntsd->dacloffset) + NDR_NTSD_OFFSETOF);
1455
1456         acl.sd_buf = (char *)pntsd;
1457         acl.sd_size = len;
1458
1459         rc = ksmbd_gen_sd_hash(conn, acl.sd_buf, acl.sd_size, acl.hash);
1460         if (rc) {
1461                 pr_err("failed to generate hash for ndr acl\n");
1462                 return rc;
1463         }
1464
1465         smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode,
1466                                                  ACL_TYPE_ACCESS);
1467         if (S_ISDIR(inode->i_mode))
1468                 def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode,
1469                                                              ACL_TYPE_DEFAULT);
1470
1471         rc = ndr_encode_posix_acl(&acl_ndr, idmap, inode,
1472                                   smb_acl, def_smb_acl);
1473         if (rc) {
1474                 pr_err("failed to encode ndr to posix acl\n");
1475                 goto out;
1476         }
1477
1478         rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset,
1479                                acl.posix_acl_hash);
1480         if (rc) {
1481                 pr_err("failed to generate hash for ndr acl\n");
1482                 goto out;
1483         }
1484
1485         rc = ndr_encode_v4_ntacl(&sd_ndr, &acl);
1486         if (rc) {
1487                 pr_err("failed to encode ndr to posix acl\n");
1488                 goto out;
1489         }
1490
1491         rc = ksmbd_vfs_setxattr(idmap, dentry,
1492                                 XATTR_NAME_SD, sd_ndr.data,
1493                                 sd_ndr.offset, 0);
1494         if (rc < 0)
1495                 pr_err("Failed to store XATTR ntacl :%d\n", rc);
1496
1497         kfree(sd_ndr.data);
1498 out:
1499         kfree(acl_ndr.data);
1500         kfree(smb_acl);
1501         kfree(def_smb_acl);
1502         return rc;
1503 }
1504
1505 int ksmbd_vfs_get_sd_xattr(struct ksmbd_conn *conn,
1506                            struct mnt_idmap *idmap,
1507                            struct dentry *dentry,
1508                            struct smb_ntsd **pntsd)
1509 {
1510         int rc;
1511         struct ndr n;
1512         struct inode *inode = d_inode(dentry);
1513         struct ndr acl_ndr = {0};
1514         struct xattr_ntacl acl;
1515         struct xattr_smb_acl *smb_acl = NULL, *def_smb_acl = NULL;
1516         __u8 cmp_hash[XATTR_SD_HASH_SIZE] = {0};
1517
1518         rc = ksmbd_vfs_getxattr(idmap, dentry, XATTR_NAME_SD, &n.data);
1519         if (rc <= 0)
1520                 return rc;
1521
1522         n.length = rc;
1523         rc = ndr_decode_v4_ntacl(&n, &acl);
1524         if (rc)
1525                 goto free_n_data;
1526
1527         smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode,
1528                                                  ACL_TYPE_ACCESS);
1529         if (S_ISDIR(inode->i_mode))
1530                 def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode,
1531                                                              ACL_TYPE_DEFAULT);
1532
1533         rc = ndr_encode_posix_acl(&acl_ndr, idmap, inode, smb_acl,
1534                                   def_smb_acl);
1535         if (rc) {
1536                 pr_err("failed to encode ndr to posix acl\n");
1537                 goto out_free;
1538         }
1539
1540         rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset, cmp_hash);
1541         if (rc) {
1542                 pr_err("failed to generate hash for ndr acl\n");
1543                 goto out_free;
1544         }
1545
1546         if (memcmp(cmp_hash, acl.posix_acl_hash, XATTR_SD_HASH_SIZE)) {
1547                 pr_err("hash value diff\n");
1548                 rc = -EINVAL;
1549                 goto out_free;
1550         }
1551
1552         *pntsd = acl.sd_buf;
1553         if (acl.sd_size < sizeof(struct smb_ntsd)) {
1554                 pr_err("sd size is invalid\n");
1555                 goto out_free;
1556         }
1557
1558         (*pntsd)->osidoffset = cpu_to_le32(le32_to_cpu((*pntsd)->osidoffset) -
1559                                            NDR_NTSD_OFFSETOF);
1560         (*pntsd)->gsidoffset = cpu_to_le32(le32_to_cpu((*pntsd)->gsidoffset) -
1561                                            NDR_NTSD_OFFSETOF);
1562         (*pntsd)->dacloffset = cpu_to_le32(le32_to_cpu((*pntsd)->dacloffset) -
1563                                            NDR_NTSD_OFFSETOF);
1564
1565         rc = acl.sd_size;
1566 out_free:
1567         kfree(acl_ndr.data);
1568         kfree(smb_acl);
1569         kfree(def_smb_acl);
1570         if (rc < 0) {
1571                 kfree(acl.sd_buf);
1572                 *pntsd = NULL;
1573         }
1574
1575 free_n_data:
1576         kfree(n.data);
1577         return rc;
1578 }
1579
1580 int ksmbd_vfs_set_dos_attrib_xattr(struct mnt_idmap *idmap,
1581                                    struct dentry *dentry,
1582                                    struct xattr_dos_attrib *da)
1583 {
1584         struct ndr n;
1585         int err;
1586
1587         err = ndr_encode_dos_attr(&n, da);
1588         if (err)
1589                 return err;
1590
1591         err = ksmbd_vfs_setxattr(idmap, dentry, XATTR_NAME_DOS_ATTRIBUTE,
1592                                  (void *)n.data, n.offset, 0);
1593         if (err)
1594                 ksmbd_debug(SMB, "failed to store dos attribute in xattr\n");
1595         kfree(n.data);
1596
1597         return err;
1598 }
1599
1600 int ksmbd_vfs_get_dos_attrib_xattr(struct mnt_idmap *idmap,
1601                                    struct dentry *dentry,
1602                                    struct xattr_dos_attrib *da)
1603 {
1604         struct ndr n;
1605         int err;
1606
1607         err = ksmbd_vfs_getxattr(idmap, dentry, XATTR_NAME_DOS_ATTRIBUTE,
1608                                  (char **)&n.data);
1609         if (err > 0) {
1610                 n.length = err;
1611                 if (ndr_decode_dos_attr(&n, da))
1612                         err = -EINVAL;
1613                 kfree(n.data);
1614         } else {
1615                 ksmbd_debug(SMB, "failed to load dos attribute in xattr\n");
1616         }
1617
1618         return err;
1619 }
1620
1621 /**
1622  * ksmbd_vfs_init_kstat() - convert unix stat information to smb stat format
1623  * @p:          destination buffer
1624  * @ksmbd_kstat:      ksmbd kstat wrapper
1625  */
1626 void *ksmbd_vfs_init_kstat(char **p, struct ksmbd_kstat *ksmbd_kstat)
1627 {
1628         struct file_directory_info *info = (struct file_directory_info *)(*p);
1629         struct kstat *kstat = ksmbd_kstat->kstat;
1630         u64 time;
1631
1632         info->FileIndex = 0;
1633         info->CreationTime = cpu_to_le64(ksmbd_kstat->create_time);
1634         time = ksmbd_UnixTimeToNT(kstat->atime);
1635         info->LastAccessTime = cpu_to_le64(time);
1636         time = ksmbd_UnixTimeToNT(kstat->mtime);
1637         info->LastWriteTime = cpu_to_le64(time);
1638         time = ksmbd_UnixTimeToNT(kstat->ctime);
1639         info->ChangeTime = cpu_to_le64(time);
1640
1641         if (ksmbd_kstat->file_attributes & FILE_ATTRIBUTE_DIRECTORY_LE) {
1642                 info->EndOfFile = 0;
1643                 info->AllocationSize = 0;
1644         } else {
1645                 info->EndOfFile = cpu_to_le64(kstat->size);
1646                 info->AllocationSize = cpu_to_le64(kstat->blocks << 9);
1647         }
1648         info->ExtFileAttributes = ksmbd_kstat->file_attributes;
1649
1650         return info;
1651 }
1652
1653 int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work,
1654                                 struct mnt_idmap *idmap,
1655                                 struct dentry *dentry,
1656                                 struct ksmbd_kstat *ksmbd_kstat)
1657 {
1658         u64 time;
1659         int rc;
1660
1661         generic_fillattr(idmap, d_inode(dentry), ksmbd_kstat->kstat);
1662
1663         time = ksmbd_UnixTimeToNT(ksmbd_kstat->kstat->ctime);
1664         ksmbd_kstat->create_time = time;
1665
1666         /*
1667          * set default value for the case that store dos attributes is not yes
1668          * or that acl is disable in server's filesystem and the config is yes.
1669          */
1670         if (S_ISDIR(ksmbd_kstat->kstat->mode))
1671                 ksmbd_kstat->file_attributes = FILE_ATTRIBUTE_DIRECTORY_LE;
1672         else
1673                 ksmbd_kstat->file_attributes = FILE_ATTRIBUTE_ARCHIVE_LE;
1674
1675         if (test_share_config_flag(work->tcon->share_conf,
1676                                    KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) {
1677                 struct xattr_dos_attrib da;
1678
1679                 rc = ksmbd_vfs_get_dos_attrib_xattr(idmap, dentry, &da);
1680                 if (rc > 0) {
1681                         ksmbd_kstat->file_attributes = cpu_to_le32(da.attr);
1682                         ksmbd_kstat->create_time = da.create_time;
1683                 } else {
1684                         ksmbd_debug(VFS, "fail to load dos attribute.\n");
1685                 }
1686         }
1687
1688         return 0;
1689 }
1690
1691 ssize_t ksmbd_vfs_casexattr_len(struct mnt_idmap *idmap,
1692                                 struct dentry *dentry, char *attr_name,
1693                                 int attr_name_len)
1694 {
1695         char *name, *xattr_list = NULL;
1696         ssize_t value_len = -ENOENT, xattr_list_len;
1697
1698         xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list);
1699         if (xattr_list_len <= 0)
1700                 goto out;
1701
1702         for (name = xattr_list; name - xattr_list < xattr_list_len;
1703                         name += strlen(name) + 1) {
1704                 ksmbd_debug(VFS, "%s, len %zd\n", name, strlen(name));
1705                 if (strncasecmp(attr_name, name, attr_name_len))
1706                         continue;
1707
1708                 value_len = ksmbd_vfs_xattr_len(idmap, dentry, name);
1709                 break;
1710         }
1711
1712 out:
1713         kvfree(xattr_list);
1714         return value_len;
1715 }
1716
1717 int ksmbd_vfs_xattr_stream_name(char *stream_name, char **xattr_stream_name,
1718                                 size_t *xattr_stream_name_size, int s_type)
1719 {
1720         char *type, *buf;
1721
1722         if (s_type == DIR_STREAM)
1723                 type = ":$INDEX_ALLOCATION";
1724         else
1725                 type = ":$DATA";
1726
1727         buf = kasprintf(GFP_KERNEL, "%s%s%s",
1728                         XATTR_NAME_STREAM, stream_name, type);
1729         if (!buf)
1730                 return -ENOMEM;
1731
1732         *xattr_stream_name = buf;
1733         *xattr_stream_name_size = strlen(buf) + 1;
1734
1735         return 0;
1736 }
1737
1738 int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work,
1739                                struct ksmbd_file *src_fp,
1740                                struct ksmbd_file *dst_fp,
1741                                struct srv_copychunk *chunks,
1742                                unsigned int chunk_count,
1743                                unsigned int *chunk_count_written,
1744                                unsigned int *chunk_size_written,
1745                                loff_t *total_size_written)
1746 {
1747         unsigned int i;
1748         loff_t src_off, dst_off, src_file_size;
1749         size_t len;
1750         int ret;
1751
1752         *chunk_count_written = 0;
1753         *chunk_size_written = 0;
1754         *total_size_written = 0;
1755
1756         if (!(src_fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) {
1757                 pr_err("no right to read(%pD)\n", src_fp->filp);
1758                 return -EACCES;
1759         }
1760         if (!(dst_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE))) {
1761                 pr_err("no right to write(%pD)\n", dst_fp->filp);
1762                 return -EACCES;
1763         }
1764
1765         if (ksmbd_stream_fd(src_fp) || ksmbd_stream_fd(dst_fp))
1766                 return -EBADF;
1767
1768         smb_break_all_levII_oplock(work, dst_fp, 1);
1769
1770         if (!work->tcon->posix_extensions) {
1771                 for (i = 0; i < chunk_count; i++) {
1772                         src_off = le64_to_cpu(chunks[i].SourceOffset);
1773                         dst_off = le64_to_cpu(chunks[i].TargetOffset);
1774                         len = le32_to_cpu(chunks[i].Length);
1775
1776                         if (check_lock_range(src_fp->filp, src_off,
1777                                              src_off + len - 1, READ))
1778                                 return -EAGAIN;
1779                         if (check_lock_range(dst_fp->filp, dst_off,
1780                                              dst_off + len - 1, WRITE))
1781                                 return -EAGAIN;
1782                 }
1783         }
1784
1785         src_file_size = i_size_read(file_inode(src_fp->filp));
1786
1787         for (i = 0; i < chunk_count; i++) {
1788                 src_off = le64_to_cpu(chunks[i].SourceOffset);
1789                 dst_off = le64_to_cpu(chunks[i].TargetOffset);
1790                 len = le32_to_cpu(chunks[i].Length);
1791
1792                 if (src_off + len > src_file_size)
1793                         return -E2BIG;
1794
1795                 ret = vfs_copy_file_range(src_fp->filp, src_off,
1796                                           dst_fp->filp, dst_off, len, 0);
1797                 if (ret == -EOPNOTSUPP || ret == -EXDEV)
1798                         ret = vfs_copy_file_range(src_fp->filp, src_off,
1799                                                   dst_fp->filp, dst_off, len,
1800                                                   COPY_FILE_SPLICE);
1801                 if (ret < 0)
1802                         return ret;
1803
1804                 *chunk_count_written += 1;
1805                 *total_size_written += ret;
1806         }
1807         return 0;
1808 }
1809
1810 void ksmbd_vfs_posix_lock_wait(struct file_lock *flock)
1811 {
1812         wait_event(flock->fl_wait, !flock->fl_blocker);
1813 }
1814
1815 int ksmbd_vfs_posix_lock_wait_timeout(struct file_lock *flock, long timeout)
1816 {
1817         return wait_event_interruptible_timeout(flock->fl_wait,
1818                                                 !flock->fl_blocker,
1819                                                 timeout);
1820 }
1821
1822 void ksmbd_vfs_posix_lock_unblock(struct file_lock *flock)
1823 {
1824         locks_delete_block(flock);
1825 }
1826
1827 int ksmbd_vfs_set_init_posix_acl(struct mnt_idmap *idmap,
1828                                  struct dentry *dentry)
1829 {
1830         struct posix_acl_state acl_state;
1831         struct posix_acl *acls;
1832         struct inode *inode = d_inode(dentry);
1833         int rc;
1834
1835         if (!IS_ENABLED(CONFIG_FS_POSIX_ACL))
1836                 return -EOPNOTSUPP;
1837
1838         ksmbd_debug(SMB, "Set posix acls\n");
1839         rc = init_acl_state(&acl_state, 1);
1840         if (rc)
1841                 return rc;
1842
1843         /* Set default owner group */
1844         acl_state.owner.allow = (inode->i_mode & 0700) >> 6;
1845         acl_state.group.allow = (inode->i_mode & 0070) >> 3;
1846         acl_state.other.allow = inode->i_mode & 0007;
1847         acl_state.users->aces[acl_state.users->n].uid = inode->i_uid;
1848         acl_state.users->aces[acl_state.users->n++].perms.allow =
1849                 acl_state.owner.allow;
1850         acl_state.groups->aces[acl_state.groups->n].gid = inode->i_gid;
1851         acl_state.groups->aces[acl_state.groups->n++].perms.allow =
1852                 acl_state.group.allow;
1853         acl_state.mask.allow = 0x07;
1854
1855         acls = posix_acl_alloc(6, GFP_KERNEL);
1856         if (!acls) {
1857                 free_acl_state(&acl_state);
1858                 return -ENOMEM;
1859         }
1860         posix_state_to_acl(&acl_state, acls->a_entries);
1861         rc = set_posix_acl(idmap, dentry, ACL_TYPE_ACCESS, acls);
1862         if (rc < 0)
1863                 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n",
1864                             rc);
1865         else if (S_ISDIR(inode->i_mode)) {
1866                 posix_state_to_acl(&acl_state, acls->a_entries);
1867                 rc = set_posix_acl(idmap, dentry, ACL_TYPE_DEFAULT, acls);
1868                 if (rc < 0)
1869                         ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n",
1870                                     rc);
1871         }
1872         free_acl_state(&acl_state);
1873         posix_acl_release(acls);
1874         return rc;
1875 }
1876
1877 int ksmbd_vfs_inherit_posix_acl(struct mnt_idmap *idmap,
1878                                 struct dentry *dentry, struct inode *parent_inode)
1879 {
1880         struct posix_acl *acls;
1881         struct posix_acl_entry *pace;
1882         struct inode *inode = d_inode(dentry);
1883         int rc, i;
1884
1885         if (!IS_ENABLED(CONFIG_FS_POSIX_ACL))
1886                 return -EOPNOTSUPP;
1887
1888         acls = get_inode_acl(parent_inode, ACL_TYPE_DEFAULT);
1889         if (!acls)
1890                 return -ENOENT;
1891         pace = acls->a_entries;
1892
1893         for (i = 0; i < acls->a_count; i++, pace++) {
1894                 if (pace->e_tag == ACL_MASK) {
1895                         pace->e_perm = 0x07;
1896                         break;
1897                 }
1898         }
1899
1900         rc = set_posix_acl(idmap, dentry, ACL_TYPE_ACCESS, acls);
1901         if (rc < 0)
1902                 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n",
1903                             rc);
1904         if (S_ISDIR(inode->i_mode)) {
1905                 rc = set_posix_acl(idmap, dentry, ACL_TYPE_DEFAULT,
1906                                    acls);
1907                 if (rc < 0)
1908                         ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n",
1909                                     rc);
1910         }
1911         posix_acl_release(acls);
1912         return rc;
1913 }