fs/vboxsf/utils.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * VirtualBox Guest Shared Folders support: Utility functions.
   4  * Mainly conversion from/to VirtualBox/Linux data structures.
   5  *
   6  * Copyright (C) 2006-2018 Oracle Corporation
   7  */
   8
   9 #include <linux/namei.h>
  10 #include <linux/nls.h>
  11 #include <linux/sizes.h>
  12 #include <linux/pagemap.h>
  13 #include <linux/vfs.h>
  14 #include "vfsmod.h"
  15
  16 struct inode *vboxsf_new_inode(struct super_block *sb)
  17 {
  18         struct vboxsf_sbi *sbi = VBOXSF_SBI(sb);
  19         struct inode *inode;
  20         unsigned long flags;
  21         int cursor, ret;
  22         u32 gen;
  23
  24         inode = new_inode(sb);
  25         if (!inode)
  26                 return ERR_PTR(-ENOMEM);
  27
  28         idr_preload(GFP_KERNEL);
  29         spin_lock_irqsave(&sbi->ino_idr_lock, flags);
  30         cursor = idr_get_cursor(&sbi->ino_idr);
  31         ret = idr_alloc_cyclic(&sbi->ino_idr, inode, 1, 0, GFP_ATOMIC);
  32         if (ret >= 0 && ret < cursor)
  33                 sbi->next_generation++;
  34         gen = sbi->next_generation;
  35         spin_unlock_irqrestore(&sbi->ino_idr_lock, flags);
  36         idr_preload_end();
  37
  38         if (ret < 0) {
  39                 iput(inode);
  40                 return ERR_PTR(ret);
  41         }
  42
  43         inode->i_ino = ret;
  44         inode->i_generation = gen;
  45         return inode;
  46 }
  47
  48 /* set [inode] attributes based on [info], uid/gid based on [sbi] */
  49 int vboxsf_init_inode(struct vboxsf_sbi *sbi, struct inode *inode,
  50                        const struct shfl_fsobjinfo *info, bool reinit)
  51 {
  52         const struct shfl_fsobjattr *attr;
  53         s64 allocated;
  54         umode_t mode;
  55
  56         attr = &info->attr;
  57
  58 #define mode_set(r) ((attr->mode & (SHFL_UNIX_##r)) ? (S_##r) : 0)
  59
  60         mode = mode_set(IRUSR);
  61         mode |= mode_set(IWUSR);
  62         mode |= mode_set(IXUSR);
  63
  64         mode |= mode_set(IRGRP);
  65         mode |= mode_set(IWGRP);
  66         mode |= mode_set(IXGRP);
  67
  68         mode |= mode_set(IROTH);
  69         mode |= mode_set(IWOTH);
  70         mode |= mode_set(IXOTH);
  71
  72 #undef mode_set
  73
  74         /* We use the host-side values for these */
  75         inode->i_flags |= S_NOATIME | S_NOCMTIME;
  76         inode->i_mapping->a_ops = &vboxsf_reg_aops;
  77
  78         if (SHFL_IS_DIRECTORY(attr->mode)) {
  79                 if (sbi->o.dmode_set)
  80                         mode = sbi->o.dmode;
  81                 mode &= ~sbi->o.dmask;
  82                 mode |= S_IFDIR;
  83                 if (!reinit) {
  84                         inode->i_op = &vboxsf_dir_iops;
  85                         inode->i_fop = &vboxsf_dir_fops;
  86                         /*
  87                          * XXX: this probably should be set to the number of entries
  88                          * in the directory plus two (. ..)
  89                          */
  90                         set_nlink(inode, 1);
  91                 } else if (!S_ISDIR(inode->i_mode))
  92                         return -ESTALE;
  93                 inode->i_mode = mode;
  94         } else if (SHFL_IS_SYMLINK(attr->mode)) {
  95                 if (sbi->o.fmode_set)
  96                         mode = sbi->o.fmode;
  97                 mode &= ~sbi->o.fmask;
  98                 mode |= S_IFLNK;
  99                 if (!reinit) {
 100                         inode->i_op = &vboxsf_lnk_iops;
 101                         set_nlink(inode, 1);
 102                 } else if (!S_ISLNK(inode->i_mode))
 103                         return -ESTALE;
 104                 inode->i_mode = mode;
 105         } else {
 106                 if (sbi->o.fmode_set)
 107                         mode = sbi->o.fmode;
 108                 mode &= ~sbi->o.fmask;
 109                 mode |= S_IFREG;
 110                 if (!reinit) {
 111                         inode->i_op = &vboxsf_reg_iops;
 112                         inode->i_fop = &vboxsf_reg_fops;
 113                         set_nlink(inode, 1);
 114                 } else if (!S_ISREG(inode->i_mode))
 115                         return -ESTALE;
 116                 inode->i_mode = mode;
 117         }
 118
 119         inode->i_uid = sbi->o.uid;
 120         inode->i_gid = sbi->o.gid;
 121
 122         inode->i_size = info->size;
 123         inode->i_blkbits = 12;
 124         /* i_blocks always in units of 512 bytes! */
 125         allocated = info->allocated + 511;
 126         do_div(allocated, 512);
 127         inode->i_blocks = allocated;
 128
 129         inode_set_atime_to_ts(inode,
 130                               ns_to_timespec64(info->access_time.ns_relative_to_unix_epoch));
 131         inode_set_ctime_to_ts(inode,
 132                               ns_to_timespec64(info->change_time.ns_relative_to_unix_epoch));
 133         inode_set_mtime_to_ts(inode,
 134                               ns_to_timespec64(info->modification_time.ns_relative_to_unix_epoch));
 135         return 0;
 136 }
 137
 138 int vboxsf_create_at_dentry(struct dentry *dentry,
 139                             struct shfl_createparms *params)
 140 {
 141         struct vboxsf_sbi *sbi = VBOXSF_SBI(dentry->d_sb);
 142         struct shfl_string *path;
 143         int err;
 144
 145         path = vboxsf_path_from_dentry(sbi, dentry);
 146         if (IS_ERR(path))
 147                 return PTR_ERR(path);
 148
 149         err = vboxsf_create(sbi->root, path, params);
 150         __putname(path);
 151
 152         return err;
 153 }
 154
 155 int vboxsf_stat(struct vboxsf_sbi *sbi, struct shfl_string *path,
 156                 struct shfl_fsobjinfo *info)
 157 {
 158         struct shfl_createparms params = {};
 159         int err;
 160
 161         params.handle = SHFL_HANDLE_NIL;
 162         params.create_flags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
 163
 164         err = vboxsf_create(sbi->root, path, &params);
 165         if (err)
 166                 return err;
 167
 168         if (params.result != SHFL_FILE_EXISTS)
 169                 return -ENOENT;
 170
 171         if (info)
 172                 *info = params.info;
 173
 174         return 0;
 175 }
 176
 177 int vboxsf_stat_dentry(struct dentry *dentry, struct shfl_fsobjinfo *info)
 178 {
 179         struct vboxsf_sbi *sbi = VBOXSF_SBI(dentry->d_sb);
 180         struct shfl_string *path;
 181         int err;
 182
 183         path = vboxsf_path_from_dentry(sbi, dentry);
 184         if (IS_ERR(path))
 185                 return PTR_ERR(path);
 186
 187         err = vboxsf_stat(sbi, path, info);
 188         __putname(path);
 189         return err;
 190 }
 191
 192 int vboxsf_inode_revalidate(struct dentry *dentry)
 193 {
 194         struct vboxsf_sbi *sbi;
 195         struct vboxsf_inode *sf_i;
 196         struct shfl_fsobjinfo info;
 197         struct timespec64 mtime, prev_mtime;
 198         struct inode *inode;
 199         int err;
 200
 201         if (!dentry || !d_really_is_positive(dentry))
 202                 return -EINVAL;
 203
 204         inode = d_inode(dentry);
 205         prev_mtime = inode_get_mtime(inode);
 206         sf_i = VBOXSF_I(inode);
 207         sbi = VBOXSF_SBI(dentry->d_sb);
 208         if (!sf_i->force_restat) {
 209                 if (time_before(jiffies, dentry->d_time + sbi->o.ttl))
 210                         return 0;
 211         }
 212
 213         err = vboxsf_stat_dentry(dentry, &info);
 214         if (err)
 215                 return err;
 216
 217         dentry->d_time = jiffies;
 218         sf_i->force_restat = 0;
 219         err = vboxsf_init_inode(sbi, inode, &info, true);
 220         if (err)
 221                 return err;
 222
 223         /*
 224          * If the file was changed on the host side we need to invalidate the
 225          * page-cache for it.  Note this also gets triggered by our own writes,
 226          * this is unavoidable.
 227          */
 228         mtime = inode_get_mtime(inode);
 229         if (timespec64_compare(&mtime, &prev_mtime) > 0)
 230                 invalidate_inode_pages2(inode->i_mapping);
 231
 232         return 0;
 233 }
 234
 235 int vboxsf_getattr(struct mnt_idmap *idmap, const struct path *path,
 236                    struct kstat *kstat, u32 request_mask, unsigned int flags)
 237 {
 238         int err;
 239         struct dentry *dentry = path->dentry;
 240         struct inode *inode = d_inode(dentry);
 241         struct vboxsf_inode *sf_i = VBOXSF_I(inode);
 242
 243         switch (flags & AT_STATX_SYNC_TYPE) {
 244         case AT_STATX_DONT_SYNC:
 245                 err = 0;
 246                 break;
 247         case AT_STATX_FORCE_SYNC:
 248                 sf_i->force_restat = 1;
 249                 fallthrough;
 250         default:
 251                 err = vboxsf_inode_revalidate(dentry);
 252         }
 253         if (err)
 254                 return err;
 255
 256         generic_fillattr(&nop_mnt_idmap, request_mask, d_inode(dentry), kstat);
 257         return 0;
 258 }
 259
 260 int vboxsf_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
 261                    struct iattr *iattr)
 262 {
 263         struct vboxsf_inode *sf_i = VBOXSF_I(d_inode(dentry));
 264         struct vboxsf_sbi *sbi = VBOXSF_SBI(dentry->d_sb);
 265         struct shfl_createparms params = {};
 266         struct shfl_fsobjinfo info = {};
 267         u32 buf_len;
 268         int err;
 269
 270         params.handle = SHFL_HANDLE_NIL;
 271         params.create_flags = SHFL_CF_ACT_OPEN_IF_EXISTS |
 272                               SHFL_CF_ACT_FAIL_IF_NEW |
 273                               SHFL_CF_ACCESS_ATTR_WRITE;
 274
 275         /* this is at least required for Posix hosts */
 276         if (iattr->ia_valid & ATTR_SIZE)
 277                 params.create_flags |= SHFL_CF_ACCESS_WRITE;
 278
 279         err = vboxsf_create_at_dentry(dentry, &params);
 280         if (err || params.result != SHFL_FILE_EXISTS)
 281                 return err ? err : -ENOENT;
 282
 283 #define mode_set(r) ((iattr->ia_mode & (S_##r)) ? SHFL_UNIX_##r : 0)
 284
 285         /*
 286          * Setting the file size and setting the other attributes has to
 287          * be handled separately.
 288          */
 289         if (iattr->ia_valid & (ATTR_MODE | ATTR_ATIME | ATTR_MTIME)) {
 290                 if (iattr->ia_valid & ATTR_MODE) {
 291                         info.attr.mode = mode_set(IRUSR);
 292                         info.attr.mode |= mode_set(IWUSR);
 293                         info.attr.mode |= mode_set(IXUSR);
 294                         info.attr.mode |= mode_set(IRGRP);
 295                         info.attr.mode |= mode_set(IWGRP);
 296                         info.attr.mode |= mode_set(IXGRP);
 297                         info.attr.mode |= mode_set(IROTH);
 298                         info.attr.mode |= mode_set(IWOTH);
 299                         info.attr.mode |= mode_set(IXOTH);
 300
 301                         if (iattr->ia_mode & S_IFDIR)
 302                                 info.attr.mode |= SHFL_TYPE_DIRECTORY;
 303                         else
 304                                 info.attr.mode |= SHFL_TYPE_FILE;
 305                 }
 306
 307                 if (iattr->ia_valid & ATTR_ATIME)
 308                         info.access_time.ns_relative_to_unix_epoch =
 309                                             timespec64_to_ns(&iattr->ia_atime);
 310
 311                 if (iattr->ia_valid & ATTR_MTIME)
 312                         info.modification_time.ns_relative_to_unix_epoch =
 313                                             timespec64_to_ns(&iattr->ia_mtime);
 314
 315                 /*
 316                  * Ignore ctime (inode change time) as it can't be set
 317                  * from userland anyway.
 318                  */
 319
 320                 buf_len = sizeof(info);
 321                 err = vboxsf_fsinfo(sbi->root, params.handle,
 322                                     SHFL_INFO_SET | SHFL_INFO_FILE, &buf_len,
 323                                     &info);
 324                 if (err) {
 325                         vboxsf_close(sbi->root, params.handle);
 326                         return err;
 327                 }
 328
 329                 /* the host may have given us different attr then requested */
 330                 sf_i->force_restat = 1;
 331         }
 332
 333 #undef mode_set
 334
 335         if (iattr->ia_valid & ATTR_SIZE) {
 336                 memset(&info, 0, sizeof(info));
 337                 info.size = iattr->ia_size;
 338                 buf_len = sizeof(info);
 339                 err = vboxsf_fsinfo(sbi->root, params.handle,
 340                                     SHFL_INFO_SET | SHFL_INFO_SIZE, &buf_len,
 341                                     &info);
 342                 if (err) {
 343                         vboxsf_close(sbi->root, params.handle);
 344                         return err;
 345                 }
 346
 347                 /* the host may have given us different attr then requested */
 348                 sf_i->force_restat = 1;
 349         }
 350
 351         vboxsf_close(sbi->root, params.handle);
 352
 353         /* Update the inode with what the host has actually given us. */
 354         if (sf_i->force_restat)
 355                 vboxsf_inode_revalidate(dentry);
 356
 357         return 0;
 358 }
 359
 360 /*
 361  * [dentry] contains string encoded in coding system that corresponds
 362  * to [sbi]->nls, we must convert it to UTF8 here.
 363  * Returns a shfl_string allocated through __getname (must be freed using
 364  * __putname), or an ERR_PTR on error.
 365  */
 366 struct shfl_string *vboxsf_path_from_dentry(struct vboxsf_sbi *sbi,
 367                                             struct dentry *dentry)
 368 {
 369         struct shfl_string *shfl_path;
 370         int path_len, out_len, nb;
 371         char *buf, *path;
 372         wchar_t uni;
 373         u8 *out;
 374
 375         buf = __getname();
 376         if (!buf)
 377                 return ERR_PTR(-ENOMEM);
 378
 379         path = dentry_path_raw(dentry, buf, PATH_MAX);
 380         if (IS_ERR(path)) {
 381                 __putname(buf);
 382                 return ERR_CAST(path);
 383         }
 384         path_len = strlen(path);
 385
 386         if (sbi->nls) {
 387                 shfl_path = __getname();
 388                 if (!shfl_path) {
 389                         __putname(buf);
 390                         return ERR_PTR(-ENOMEM);
 391                 }
 392
 393                 out = shfl_path->string.utf8;
 394                 out_len = PATH_MAX - SHFLSTRING_HEADER_SIZE - 1;
 395
 396                 while (path_len) {
 397                         nb = sbi->nls->char2uni(path, path_len, &uni);
 398                         if (nb < 0) {
 399                                 __putname(shfl_path);
 400                                 __putname(buf);
 401                                 return ERR_PTR(-EINVAL);
 402                         }
 403                         path += nb;
 404                         path_len -= nb;
 405
 406                         nb = utf32_to_utf8(uni, out, out_len);
 407                         if (nb < 0) {
 408                                 __putname(shfl_path);
 409                                 __putname(buf);
 410                                 return ERR_PTR(-ENAMETOOLONG);
 411                         }
 412                         out += nb;
 413                         out_len -= nb;
 414                 }
 415                 *out = 0;
 416                 shfl_path->length = out - shfl_path->string.utf8;
 417                 shfl_path->size = shfl_path->length + 1;
 418                 __putname(buf);
 419         } else {
 420                 if ((SHFLSTRING_HEADER_SIZE + path_len + 1) > PATH_MAX) {
 421                         __putname(buf);
 422                         return ERR_PTR(-ENAMETOOLONG);
 423                 }
 424                 /*
 425                  * dentry_path stores the name at the end of buf, but the
 426                  * shfl_string string we return must be properly aligned.
 427                  */
 428                 shfl_path = (struct shfl_string *)buf;
 429                 memmove(shfl_path->string.utf8, path, path_len);
 430                 shfl_path->string.utf8[path_len] = 0;
 431                 shfl_path->length = path_len;
 432                 shfl_path->size = path_len + 1;
 433         }
 434
 435         return shfl_path;
 436 }
 437
 438 int vboxsf_nlscpy(struct vboxsf_sbi *sbi, char *name, size_t name_bound_len,
 439                   const unsigned char *utf8_name, size_t utf8_len)
 440 {
 441         const char *in;
 442         char *out;
 443         size_t out_bound_len;
 444         size_t in_bound_len;
 445
 446         in = utf8_name;
 447         in_bound_len = utf8_len;
 448
 449         out = name;
 450         /* Reserve space for terminating 0 */
 451         out_bound_len = name_bound_len - 1;
 452
 453         while (in_bound_len) {
 454                 int nb;
 455                 unicode_t uni;
 456
 457                 nb = utf8_to_utf32(in, in_bound_len, &uni);
 458                 if (nb < 0)
 459                         return -EINVAL;
 460
 461                 in += nb;
 462                 in_bound_len -= nb;
 463
 464                 nb = sbi->nls->uni2char(uni, out, out_bound_len);
 465                 if (nb < 0)
 466                         return nb;
 467
 468                 out += nb;
 469                 out_bound_len -= nb;
 470         }
 471
 472         *out = 0;
 473
 474         return 0;
 475 }
 476
 477 static struct vboxsf_dir_buf *vboxsf_dir_buf_alloc(struct list_head *list)
 478 {
 479         struct vboxsf_dir_buf *b;
 480
 481         b = kmalloc(sizeof(*b), GFP_KERNEL);
 482         if (!b)
 483                 return NULL;
 484
 485         b->buf = kmalloc(DIR_BUFFER_SIZE, GFP_KERNEL);
 486         if (!b->buf) {
 487                 kfree(b);
 488                 return NULL;
 489         }
 490
 491         b->entries = 0;
 492         b->used = 0;
 493         b->free = DIR_BUFFER_SIZE;
 494         list_add(&b->head, list);
 495
 496         return b;
 497 }
 498
 499 static void vboxsf_dir_buf_free(struct vboxsf_dir_buf *b)
 500 {
 501         list_del(&b->head);
 502         kfree(b->buf);
 503         kfree(b);
 504 }
 505
 506 struct vboxsf_dir_info *vboxsf_dir_info_alloc(void)
 507 {
 508         struct vboxsf_dir_info *p;
 509
 510         p = kmalloc(sizeof(*p), GFP_KERNEL);
 511         if (!p)
 512                 return NULL;
 513
 514         INIT_LIST_HEAD(&p->info_list);
 515         return p;
 516 }
 517
 518 void vboxsf_dir_info_free(struct vboxsf_dir_info *p)
 519 {
 520         struct list_head *list, *pos, *tmp;
 521
 522         list = &p->info_list;
 523         list_for_each_safe(pos, tmp, list) {
 524                 struct vboxsf_dir_buf *b;
 525
 526                 b = list_entry(pos, struct vboxsf_dir_buf, head);
 527                 vboxsf_dir_buf_free(b);
 528         }
 529         kfree(p);
 530 }
 531
 532 int vboxsf_dir_read_all(struct vboxsf_sbi *sbi, struct vboxsf_dir_info *sf_d,
 533                         u64 handle)
 534 {
 535         struct vboxsf_dir_buf *b;
 536         u32 entries, size;
 537         int err = 0;
 538         void *buf;
 539
 540         /* vboxsf_dirinfo returns 1 on end of dir */
 541         while (err == 0) {
 542                 b = vboxsf_dir_buf_alloc(&sf_d->info_list);
 543                 if (!b) {
 544                         err = -ENOMEM;
 545                         break;
 546                 }
 547
 548                 buf = b->buf;
 549                 size = b->free;
 550
 551                 err = vboxsf_dirinfo(sbi->root, handle, NULL, 0, 0,
 552                                      &size, buf, &entries);
 553                 if (err < 0)
 554                         break;
 555
 556                 b->entries += entries;
 557                 b->free -= size;
 558                 b->used += size;
 559         }
 560
 561         if (b && b->used == 0)
 562                 vboxsf_dir_buf_free(b);
 563
 564         /* -EILSEQ means the host could not translate a filename, ignore */
 565         if (err > 0 || err == -EILSEQ)
 566                 err = 0;
 567
 568         return err;
 569 }