fs/smb/server/vfs.c

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