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