fs/vboxsf/dir.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * VirtualBox Guest Shared Folders support: Directory inode and file operations
   4  *
   5  * Copyright (C) 2006-2018 Oracle Corporation
   6  */
   7
   8 #include <linux/namei.h>
   9 #include <linux/vbox_utils.h>
  10 #include "vfsmod.h"
  11
  12 static int vboxsf_dir_open(struct inode *inode, struct file *file)
  13 {
  14         struct vboxsf_sbi *sbi = VBOXSF_SBI(inode->i_sb);
  15         struct shfl_createparms params = {};
  16         struct vboxsf_dir_info *sf_d;
  17         int err;
  18
  19         sf_d = vboxsf_dir_info_alloc();
  20         if (!sf_d)
  21                 return -ENOMEM;
  22
  23         params.handle = SHFL_HANDLE_NIL;
  24         params.create_flags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_OPEN_IF_EXISTS |
  25                               SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READ;
  26
  27         err = vboxsf_create_at_dentry(file_dentry(file), &params);
  28         if (err)
  29                 goto err_free_dir_info;
  30
  31         if (params.result != SHFL_FILE_EXISTS) {
  32                 err = -ENOENT;
  33                 goto err_close;
  34         }
  35
  36         err = vboxsf_dir_read_all(sbi, sf_d, params.handle);
  37         if (err)
  38                 goto err_close;
  39
  40         vboxsf_close(sbi->root, params.handle);
  41         file->private_data = sf_d;
  42         return 0;
  43
  44 err_close:
  45         vboxsf_close(sbi->root, params.handle);
  46 err_free_dir_info:
  47         vboxsf_dir_info_free(sf_d);
  48         return err;
  49 }
  50
  51 static int vboxsf_dir_release(struct inode *inode, struct file *file)
  52 {
  53         if (file->private_data)
  54                 vboxsf_dir_info_free(file->private_data);
  55
  56         return 0;
  57 }
  58
  59 static unsigned int vboxsf_get_d_type(u32 mode)
  60 {
  61         unsigned int d_type;
  62
  63         switch (mode & SHFL_TYPE_MASK) {
  64         case SHFL_TYPE_FIFO:
  65                 d_type = DT_FIFO;
  66                 break;
  67         case SHFL_TYPE_DEV_CHAR:
  68                 d_type = DT_CHR;
  69                 break;
  70         case SHFL_TYPE_DIRECTORY:
  71                 d_type = DT_DIR;
  72                 break;
  73         case SHFL_TYPE_DEV_BLOCK:
  74                 d_type = DT_BLK;
  75                 break;
  76         case SHFL_TYPE_FILE:
  77                 d_type = DT_REG;
  78                 break;
  79         case SHFL_TYPE_SYMLINK:
  80                 d_type = DT_LNK;
  81                 break;
  82         case SHFL_TYPE_SOCKET:
  83                 d_type = DT_SOCK;
  84                 break;
  85         case SHFL_TYPE_WHITEOUT:
  86                 d_type = DT_WHT;
  87                 break;
  88         default:
  89                 d_type = DT_UNKNOWN;
  90                 break;
  91         }
  92         return d_type;
  93 }
  94
  95 static bool vboxsf_dir_emit(struct file *dir, struct dir_context *ctx)
  96 {
  97         struct vboxsf_sbi *sbi = VBOXSF_SBI(file_inode(dir)->i_sb);
  98         struct vboxsf_dir_info *sf_d = dir->private_data;
  99         struct shfl_dirinfo *info;
 100         struct vboxsf_dir_buf *b;
 101         unsigned int d_type;
 102         loff_t i, cur = 0;
 103         ino_t fake_ino;
 104         void *end;
 105         int err;
 106
 107         list_for_each_entry(b, &sf_d->info_list, head) {
 108 try_next_entry:
 109                 if (ctx->pos >= cur + b->entries) {
 110                         cur += b->entries;
 111                         continue;
 112                 }
 113
 114                 /*
 115                  * Note the vboxsf_dir_info objects we are iterating over here
 116                  * are variable sized, so the info pointer may end up being
 117                  * unaligned. This is how we get the data from the host.
 118                  * Since vboxsf is only supported on x86 machines this is not
 119                  * a problem.
 120                  */
 121                 for (i = 0, info = b->buf; i < ctx->pos - cur; i++) {
 122                         end = &info->name.string.utf8[info->name.size];
 123                         /* Only happens if the host gives us corrupt data */
 124                         if (WARN_ON(end > (b->buf + b->used)))
 125                                 return false;
 126                         info = end;
 127                 }
 128
 129                 end = &info->name.string.utf8[info->name.size];
 130                 if (WARN_ON(end > (b->buf + b->used)))
 131                         return false;
 132
 133                 /* Info now points to the right entry, emit it. */
 134                 d_type = vboxsf_get_d_type(info->info.attr.mode);
 135
 136                 /*
 137                  * On 32-bit systems pos is 64-bit signed, while ino is 32-bit
 138                  * unsigned so fake_ino may overflow, check for this.
 139                  */
 140                 if ((ino_t)(ctx->pos + 1) != (u64)(ctx->pos + 1)) {
 141                         vbg_err("vboxsf: fake ino overflow, truncating dir\n");
 142                         return false;
 143                 }
 144                 fake_ino = ctx->pos + 1;
 145
 146                 if (sbi->nls) {
 147                         char d_name[NAME_MAX];
 148
 149                         err = vboxsf_nlscpy(sbi, d_name, NAME_MAX,
 150                                             info->name.string.utf8,
 151                                             info->name.length);
 152                         if (err) {
 153                                 /* skip erroneous entry and proceed */
 154                                 ctx->pos += 1;
 155                                 goto try_next_entry;
 156                         }
 157
 158                         return dir_emit(ctx, d_name, strlen(d_name),
 159                                         fake_ino, d_type);
 160                 }
 161
 162                 return dir_emit(ctx, info->name.string.utf8, info->name.length,
 163                                 fake_ino, d_type);
 164         }
 165
 166         return false;
 167 }
 168
 169 static int vboxsf_dir_iterate(struct file *dir, struct dir_context *ctx)
 170 {
 171         bool emitted;
 172
 173         do {
 174                 emitted = vboxsf_dir_emit(dir, ctx);
 175                 if (emitted)
 176                         ctx->pos += 1;
 177         } while (emitted);
 178
 179         return 0;
 180 }
 181
 182 WRAP_DIR_ITER(vboxsf_dir_iterate) // FIXME!
 183 const struct file_operations vboxsf_dir_fops = {
 184         .open = vboxsf_dir_open,
 185         .iterate_shared = shared_vboxsf_dir_iterate,
 186         .release = vboxsf_dir_release,
 187         .read = generic_read_dir,
 188         .llseek = generic_file_llseek,
 189 };
 190
 191 /*
 192  * This is called during name resolution/lookup to check if the @dentry in
 193  * the cache is still valid. the job is handled by vboxsf_inode_revalidate.
 194  */
 195 static int vboxsf_dentry_revalidate(struct inode *dir, const struct qstr *name,
 196                                     struct dentry *dentry, unsigned int flags)
 197 {
 198         if (flags & LOOKUP_RCU)
 199                 return -ECHILD;
 200
 201         if (d_really_is_positive(dentry))
 202                 return vboxsf_inode_revalidate(dentry) == 0;
 203         else
 204                 return vboxsf_stat_dentry(dentry, NULL) == -ENOENT;
 205 }
 206
 207 const struct dentry_operations vboxsf_dentry_ops = {
 208         .d_revalidate = vboxsf_dentry_revalidate
 209 };
 210
 211 /* iops */
 212
 213 static struct dentry *vboxsf_dir_lookup(struct inode *parent,
 214                                         struct dentry *dentry,
 215                                         unsigned int flags)
 216 {
 217         struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
 218         struct shfl_fsobjinfo fsinfo;
 219         struct inode *inode;
 220         int err;
 221
 222         dentry->d_time = jiffies;
 223
 224         err = vboxsf_stat_dentry(dentry, &fsinfo);
 225         if (err) {
 226                 inode = (err == -ENOENT) ? NULL : ERR_PTR(err);
 227         } else {
 228                 inode = vboxsf_new_inode(parent->i_sb);
 229                 if (!IS_ERR(inode))
 230                         vboxsf_init_inode(sbi, inode, &fsinfo, false);
 231         }
 232
 233         return d_splice_alias(inode, dentry);
 234 }
 235
 236 static int vboxsf_dir_instantiate(struct inode *parent, struct dentry *dentry,
 237                                   struct shfl_fsobjinfo *info)
 238 {
 239         struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
 240         struct vboxsf_inode *sf_i;
 241         struct inode *inode;
 242
 243         inode = vboxsf_new_inode(parent->i_sb);
 244         if (IS_ERR(inode))
 245                 return PTR_ERR(inode);
 246
 247         sf_i = VBOXSF_I(inode);
 248         /* The host may have given us different attr then requested */
 249         sf_i->force_restat = 1;
 250         vboxsf_init_inode(sbi, inode, info, false);
 251
 252         d_instantiate(dentry, inode);
 253
 254         return 0;
 255 }
 256
 257 static int vboxsf_dir_create(struct inode *parent, struct dentry *dentry,
 258                              umode_t mode, bool is_dir, bool excl, u64 *handle_ret)
 259 {
 260         struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
 261         struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
 262         struct shfl_createparms params = {};
 263         int err;
 264
 265         params.handle = SHFL_HANDLE_NIL;
 266         params.create_flags = SHFL_CF_ACT_CREATE_IF_NEW | SHFL_CF_ACCESS_READWRITE;
 267         if (is_dir)
 268                 params.create_flags |= SHFL_CF_DIRECTORY;
 269         if (excl)
 270                 params.create_flags |= SHFL_CF_ACT_FAIL_IF_EXISTS;
 271
 272         params.info.attr.mode = (mode & 0777) |
 273                                 (is_dir ? SHFL_TYPE_DIRECTORY : SHFL_TYPE_FILE);
 274         params.info.attr.additional = SHFLFSOBJATTRADD_NOTHING;
 275
 276         err = vboxsf_create_at_dentry(dentry, &params);
 277         if (err)
 278                 return err;
 279
 280         if (params.result != SHFL_FILE_CREATED)
 281                 return -EPERM;
 282
 283         err = vboxsf_dir_instantiate(parent, dentry, &params.info);
 284         if (err)
 285                 goto out;
 286
 287         /* parent directory access/change time changed */
 288         sf_parent_i->force_restat = 1;
 289
 290 out:
 291         if (err == 0 && handle_ret)
 292                 *handle_ret = params.handle;
 293         else
 294                 vboxsf_close(sbi->root, params.handle);
 295
 296         return err;
 297 }
 298
 299 static int vboxsf_dir_mkfile(struct mnt_idmap *idmap,
 300                              struct inode *parent, struct dentry *dentry,
 301                              umode_t mode, bool excl)
 302 {
 303         return vboxsf_dir_create(parent, dentry, mode, false, excl, NULL);
 304 }
 305
 306 static int vboxsf_dir_mkdir(struct mnt_idmap *idmap,
 307                             struct inode *parent, struct dentry *dentry,
 308                             umode_t mode)
 309 {
 310         return vboxsf_dir_create(parent, dentry, mode, true, true, NULL);
 311 }
 312
 313 static int vboxsf_dir_atomic_open(struct inode *parent, struct dentry *dentry,
 314                                   struct file *file, unsigned int flags, umode_t mode)
 315 {
 316         struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
 317         struct vboxsf_handle *sf_handle;
 318         struct dentry *res = NULL;
 319         u64 handle;
 320         int err;
 321
 322         if (d_in_lookup(dentry)) {
 323                 res = vboxsf_dir_lookup(parent, dentry, 0);
 324                 if (IS_ERR(res))
 325                         return PTR_ERR(res);
 326
 327                 if (res)
 328                         dentry = res;
 329         }
 330
 331         /* Only creates */
 332         if (!(flags & O_CREAT) || d_really_is_positive(dentry))
 333                 return finish_no_open(file, res);
 334
 335         err = vboxsf_dir_create(parent, dentry, mode, false, flags & O_EXCL, &handle);
 336         if (err)
 337                 goto out;
 338
 339         sf_handle = vboxsf_create_sf_handle(d_inode(dentry), handle, SHFL_CF_ACCESS_READWRITE);
 340         if (IS_ERR(sf_handle)) {
 341                 vboxsf_close(sbi->root, handle);
 342                 err = PTR_ERR(sf_handle);
 343                 goto out;
 344         }
 345
 346         err = finish_open(file, dentry, generic_file_open);
 347         if (err) {
 348                 /* This also closes the handle passed to vboxsf_create_sf_handle() */
 349                 vboxsf_release_sf_handle(d_inode(dentry), sf_handle);
 350                 goto out;
 351         }
 352
 353         file->private_data = sf_handle;
 354         file->f_mode |= FMODE_CREATED;
 355 out:
 356         dput(res);
 357         return err;
 358 }
 359
 360 static int vboxsf_dir_unlink(struct inode *parent, struct dentry *dentry)
 361 {
 362         struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
 363         struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
 364         struct inode *inode = d_inode(dentry);
 365         struct shfl_string *path;
 366         u32 flags;
 367         int err;
 368
 369         if (S_ISDIR(inode->i_mode))
 370                 flags = SHFL_REMOVE_DIR;
 371         else
 372                 flags = SHFL_REMOVE_FILE;
 373
 374         if (S_ISLNK(inode->i_mode))
 375                 flags |= SHFL_REMOVE_SYMLINK;
 376
 377         path = vboxsf_path_from_dentry(sbi, dentry);
 378         if (IS_ERR(path))
 379                 return PTR_ERR(path);
 380
 381         err = vboxsf_remove(sbi->root, path, flags);
 382         __putname(path);
 383         if (err)
 384                 return err;
 385
 386         /* parent directory access/change time changed */
 387         sf_parent_i->force_restat = 1;
 388
 389         return 0;
 390 }
 391
 392 static int vboxsf_dir_rename(struct mnt_idmap *idmap,
 393                              struct inode *old_parent,
 394                              struct dentry *old_dentry,
 395                              struct inode *new_parent,
 396                              struct dentry *new_dentry,
 397                              unsigned int flags)
 398 {
 399         struct vboxsf_sbi *sbi = VBOXSF_SBI(old_parent->i_sb);
 400         struct vboxsf_inode *sf_old_parent_i = VBOXSF_I(old_parent);
 401         struct vboxsf_inode *sf_new_parent_i = VBOXSF_I(new_parent);
 402         u32 shfl_flags = SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS;
 403         struct shfl_string *old_path, *new_path;
 404         int err;
 405
 406         if (flags)
 407                 return -EINVAL;
 408
 409         old_path = vboxsf_path_from_dentry(sbi, old_dentry);
 410         if (IS_ERR(old_path))
 411                 return PTR_ERR(old_path);
 412
 413         new_path = vboxsf_path_from_dentry(sbi, new_dentry);
 414         if (IS_ERR(new_path)) {
 415                 err = PTR_ERR(new_path);
 416                 goto err_put_old_path;
 417         }
 418
 419         if (d_inode(old_dentry)->i_mode & S_IFDIR)
 420                 shfl_flags = 0;
 421
 422         err = vboxsf_rename(sbi->root, old_path, new_path, shfl_flags);
 423         if (err == 0) {
 424                 /* parent directories access/change time changed */
 425                 sf_new_parent_i->force_restat = 1;
 426                 sf_old_parent_i->force_restat = 1;
 427         }
 428
 429         __putname(new_path);
 430 err_put_old_path:
 431         __putname(old_path);
 432         return err;
 433 }
 434
 435 static int vboxsf_dir_symlink(struct mnt_idmap *idmap,
 436                               struct inode *parent, struct dentry *dentry,
 437                               const char *symname)
 438 {
 439         struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
 440         struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
 441         int symname_size = strlen(symname) + 1;
 442         struct shfl_string *path, *ssymname;
 443         struct shfl_fsobjinfo info;
 444         int err;
 445
 446         path = vboxsf_path_from_dentry(sbi, dentry);
 447         if (IS_ERR(path))
 448                 return PTR_ERR(path);
 449
 450         ssymname = kmalloc(SHFLSTRING_HEADER_SIZE + symname_size, GFP_KERNEL);
 451         if (!ssymname) {
 452                 __putname(path);
 453                 return -ENOMEM;
 454         }
 455         ssymname->length = symname_size - 1;
 456         ssymname->size = symname_size;
 457         memcpy(ssymname->string.utf8, symname, symname_size);
 458
 459         err = vboxsf_symlink(sbi->root, path, ssymname, &info);
 460         kfree(ssymname);
 461         __putname(path);
 462         if (err) {
 463                 /* -EROFS means symlinks are note support -> -EPERM */
 464                 return (err == -EROFS) ? -EPERM : err;
 465         }
 466
 467         err = vboxsf_dir_instantiate(parent, dentry, &info);
 468         if (err)
 469                 return err;
 470
 471         /* parent directory access/change time changed */
 472         sf_parent_i->force_restat = 1;
 473         return 0;
 474 }
 475
 476 const struct inode_operations vboxsf_dir_iops = {
 477         .lookup  = vboxsf_dir_lookup,
 478         .create  = vboxsf_dir_mkfile,
 479         .mkdir   = vboxsf_dir_mkdir,
 480         .atomic_open = vboxsf_dir_atomic_open,
 481         .rmdir   = vboxsf_dir_unlink,
 482         .unlink  = vboxsf_dir_unlink,
 483         .rename  = vboxsf_dir_rename,
 484         .symlink = vboxsf_dir_symlink,
 485         .getattr = vboxsf_getattr,
 486         .setattr = vboxsf_setattr,
 487 };