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_valid_type(o->attr.mode))
 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 ||
 204                     get_node_id(inode) != o->nodeid ||
 205                     ((o->attr.mode ^ inode->i_mode) & S_IFMT)) {
 206                         d_invalidate(dentry);
 207                         dput(dentry);
 208                         goto retry;
 209                 }
 210                 if (is_bad_inode(inode)) {
 211                         dput(dentry);
 212                         return -EIO;
 213                 }
 214
 215                 fi = get_fuse_inode(inode);
 216                 spin_lock(&fi->lock);
 217                 fi->nlookup++;
 218                 spin_unlock(&fi->lock);
 219
 220                 forget_all_cached_acls(inode);
 221                 fuse_change_attributes(inode, &o->attr,
 222                                        entry_attr_timeout(o),
 223                                        attr_version);
 224                 /*
 225                  * The other branch comes via fuse_iget()
 226                  * which bumps nlookup inside
 227                  */
 228         } else {
 229                 inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
 230                                   &o->attr, entry_attr_timeout(o),
 231                                   attr_version);
 232                 if (!inode)
 233                         inode = ERR_PTR(-ENOMEM);
 234
 235                 alias = d_splice_alias(inode, dentry);
 236                 d_lookup_done(dentry);
 237                 if (alias) {
 238                         dput(dentry);
 239                         dentry = alias;
 240                 }
 241                 if (IS_ERR(dentry))
 242                         return PTR_ERR(dentry);
 243         }
 244         if (fc->readdirplus_auto)
 245                 set_bit(FUSE_I_INIT_RDPLUS, &get_fuse_inode(inode)->state);
 246         fuse_change_entry_timeout(dentry, o);
 247
 248         dput(dentry);
 249         return 0;
 250 }
 251
 252 static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
 253                              struct dir_context *ctx, u64 attr_version)
 254 {
 255         struct fuse_direntplus *direntplus;
 256         struct fuse_dirent *dirent;
 257         size_t reclen;
 258         int over = 0;
 259         int ret;
 260
 261         while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
 262                 direntplus = (struct fuse_direntplus *) buf;
 263                 dirent = &direntplus->dirent;
 264                 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
 265
 266                 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
 267                         return -EIO;
 268                 if (reclen > nbytes)
 269                         break;
 270                 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
 271                         return -EIO;
 272
 273                 if (!over) {
 274                         /* We fill entries into dstbuf only as much as
 275                            it can hold. But we still continue iterating
 276                            over remaining entries to link them. If not,
 277                            we need to send a FORGET for each of those
 278                            which we did not link.
 279                         */
 280                         over = !fuse_emit(file, ctx, dirent);
 281                         if (!over)
 282                                 ctx->pos = dirent->off;
 283                 }
 284
 285                 buf += reclen;
 286                 nbytes -= reclen;
 287
 288                 ret = fuse_direntplus_link(file, direntplus, attr_version);
 289                 if (ret)
 290                         fuse_force_forget(file, direntplus->entry_out.nodeid);
 291         }
 292
 293         return 0;
 294 }
 295
 296 static int fuse_readdir_uncached(struct file *file, struct dir_context *ctx)
 297 {
 298         int plus, err;
 299         size_t nbytes;
 300         struct page *page;
 301         struct inode *inode = file_inode(file);
 302         struct fuse_conn *fc = get_fuse_conn(inode);
 303         struct fuse_req *req;
 304         u64 attr_version = 0;
 305         bool locked;
 306
 307         req = fuse_get_req(fc, 1);
 308         if (IS_ERR(req))
 309                 return PTR_ERR(req);
 310
 311         page = alloc_page(GFP_KERNEL);
 312         if (!page) {
 313                 fuse_put_request(fc, req);
 314                 return -ENOMEM;
 315         }
 316
 317         plus = fuse_use_readdirplus(inode, ctx);
 318         req->out.argpages = 1;
 319         req->num_pages = 1;
 320         req->pages[0] = page;
 321         req->page_descs[0].length = PAGE_SIZE;
 322         if (plus) {
 323                 attr_version = fuse_get_attr_version(fc);
 324                 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
 325                                FUSE_READDIRPLUS);
 326         } else {
 327                 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
 328                                FUSE_READDIR);
 329         }
 330         locked = fuse_lock_inode(inode);
 331         fuse_request_send(fc, req);
 332         fuse_unlock_inode(inode, locked);
 333         nbytes = req->out.args[0].size;
 334         err = req->out.h.error;
 335         fuse_put_request(fc, req);
 336         if (!err) {
 337                 if (!nbytes) {
 338                         struct fuse_file *ff = file->private_data;
 339
 340                         if (ff->open_flags & FOPEN_CACHE_DIR)
 341                                 fuse_readdir_cache_end(file, ctx->pos);
 342                 } else if (plus) {
 343                         err = parse_dirplusfile(page_address(page), nbytes,
 344                                                 file, ctx, attr_version);
 345                 } else {
 346                         err = parse_dirfile(page_address(page), nbytes, file,
 347                                             ctx);
 348                 }
 349         }
 350
 351         __free_page(page);
 352         fuse_invalidate_atime(inode);
 353         return err;
 354 }
 355
 356 enum fuse_parse_result {
 357         FOUND_ERR = -1,
 358         FOUND_NONE = 0,
 359         FOUND_SOME,
 360         FOUND_ALL,
 361 };
 362
 363 static enum fuse_parse_result fuse_parse_cache(struct fuse_file *ff,
 364                                                void *addr, unsigned int size,
 365                                                struct dir_context *ctx)
 366 {
 367         unsigned int offset = ff->readdir.cache_off & ~PAGE_MASK;
 368         enum fuse_parse_result res = FOUND_NONE;
 369
 370         WARN_ON(offset >= size);
 371
 372         for (;;) {
 373                 struct fuse_dirent *dirent = addr + offset;
 374                 unsigned int nbytes = size - offset;
 375                 size_t reclen;
 376
 377                 if (nbytes < FUSE_NAME_OFFSET || !dirent->namelen)
 378                         break;
 379
 380                 reclen = FUSE_DIRENT_SIZE(dirent); /* derefs ->namelen */
 381
 382                 if (WARN_ON(dirent->namelen > FUSE_NAME_MAX))
 383                         return FOUND_ERR;
 384                 if (WARN_ON(reclen > nbytes))
 385                         return FOUND_ERR;
 386                 if (WARN_ON(memchr(dirent->name, '/', dirent->namelen) != NULL))
 387                         return FOUND_ERR;
 388
 389                 if (ff->readdir.pos == ctx->pos) {
 390                         res = FOUND_SOME;
 391                         if (!dir_emit(ctx, dirent->name, dirent->namelen,
 392                                       dirent->ino, dirent->type))
 393                                 return FOUND_ALL;
 394                         ctx->pos = dirent->off;
 395                 }
 396                 ff->readdir.pos = dirent->off;
 397                 ff->readdir.cache_off += reclen;
 398
 399                 offset += reclen;
 400         }
 401
 402         return res;
 403 }
 404
 405 static void fuse_rdc_reset(struct inode *inode)
 406 {
 407         struct fuse_inode *fi = get_fuse_inode(inode);
 408
 409         fi->rdc.cached = false;
 410         fi->rdc.version++;
 411         fi->rdc.size = 0;
 412         fi->rdc.pos = 0;
 413 }
 414
 415 #define UNCACHED 1
 416
 417 static int fuse_readdir_cached(struct file *file, struct dir_context *ctx)
 418 {
 419         struct fuse_file *ff = file->private_data;
 420         struct inode *inode = file_inode(file);
 421         struct fuse_conn *fc = get_fuse_conn(inode);
 422         struct fuse_inode *fi = get_fuse_inode(inode);
 423         enum fuse_parse_result res;
 424         pgoff_t index;
 425         unsigned int size;
 426         struct page *page;
 427         void *addr;
 428
 429         /* Seeked?  If so, reset the cache stream */
 430         if (ff->readdir.pos != ctx->pos) {
 431                 ff->readdir.pos = 0;
 432                 ff->readdir.cache_off = 0;
 433         }
 434
 435         /*
 436          * We're just about to start reading into the cache or reading the
 437          * cache; both cases require an up-to-date mtime value.
 438          */
 439         if (!ctx->pos && fc->auto_inval_data) {
 440                 int err = fuse_update_attributes(inode, file);
 441
 442                 if (err)
 443                         return err;
 444         }
 445
 446 retry:
 447         spin_lock(&fi->rdc.lock);
 448 retry_locked:
 449         if (!fi->rdc.cached) {
 450                 /* Starting cache? Set cache mtime. */
 451                 if (!ctx->pos && !fi->rdc.size) {
 452                         fi->rdc.mtime = inode->i_mtime;
 453                         fi->rdc.iversion = inode_query_iversion(inode);
 454                 }
 455                 spin_unlock(&fi->rdc.lock);
 456                 return UNCACHED;
 457         }
 458         /*
 459          * When at the beginning of the directory (i.e. just after opendir(3) or
 460          * rewinddir(3)), then need to check whether directory contents have
 461          * changed, and reset the cache if so.
 462          */
 463         if (!ctx->pos) {
 464                 if (inode_peek_iversion(inode) != fi->rdc.iversion ||
 465                     !timespec64_equal(&fi->rdc.mtime, &inode->i_mtime)) {
 466                         fuse_rdc_reset(inode);
 467                         goto retry_locked;
 468                 }
 469         }
 470
 471         /*
 472          * If cache version changed since the last getdents() call, then reset
 473          * the cache stream.
 474          */
 475         if (ff->readdir.version != fi->rdc.version) {
 476                 ff->readdir.pos = 0;
 477                 ff->readdir.cache_off = 0;
 478         }
 479         /*
 480          * If at the beginning of the cache, than reset version to
 481          * current.
 482          */
 483         if (ff->readdir.pos == 0)
 484                 ff->readdir.version = fi->rdc.version;
 485
 486         WARN_ON(fi->rdc.size < ff->readdir.cache_off);
 487
 488         index = ff->readdir.cache_off >> PAGE_SHIFT;
 489
 490         if (index == (fi->rdc.size >> PAGE_SHIFT))
 491                 size = fi->rdc.size & ~PAGE_MASK;
 492         else
 493                 size = PAGE_SIZE;
 494         spin_unlock(&fi->rdc.lock);
 495
 496         /* EOF? */
 497         if ((ff->readdir.cache_off & ~PAGE_MASK) == size)
 498                 return 0;
 499
 500         page = find_get_page_flags(file->f_mapping, index,
 501                                    FGP_ACCESSED | FGP_LOCK);
 502         spin_lock(&fi->rdc.lock);
 503         if (!page) {
 504                 /*
 505                  * Uh-oh: page gone missing, cache is useless
 506                  */
 507                 if (fi->rdc.version == ff->readdir.version)
 508                         fuse_rdc_reset(inode);
 509                 goto retry_locked;
 510         }
 511
 512         /* Make sure it's still the same version after getting the page. */
 513         if (ff->readdir.version != fi->rdc.version) {
 514                 spin_unlock(&fi->rdc.lock);
 515                 unlock_page(page);
 516                 put_page(page);
 517                 goto retry;
 518         }
 519         spin_unlock(&fi->rdc.lock);
 520
 521         /*
 522          * Contents of the page are now protected against changing by holding
 523          * the page lock.
 524          */
 525         addr = kmap(page);
 526         res = fuse_parse_cache(ff, addr, size, ctx);
 527         kunmap(page);
 528         unlock_page(page);
 529         put_page(page);
 530
 531         if (res == FOUND_ERR)
 532                 return -EIO;
 533
 534         if (res == FOUND_ALL)
 535                 return 0;
 536
 537         if (size == PAGE_SIZE) {
 538                 /* We hit end of page: skip to next page. */
 539                 ff->readdir.cache_off = ALIGN(ff->readdir.cache_off, PAGE_SIZE);
 540                 goto retry;
 541         }
 542
 543         /*
 544          * End of cache reached.  If found position, then we are done, otherwise
 545          * need to fall back to uncached, since the position we were looking for
 546          * wasn't in the cache.
 547          */
 548         return res == FOUND_SOME ? 0 : UNCACHED;
 549 }
 550
 551 int fuse_readdir(struct file *file, struct dir_context *ctx)
 552 {
 553         struct fuse_file *ff = file->private_data;
 554         struct inode *inode = file_inode(file);
 555         int err;
 556
 557         if (is_bad_inode(inode))
 558                 return -EIO;
 559
 560         mutex_lock(&ff->readdir.lock);
 561
 562         err = UNCACHED;
 563         if (ff->open_flags & FOPEN_CACHE_DIR)
 564                 err = fuse_readdir_cached(file, ctx);
 565         if (err == UNCACHED)
 566                 err = fuse_readdir_uncached(file, ctx);
 567
 568         mutex_unlock(&ff->readdir.lock);
 569
 570         return err;
 571 }