fs/fuse/readdir.c

   1 /*
   2   FUSE: Filesystem in Userspace
   3   Copyright (C) 2001-2018  Miklos Szeredi <miklos@szeredi.hu>
   4
   5   This program can be distributed under the terms of the GNU GPL.
   6   See the file COPYING.
   7 */
   8
   9
  10 #include "fuse_i.h"
  11 #include <linux/iversion.h>
  12 #include <linux/posix_acl.h>
  13 #include <linux/pagemap.h>
  14 #include <linux/highmem.h>
  15
  16 static bool fuse_use_readdirplus(struct inode *dir, struct dir_context *ctx)
  17 {
  18         struct fuse_conn *fc = get_fuse_conn(dir);
  19         struct fuse_inode *fi = get_fuse_inode(dir);
  20
  21         if (!fc->do_readdirplus)
  22                 return false;
  23         if (!fc->readdirplus_auto)
  24                 return true;
  25         if (test_and_clear_bit(FUSE_I_ADVISE_RDPLUS, &fi->state))
  26                 return true;
  27         if (ctx->pos == 0)
  28                 return true;
  29         return false;
  30 }
  31
  32 static void fuse_add_dirent_to_cache(struct file *file,
  33                                      struct fuse_dirent *dirent, loff_t pos)
  34 {
  35         struct fuse_inode *fi = get_fuse_inode(file_inode(file));
  36         size_t reclen = FUSE_DIRENT_SIZE(dirent);
  37         pgoff_t index;
  38         struct page *page;
  39         loff_t size;
  40         u64 version;
  41         unsigned int offset;
  42         void *addr;
  43
  44         spin_lock(&fi->rdc.lock);
  45         /*
  46          * Is cache already completed?  Or this entry does not go at the end of
  47          * cache?
  48          */
  49         if (fi->rdc.cached || pos != fi->rdc.pos) {
  50                 spin_unlock(&fi->rdc.lock);
  51                 return;
  52         }
  53         version = fi->rdc.version;
  54         size = fi->rdc.size;
  55         offset = size & ~PAGE_MASK;
  56         index = size >> PAGE_SHIFT;
  57         /* Dirent doesn't fit in current page?  Jump to next page. */
  58         if (offset + reclen > PAGE_SIZE) {
  59                 index++;
  60                 offset = 0;
  61         }
  62         spin_unlock(&fi->rdc.lock);
  63
  64         if (offset) {
  65                 page = find_lock_page(file->f_mapping, index);
  66         } else {
  67                 page = find_or_create_page(file->f_mapping, index,
  68                                            mapping_gfp_mask(file->f_mapping));
  69         }
  70         if (!page)
  71                 return;
  72
  73         spin_lock(&fi->rdc.lock);
  74         /* Raced with another readdir */
  75         if (fi->rdc.version != version || fi->rdc.size != size ||
  76             WARN_ON(fi->rdc.pos != pos))
  77                 goto unlock;
  78
  79         addr = kmap_atomic(page);
  80         if (!offset)
  81                 clear_page(addr);
  82         memcpy(addr + offset, dirent, reclen);
  83         kunmap_atomic(addr);
  84         fi->rdc.size = (index << PAGE_SHIFT) + offset + reclen;
  85         fi->rdc.pos = dirent->off;
  86 unlock:
  87         spin_unlock(&fi->rdc.lock);
  88         unlock_page(page);
  89         put_page(page);
  90 }
  91
  92 static void fuse_readdir_cache_end(struct file *file, loff_t pos)
  93 {
  94         struct fuse_inode *fi = get_fuse_inode(file_inode(file));
  95         loff_t end;
  96
  97         spin_lock(&fi->rdc.lock);
  98         /* does cache end position match current position? */
  99         if (fi->rdc.pos != pos) {
 100                 spin_unlock(&fi->rdc.lock);
 101                 return;
 102         }
 103
 104         fi->rdc.cached = true;
 105         end = ALIGN(fi->rdc.size, PAGE_SIZE);
 106         spin_unlock(&fi->rdc.lock);
 107
 108         /* truncate unused tail of cache */
 109         truncate_inode_pages(file->f_mapping, end);
 110 }
 111
 112 static bool fuse_emit(struct file *file, struct dir_context *ctx,
 113                       struct fuse_dirent *dirent)
 114 {
 115         struct fuse_file *ff = file->private_data;
 116
 117         if (ff->open_flags & FOPEN_CACHE_DIR)
 118                 fuse_add_dirent_to_cache(file, dirent, ctx->pos);
 119
 120         return dir_emit(ctx, dirent->name, dirent->namelen, dirent->ino,
 121                         dirent->type);
 122 }
 123
 124 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
 125                          struct dir_context *ctx)
 126 {
 127         while (nbytes >= FUSE_NAME_OFFSET) {
 128                 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
 129                 size_t reclen = FUSE_DIRENT_SIZE(dirent);
 130                 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
 131                         return -EIO;
 132                 if (reclen > nbytes)
 133                         break;
 134                 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
 135                         return -EIO;
 136
 137                 if (!fuse_emit(file, ctx, dirent))
 138                         break;
 139
 140                 buf += reclen;
 141                 nbytes -= reclen;
 142                 ctx->pos = dirent->off;
 143         }
 144
 145         return 0;
 146 }
 147
 148 static int fuse_direntplus_link(struct file *file,
 149                                 struct fuse_direntplus *direntplus,
 150                                 u64 attr_version)
 151 {
 152         struct fuse_entry_out *o = &direntplus->entry_out;
 153         struct fuse_dirent *dirent = &direntplus->dirent;
 154         struct dentry *parent = file->f_path.dentry;
 155         struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
 156         struct dentry *dentry;
 157         struct dentry *alias;
 158         struct inode *dir = d_inode(parent);
 159         struct fuse_conn *fc;
 160         struct inode *inode;
 161         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
 162
 163         if (!o->nodeid) {
 164                 /*
 165                  * Unlike in the case of fuse_lookup, zero nodeid does not mean
 166                  * ENOENT. Instead, it only means the userspace filesystem did
 167                  * not want to return attributes/handle for this entry.
 168                  *
 169                  * So do nothing.
 170                  */
 171                 return 0;
 172         }
 173
 174         if (name.name[0] == '.') {
 175                 /*
 176                  * We could potentially refresh the attributes of the directory
 177                  * and its parent?
 178                  */
 179                 if (name.len == 1)
 180                         return 0;
 181                 if (name.name[1] == '.' && name.len == 2)
 182                         return 0;
 183         }
 184
 185         if (invalid_nodeid(o->nodeid))
 186                 return -EIO;
 187         if (fuse_invalid_attr(&o->attr))
 188                 return -EIO;
 189
 190         fc = get_fuse_conn(dir);
 191
 192         name.hash = full_name_hash(parent, name.name, name.len);
 193         dentry = d_lookup(parent, &name);
 194         if (!dentry) {
 195 retry:
 196                 dentry = d_alloc_parallel(parent, &name, &wq);
 197                 if (IS_ERR(dentry))
 198                         return PTR_ERR(dentry);
 199         }
 200         if (!d_in_lookup(dentry)) {
 201                 struct fuse_inode *fi;
 202                 inode = d_inode(dentry);
 203                 if (inode && get_node_id(inode) != o->nodeid)
 204                         inode = NULL;
 205                 if (!inode ||
 206                     fuse_stale_inode(inode, o->generation, &o->attr)) {
 207                         if (inode)
 208                                 fuse_make_bad(inode);
 209                         d_invalidate(dentry);
 210                         dput(dentry);
 211                         goto retry;
 212                 }
 213                 if (fuse_is_bad(inode)) {
 214                         dput(dentry);
 215                         return -EIO;
 216                 }
 217
 218                 fi = get_fuse_inode(inode);
 219                 spin_lock(&fi->lock);
 220                 fi->nlookup++;
 221                 spin_unlock(&fi->lock);
 222
 223                 forget_all_cached_acls(inode);
 224                 fuse_change_attributes(inode, &o->attr,
 225                                        entry_attr_timeout(o),
 226                                        attr_version);
 227                 /*
 228                  * The other branch comes via fuse_iget()
 229                  * which bumps nlookup inside
 230                  */
 231         } else {
 232                 inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
 233                                   &o->attr, entry_attr_timeout(o),
 234                                   attr_version);
 235                 if (!inode)
 236                         inode = ERR_PTR(-ENOMEM);
 237
 238                 alias = d_splice_alias(inode, dentry);
 239                 d_lookup_done(dentry);
 240                 if (alias) {
 241                         dput(dentry);
 242                         dentry = alias;
 243                 }
 244                 if (IS_ERR(dentry))
 245                         return PTR_ERR(dentry);
 246         }
 247         if (fc->readdirplus_auto)
 248                 set_bit(FUSE_I_INIT_RDPLUS, &get_fuse_inode(inode)->state);
 249         fuse_change_entry_timeout(dentry, o);
 250
 251         dput(dentry);
 252         return 0;
 253 }
 254
 255 static void fuse_force_forget(struct file *file, u64 nodeid)
 256 {
 257         struct inode *inode = file_inode(file);
 258         struct fuse_mount *fm = get_fuse_mount(inode);
 259         struct fuse_forget_in inarg;
 260         FUSE_ARGS(args);
 261
 262         memset(&inarg, 0, sizeof(inarg));
 263         inarg.nlookup = 1;
 264         args.opcode = FUSE_FORGET;
 265         args.nodeid = nodeid;
 266         args.in_numargs = 1;
 267         args.in_args[0].size = sizeof(inarg);
 268         args.in_args[0].value = &inarg;
 269         args.force = true;
 270         args.noreply = true;
 271
 272         fuse_simple_request(fm, &args);
 273         /* ignore errors */
 274 }
 275
 276 static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
 277                              struct dir_context *ctx, u64 attr_version)
 278 {
 279         struct fuse_direntplus *direntplus;
 280         struct fuse_dirent *dirent;
 281         size_t reclen;
 282         int over = 0;
 283         int ret;
 284
 285         while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
 286                 direntplus = (struct fuse_direntplus *) buf;
 287                 dirent = &direntplus->dirent;
 288                 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
 289
 290                 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
 291                         return -EIO;
 292                 if (reclen > nbytes)
 293                         break;
 294                 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
 295                         return -EIO;
 296
 297                 if (!over) {
 298                         /* We fill entries into dstbuf only as much as
 299                            it can hold. But we still continue iterating
 300                            over remaining entries to link them. If not,
 301                            we need to send a FORGET for each of those
 302                            which we did not link.
 303                         */
 304                         over = !fuse_emit(file, ctx, dirent);
 305                         if (!over)
 306                                 ctx->pos = dirent->off;
 307                 }
 308
 309                 buf += reclen;
 310                 nbytes -= reclen;
 311
 312                 ret = fuse_direntplus_link(file, direntplus, attr_version);
 313                 if (ret)
 314                         fuse_force_forget(file, direntplus->entry_out.nodeid);
 315         }
 316
 317         return 0;
 318 }
 319
 320 static int fuse_readdir_uncached(struct file *file, struct dir_context *ctx)
 321 {
 322         int plus;
 323         ssize_t res;
 324         struct page *page;
 325         struct inode *inode = file_inode(file);
 326         struct fuse_mount *fm = get_fuse_mount(inode);
 327         struct fuse_io_args ia = {};
 328         struct fuse_args_pages *ap = &ia.ap;
 329         struct fuse_page_desc desc = { .length = PAGE_SIZE };
 330         u64 attr_version = 0;
 331         bool locked;
 332
 333         page = alloc_page(GFP_KERNEL);
 334         if (!page)
 335                 return -ENOMEM;
 336
 337         plus = fuse_use_readdirplus(inode, ctx);
 338         ap->args.out_pages = true;
 339         ap->num_pages = 1;
 340         ap->pages = &page;
 341         ap->descs = &desc;
 342         if (plus) {
 343                 attr_version = fuse_get_attr_version(fm->fc);
 344                 fuse_read_args_fill(&ia, file, ctx->pos, PAGE_SIZE,
 345                                     FUSE_READDIRPLUS);
 346         } else {
 347                 fuse_read_args_fill(&ia, file, ctx->pos, PAGE_SIZE,
 348                                     FUSE_READDIR);
 349         }
 350         locked = fuse_lock_inode(inode);
 351         res = fuse_simple_request(fm, &ap->args);
 352         fuse_unlock_inode(inode, locked);
 353         if (res >= 0) {
 354                 if (!res) {
 355                         struct fuse_file *ff = file->private_data;
 356
 357                         if (ff->open_flags & FOPEN_CACHE_DIR)
 358                                 fuse_readdir_cache_end(file, ctx->pos);
 359                 } else if (plus) {
 360                         res = parse_dirplusfile(page_address(page), res,
 361                                                 file, ctx, attr_version);
 362                 } else {
 363                         res = parse_dirfile(page_address(page), res, file,
 364                                             ctx);
 365                 }
 366         }
 367
 368         __free_page(page);
 369         fuse_invalidate_atime(inode);
 370         return res;
 371 }
 372
 373 enum fuse_parse_result {
 374         FOUND_ERR = -1,
 375         FOUND_NONE = 0,
 376         FOUND_SOME,
 377         FOUND_ALL,
 378 };
 379
 380 static enum fuse_parse_result fuse_parse_cache(struct fuse_file *ff,
 381                                                void *addr, unsigned int size,
 382                                                struct dir_context *ctx)
 383 {
 384         unsigned int offset = ff->readdir.cache_off & ~PAGE_MASK;
 385         enum fuse_parse_result res = FOUND_NONE;
 386
 387         WARN_ON(offset >= size);
 388
 389         for (;;) {
 390                 struct fuse_dirent *dirent = addr + offset;
 391                 unsigned int nbytes = size - offset;
 392                 size_t reclen;
 393
 394                 if (nbytes < FUSE_NAME_OFFSET || !dirent->namelen)
 395                         break;
 396
 397                 reclen = FUSE_DIRENT_SIZE(dirent); /* derefs ->namelen */
 398
 399                 if (WARN_ON(dirent->namelen > FUSE_NAME_MAX))
 400                         return FOUND_ERR;
 401                 if (WARN_ON(reclen > nbytes))
 402                         return FOUND_ERR;
 403                 if (WARN_ON(memchr(dirent->name, '/', dirent->namelen) != NULL))
 404                         return FOUND_ERR;
 405
 406                 if (ff->readdir.pos == ctx->pos) {
 407                         res = FOUND_SOME;
 408                         if (!dir_emit(ctx, dirent->name, dirent->namelen,
 409                                       dirent->ino, dirent->type))
 410                                 return FOUND_ALL;
 411                         ctx->pos = dirent->off;
 412                 }
 413                 ff->readdir.pos = dirent->off;
 414                 ff->readdir.cache_off += reclen;
 415
 416                 offset += reclen;
 417         }
 418
 419         return res;
 420 }
 421
 422 static void fuse_rdc_reset(struct inode *inode)
 423 {
 424         struct fuse_inode *fi = get_fuse_inode(inode);
 425
 426         fi->rdc.cached = false;
 427         fi->rdc.version++;
 428         fi->rdc.size = 0;
 429         fi->rdc.pos = 0;
 430 }
 431
 432 #define UNCACHED 1
 433
 434 static int fuse_readdir_cached(struct file *file, struct dir_context *ctx)
 435 {
 436         struct fuse_file *ff = file->private_data;
 437         struct inode *inode = file_inode(file);
 438         struct fuse_conn *fc = get_fuse_conn(inode);
 439         struct fuse_inode *fi = get_fuse_inode(inode);
 440         enum fuse_parse_result res;
 441         pgoff_t index;
 442         unsigned int size;
 443         struct page *page;
 444         void *addr;
 445
 446         /* Seeked?  If so, reset the cache stream */
 447         if (ff->readdir.pos != ctx->pos) {
 448                 ff->readdir.pos = 0;
 449                 ff->readdir.cache_off = 0;
 450         }
 451
 452         /*
 453          * We're just about to start reading into the cache or reading the
 454          * cache; both cases require an up-to-date mtime value.
 455          */
 456         if (!ctx->pos && fc->auto_inval_data) {
 457                 int err = fuse_update_attributes(inode, file);
 458
 459                 if (err)
 460                         return err;
 461         }
 462
 463 retry:
 464         spin_lock(&fi->rdc.lock);
 465 retry_locked:
 466         if (!fi->rdc.cached) {
 467                 /* Starting cache? Set cache mtime. */
 468                 if (!ctx->pos && !fi->rdc.size) {
 469                         fi->rdc.mtime = inode->i_mtime;
 470                         fi->rdc.iversion = inode_query_iversion(inode);
 471                 }
 472                 spin_unlock(&fi->rdc.lock);
 473                 return UNCACHED;
 474         }
 475         /*
 476          * When at the beginning of the directory (i.e. just after opendir(3) or
 477          * rewinddir(3)), then need to check whether directory contents have
 478          * changed, and reset the cache if so.
 479          */
 480         if (!ctx->pos) {
 481                 if (inode_peek_iversion(inode) != fi->rdc.iversion ||
 482                     !timespec64_equal(&fi->rdc.mtime, &inode->i_mtime)) {
 483                         fuse_rdc_reset(inode);
 484                         goto retry_locked;
 485                 }
 486         }
 487
 488         /*
 489          * If cache version changed since the last getdents() call, then reset
 490          * the cache stream.
 491          */
 492         if (ff->readdir.version != fi->rdc.version) {
 493                 ff->readdir.pos = 0;
 494                 ff->readdir.cache_off = 0;
 495         }
 496         /*
 497          * If at the beginning of the cache, than reset version to
 498          * current.
 499          */
 500         if (ff->readdir.pos == 0)
 501                 ff->readdir.version = fi->rdc.version;
 502
 503         WARN_ON(fi->rdc.size < ff->readdir.cache_off);
 504
 505         index = ff->readdir.cache_off >> PAGE_SHIFT;
 506
 507         if (index == (fi->rdc.size >> PAGE_SHIFT))
 508                 size = fi->rdc.size & ~PAGE_MASK;
 509         else
 510                 size = PAGE_SIZE;
 511         spin_unlock(&fi->rdc.lock);
 512
 513         /* EOF? */
 514         if ((ff->readdir.cache_off & ~PAGE_MASK) == size)
 515                 return 0;
 516
 517         page = find_get_page_flags(file->f_mapping, index,
 518                                    FGP_ACCESSED | FGP_LOCK);
 519         spin_lock(&fi->rdc.lock);
 520         if (!page) {
 521                 /*
 522                  * Uh-oh: page gone missing, cache is useless
 523                  */
 524                 if (fi->rdc.version == ff->readdir.version)
 525                         fuse_rdc_reset(inode);
 526                 goto retry_locked;
 527         }
 528
 529         /* Make sure it's still the same version after getting the page. */
 530         if (ff->readdir.version != fi->rdc.version) {
 531                 spin_unlock(&fi->rdc.lock);
 532                 unlock_page(page);
 533                 put_page(page);
 534                 goto retry;
 535         }
 536         spin_unlock(&fi->rdc.lock);
 537
 538         /*
 539          * Contents of the page are now protected against changing by holding
 540          * the page lock.
 541          */
 542         addr = kmap(page);
 543         res = fuse_parse_cache(ff, addr, size, ctx);
 544         kunmap(page);
 545         unlock_page(page);
 546         put_page(page);
 547
 548         if (res == FOUND_ERR)
 549                 return -EIO;
 550
 551         if (res == FOUND_ALL)
 552                 return 0;
 553
 554         if (size == PAGE_SIZE) {
 555                 /* We hit end of page: skip to next page. */
 556                 ff->readdir.cache_off = ALIGN(ff->readdir.cache_off, PAGE_SIZE);
 557                 goto retry;
 558         }
 559
 560         /*
 561          * End of cache reached.  If found position, then we are done, otherwise
 562          * need to fall back to uncached, since the position we were looking for
 563          * wasn't in the cache.
 564          */
 565         return res == FOUND_SOME ? 0 : UNCACHED;
 566 }
 567
 568 int fuse_readdir(struct file *file, struct dir_context *ctx)
 569 {
 570         struct fuse_file *ff = file->private_data;
 571         struct inode *inode = file_inode(file);
 572         int err;
 573
 574         if (fuse_is_bad(inode))
 575                 return -EIO;
 576
 577         mutex_lock(&ff->readdir.lock);
 578
 579         err = UNCACHED;
 580         if (ff->open_flags & FOPEN_CACHE_DIR)
 581                 err = fuse_readdir_cached(file, ctx);
 582         if (err == UNCACHED)
 583                 err = fuse_readdir_uncached(file, ctx);
 584
 585         mutex_unlock(&ff->readdir.lock);
 586
 587         return err;
 588 }