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(&fc->lock); 217 fi->nlookup++; 218 spin_unlock(&fc->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 = FUSE_DIRENT_SIZE(dirent); 376 377 if (nbytes < FUSE_NAME_OFFSET || !dirent->namelen) 378 break; 379 380 if (WARN_ON(dirent->namelen > FUSE_NAME_MAX)) 381 return FOUND_ERR; 382 if (WARN_ON(reclen > nbytes)) 383 return FOUND_ERR; 384 if (WARN_ON(memchr(dirent->name, '/', dirent->namelen) != NULL)) 385 return FOUND_ERR; 386 387 if (ff->readdir.pos == ctx->pos) { 388 res = FOUND_SOME; 389 if (!dir_emit(ctx, dirent->name, dirent->namelen, 390 dirent->ino, dirent->type)) 391 return FOUND_ALL; 392 ctx->pos = dirent->off; 393 } 394 ff->readdir.pos = dirent->off; 395 ff->readdir.cache_off += reclen; 396 397 offset += reclen; 398 } 399 400 return res; 401 } 402 403 static void fuse_rdc_reset(struct inode *inode) 404 { 405 struct fuse_inode *fi = get_fuse_inode(inode); 406 407 fi->rdc.cached = false; 408 fi->rdc.version++; 409 fi->rdc.size = 0; 410 fi->rdc.pos = 0; 411 } 412 413 #define UNCACHED 1 414 415 static int fuse_readdir_cached(struct file *file, struct dir_context *ctx) 416 { 417 struct fuse_file *ff = file->private_data; 418 struct inode *inode = file_inode(file); 419 struct fuse_conn *fc = get_fuse_conn(inode); 420 struct fuse_inode *fi = get_fuse_inode(inode); 421 enum fuse_parse_result res; 422 pgoff_t index; 423 unsigned int size; 424 struct page *page; 425 void *addr; 426 427 /* Seeked? If so, reset the cache stream */ 428 if (ff->readdir.pos != ctx->pos) { 429 ff->readdir.pos = 0; 430 ff->readdir.cache_off = 0; 431 } 432 433 /* 434 * We're just about to start reading into the cache or reading the 435 * cache; both cases require an up-to-date mtime value. 436 */ 437 if (!ctx->pos && fc->auto_inval_data) { 438 int err = fuse_update_attributes(inode, file); 439 440 if (err) 441 return err; 442 } 443 444 retry: 445 spin_lock(&fi->rdc.lock); 446 retry_locked: 447 if (!fi->rdc.cached) { 448 /* Starting cache? Set cache mtime. */ 449 if (!ctx->pos && !fi->rdc.size) { 450 fi->rdc.mtime = inode->i_mtime; 451 fi->rdc.iversion = inode_query_iversion(inode); 452 } 453 spin_unlock(&fi->rdc.lock); 454 return UNCACHED; 455 } 456 /* 457 * When at the beginning of the directory (i.e. just after opendir(3) or 458 * rewinddir(3)), then need to check whether directory contents have 459 * changed, and reset the cache if so. 460 */ 461 if (!ctx->pos) { 462 if (inode_peek_iversion(inode) != fi->rdc.iversion || 463 !timespec64_equal(&fi->rdc.mtime, &inode->i_mtime)) { 464 fuse_rdc_reset(inode); 465 goto retry_locked; 466 } 467 } 468 469 /* 470 * If cache version changed since the last getdents() call, then reset 471 * the cache stream. 472 */ 473 if (ff->readdir.version != fi->rdc.version) { 474 ff->readdir.pos = 0; 475 ff->readdir.cache_off = 0; 476 } 477 /* 478 * If at the beginning of the cache, than reset version to 479 * current. 480 */ 481 if (ff->readdir.pos == 0) 482 ff->readdir.version = fi->rdc.version; 483 484 WARN_ON(fi->rdc.size < ff->readdir.cache_off); 485 486 index = ff->readdir.cache_off >> PAGE_SHIFT; 487 488 if (index == (fi->rdc.size >> PAGE_SHIFT)) 489 size = fi->rdc.size & ~PAGE_MASK; 490 else 491 size = PAGE_SIZE; 492 spin_unlock(&fi->rdc.lock); 493 494 /* EOF? */ 495 if ((ff->readdir.cache_off & ~PAGE_MASK) == size) 496 return 0; 497 498 page = find_get_page_flags(file->f_mapping, index, 499 FGP_ACCESSED | FGP_LOCK); 500 spin_lock(&fi->rdc.lock); 501 if (!page) { 502 /* 503 * Uh-oh: page gone missing, cache is useless 504 */ 505 if (fi->rdc.version == ff->readdir.version) 506 fuse_rdc_reset(inode); 507 goto retry_locked; 508 } 509 510 /* Make sure it's still the same version after getting the page. */ 511 if (ff->readdir.version != fi->rdc.version) { 512 spin_unlock(&fi->rdc.lock); 513 unlock_page(page); 514 put_page(page); 515 goto retry; 516 } 517 spin_unlock(&fi->rdc.lock); 518 519 /* 520 * Contents of the page are now protected against changing by holding 521 * the page lock. 522 */ 523 addr = kmap(page); 524 res = fuse_parse_cache(ff, addr, size, ctx); 525 kunmap(page); 526 unlock_page(page); 527 put_page(page); 528 529 if (res == FOUND_ERR) 530 return -EIO; 531 532 if (res == FOUND_ALL) 533 return 0; 534 535 if (size == PAGE_SIZE) { 536 /* We hit end of page: skip to next page. */ 537 ff->readdir.cache_off = ALIGN(ff->readdir.cache_off, PAGE_SIZE); 538 goto retry; 539 } 540 541 /* 542 * End of cache reached. If found position, then we are done, otherwise 543 * need to fall back to uncached, since the position we were looking for 544 * wasn't in the cache. 545 */ 546 return res == FOUND_SOME ? 0 : UNCACHED; 547 } 548 549 int fuse_readdir(struct file *file, struct dir_context *ctx) 550 { 551 struct fuse_file *ff = file->private_data; 552 struct inode *inode = file_inode(file); 553 int err; 554 555 if (is_bad_inode(inode)) 556 return -EIO; 557 558 mutex_lock(&ff->readdir.lock); 559 560 err = UNCACHED; 561 if (ff->open_flags & FOPEN_CACHE_DIR) 562 err = fuse_readdir_cached(file, ctx); 563 if (err == UNCACHED) 564 err = fuse_readdir_uncached(file, ctx); 565 566 mutex_unlock(&ff->readdir.lock); 567 568 return err; 569 } 570