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_local_page(page); 80 if (!offset) 81 clear_page(addr); 82 memcpy(addr + offset, dirent, reclen); 83 kunmap_local(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, STATX_MTIME); 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 } 589