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