tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'vfs-6.10-rc8.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs

Pull vfs fixes from Christian Brauner:
"cachefiles:

- Export an existing and add a new cachefile helper to be used in
filesystems to fix reference count bugs

- Use the newly added fscache_ty_get_volume() helper to get a
reference count on an fscache_volume to handle volumes that are
about to be removed cleanly

- After withdrawing a fscache_cache via FSCACHE_CACHE_IS_WITHDRAWN
wait for all ongoing cookie lookups to complete and for the object
count to reach zero

- Propagate errors from vfs_getxattr() to avoid an infinite loop in
cachefiles_check_volume_xattr() because it keeps seeing ESTALE

- Don't send new requests when an object is dropped by raising
CACHEFILES_ONDEMAND_OJBSTATE_DROPPING

- Cancel all requests for an object that is about to be dropped

- Wait for the ondemand_boject_worker to finish before dropping a
cachefiles object to prevent use-after-free

- Use cyclic allocation for message ids to better handle id recycling

- Add missing lock protection when iterating through the xarray when
polling

netfs:

- Use standard logging helpers for debug logging

VFS:

- Fix potential use-after-free in file locks during
trace_posix_lock_inode(). The tracepoint could fire while another
task raced it and freed the lock that was requested to be traced

- Only increment the nr_dentry_negative counter for dentries that are
present on the superblock LRU. Currently, DCACHE_LRU_LIST list is
used to detect this case. However, the flag is also raised in
combination with DCACHE_SHRINK_LIST to indicate that dentry->d_lru
is used. So checking only DCACHE_LRU_LIST will lead to wrong
nr_dentry_negative count. Fix the check to not count dentries that
are on a shrink related list

Misc:

- hfsplus: fix an uninitialized value issue in copy_name

- minix: fix minixfs_rename with HIGHMEM. It still uses kunmap() even
though we switched it to kmap_local_page() a while ago"

* tag 'vfs-6.10-rc8.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs:
minixfs: Fix minixfs_rename with HIGHMEM
hfsplus: fix uninit-value in copy_name
vfs: don't mod negative dentry count when on shrinker list
filelock: fix potential use-after-free in posix_lock_inode
cachefiles: add missing lock protection when polling
cachefiles: cyclic allocation of msg_id to avoid reuse
cachefiles: wait for ondemand_object_worker to finish when dropping object
cachefiles: cancel all requests for the object that is being dropped
cachefiles: stop sending new request when dropping object
cachefiles: propagate errors from vfs_getxattr() to avoid infinite loop
cachefiles: fix slab-use-after-free in cachefiles_withdraw_cookie()
cachefiles: fix slab-use-after-free in fscache_withdraw_volume()
netfs, fscache: export fscache_put_volume() and add fscache_try_get_volume()
netfs: Switch debug logging to pr_debug()

Linus Torvalds 83ab4b46 9d9a2f29

+213 -133
+44 -1
fs/cachefiles/cache.c
··· 8 8 #include <linux/slab.h> 9 9 #include <linux/statfs.h> 10 10 #include <linux/namei.h> 11 + #include <trace/events/fscache.h> 11 12 #include "internal.h" 12 13 13 14 /* ··· 313 312 } 314 313 315 314 /* 316 - * Withdraw volumes. 315 + * Withdraw fscache volumes. 316 + */ 317 + static void cachefiles_withdraw_fscache_volumes(struct cachefiles_cache *cache) 318 + { 319 + struct list_head *cur; 320 + struct cachefiles_volume *volume; 321 + struct fscache_volume *vcookie; 322 + 323 + _enter(""); 324 + retry: 325 + spin_lock(&cache->object_list_lock); 326 + list_for_each(cur, &cache->volumes) { 327 + volume = list_entry(cur, struct cachefiles_volume, cache_link); 328 + 329 + if (atomic_read(&volume->vcookie->n_accesses) == 0) 330 + continue; 331 + 332 + vcookie = fscache_try_get_volume(volume->vcookie, 333 + fscache_volume_get_withdraw); 334 + if (vcookie) { 335 + spin_unlock(&cache->object_list_lock); 336 + fscache_withdraw_volume(vcookie); 337 + fscache_put_volume(vcookie, fscache_volume_put_withdraw); 338 + goto retry; 339 + } 340 + } 341 + spin_unlock(&cache->object_list_lock); 342 + 343 + _leave(""); 344 + } 345 + 346 + /* 347 + * Withdraw cachefiles volumes. 317 348 */ 318 349 static void cachefiles_withdraw_volumes(struct cachefiles_cache *cache) 319 350 { 320 351 _enter(""); 321 352 322 353 for (;;) { 354 + struct fscache_volume *vcookie = NULL; 323 355 struct cachefiles_volume *volume = NULL; 324 356 325 357 spin_lock(&cache->object_list_lock); 326 358 if (!list_empty(&cache->volumes)) { 327 359 volume = list_first_entry(&cache->volumes, 328 360 struct cachefiles_volume, cache_link); 361 + vcookie = fscache_try_get_volume(volume->vcookie, 362 + fscache_volume_get_withdraw); 363 + if (!vcookie) { 364 + spin_unlock(&cache->object_list_lock); 365 + cpu_relax(); 366 + continue; 367 + } 329 368 list_del_init(&volume->cache_link); 330 369 } 331 370 spin_unlock(&cache->object_list_lock); ··· 373 332 break; 374 333 375 334 cachefiles_withdraw_volume(volume); 335 + fscache_put_volume(vcookie, fscache_volume_put_withdraw); 376 336 } 377 337 378 338 _leave(""); ··· 413 371 pr_info("File cache on %s unregistering\n", fscache->name); 414 372 415 373 fscache_withdraw_cache(fscache); 374 + cachefiles_withdraw_fscache_volumes(cache); 416 375 417 376 /* we now have to destroy all the active objects pertaining to this 418 377 * cache - which we do by passing them off to thread pool to be
+2 -2
fs/cachefiles/daemon.c
··· 366 366 367 367 if (cachefiles_in_ondemand_mode(cache)) { 368 368 if (!xa_empty(&cache->reqs)) { 369 - rcu_read_lock(); 369 + xas_lock(&xas); 370 370 xas_for_each_marked(&xas, req, ULONG_MAX, CACHEFILES_REQ_NEW) { 371 371 if (!cachefiles_ondemand_is_reopening_read(req)) { 372 372 mask |= EPOLLIN; 373 373 break; 374 374 } 375 375 } 376 - rcu_read_unlock(); 376 + xas_unlock(&xas); 377 377 } 378 378 } else { 379 379 if (test_bit(CACHEFILES_STATE_CHANGED, &cache->flags))
+3
fs/cachefiles/internal.h
··· 48 48 CACHEFILES_ONDEMAND_OBJSTATE_CLOSE, /* Anonymous fd closed by daemon or initial state */ 49 49 CACHEFILES_ONDEMAND_OBJSTATE_OPEN, /* Anonymous fd associated with object is available */ 50 50 CACHEFILES_ONDEMAND_OBJSTATE_REOPENING, /* Object that was closed and is being reopened. */ 51 + CACHEFILES_ONDEMAND_OBJSTATE_DROPPING, /* Object is being dropped. */ 51 52 }; 52 53 53 54 struct cachefiles_ondemand_info { ··· 129 128 unsigned long req_id_next; 130 129 struct xarray ondemand_ids; /* xarray for ondemand_id allocation */ 131 130 u32 ondemand_id_next; 131 + u32 msg_id_next; 132 132 }; 133 133 134 134 static inline bool cachefiles_in_ondemand_mode(struct cachefiles_cache *cache) ··· 337 335 CACHEFILES_OBJECT_STATE_FUNCS(open, OPEN); 338 336 CACHEFILES_OBJECT_STATE_FUNCS(close, CLOSE); 339 337 CACHEFILES_OBJECT_STATE_FUNCS(reopening, REOPENING); 338 + CACHEFILES_OBJECT_STATE_FUNCS(dropping, DROPPING); 340 339 341 340 static inline bool cachefiles_ondemand_is_reopening_read(struct cachefiles_req *req) 342 341 {
+46 -6
fs/cachefiles/ondemand.c
··· 517 517 */ 518 518 xas_lock(&xas); 519 519 520 - if (test_bit(CACHEFILES_DEAD, &cache->flags)) { 520 + if (test_bit(CACHEFILES_DEAD, &cache->flags) || 521 + cachefiles_ondemand_object_is_dropping(object)) { 521 522 xas_unlock(&xas); 522 523 ret = -EIO; 523 524 goto out; ··· 528 527 smp_mb(); 529 528 530 529 if (opcode == CACHEFILES_OP_CLOSE && 531 - !cachefiles_ondemand_object_is_open(object)) { 530 + !cachefiles_ondemand_object_is_open(object)) { 532 531 WARN_ON_ONCE(object->ondemand->ondemand_id == 0); 533 532 xas_unlock(&xas); 534 533 ret = -EIO; 535 534 goto out; 536 535 } 537 536 538 - xas.xa_index = 0; 537 + /* 538 + * Cyclically find a free xas to avoid msg_id reuse that would 539 + * cause the daemon to successfully copen a stale msg_id. 540 + */ 541 + xas.xa_index = cache->msg_id_next; 539 542 xas_find_marked(&xas, UINT_MAX, XA_FREE_MARK); 543 + if (xas.xa_node == XAS_RESTART) { 544 + xas.xa_index = 0; 545 + xas_find_marked(&xas, cache->msg_id_next - 1, XA_FREE_MARK); 546 + } 540 547 if (xas.xa_node == XAS_RESTART) 541 548 xas_set_err(&xas, -EBUSY); 549 + 542 550 xas_store(&xas, req); 543 - xas_clear_mark(&xas, XA_FREE_MARK); 544 - xas_set_mark(&xas, CACHEFILES_REQ_NEW); 551 + if (xas_valid(&xas)) { 552 + cache->msg_id_next = xas.xa_index + 1; 553 + xas_clear_mark(&xas, XA_FREE_MARK); 554 + xas_set_mark(&xas, CACHEFILES_REQ_NEW); 555 + } 545 556 xas_unlock(&xas); 546 557 } while (xas_nomem(&xas, GFP_KERNEL)); 547 558 ··· 581 568 * If error occurs after creating the anonymous fd, 582 569 * cachefiles_ondemand_fd_release() will set object to close. 583 570 */ 584 - if (opcode == CACHEFILES_OP_OPEN) 571 + if (opcode == CACHEFILES_OP_OPEN && 572 + !cachefiles_ondemand_object_is_dropping(object)) 585 573 cachefiles_ondemand_set_object_close(object); 586 574 kfree(req); 587 575 return ret; ··· 681 667 682 668 void cachefiles_ondemand_clean_object(struct cachefiles_object *object) 683 669 { 670 + unsigned long index; 671 + struct cachefiles_req *req; 672 + struct cachefiles_cache *cache; 673 + 674 + if (!object->ondemand) 675 + return; 676 + 684 677 cachefiles_ondemand_send_req(object, CACHEFILES_OP_CLOSE, 0, 685 678 cachefiles_ondemand_init_close_req, NULL); 679 + 680 + if (!object->ondemand->ondemand_id) 681 + return; 682 + 683 + /* Cancel all requests for the object that is being dropped. */ 684 + cache = object->volume->cache; 685 + xa_lock(&cache->reqs); 686 + cachefiles_ondemand_set_object_dropping(object); 687 + xa_for_each(&cache->reqs, index, req) { 688 + if (req->object == object) { 689 + req->error = -EIO; 690 + complete(&req->done); 691 + __xa_erase(&cache->reqs, index); 692 + } 693 + } 694 + xa_unlock(&cache->reqs); 695 + 696 + /* Wait for ondemand_object_worker() to finish to avoid UAF. */ 697 + cancel_work_sync(&object->ondemand->ondemand_work); 686 698 } 687 699 688 700 int cachefiles_ondemand_init_obj_info(struct cachefiles_object *object,
-1
fs/cachefiles/volume.c
··· 133 133 134 134 void cachefiles_withdraw_volume(struct cachefiles_volume *volume) 135 135 { 136 - fscache_withdraw_volume(volume->vcookie); 137 136 cachefiles_set_volume_xattr(volume); 138 137 __cachefiles_free_volume(volume); 139 138 }
+4 -1
fs/cachefiles/xattr.c
··· 110 110 if (xlen == 0) 111 111 xlen = vfs_getxattr(&nop_mnt_idmap, dentry, cachefiles_xattr_cache, buf, tlen); 112 112 if (xlen != tlen) { 113 - if (xlen < 0) 113 + if (xlen < 0) { 114 + ret = xlen; 114 115 trace_cachefiles_vfs_error(object, file_inode(file), xlen, 115 116 cachefiles_trace_getxattr_error); 117 + } 116 118 if (xlen == -EIO) 117 119 cachefiles_io_error_obj( 118 120 object, ··· 254 252 xlen = vfs_getxattr(&nop_mnt_idmap, dentry, cachefiles_xattr_cache, buf, len); 255 253 if (xlen != len) { 256 254 if (xlen < 0) { 255 + ret = xlen; 257 256 trace_cachefiles_vfs_error(NULL, d_inode(dentry), xlen, 258 257 cachefiles_trace_getxattr_error); 259 258 if (xlen == -EIO)
+9 -3
fs/dcache.c
··· 355 355 flags &= ~DCACHE_ENTRY_TYPE; 356 356 WRITE_ONCE(dentry->d_flags, flags); 357 357 dentry->d_inode = NULL; 358 - if (flags & DCACHE_LRU_LIST) 358 + /* 359 + * The negative counter only tracks dentries on the LRU. Don't inc if 360 + * d_lru is on another list. 361 + */ 362 + if ((flags & (DCACHE_LRU_LIST|DCACHE_SHRINK_LIST)) == DCACHE_LRU_LIST) 359 363 this_cpu_inc(nr_dentry_negative); 360 364 } 361 365 ··· 1848 1844 1849 1845 spin_lock(&dentry->d_lock); 1850 1846 /* 1851 - * Decrement negative dentry count if it was in the LRU list. 1847 + * The negative counter only tracks dentries on the LRU. Don't dec if 1848 + * d_lru is on another list. 1852 1849 */ 1853 - if (dentry->d_flags & DCACHE_LRU_LIST) 1850 + if ((dentry->d_flags & 1851 + (DCACHE_LRU_LIST|DCACHE_SHRINK_LIST)) == DCACHE_LRU_LIST) 1854 1852 this_cpu_dec(nr_dentry_negative); 1855 1853 hlist_add_head(&dentry->d_u.d_alias, &inode->i_dentry); 1856 1854 raw_write_seqcount_begin(&dentry->d_seq);
+1 -1
fs/hfsplus/xattr.c
··· 696 696 return err; 697 697 } 698 698 699 - strbuf = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 699 + strbuf = kzalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 700 700 XATTR_MAC_OSX_PREFIX_LEN + 1, GFP_KERNEL); 701 701 if (!strbuf) { 702 702 res = -ENOMEM;
+1 -1
fs/locks.c
··· 1367 1367 locks_wake_up_blocks(&left->c); 1368 1368 } 1369 1369 out: 1370 + trace_posix_lock_inode(inode, request, error); 1370 1371 spin_unlock(&ctx->flc_lock); 1371 1372 percpu_up_read(&file_rwsem); 1372 - trace_posix_lock_inode(inode, request, error); 1373 1373 /* 1374 1374 * Free any unused locks. 1375 1375 */
+1 -2
fs/minix/namei.c
··· 213 213 if (!new_de) 214 214 goto out_dir; 215 215 err = minix_set_link(new_de, new_page, old_inode); 216 - kunmap(new_page); 217 - put_page(new_page); 216 + unmap_and_put_page(new_page, new_de); 218 217 if (err) 219 218 goto out_dir; 220 219 inode_set_ctime_current(new_inode);
+7 -7
fs/netfs/buffered_read.c
··· 117 117 if (!test_bit(NETFS_RREQ_DONT_UNLOCK_FOLIOS, &rreq->flags)) { 118 118 if (folio->index == rreq->no_unlock_folio && 119 119 test_bit(NETFS_RREQ_NO_UNLOCK_FOLIO, &rreq->flags)) 120 - _debug("no unlock"); 120 + kdebug("no unlock"); 121 121 else 122 122 folio_unlock(folio); 123 123 } ··· 204 204 struct netfs_inode *ctx = netfs_inode(ractl->mapping->host); 205 205 int ret; 206 206 207 - _enter("%lx,%x", readahead_index(ractl), readahead_count(ractl)); 207 + kenter("%lx,%x", readahead_index(ractl), readahead_count(ractl)); 208 208 209 209 if (readahead_count(ractl) == 0) 210 210 return; ··· 268 268 struct folio *sink = NULL; 269 269 int ret; 270 270 271 - _enter("%lx", folio->index); 271 + kenter("%lx", folio->index); 272 272 273 273 rreq = netfs_alloc_request(mapping, file, 274 274 folio_file_pos(folio), folio_size(folio), ··· 508 508 509 509 have_folio: 510 510 *_folio = folio; 511 - _leave(" = 0"); 511 + kleave(" = 0"); 512 512 return 0; 513 513 514 514 error_put: ··· 518 518 folio_unlock(folio); 519 519 folio_put(folio); 520 520 } 521 - _leave(" = %d", ret); 521 + kleave(" = %d", ret); 522 522 return ret; 523 523 } 524 524 EXPORT_SYMBOL(netfs_write_begin); ··· 536 536 size_t flen = folio_size(folio); 537 537 int ret; 538 538 539 - _enter("%zx @%llx", flen, start); 539 + kenter("%zx @%llx", flen, start); 540 540 541 541 ret = -ENOMEM; 542 542 ··· 567 567 error_put: 568 568 netfs_put_request(rreq, false, netfs_rreq_trace_put_discard); 569 569 error: 570 - _leave(" = %d", ret); 570 + kleave(" = %d", ret); 571 571 return ret; 572 572 } 573 573
+6 -6
fs/netfs/buffered_write.c
··· 56 56 struct netfs_group *group = netfs_folio_group(folio); 57 57 loff_t pos = folio_file_pos(folio); 58 58 59 - _enter(""); 59 + kenter(""); 60 60 61 61 if (group != netfs_group && group != NETFS_FOLIO_COPY_TO_CACHE) 62 62 return NETFS_FLUSH_CONTENT; ··· 272 272 */ 273 273 howto = netfs_how_to_modify(ctx, file, folio, netfs_group, 274 274 flen, offset, part, maybe_trouble); 275 - _debug("howto %u", howto); 275 + kdebug("howto %u", howto); 276 276 switch (howto) { 277 277 case NETFS_JUST_PREFETCH: 278 278 ret = netfs_prefetch_for_write(file, folio, offset, part); 279 279 if (ret < 0) { 280 - _debug("prefetch = %zd", ret); 280 + kdebug("prefetch = %zd", ret); 281 281 goto error_folio_unlock; 282 282 } 283 283 break; ··· 418 418 } 419 419 420 420 iocb->ki_pos += written; 421 - _leave(" = %zd [%zd]", written, ret); 421 + kleave(" = %zd [%zd]", written, ret); 422 422 return written ? written : ret; 423 423 424 424 error_folio_unlock: ··· 491 491 struct netfs_inode *ictx = netfs_inode(inode); 492 492 ssize_t ret; 493 493 494 - _enter("%llx,%zx,%llx", iocb->ki_pos, iov_iter_count(from), i_size_read(inode)); 494 + kenter("%llx,%zx,%llx", iocb->ki_pos, iov_iter_count(from), i_size_read(inode)); 495 495 496 496 if (!iov_iter_count(from)) 497 497 return 0; ··· 529 529 vm_fault_t ret = VM_FAULT_RETRY; 530 530 int err; 531 531 532 - _enter("%lx", folio->index); 532 + kenter("%lx", folio->index); 533 533 534 534 sb_start_pagefault(inode->i_sb); 535 535
+1 -1
fs/netfs/direct_read.c
··· 33 33 size_t orig_count = iov_iter_count(iter); 34 34 bool async = !is_sync_kiocb(iocb); 35 35 36 - _enter(""); 36 + kenter(""); 37 37 38 38 if (!orig_count) 39 39 return 0; /* Don't update atime */
+4 -4
fs/netfs/direct_write.c
··· 37 37 size_t len = iov_iter_count(iter); 38 38 bool async = !is_sync_kiocb(iocb); 39 39 40 - _enter(""); 40 + kenter(""); 41 41 42 42 /* We're going to need a bounce buffer if what we transmit is going to 43 43 * be different in some way to the source buffer, e.g. because it gets ··· 45 45 */ 46 46 // TODO 47 47 48 - _debug("uw %llx-%llx", start, end); 48 + kdebug("uw %llx-%llx", start, end); 49 49 50 50 wreq = netfs_create_write_req(iocb->ki_filp->f_mapping, iocb->ki_filp, start, 51 51 iocb->ki_flags & IOCB_DIRECT ? ··· 96 96 wreq->cleanup = netfs_cleanup_dio_write; 97 97 ret = netfs_unbuffered_write(wreq, is_sync_kiocb(iocb), wreq->len); 98 98 if (ret < 0) { 99 - _debug("begin = %zd", ret); 99 + kdebug("begin = %zd", ret); 100 100 goto out; 101 101 } 102 102 ··· 143 143 loff_t pos = iocb->ki_pos; 144 144 unsigned long long end = pos + iov_iter_count(from) - 1; 145 145 146 - _enter("%llx,%zx,%llx", pos, iov_iter_count(from), i_size_read(inode)); 146 + kenter("%llx,%zx,%llx", pos, iov_iter_count(from), i_size_read(inode)); 147 147 148 148 if (!iov_iter_count(from)) 149 149 return 0;
+2 -2
fs/netfs/fscache_cache.c
··· 237 237 { 238 238 int n_accesses; 239 239 240 - _enter("{%s,%s}", ops->name, cache->name); 240 + kenter("{%s,%s}", ops->name, cache->name); 241 241 242 242 BUG_ON(fscache_cache_state(cache) != FSCACHE_CACHE_IS_PREPARING); 243 243 ··· 257 257 258 258 up_write(&fscache_addremove_sem); 259 259 pr_notice("Cache \"%s\" added (type %s)\n", cache->name, ops->name); 260 - _leave(" = 0 [%s]", cache->name); 260 + kleave(" = 0 [%s]", cache->name); 261 261 return 0; 262 262 } 263 263 EXPORT_SYMBOL(fscache_add_cache);
+14 -14
fs/netfs/fscache_cookie.c
··· 456 456 { 457 457 struct fscache_cookie *cookie; 458 458 459 - _enter("V=%x", volume->debug_id); 459 + kenter("V=%x", volume->debug_id); 460 460 461 461 if (!index_key || !index_key_len || index_key_len > 255 || aux_data_len > 255) 462 462 return NULL; ··· 484 484 485 485 trace_fscache_acquire(cookie); 486 486 fscache_stat(&fscache_n_acquires_ok); 487 - _leave(" = c=%08x", cookie->debug_id); 487 + kleave(" = c=%08x", cookie->debug_id); 488 488 return cookie; 489 489 } 490 490 EXPORT_SYMBOL(__fscache_acquire_cookie); ··· 505 505 enum fscache_access_trace trace = fscache_access_lookup_cookie_end_failed; 506 506 bool need_withdraw = false; 507 507 508 - _enter(""); 508 + kenter(""); 509 509 510 510 if (!cookie->volume->cache_priv) { 511 511 fscache_create_volume(cookie->volume, true); ··· 519 519 if (cookie->state != FSCACHE_COOKIE_STATE_FAILED) 520 520 fscache_set_cookie_state(cookie, FSCACHE_COOKIE_STATE_QUIESCENT); 521 521 need_withdraw = true; 522 - _leave(" [fail]"); 522 + kleave(" [fail]"); 523 523 goto out; 524 524 } 525 525 ··· 572 572 bool queue = false; 573 573 int n_active; 574 574 575 - _enter("c=%08x", cookie->debug_id); 575 + kenter("c=%08x", cookie->debug_id); 576 576 577 577 if (WARN(test_bit(FSCACHE_COOKIE_RELINQUISHED, &cookie->flags), 578 578 "Trying to use relinquished cookie\n")) ··· 636 636 spin_unlock(&cookie->lock); 637 637 if (queue) 638 638 fscache_queue_cookie(cookie, fscache_cookie_get_use_work); 639 - _leave(""); 639 + kleave(""); 640 640 } 641 641 EXPORT_SYMBOL(__fscache_use_cookie); 642 642 ··· 702 702 enum fscache_cookie_state state; 703 703 bool wake = false; 704 704 705 - _enter("c=%x", cookie->debug_id); 705 + kenter("c=%x", cookie->debug_id); 706 706 707 707 again: 708 708 spin_lock(&cookie->lock); ··· 820 820 spin_unlock(&cookie->lock); 821 821 if (wake) 822 822 wake_up_cookie_state(cookie); 823 - _leave(""); 823 + kleave(""); 824 824 } 825 825 826 826 static void fscache_cookie_worker(struct work_struct *work) ··· 867 867 set_bit(FSCACHE_COOKIE_DO_LRU_DISCARD, &cookie->flags); 868 868 spin_unlock(&cookie->lock); 869 869 fscache_stat(&fscache_n_cookies_lru_expired); 870 - _debug("lru c=%x", cookie->debug_id); 870 + kdebug("lru c=%x", cookie->debug_id); 871 871 __fscache_withdraw_cookie(cookie); 872 872 } 873 873 ··· 971 971 if (retire) 972 972 fscache_stat(&fscache_n_relinquishes_retire); 973 973 974 - _enter("c=%08x{%d},%d", 974 + kenter("c=%08x{%d},%d", 975 975 cookie->debug_id, atomic_read(&cookie->n_active), retire); 976 976 977 977 if (WARN(test_and_set_bit(FSCACHE_COOKIE_RELINQUISHED, &cookie->flags), ··· 1050 1050 { 1051 1051 bool is_caching; 1052 1052 1053 - _enter("c=%x", cookie->debug_id); 1053 + kenter("c=%x", cookie->debug_id); 1054 1054 1055 1055 fscache_stat(&fscache_n_invalidates); 1056 1056 ··· 1072 1072 case FSCACHE_COOKIE_STATE_INVALIDATING: /* is_still_valid will catch it */ 1073 1073 default: 1074 1074 spin_unlock(&cookie->lock); 1075 - _leave(" [no %u]", cookie->state); 1075 + kleave(" [no %u]", cookie->state); 1076 1076 return; 1077 1077 1078 1078 case FSCACHE_COOKIE_STATE_LOOKING_UP: ··· 1081 1081 fallthrough; 1082 1082 case FSCACHE_COOKIE_STATE_CREATING: 1083 1083 spin_unlock(&cookie->lock); 1084 - _leave(" [look %x]", cookie->inval_counter); 1084 + kleave(" [look %x]", cookie->inval_counter); 1085 1085 return; 1086 1086 1087 1087 case FSCACHE_COOKIE_STATE_ACTIVE: ··· 1094 1094 1095 1095 if (is_caching) 1096 1096 fscache_queue_cookie(cookie, fscache_cookie_get_inval_work); 1097 - _leave(" [inv]"); 1097 + kleave(" [inv]"); 1098 1098 return; 1099 1099 } 1100 1100 }
+6 -6
fs/netfs/fscache_io.c
··· 28 28 29 29 again: 30 30 if (!fscache_cache_is_live(cookie->volume->cache)) { 31 - _leave(" [broken]"); 31 + kleave(" [broken]"); 32 32 return false; 33 33 } 34 34 35 35 state = fscache_cookie_state(cookie); 36 - _enter("c=%08x{%u},%x", cookie->debug_id, state, want_state); 36 + kenter("c=%08x{%u},%x", cookie->debug_id, state, want_state); 37 37 38 38 switch (state) { 39 39 case FSCACHE_COOKIE_STATE_CREATING: ··· 52 52 case FSCACHE_COOKIE_STATE_DROPPED: 53 53 case FSCACHE_COOKIE_STATE_RELINQUISHING: 54 54 default: 55 - _leave(" [not live]"); 55 + kleave(" [not live]"); 56 56 return false; 57 57 } 58 58 ··· 92 92 spin_lock(&cookie->lock); 93 93 94 94 state = fscache_cookie_state(cookie); 95 - _enter("c=%08x{%u},%x", cookie->debug_id, state, want_state); 95 + kenter("c=%08x{%u},%x", cookie->debug_id, state, want_state); 96 96 97 97 switch (state) { 98 98 case FSCACHE_COOKIE_STATE_LOOKING_UP: ··· 140 140 cres->cache_priv = NULL; 141 141 cres->ops = NULL; 142 142 fscache_end_cookie_access(cookie, fscache_access_io_not_live); 143 - _leave(" = -ENOBUFS"); 143 + kleave(" = -ENOBUFS"); 144 144 return -ENOBUFS; 145 145 } 146 146 ··· 224 224 if (len == 0) 225 225 goto abandon; 226 226 227 - _enter("%llx,%zx", start, len); 227 + kenter("%llx,%zx", start, len); 228 228 229 229 wreq = kzalloc(sizeof(struct fscache_write_request), GFP_NOFS); 230 230 if (!wreq)
+1 -1
fs/netfs/fscache_main.c
··· 99 99 */ 100 100 void __exit fscache_exit(void) 101 101 { 102 - _enter(""); 102 + kenter(""); 103 103 104 104 kmem_cache_destroy(fscache_cookie_jar); 105 105 fscache_proc_cleanup();
+16 -2
fs/netfs/fscache_volume.c
··· 27 27 return volume; 28 28 } 29 29 30 + struct fscache_volume *fscache_try_get_volume(struct fscache_volume *volume, 31 + enum fscache_volume_trace where) 32 + { 33 + int ref; 34 + 35 + if (!__refcount_inc_not_zero(&volume->ref, &ref)) 36 + return NULL; 37 + 38 + trace_fscache_volume(volume->debug_id, ref + 1, where); 39 + return volume; 40 + } 41 + EXPORT_SYMBOL(fscache_try_get_volume); 42 + 30 43 static void fscache_see_volume(struct fscache_volume *volume, 31 44 enum fscache_volume_trace where) 32 45 { ··· 264 251 fscache_see_volume(volume, fscache_volume_new_acquire); 265 252 fscache_stat(&fscache_n_volumes); 266 253 up_write(&fscache_addremove_sem); 267 - _leave(" = v=%x", volume->debug_id); 254 + kleave(" = v=%x", volume->debug_id); 268 255 return volume; 269 256 270 257 err_vol: ··· 433 420 fscache_free_volume(volume); 434 421 } 435 422 } 423 + EXPORT_SYMBOL(fscache_put_volume); 436 424 437 425 /* 438 426 * Relinquish a volume representation cookie. ··· 466 452 { 467 453 int n_accesses; 468 454 469 - _debug("withdraw V=%x", volume->debug_id); 455 + kdebug("withdraw V=%x", volume->debug_id); 470 456 471 457 /* Allow wakeups on dec-to-0 */ 472 458 n_accesses = atomic_dec_return(&volume->n_accesses);
+1 -34
fs/netfs/internal.h
··· 34 34 /* 35 35 * main.c 36 36 */ 37 - extern unsigned int netfs_debug; 38 37 extern struct list_head netfs_io_requests; 39 38 extern spinlock_t netfs_proc_lock; 40 39 extern mempool_t netfs_request_pool; ··· 343 344 344 345 struct fscache_volume *fscache_get_volume(struct fscache_volume *volume, 345 346 enum fscache_volume_trace where); 346 - void fscache_put_volume(struct fscache_volume *volume, 347 - enum fscache_volume_trace where); 348 347 bool fscache_begin_volume_access(struct fscache_volume *volume, 349 348 struct fscache_cookie *cookie, 350 349 enum fscache_access_trace why); ··· 353 356 * debug tracing 354 357 */ 355 358 #define dbgprintk(FMT, ...) \ 356 - printk("[%-6.6s] "FMT"\n", current->comm, ##__VA_ARGS__) 359 + pr_debug("[%-6.6s] "FMT"\n", current->comm, ##__VA_ARGS__) 357 360 358 361 #define kenter(FMT, ...) dbgprintk("==> %s("FMT")", __func__, ##__VA_ARGS__) 359 362 #define kleave(FMT, ...) dbgprintk("<== %s()"FMT"", __func__, ##__VA_ARGS__) 360 363 #define kdebug(FMT, ...) dbgprintk(FMT, ##__VA_ARGS__) 361 - 362 - #ifdef __KDEBUG 363 - #define _enter(FMT, ...) kenter(FMT, ##__VA_ARGS__) 364 - #define _leave(FMT, ...) kleave(FMT, ##__VA_ARGS__) 365 - #define _debug(FMT, ...) kdebug(FMT, ##__VA_ARGS__) 366 - 367 - #elif defined(CONFIG_NETFS_DEBUG) 368 - #define _enter(FMT, ...) \ 369 - do { \ 370 - if (netfs_debug) \ 371 - kenter(FMT, ##__VA_ARGS__); \ 372 - } while (0) 373 - 374 - #define _leave(FMT, ...) \ 375 - do { \ 376 - if (netfs_debug) \ 377 - kleave(FMT, ##__VA_ARGS__); \ 378 - } while (0) 379 - 380 - #define _debug(FMT, ...) \ 381 - do { \ 382 - if (netfs_debug) \ 383 - kdebug(FMT, ##__VA_ARGS__); \ 384 - } while (0) 385 - 386 - #else 387 - #define _enter(FMT, ...) no_printk("==> %s("FMT")", __func__, ##__VA_ARGS__) 388 - #define _leave(FMT, ...) no_printk("<== %s()"FMT"", __func__, ##__VA_ARGS__) 389 - #define _debug(FMT, ...) no_printk(FMT, ##__VA_ARGS__) 390 - #endif 391 364 392 365 /* 393 366 * assertions
+6 -6
fs/netfs/io.c
··· 130 130 if (count == remaining) 131 131 return; 132 132 133 - _debug("R=%08x[%u] ITER RESUB-MISMATCH %zx != %zx-%zx-%llx %x\n", 133 + kdebug("R=%08x[%u] ITER RESUB-MISMATCH %zx != %zx-%zx-%llx %x\n", 134 134 rreq->debug_id, subreq->debug_index, 135 135 iov_iter_count(&subreq->io_iter), subreq->transferred, 136 136 subreq->len, rreq->i_size, ··· 326 326 struct netfs_io_request *rreq = subreq->rreq; 327 327 int u; 328 328 329 - _enter("R=%x[%x]{%llx,%lx},%zd", 329 + kenter("R=%x[%x]{%llx,%lx},%zd", 330 330 rreq->debug_id, subreq->debug_index, 331 331 subreq->start, subreq->flags, transferred_or_error); 332 332 ··· 435 435 struct netfs_inode *ictx = netfs_inode(rreq->inode); 436 436 size_t lsize; 437 437 438 - _enter("%llx-%llx,%llx", subreq->start, subreq->start + subreq->len, rreq->i_size); 438 + kenter("%llx-%llx,%llx", subreq->start, subreq->start + subreq->len, rreq->i_size); 439 439 440 440 if (rreq->origin != NETFS_DIO_READ) { 441 441 source = netfs_cache_prepare_read(subreq, rreq->i_size); ··· 518 518 subreq->start = rreq->start + rreq->submitted; 519 519 subreq->len = io_iter->count; 520 520 521 - _debug("slice %llx,%zx,%llx", subreq->start, subreq->len, rreq->submitted); 521 + kdebug("slice %llx,%zx,%llx", subreq->start, subreq->len, rreq->submitted); 522 522 list_add_tail(&subreq->rreq_link, &rreq->subrequests); 523 523 524 524 /* Call out to the cache to find out what it can do with the remaining ··· 570 570 struct iov_iter io_iter; 571 571 int ret; 572 572 573 - _enter("R=%x %llx-%llx", 573 + kenter("R=%x %llx-%llx", 574 574 rreq->debug_id, rreq->start, rreq->start + rreq->len - 1); 575 575 576 576 if (rreq->len == 0) { ··· 593 593 atomic_set(&rreq->nr_outstanding, 1); 594 594 io_iter = rreq->io_iter; 595 595 do { 596 - _debug("submit %llx + %llx >= %llx", 596 + kdebug("submit %llx + %llx >= %llx", 597 597 rreq->start, rreq->submitted, rreq->i_size); 598 598 if (rreq->origin == NETFS_DIO_READ && 599 599 rreq->start + rreq->submitted >= rreq->i_size)
-4
fs/netfs/main.c
··· 20 20 21 21 EXPORT_TRACEPOINT_SYMBOL(netfs_sreq); 22 22 23 - unsigned netfs_debug; 24 - module_param_named(debug, netfs_debug, uint, S_IWUSR | S_IRUGO); 25 - MODULE_PARM_DESC(netfs_debug, "Netfs support debugging mask"); 26 - 27 23 static struct kmem_cache *netfs_request_slab; 28 24 static struct kmem_cache *netfs_subrequest_slab; 29 25 mempool_t netfs_request_pool;
+2 -2
fs/netfs/misc.c
··· 26 26 struct fscache_cookie *cookie = netfs_i_cookie(ictx); 27 27 bool need_use = false; 28 28 29 - _enter(""); 29 + kenter(""); 30 30 31 31 if (!filemap_dirty_folio(mapping, folio)) 32 32 return false; ··· 99 99 struct netfs_folio *finfo; 100 100 size_t flen = folio_size(folio); 101 101 102 - _enter("{%lx},%zx,%zx", folio->index, offset, length); 102 + kenter("{%lx},%zx,%zx", folio->index, offset, length); 103 103 104 104 if (!folio_test_private(folio)) 105 105 return;
+8 -8
fs/netfs/write_collect.c
··· 161 161 { 162 162 struct list_head *next; 163 163 164 - _enter("R=%x[%x:]", wreq->debug_id, stream->stream_nr); 164 + kenter("R=%x[%x:]", wreq->debug_id, stream->stream_nr); 165 165 166 166 if (list_empty(&stream->subrequests)) 167 167 return; ··· 374 374 unsigned int notes; 375 375 int s; 376 376 377 - _enter("%llx-%llx", wreq->start, wreq->start + wreq->len); 377 + kenter("%llx-%llx", wreq->start, wreq->start + wreq->len); 378 378 trace_netfs_collect(wreq); 379 379 trace_netfs_rreq(wreq, netfs_rreq_trace_collect); 380 380 ··· 409 409 front = stream->front; 410 410 while (front) { 411 411 trace_netfs_collect_sreq(wreq, front); 412 - //_debug("sreq [%x] %llx %zx/%zx", 412 + //kdebug("sreq [%x] %llx %zx/%zx", 413 413 // front->debug_index, front->start, front->transferred, front->len); 414 414 415 415 /* Stall if there may be a discontinuity. */ ··· 598 598 out: 599 599 netfs_put_group_many(wreq->group, wreq->nr_group_rel); 600 600 wreq->nr_group_rel = 0; 601 - _leave(" = %x", notes); 601 + kleave(" = %x", notes); 602 602 return; 603 603 604 604 need_retry: ··· 606 606 * that any partially completed op will have had any wholly transferred 607 607 * folios removed from it. 608 608 */ 609 - _debug("retry"); 609 + kdebug("retry"); 610 610 netfs_retry_writes(wreq); 611 611 goto out; 612 612 } ··· 621 621 size_t transferred; 622 622 int s; 623 623 624 - _enter("R=%x", wreq->debug_id); 624 + kenter("R=%x", wreq->debug_id); 625 625 626 626 netfs_see_request(wreq, netfs_rreq_trace_see_work); 627 627 if (!test_bit(NETFS_RREQ_IN_PROGRESS, &wreq->flags)) { ··· 684 684 if (wreq->origin == NETFS_DIO_WRITE) 685 685 inode_dio_end(wreq->inode); 686 686 687 - _debug("finished"); 687 + kdebug("finished"); 688 688 trace_netfs_rreq(wreq, netfs_rreq_trace_wake_ip); 689 689 clear_bit_unlock(NETFS_RREQ_IN_PROGRESS, &wreq->flags); 690 690 wake_up_bit(&wreq->flags, NETFS_RREQ_IN_PROGRESS); ··· 744 744 struct netfs_io_request *wreq = subreq->rreq; 745 745 struct netfs_io_stream *stream = &wreq->io_streams[subreq->stream_nr]; 746 746 747 - _enter("%x[%x] %zd", wreq->debug_id, subreq->debug_index, transferred_or_error); 747 + kenter("%x[%x] %zd", wreq->debug_id, subreq->debug_index, transferred_or_error); 748 748 749 749 switch (subreq->source) { 750 750 case NETFS_UPLOAD_TO_SERVER:
+18 -18
fs/netfs/write_issue.c
··· 99 99 if (IS_ERR(wreq)) 100 100 return wreq; 101 101 102 - _enter("R=%x", wreq->debug_id); 102 + kenter("R=%x", wreq->debug_id); 103 103 104 104 ictx = netfs_inode(wreq->inode); 105 105 if (test_bit(NETFS_RREQ_WRITE_TO_CACHE, &wreq->flags)) ··· 159 159 subreq->max_nr_segs = INT_MAX; 160 160 subreq->stream_nr = stream->stream_nr; 161 161 162 - _enter("R=%x[%x]", wreq->debug_id, subreq->debug_index); 162 + kenter("R=%x[%x]", wreq->debug_id, subreq->debug_index); 163 163 164 164 trace_netfs_sreq_ref(wreq->debug_id, subreq->debug_index, 165 165 refcount_read(&subreq->ref), ··· 215 215 { 216 216 struct netfs_io_request *wreq = subreq->rreq; 217 217 218 - _enter("R=%x[%x],%zx", wreq->debug_id, subreq->debug_index, subreq->len); 218 + kenter("R=%x[%x],%zx", wreq->debug_id, subreq->debug_index, subreq->len); 219 219 220 220 if (test_bit(NETFS_SREQ_FAILED, &subreq->flags)) 221 221 return netfs_write_subrequest_terminated(subreq, subreq->error, false); ··· 272 272 size_t part; 273 273 274 274 if (!stream->avail) { 275 - _leave("no write"); 275 + kleave("no write"); 276 276 return len; 277 277 } 278 278 279 - _enter("R=%x[%x]", wreq->debug_id, subreq ? subreq->debug_index : 0); 279 + kenter("R=%x[%x]", wreq->debug_id, subreq ? subreq->debug_index : 0); 280 280 281 281 if (subreq && start != subreq->start + subreq->len) { 282 282 netfs_issue_write(wreq, stream); ··· 288 288 subreq = stream->construct; 289 289 290 290 part = min(subreq->max_len - subreq->len, len); 291 - _debug("part %zx/%zx %zx/%zx", subreq->len, subreq->max_len, part, len); 291 + kdebug("part %zx/%zx %zx/%zx", subreq->len, subreq->max_len, part, len); 292 292 subreq->len += part; 293 293 subreq->nr_segs++; 294 294 ··· 319 319 bool to_eof = false, streamw = false; 320 320 bool debug = false; 321 321 322 - _enter(""); 322 + kenter(""); 323 323 324 324 /* netfs_perform_write() may shift i_size around the page or from out 325 325 * of the page to beyond it, but cannot move i_size into or through the ··· 329 329 330 330 if (fpos >= i_size) { 331 331 /* mmap beyond eof. */ 332 - _debug("beyond eof"); 332 + kdebug("beyond eof"); 333 333 folio_start_writeback(folio); 334 334 folio_unlock(folio); 335 335 wreq->nr_group_rel += netfs_folio_written_back(folio); ··· 363 363 } 364 364 flen -= foff; 365 365 366 - _debug("folio %zx %zx %zx", foff, flen, fsize); 366 + kdebug("folio %zx %zx %zx", foff, flen, fsize); 367 367 368 368 /* Deal with discontinuities in the stream of dirty pages. These can 369 369 * arise from a number of sources: ··· 487 487 for (int s = 0; s < NR_IO_STREAMS; s++) 488 488 netfs_issue_write(wreq, &wreq->io_streams[s]); 489 489 490 - _leave(" = 0"); 490 + kleave(" = 0"); 491 491 return 0; 492 492 } 493 493 ··· 522 522 netfs_stat(&netfs_n_wh_writepages); 523 523 524 524 do { 525 - _debug("wbiter %lx %llx", folio->index, wreq->start + wreq->submitted); 525 + kdebug("wbiter %lx %llx", folio->index, wreq->start + wreq->submitted); 526 526 527 527 /* It appears we don't have to handle cyclic writeback wrapping. */ 528 528 WARN_ON_ONCE(wreq && folio_pos(folio) < wreq->start + wreq->submitted); ··· 546 546 mutex_unlock(&ictx->wb_lock); 547 547 548 548 netfs_put_request(wreq, false, netfs_rreq_trace_put_return); 549 - _leave(" = %d", error); 549 + kleave(" = %d", error); 550 550 return error; 551 551 552 552 couldnt_start: 553 553 netfs_kill_dirty_pages(mapping, wbc, folio); 554 554 out: 555 555 mutex_unlock(&ictx->wb_lock); 556 - _leave(" = %d", error); 556 + kleave(" = %d", error); 557 557 return error; 558 558 } 559 559 EXPORT_SYMBOL(netfs_writepages); ··· 590 590 struct folio *folio, size_t copied, bool to_page_end, 591 591 struct folio **writethrough_cache) 592 592 { 593 - _enter("R=%x ic=%zu ws=%u cp=%zu tp=%u", 593 + kenter("R=%x ic=%zu ws=%u cp=%zu tp=%u", 594 594 wreq->debug_id, wreq->iter.count, wreq->wsize, copied, to_page_end); 595 595 596 596 if (!*writethrough_cache) { ··· 624 624 struct netfs_inode *ictx = netfs_inode(wreq->inode); 625 625 int ret; 626 626 627 - _enter("R=%x", wreq->debug_id); 627 + kenter("R=%x", wreq->debug_id); 628 628 629 629 if (writethrough_cache) 630 630 netfs_write_folio(wreq, wbc, writethrough_cache); ··· 657 657 loff_t start = wreq->start; 658 658 int error = 0; 659 659 660 - _enter("%zx", len); 660 + kenter("%zx", len); 661 661 662 662 if (wreq->origin == NETFS_DIO_WRITE) 663 663 inode_dio_begin(wreq->inode); ··· 665 665 while (len) { 666 666 // TODO: Prepare content encryption 667 667 668 - _debug("unbuffered %zx", len); 668 + kdebug("unbuffered %zx", len); 669 669 part = netfs_advance_write(wreq, upload, start, len, false); 670 670 start += part; 671 671 len -= part; ··· 684 684 if (list_empty(&upload->subrequests)) 685 685 netfs_wake_write_collector(wreq, false); 686 686 687 - _leave(" = %d", error); 687 + kleave(" = %d", error); 688 688 return error; 689 689 }
+6
include/linux/fscache-cache.h
··· 19 19 enum fscache_cache_trace; 20 20 enum fscache_cookie_trace; 21 21 enum fscache_access_trace; 22 + enum fscache_volume_trace; 22 23 23 24 enum fscache_cache_state { 24 25 FSCACHE_CACHE_IS_NOT_PRESENT, /* No cache is present for this name */ ··· 98 97 99 98 extern void fscache_io_error(struct fscache_cache *cache); 100 99 100 + extern struct fscache_volume * 101 + fscache_try_get_volume(struct fscache_volume *volume, 102 + enum fscache_volume_trace where); 103 + extern void fscache_put_volume(struct fscache_volume *volume, 104 + enum fscache_volume_trace where); 101 105 extern void fscache_end_volume_access(struct fscache_volume *volume, 102 106 struct fscache_cookie *cookie, 103 107 enum fscache_access_trace why);
+4
include/trace/events/fscache.h
··· 35 35 fscache_volume_get_cookie, 36 36 fscache_volume_get_create_work, 37 37 fscache_volume_get_hash_collision, 38 + fscache_volume_get_withdraw, 38 39 fscache_volume_free, 39 40 fscache_volume_new_acquire, 40 41 fscache_volume_put_cookie, 41 42 fscache_volume_put_create_work, 42 43 fscache_volume_put_hash_collision, 43 44 fscache_volume_put_relinquish, 45 + fscache_volume_put_withdraw, 44 46 fscache_volume_see_create_work, 45 47 fscache_volume_see_hash_wake, 46 48 fscache_volume_wait_create_work, ··· 122 120 EM(fscache_volume_get_cookie, "GET cook ") \ 123 121 EM(fscache_volume_get_create_work, "GET creat") \ 124 122 EM(fscache_volume_get_hash_collision, "GET hcoll") \ 123 + EM(fscache_volume_get_withdraw, "GET withd") \ 125 124 EM(fscache_volume_free, "FREE ") \ 126 125 EM(fscache_volume_new_acquire, "NEW acq ") \ 127 126 EM(fscache_volume_put_cookie, "PUT cook ") \ 128 127 EM(fscache_volume_put_create_work, "PUT creat") \ 129 128 EM(fscache_volume_put_hash_collision, "PUT hcoll") \ 130 129 EM(fscache_volume_put_relinquish, "PUT relnq") \ 130 + EM(fscache_volume_put_withdraw, "PUT withd") \ 131 131 EM(fscache_volume_see_create_work, "SEE creat") \ 132 132 EM(fscache_volume_see_hash_wake, "SEE hwake") \ 133 133 E_(fscache_volume_wait_create_work, "WAIT crea")