1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright 2011 Nexenta Systems, Inc. All rights reserved. 24 * Copyright (c) 2012, Joyent, Inc. All rights reserved. 25 * Copyright (c) 2013 by Delphix. All rights reserved. 26 * Copyright (c) 2013 by Saso Kiselkov. All rights reserved. 27 */ 28 29 /* 30 * DVA-based Adjustable Replacement Cache 31 * 32 * While much of the theory of operation used here is 33 * based on the self-tuning, low overhead replacement cache 34 * presented by Megiddo and Modha at FAST 2003, there are some 35 * significant differences: 36 * 37 * 1. The Megiddo and Modha model assumes any page is evictable. 38 * Pages in its cache cannot be "locked" into memory. This makes 39 * the eviction algorithm simple: evict the last page in the list. 40 * This also make the performance characteristics easy to reason 41 * about. Our cache is not so simple. At any given moment, some 42 * subset of the blocks in the cache are un-evictable because we 43 * have handed out a reference to them. Blocks are only evictable 44 * when there are no external references active. This makes 45 * eviction far more problematic: we choose to evict the evictable 46 * blocks that are the "lowest" in the list. 47 * 48 * There are times when it is not possible to evict the requested 49 * space. In these circumstances we are unable to adjust the cache 50 * size. To prevent the cache growing unbounded at these times we 51 * implement a "cache throttle" that slows the flow of new data 52 * into the cache until we can make space available. 53 * 54 * 2. The Megiddo and Modha model assumes a fixed cache size. 55 * Pages are evicted when the cache is full and there is a cache 56 * miss. Our model has a variable sized cache. It grows with 57 * high use, but also tries to react to memory pressure from the 58 * operating system: decreasing its size when system memory is 59 * tight. 60 * 61 * 3. The Megiddo and Modha model assumes a fixed page size. All 62 * elements of the cache are therefore exactly the same size. So 63 * when adjusting the cache size following a cache miss, its simply 64 * a matter of choosing a single page to evict. In our model, we 65 * have variable sized cache blocks (rangeing from 512 bytes to 66 * 128K bytes). We therefore choose a set of blocks to evict to make 67 * space for a cache miss that approximates as closely as possible 68 * the space used by the new block. 69 * 70 * See also: "ARC: A Self-Tuning, Low Overhead Replacement Cache" 71 * by N. Megiddo & D. Modha, FAST 2003 72 */ 73 74 /* 75 * The locking model: 76 * 77 * A new reference to a cache buffer can be obtained in two 78 * ways: 1) via a hash table lookup using the DVA as a key, 79 * or 2) via one of the ARC lists. The arc_read() interface 80 * uses method 1, while the internal arc algorithms for 81 * adjusting the cache use method 2. We therefore provide two 82 * types of locks: 1) the hash table lock array, and 2) the 83 * arc list locks. 84 * 85 * Buffers do not have their own mutexes, rather they rely on the 86 * hash table mutexes for the bulk of their protection (i.e. most 87 * fields in the arc_buf_hdr_t are protected by these mutexes). 88 * 89 * buf_hash_find() returns the appropriate mutex (held) when it 90 * locates the requested buffer in the hash table. It returns 91 * NULL for the mutex if the buffer was not in the table. 92 * 93 * buf_hash_remove() expects the appropriate hash mutex to be 94 * already held before it is invoked. 95 * 96 * Each arc state also has a mutex which is used to protect the 97 * buffer list associated with the state. When attempting to 98 * obtain a hash table lock while holding an arc list lock you 99 * must use: mutex_tryenter() to avoid deadlock. Also note that 100 * the active state mutex must be held before the ghost state mutex. 101 * 102 * Arc buffers may have an associated eviction callback function. 103 * This function will be invoked prior to removing the buffer (e.g. 104 * in arc_do_user_evicts()). Note however that the data associated 105 * with the buffer may be evicted prior to the callback. The callback 106 * must be made with *no locks held* (to prevent deadlock). Additionally, 107 * the users of callbacks must ensure that their private data is 108 * protected from simultaneous callbacks from arc_buf_evict() 109 * and arc_do_user_evicts(). 110 * 111 * Note that the majority of the performance stats are manipulated 112 * with atomic operations. 113 * 114 * The L2ARC uses the l2arc_buflist_mtx global mutex for the following: 115 * 116 * - L2ARC buflist creation 117 * - L2ARC buflist eviction 118 * - L2ARC write completion, which walks L2ARC buflists 119 * - ARC header destruction, as it removes from L2ARC buflists 120 * - ARC header release, as it removes from L2ARC buflists 121 */ 122 123 #include <sys/spa.h> 124 #include <sys/zio.h> 125 #include <sys/zio_compress.h> 126 #include <sys/zfs_context.h> 127 #include <sys/arc.h> 128 #include <sys/refcount.h> 129 #include <sys/vdev.h> 130 #include <sys/vdev_impl.h> 131 #include <sys/dsl_pool.h> 132 #ifdef _KERNEL 133 #include <sys/vmsystm.h> 134 #include <vm/anon.h> 135 #include <sys/fs/swapnode.h> 136 #include <sys/dnlc.h> 137 #endif 138 #include <sys/callb.h> 139 #include <sys/kstat.h> 140 #include <zfs_fletcher.h> 141 142 #ifndef _KERNEL 143 /* set with ZFS_DEBUG=watch, to enable watchpoints on frozen buffers */ 144 boolean_t arc_watch = B_FALSE; 145 int arc_procfd; 146 #endif 147 148 static kmutex_t arc_reclaim_thr_lock; 149 static kcondvar_t arc_reclaim_thr_cv; /* used to signal reclaim thr */ 150 static uint8_t arc_thread_exit; 151 152 #define ARC_REDUCE_DNLC_PERCENT 3 153 uint_t arc_reduce_dnlc_percent = ARC_REDUCE_DNLC_PERCENT; 154 155 typedef enum arc_reclaim_strategy { 156 ARC_RECLAIM_AGGR, /* Aggressive reclaim strategy */ 157 ARC_RECLAIM_CONS /* Conservative reclaim strategy */ 158 } arc_reclaim_strategy_t; 159 160 /* 161 * The number of iterations through arc_evict_*() before we 162 * drop & reacquire the lock. 163 */ 164 int arc_evict_iterations = 100; 165 166 /* number of seconds before growing cache again */ 167 static int arc_grow_retry = 60; 168 169 /* shift of arc_c for calculating both min and max arc_p */ 170 static int arc_p_min_shift = 4; 171 172 /* log2(fraction of arc to reclaim) */ 173 static int arc_shrink_shift = 5; 174 175 /* 176 * minimum lifespan of a prefetch block in clock ticks 177 * (initialized in arc_init()) 178 */ 179 static int arc_min_prefetch_lifespan; 180 181 /* 182 * If this percent of memory is free, don't throttle. 183 */ 184 int arc_lotsfree_percent = 10; 185 186 static int arc_dead; 187 188 /* 189 * The arc has filled available memory and has now warmed up. 190 */ 191 static boolean_t arc_warm; 192 193 /* 194 * These tunables are for performance analysis. 195 */ 196 uint64_t zfs_arc_max; 197 uint64_t zfs_arc_min; 198 uint64_t zfs_arc_meta_limit = 0; 199 int zfs_arc_grow_retry = 0; 200 int zfs_arc_shrink_shift = 0; 201 int zfs_arc_p_min_shift = 0; 202 int zfs_disable_dup_eviction = 0; 203 204 /* 205 * Note that buffers can be in one of 6 states: 206 * ARC_anon - anonymous (discussed below) 207 * ARC_mru - recently used, currently cached 208 * ARC_mru_ghost - recentely used, no longer in cache 209 * ARC_mfu - frequently used, currently cached 210 * ARC_mfu_ghost - frequently used, no longer in cache 211 * ARC_l2c_only - exists in L2ARC but not other states 212 * When there are no active references to the buffer, they are 213 * are linked onto a list in one of these arc states. These are 214 * the only buffers that can be evicted or deleted. Within each 215 * state there are multiple lists, one for meta-data and one for 216 * non-meta-data. Meta-data (indirect blocks, blocks of dnodes, 217 * etc.) is tracked separately so that it can be managed more 218 * explicitly: favored over data, limited explicitly. 219 * 220 * Anonymous buffers are buffers that are not associated with 221 * a DVA. These are buffers that hold dirty block copies 222 * before they are written to stable storage. By definition, 223 * they are "ref'd" and are considered part of arc_mru 224 * that cannot be freed. Generally, they will aquire a DVA 225 * as they are written and migrate onto the arc_mru list. 226 * 227 * The ARC_l2c_only state is for buffers that are in the second 228 * level ARC but no longer in any of the ARC_m* lists. The second 229 * level ARC itself may also contain buffers that are in any of 230 * the ARC_m* states - meaning that a buffer can exist in two 231 * places. The reason for the ARC_l2c_only state is to keep the 232 * buffer header in the hash table, so that reads that hit the 233 * second level ARC benefit from these fast lookups. 234 */ 235 236 typedef struct arc_state { 237 list_t arcs_list[ARC_BUFC_NUMTYPES]; /* list of evictable buffers */ 238 uint64_t arcs_lsize[ARC_BUFC_NUMTYPES]; /* amount of evictable data */ 239 uint64_t arcs_size; /* total amount of data in this state */ 240 kmutex_t arcs_mtx; 241 } arc_state_t; 242 243 /* The 6 states: */ 244 static arc_state_t ARC_anon; 245 static arc_state_t ARC_mru; 246 static arc_state_t ARC_mru_ghost; 247 static arc_state_t ARC_mfu; 248 static arc_state_t ARC_mfu_ghost; 249 static arc_state_t ARC_l2c_only; 250 251 typedef struct arc_stats { 252 kstat_named_t arcstat_hits; 253 kstat_named_t arcstat_misses; 254 kstat_named_t arcstat_demand_data_hits; 255 kstat_named_t arcstat_demand_data_misses; 256 kstat_named_t arcstat_demand_metadata_hits; 257 kstat_named_t arcstat_demand_metadata_misses; 258 kstat_named_t arcstat_prefetch_data_hits; 259 kstat_named_t arcstat_prefetch_data_misses; 260 kstat_named_t arcstat_prefetch_metadata_hits; 261 kstat_named_t arcstat_prefetch_metadata_misses; 262 kstat_named_t arcstat_mru_hits; 263 kstat_named_t arcstat_mru_ghost_hits; 264 kstat_named_t arcstat_mfu_hits; 265 kstat_named_t arcstat_mfu_ghost_hits; 266 kstat_named_t arcstat_deleted; 267 kstat_named_t arcstat_recycle_miss; 268 /* 269 * Number of buffers that could not be evicted because the hash lock 270 * was held by another thread. The lock may not necessarily be held 271 * by something using the same buffer, since hash locks are shared 272 * by multiple buffers. 273 */ 274 kstat_named_t arcstat_mutex_miss; 275 /* 276 * Number of buffers skipped because they have I/O in progress, are 277 * indrect prefetch buffers that have not lived long enough, or are 278 * not from the spa we're trying to evict from. 279 */ 280 kstat_named_t arcstat_evict_skip; 281 kstat_named_t arcstat_evict_l2_cached; 282 kstat_named_t arcstat_evict_l2_eligible; 283 kstat_named_t arcstat_evict_l2_ineligible; 284 kstat_named_t arcstat_hash_elements; 285 kstat_named_t arcstat_hash_elements_max; 286 kstat_named_t arcstat_hash_collisions; 287 kstat_named_t arcstat_hash_chains; 288 kstat_named_t arcstat_hash_chain_max; 289 kstat_named_t arcstat_p; 290 kstat_named_t arcstat_c; 291 kstat_named_t arcstat_c_min; 292 kstat_named_t arcstat_c_max; 293 kstat_named_t arcstat_size; 294 kstat_named_t arcstat_hdr_size; 295 kstat_named_t arcstat_data_size; 296 kstat_named_t arcstat_other_size; 297 kstat_named_t arcstat_l2_hits; 298 kstat_named_t arcstat_l2_misses; 299 kstat_named_t arcstat_l2_feeds; 300 kstat_named_t arcstat_l2_rw_clash; 301 kstat_named_t arcstat_l2_read_bytes; 302 kstat_named_t arcstat_l2_write_bytes; 303 kstat_named_t arcstat_l2_writes_sent; 304 kstat_named_t arcstat_l2_writes_done; 305 kstat_named_t arcstat_l2_writes_error; 306 kstat_named_t arcstat_l2_writes_hdr_miss; 307 kstat_named_t arcstat_l2_evict_lock_retry; 308 kstat_named_t arcstat_l2_evict_reading; 309 kstat_named_t arcstat_l2_free_on_write; 310 kstat_named_t arcstat_l2_abort_lowmem; 311 kstat_named_t arcstat_l2_cksum_bad; 312 kstat_named_t arcstat_l2_io_error; 313 kstat_named_t arcstat_l2_size; 314 kstat_named_t arcstat_l2_asize; 315 kstat_named_t arcstat_l2_hdr_size; 316 kstat_named_t arcstat_l2_compress_successes; 317 kstat_named_t arcstat_l2_compress_zeros; 318 kstat_named_t arcstat_l2_compress_failures; 319 kstat_named_t arcstat_memory_throttle_count; 320 kstat_named_t arcstat_duplicate_buffers; 321 kstat_named_t arcstat_duplicate_buffers_size; 322 kstat_named_t arcstat_duplicate_reads; 323 kstat_named_t arcstat_meta_used; 324 kstat_named_t arcstat_meta_limit; 325 kstat_named_t arcstat_meta_max; 326 } arc_stats_t; 327 328 static arc_stats_t arc_stats = { 329 { "hits", KSTAT_DATA_UINT64 }, 330 { "misses", KSTAT_DATA_UINT64 }, 331 { "demand_data_hits", KSTAT_DATA_UINT64 }, 332 { "demand_data_misses", KSTAT_DATA_UINT64 }, 333 { "demand_metadata_hits", KSTAT_DATA_UINT64 }, 334 { "demand_metadata_misses", KSTAT_DATA_UINT64 }, 335 { "prefetch_data_hits", KSTAT_DATA_UINT64 }, 336 { "prefetch_data_misses", KSTAT_DATA_UINT64 }, 337 { "prefetch_metadata_hits", KSTAT_DATA_UINT64 }, 338 { "prefetch_metadata_misses", KSTAT_DATA_UINT64 }, 339 { "mru_hits", KSTAT_DATA_UINT64 }, 340 { "mru_ghost_hits", KSTAT_DATA_UINT64 }, 341 { "mfu_hits", KSTAT_DATA_UINT64 }, 342 { "mfu_ghost_hits", KSTAT_DATA_UINT64 }, 343 { "deleted", KSTAT_DATA_UINT64 }, 344 { "recycle_miss", KSTAT_DATA_UINT64 }, 345 { "mutex_miss", KSTAT_DATA_UINT64 }, 346 { "evict_skip", KSTAT_DATA_UINT64 }, 347 { "evict_l2_cached", KSTAT_DATA_UINT64 }, 348 { "evict_l2_eligible", KSTAT_DATA_UINT64 }, 349 { "evict_l2_ineligible", KSTAT_DATA_UINT64 }, 350 { "hash_elements", KSTAT_DATA_UINT64 }, 351 { "hash_elements_max", KSTAT_DATA_UINT64 }, 352 { "hash_collisions", KSTAT_DATA_UINT64 }, 353 { "hash_chains", KSTAT_DATA_UINT64 }, 354 { "hash_chain_max", KSTAT_DATA_UINT64 }, 355 { "p", KSTAT_DATA_UINT64 }, 356 { "c", KSTAT_DATA_UINT64 }, 357 { "c_min", KSTAT_DATA_UINT64 }, 358 { "c_max", KSTAT_DATA_UINT64 }, 359 { "size", KSTAT_DATA_UINT64 }, 360 { "hdr_size", KSTAT_DATA_UINT64 }, 361 { "data_size", KSTAT_DATA_UINT64 }, 362 { "other_size", KSTAT_DATA_UINT64 }, 363 { "l2_hits", KSTAT_DATA_UINT64 }, 364 { "l2_misses", KSTAT_DATA_UINT64 }, 365 { "l2_feeds", KSTAT_DATA_UINT64 }, 366 { "l2_rw_clash", KSTAT_DATA_UINT64 }, 367 { "l2_read_bytes", KSTAT_DATA_UINT64 }, 368 { "l2_write_bytes", KSTAT_DATA_UINT64 }, 369 { "l2_writes_sent", KSTAT_DATA_UINT64 }, 370 { "l2_writes_done", KSTAT_DATA_UINT64 }, 371 { "l2_writes_error", KSTAT_DATA_UINT64 }, 372 { "l2_writes_hdr_miss", KSTAT_DATA_UINT64 }, 373 { "l2_evict_lock_retry", KSTAT_DATA_UINT64 }, 374 { "l2_evict_reading", KSTAT_DATA_UINT64 }, 375 { "l2_free_on_write", KSTAT_DATA_UINT64 }, 376 { "l2_abort_lowmem", KSTAT_DATA_UINT64 }, 377 { "l2_cksum_bad", KSTAT_DATA_UINT64 }, 378 { "l2_io_error", KSTAT_DATA_UINT64 }, 379 { "l2_size", KSTAT_DATA_UINT64 }, 380 { "l2_asize", KSTAT_DATA_UINT64 }, 381 { "l2_hdr_size", KSTAT_DATA_UINT64 }, 382 { "l2_compress_successes", KSTAT_DATA_UINT64 }, 383 { "l2_compress_zeros", KSTAT_DATA_UINT64 }, 384 { "l2_compress_failures", KSTAT_DATA_UINT64 }, 385 { "memory_throttle_count", KSTAT_DATA_UINT64 }, 386 { "duplicate_buffers", KSTAT_DATA_UINT64 }, 387 { "duplicate_buffers_size", KSTAT_DATA_UINT64 }, 388 { "duplicate_reads", KSTAT_DATA_UINT64 }, 389 { "arc_meta_used", KSTAT_DATA_UINT64 }, 390 { "arc_meta_limit", KSTAT_DATA_UINT64 }, 391 { "arc_meta_max", KSTAT_DATA_UINT64 } 392 }; 393 394 #define ARCSTAT(stat) (arc_stats.stat.value.ui64) 395 396 #define ARCSTAT_INCR(stat, val) \ 397 atomic_add_64(&arc_stats.stat.value.ui64, (val)) 398 399 #define ARCSTAT_BUMP(stat) ARCSTAT_INCR(stat, 1) 400 #define ARCSTAT_BUMPDOWN(stat) ARCSTAT_INCR(stat, -1) 401 402 #define ARCSTAT_MAX(stat, val) { \ 403 uint64_t m; \ 404 while ((val) > (m = arc_stats.stat.value.ui64) && \ 405 (m != atomic_cas_64(&arc_stats.stat.value.ui64, m, (val)))) \ 406 continue; \ 407 } 408 409 #define ARCSTAT_MAXSTAT(stat) \ 410 ARCSTAT_MAX(stat##_max, arc_stats.stat.value.ui64) 411 412 /* 413 * We define a macro to allow ARC hits/misses to be easily broken down by 414 * two separate conditions, giving a total of four different subtypes for 415 * each of hits and misses (so eight statistics total). 416 */ 417 #define ARCSTAT_CONDSTAT(cond1, stat1, notstat1, cond2, stat2, notstat2, stat) \ 418 if (cond1) { \ 419 if (cond2) { \ 420 ARCSTAT_BUMP(arcstat_##stat1##_##stat2##_##stat); \ 421 } else { \ 422 ARCSTAT_BUMP(arcstat_##stat1##_##notstat2##_##stat); \ 423 } \ 424 } else { \ 425 if (cond2) { \ 426 ARCSTAT_BUMP(arcstat_##notstat1##_##stat2##_##stat); \ 427 } else { \ 428 ARCSTAT_BUMP(arcstat_##notstat1##_##notstat2##_##stat);\ 429 } \ 430 } 431 432 kstat_t *arc_ksp; 433 static arc_state_t *arc_anon; 434 static arc_state_t *arc_mru; 435 static arc_state_t *arc_mru_ghost; 436 static arc_state_t *arc_mfu; 437 static arc_state_t *arc_mfu_ghost; 438 static arc_state_t *arc_l2c_only; 439 440 /* 441 * There are several ARC variables that are critical to export as kstats -- 442 * but we don't want to have to grovel around in the kstat whenever we wish to 443 * manipulate them. For these variables, we therefore define them to be in 444 * terms of the statistic variable. This assures that we are not introducing 445 * the possibility of inconsistency by having shadow copies of the variables, 446 * while still allowing the code to be readable. 447 */ 448 #define arc_size ARCSTAT(arcstat_size) /* actual total arc size */ 449 #define arc_p ARCSTAT(arcstat_p) /* target size of MRU */ 450 #define arc_c ARCSTAT(arcstat_c) /* target size of cache */ 451 #define arc_c_min ARCSTAT(arcstat_c_min) /* min target cache size */ 452 #define arc_c_max ARCSTAT(arcstat_c_max) /* max target cache size */ 453 #define arc_meta_limit ARCSTAT(arcstat_meta_limit) /* max size for metadata */ 454 #define arc_meta_used ARCSTAT(arcstat_meta_used) /* size of metadata */ 455 #define arc_meta_max ARCSTAT(arcstat_meta_max) /* max size of metadata */ 456 457 #define L2ARC_IS_VALID_COMPRESS(_c_) \ 458 ((_c_) == ZIO_COMPRESS_LZ4 || (_c_) == ZIO_COMPRESS_EMPTY) 459 460 static int arc_no_grow; /* Don't try to grow cache size */ 461 static uint64_t arc_tempreserve; 462 static uint64_t arc_loaned_bytes; 463 464 typedef struct l2arc_buf_hdr l2arc_buf_hdr_t; 465 466 typedef struct arc_callback arc_callback_t; 467 468 struct arc_callback { 469 void *acb_private; 470 arc_done_func_t *acb_done; 471 arc_buf_t *acb_buf; 472 zio_t *acb_zio_dummy; 473 arc_callback_t *acb_next; 474 }; 475 476 typedef struct arc_write_callback arc_write_callback_t; 477 478 struct arc_write_callback { 479 void *awcb_private; 480 arc_done_func_t *awcb_ready; 481 arc_done_func_t *awcb_physdone; 482 arc_done_func_t *awcb_done; 483 arc_buf_t *awcb_buf; 484 }; 485 486 struct arc_buf_hdr { 487 /* protected by hash lock */ 488 dva_t b_dva; 489 uint64_t b_birth; 490 uint64_t b_cksum0; 491 492 kmutex_t b_freeze_lock; 493 zio_cksum_t *b_freeze_cksum; 494 void *b_thawed; 495 496 arc_buf_hdr_t *b_hash_next; 497 arc_buf_t *b_buf; 498 uint32_t b_flags; 499 uint32_t b_datacnt; 500 501 arc_callback_t *b_acb; 502 kcondvar_t b_cv; 503 504 /* immutable */ 505 arc_buf_contents_t b_type; 506 uint64_t b_size; 507 uint64_t b_spa; 508 509 /* protected by arc state mutex */ 510 arc_state_t *b_state; 511 list_node_t b_arc_node; 512 513 /* updated atomically */ 514 clock_t b_arc_access; 515 516 /* self protecting */ 517 refcount_t b_refcnt; 518 519 l2arc_buf_hdr_t *b_l2hdr; 520 list_node_t b_l2node; 521 }; 522 523 static arc_buf_t *arc_eviction_list; 524 static kmutex_t arc_eviction_mtx; 525 static arc_buf_hdr_t arc_eviction_hdr; 526 static void arc_get_data_buf(arc_buf_t *buf); 527 static void arc_access(arc_buf_hdr_t *buf, kmutex_t *hash_lock); 528 static int arc_evict_needed(arc_buf_contents_t type); 529 static void arc_evict_ghost(arc_state_t *state, uint64_t spa, int64_t bytes); 530 static void arc_buf_watch(arc_buf_t *buf); 531 532 static boolean_t l2arc_write_eligible(uint64_t spa_guid, arc_buf_hdr_t *ab); 533 534 #define GHOST_STATE(state) \ 535 ((state) == arc_mru_ghost || (state) == arc_mfu_ghost || \ 536 (state) == arc_l2c_only) 537 538 /* 539 * Private ARC flags. These flags are private ARC only flags that will show up 540 * in b_flags in the arc_hdr_buf_t. Some flags are publicly declared, and can 541 * be passed in as arc_flags in things like arc_read. However, these flags 542 * should never be passed and should only be set by ARC code. When adding new 543 * public flags, make sure not to smash the private ones. 544 */ 545 546 #define ARC_IN_HASH_TABLE (1 << 9) /* this buffer is hashed */ 547 #define ARC_IO_IN_PROGRESS (1 << 10) /* I/O in progress for buf */ 548 #define ARC_IO_ERROR (1 << 11) /* I/O failed for buf */ 549 #define ARC_FREED_IN_READ (1 << 12) /* buf freed while in read */ 550 #define ARC_BUF_AVAILABLE (1 << 13) /* block not in active use */ 551 #define ARC_INDIRECT (1 << 14) /* this is an indirect block */ 552 #define ARC_FREE_IN_PROGRESS (1 << 15) /* hdr about to be freed */ 553 #define ARC_L2_WRITING (1 << 16) /* L2ARC write in progress */ 554 #define ARC_L2_EVICTED (1 << 17) /* evicted during I/O */ 555 #define ARC_L2_WRITE_HEAD (1 << 18) /* head of write list */ 556 557 #define HDR_IN_HASH_TABLE(hdr) ((hdr)->b_flags & ARC_IN_HASH_TABLE) 558 #define HDR_IO_IN_PROGRESS(hdr) ((hdr)->b_flags & ARC_IO_IN_PROGRESS) 559 #define HDR_IO_ERROR(hdr) ((hdr)->b_flags & ARC_IO_ERROR) 560 #define HDR_PREFETCH(hdr) ((hdr)->b_flags & ARC_PREFETCH) 561 #define HDR_FREED_IN_READ(hdr) ((hdr)->b_flags & ARC_FREED_IN_READ) 562 #define HDR_BUF_AVAILABLE(hdr) ((hdr)->b_flags & ARC_BUF_AVAILABLE) 563 #define HDR_FREE_IN_PROGRESS(hdr) ((hdr)->b_flags & ARC_FREE_IN_PROGRESS) 564 #define HDR_L2CACHE(hdr) ((hdr)->b_flags & ARC_L2CACHE) 565 #define HDR_L2_READING(hdr) ((hdr)->b_flags & ARC_IO_IN_PROGRESS && \ 566 (hdr)->b_l2hdr != NULL) 567 #define HDR_L2_WRITING(hdr) ((hdr)->b_flags & ARC_L2_WRITING) 568 #define HDR_L2_EVICTED(hdr) ((hdr)->b_flags & ARC_L2_EVICTED) 569 #define HDR_L2_WRITE_HEAD(hdr) ((hdr)->b_flags & ARC_L2_WRITE_HEAD) 570 571 /* 572 * Other sizes 573 */ 574 575 #define HDR_SIZE ((int64_t)sizeof (arc_buf_hdr_t)) 576 #define L2HDR_SIZE ((int64_t)sizeof (l2arc_buf_hdr_t)) 577 578 /* 579 * Hash table routines 580 */ 581 582 #define HT_LOCK_PAD 64 583 584 struct ht_lock { 585 kmutex_t ht_lock; 586 #ifdef _KERNEL 587 unsigned char pad[(HT_LOCK_PAD - sizeof (kmutex_t))]; 588 #endif 589 }; 590 591 #define BUF_LOCKS 256 592 typedef struct buf_hash_table { 593 uint64_t ht_mask; 594 arc_buf_hdr_t **ht_table; 595 struct ht_lock ht_locks[BUF_LOCKS]; 596 } buf_hash_table_t; 597 598 static buf_hash_table_t buf_hash_table; 599 600 #define BUF_HASH_INDEX(spa, dva, birth) \ 601 (buf_hash(spa, dva, birth) & buf_hash_table.ht_mask) 602 #define BUF_HASH_LOCK_NTRY(idx) (buf_hash_table.ht_locks[idx & (BUF_LOCKS-1)]) 603 #define BUF_HASH_LOCK(idx) (&(BUF_HASH_LOCK_NTRY(idx).ht_lock)) 604 #define HDR_LOCK(hdr) \ 605 (BUF_HASH_LOCK(BUF_HASH_INDEX(hdr->b_spa, &hdr->b_dva, hdr->b_birth))) 606 607 uint64_t zfs_crc64_table[256]; 608 609 /* 610 * Level 2 ARC 611 */ 612 613 #define L2ARC_WRITE_SIZE (8 * 1024 * 1024) /* initial write max */ 614 #define L2ARC_HEADROOM 2 /* num of writes */ 615 /* 616 * If we discover during ARC scan any buffers to be compressed, we boost 617 * our headroom for the next scanning cycle by this percentage multiple. 618 */ 619 #define L2ARC_HEADROOM_BOOST 200 620 #define L2ARC_FEED_SECS 1 /* caching interval secs */ 621 #define L2ARC_FEED_MIN_MS 200 /* min caching interval ms */ 622 623 #define l2arc_writes_sent ARCSTAT(arcstat_l2_writes_sent) 624 #define l2arc_writes_done ARCSTAT(arcstat_l2_writes_done) 625 626 /* L2ARC Performance Tunables */ 627 uint64_t l2arc_write_max = L2ARC_WRITE_SIZE; /* default max write size */ 628 uint64_t l2arc_write_boost = L2ARC_WRITE_SIZE; /* extra write during warmup */ 629 uint64_t l2arc_headroom = L2ARC_HEADROOM; /* number of dev writes */ 630 uint64_t l2arc_headroom_boost = L2ARC_HEADROOM_BOOST; 631 uint64_t l2arc_feed_secs = L2ARC_FEED_SECS; /* interval seconds */ 632 uint64_t l2arc_feed_min_ms = L2ARC_FEED_MIN_MS; /* min interval milliseconds */ 633 boolean_t l2arc_noprefetch = B_TRUE; /* don't cache prefetch bufs */ 634 boolean_t l2arc_feed_again = B_TRUE; /* turbo warmup */ 635 boolean_t l2arc_norw = B_TRUE; /* no reads during writes */ 636 637 /* 638 * L2ARC Internals 639 */ 640 typedef struct l2arc_dev { 641 vdev_t *l2ad_vdev; /* vdev */ 642 spa_t *l2ad_spa; /* spa */ 643 uint64_t l2ad_hand; /* next write location */ 644 uint64_t l2ad_start; /* first addr on device */ 645 uint64_t l2ad_end; /* last addr on device */ 646 uint64_t l2ad_evict; /* last addr eviction reached */ 647 boolean_t l2ad_first; /* first sweep through */ 648 boolean_t l2ad_writing; /* currently writing */ 649 list_t *l2ad_buflist; /* buffer list */ 650 list_node_t l2ad_node; /* device list node */ 651 } l2arc_dev_t; 652 653 static list_t L2ARC_dev_list; /* device list */ 654 static list_t *l2arc_dev_list; /* device list pointer */ 655 static kmutex_t l2arc_dev_mtx; /* device list mutex */ 656 static l2arc_dev_t *l2arc_dev_last; /* last device used */ 657 static kmutex_t l2arc_buflist_mtx; /* mutex for all buflists */ 658 static list_t L2ARC_free_on_write; /* free after write buf list */ 659 static list_t *l2arc_free_on_write; /* free after write list ptr */ 660 static kmutex_t l2arc_free_on_write_mtx; /* mutex for list */ 661 static uint64_t l2arc_ndev; /* number of devices */ 662 663 typedef struct l2arc_read_callback { 664 arc_buf_t *l2rcb_buf; /* read buffer */ 665 spa_t *l2rcb_spa; /* spa */ 666 blkptr_t l2rcb_bp; /* original blkptr */ 667 zbookmark_t l2rcb_zb; /* original bookmark */ 668 int l2rcb_flags; /* original flags */ 669 enum zio_compress l2rcb_compress; /* applied compress */ 670 } l2arc_read_callback_t; 671 672 typedef struct l2arc_write_callback { 673 l2arc_dev_t *l2wcb_dev; /* device info */ 674 arc_buf_hdr_t *l2wcb_head; /* head of write buflist */ 675 } l2arc_write_callback_t; 676 677 struct l2arc_buf_hdr { 678 /* protected by arc_buf_hdr mutex */ 679 l2arc_dev_t *b_dev; /* L2ARC device */ 680 uint64_t b_daddr; /* disk address, offset byte */ 681 /* compression applied to buffer data */ 682 enum zio_compress b_compress; 683 /* real alloc'd buffer size depending on b_compress applied */ 684 int b_asize; 685 /* temporary buffer holder for in-flight compressed data */ 686 void *b_tmp_cdata; 687 }; 688 689 typedef struct l2arc_data_free { 690 /* protected by l2arc_free_on_write_mtx */ 691 void *l2df_data; 692 size_t l2df_size; 693 void (*l2df_func)(void *, size_t); 694 list_node_t l2df_list_node; 695 } l2arc_data_free_t; 696 697 static kmutex_t l2arc_feed_thr_lock; 698 static kcondvar_t l2arc_feed_thr_cv; 699 static uint8_t l2arc_thread_exit; 700 701 static void l2arc_read_done(zio_t *zio); 702 static void l2arc_hdr_stat_add(void); 703 static void l2arc_hdr_stat_remove(void); 704 705 static boolean_t l2arc_compress_buf(l2arc_buf_hdr_t *l2hdr); 706 static void l2arc_decompress_zio(zio_t *zio, arc_buf_hdr_t *hdr, 707 enum zio_compress c); 708 static void l2arc_release_cdata_buf(arc_buf_hdr_t *ab); 709 710 static uint64_t 711 buf_hash(uint64_t spa, const dva_t *dva, uint64_t birth) 712 { 713 uint8_t *vdva = (uint8_t *)dva; 714 uint64_t crc = -1ULL; 715 int i; 716 717 ASSERT(zfs_crc64_table[128] == ZFS_CRC64_POLY); 718 719 for (i = 0; i < sizeof (dva_t); i++) 720 crc = (crc >> 8) ^ zfs_crc64_table[(crc ^ vdva[i]) & 0xFF]; 721 722 crc ^= (spa>>8) ^ birth; 723 724 return (crc); 725 } 726 727 #define BUF_EMPTY(buf) \ 728 ((buf)->b_dva.dva_word[0] == 0 && \ 729 (buf)->b_dva.dva_word[1] == 0 && \ 730 (buf)->b_birth == 0) 731 732 #define BUF_EQUAL(spa, dva, birth, buf) \ 733 ((buf)->b_dva.dva_word[0] == (dva)->dva_word[0]) && \ 734 ((buf)->b_dva.dva_word[1] == (dva)->dva_word[1]) && \ 735 ((buf)->b_birth == birth) && ((buf)->b_spa == spa) 736 737 static void 738 buf_discard_identity(arc_buf_hdr_t *hdr) 739 { 740 hdr->b_dva.dva_word[0] = 0; 741 hdr->b_dva.dva_word[1] = 0; 742 hdr->b_birth = 0; 743 hdr->b_cksum0 = 0; 744 } 745 746 static arc_buf_hdr_t * 747 buf_hash_find(uint64_t spa, const dva_t *dva, uint64_t birth, kmutex_t **lockp) 748 { 749 uint64_t idx = BUF_HASH_INDEX(spa, dva, birth); 750 kmutex_t *hash_lock = BUF_HASH_LOCK(idx); 751 arc_buf_hdr_t *buf; 752 753 mutex_enter(hash_lock); 754 for (buf = buf_hash_table.ht_table[idx]; buf != NULL; 755 buf = buf->b_hash_next) { 756 if (BUF_EQUAL(spa, dva, birth, buf)) { 757 *lockp = hash_lock; 758 return (buf); 759 } 760 } 761 mutex_exit(hash_lock); 762 *lockp = NULL; 763 return (NULL); 764 } 765 766 /* 767 * Insert an entry into the hash table. If there is already an element 768 * equal to elem in the hash table, then the already existing element 769 * will be returned and the new element will not be inserted. 770 * Otherwise returns NULL. 771 */ 772 static arc_buf_hdr_t * 773 buf_hash_insert(arc_buf_hdr_t *buf, kmutex_t **lockp) 774 { 775 uint64_t idx = BUF_HASH_INDEX(buf->b_spa, &buf->b_dva, buf->b_birth); 776 kmutex_t *hash_lock = BUF_HASH_LOCK(idx); 777 arc_buf_hdr_t *fbuf; 778 uint32_t i; 779 780 ASSERT(!HDR_IN_HASH_TABLE(buf)); 781 *lockp = hash_lock; 782 mutex_enter(hash_lock); 783 for (fbuf = buf_hash_table.ht_table[idx], i = 0; fbuf != NULL; 784 fbuf = fbuf->b_hash_next, i++) { 785 if (BUF_EQUAL(buf->b_spa, &buf->b_dva, buf->b_birth, fbuf)) 786 return (fbuf); 787 } 788 789 buf->b_hash_next = buf_hash_table.ht_table[idx]; 790 buf_hash_table.ht_table[idx] = buf; 791 buf->b_flags |= ARC_IN_HASH_TABLE; 792 793 /* collect some hash table performance data */ 794 if (i > 0) { 795 ARCSTAT_BUMP(arcstat_hash_collisions); 796 if (i == 1) 797 ARCSTAT_BUMP(arcstat_hash_chains); 798 799 ARCSTAT_MAX(arcstat_hash_chain_max, i); 800 } 801 802 ARCSTAT_BUMP(arcstat_hash_elements); 803 ARCSTAT_MAXSTAT(arcstat_hash_elements); 804 805 return (NULL); 806 } 807 808 static void 809 buf_hash_remove(arc_buf_hdr_t *buf) 810 { 811 arc_buf_hdr_t *fbuf, **bufp; 812 uint64_t idx = BUF_HASH_INDEX(buf->b_spa, &buf->b_dva, buf->b_birth); 813 814 ASSERT(MUTEX_HELD(BUF_HASH_LOCK(idx))); 815 ASSERT(HDR_IN_HASH_TABLE(buf)); 816 817 bufp = &buf_hash_table.ht_table[idx]; 818 while ((fbuf = *bufp) != buf) { 819 ASSERT(fbuf != NULL); 820 bufp = &fbuf->b_hash_next; 821 } 822 *bufp = buf->b_hash_next; 823 buf->b_hash_next = NULL; 824 buf->b_flags &= ~ARC_IN_HASH_TABLE; 825 826 /* collect some hash table performance data */ 827 ARCSTAT_BUMPDOWN(arcstat_hash_elements); 828 829 if (buf_hash_table.ht_table[idx] && 830 buf_hash_table.ht_table[idx]->b_hash_next == NULL) 831 ARCSTAT_BUMPDOWN(arcstat_hash_chains); 832 } 833 834 /* 835 * Global data structures and functions for the buf kmem cache. 836 */ 837 static kmem_cache_t *hdr_cache; 838 static kmem_cache_t *buf_cache; 839 840 static void 841 buf_fini(void) 842 { 843 int i; 844 845 kmem_free(buf_hash_table.ht_table, 846 (buf_hash_table.ht_mask + 1) * sizeof (void *)); 847 for (i = 0; i < BUF_LOCKS; i++) 848 mutex_destroy(&buf_hash_table.ht_locks[i].ht_lock); 849 kmem_cache_destroy(hdr_cache); 850 kmem_cache_destroy(buf_cache); 851 } 852 853 /* 854 * Constructor callback - called when the cache is empty 855 * and a new buf is requested. 856 */ 857 /* ARGSUSED */ 858 static int 859 hdr_cons(void *vbuf, void *unused, int kmflag) 860 { 861 arc_buf_hdr_t *buf = vbuf; 862 863 bzero(buf, sizeof (arc_buf_hdr_t)); 864 refcount_create(&buf->b_refcnt); 865 cv_init(&buf->b_cv, NULL, CV_DEFAULT, NULL); 866 mutex_init(&buf->b_freeze_lock, NULL, MUTEX_DEFAULT, NULL); 867 arc_space_consume(sizeof (arc_buf_hdr_t), ARC_SPACE_HDRS); 868 869 return (0); 870 } 871 872 /* ARGSUSED */ 873 static int 874 buf_cons(void *vbuf, void *unused, int kmflag) 875 { 876 arc_buf_t *buf = vbuf; 877 878 bzero(buf, sizeof (arc_buf_t)); 879 mutex_init(&buf->b_evict_lock, NULL, MUTEX_DEFAULT, NULL); 880 arc_space_consume(sizeof (arc_buf_t), ARC_SPACE_HDRS); 881 882 return (0); 883 } 884 885 /* 886 * Destructor callback - called when a cached buf is 887 * no longer required. 888 */ 889 /* ARGSUSED */ 890 static void 891 hdr_dest(void *vbuf, void *unused) 892 { 893 arc_buf_hdr_t *buf = vbuf; 894 895 ASSERT(BUF_EMPTY(buf)); 896 refcount_destroy(&buf->b_refcnt); 897 cv_destroy(&buf->b_cv); 898 mutex_destroy(&buf->b_freeze_lock); 899 arc_space_return(sizeof (arc_buf_hdr_t), ARC_SPACE_HDRS); 900 } 901 902 /* ARGSUSED */ 903 static void 904 buf_dest(void *vbuf, void *unused) 905 { 906 arc_buf_t *buf = vbuf; 907 908 mutex_destroy(&buf->b_evict_lock); 909 arc_space_return(sizeof (arc_buf_t), ARC_SPACE_HDRS); 910 } 911 912 /* 913 * Reclaim callback -- invoked when memory is low. 914 */ 915 /* ARGSUSED */ 916 static void 917 hdr_recl(void *unused) 918 { 919 dprintf("hdr_recl called\n"); 920 /* 921 * umem calls the reclaim func when we destroy the buf cache, 922 * which is after we do arc_fini(). 923 */ 924 if (!arc_dead) 925 cv_signal(&arc_reclaim_thr_cv); 926 } 927 928 static void 929 buf_init(void) 930 { 931 uint64_t *ct; 932 uint64_t hsize = 1ULL << 12; 933 int i, j; 934 935 /* 936 * The hash table is big enough to fill all of physical memory 937 * with an average 64K block size. The table will take up 938 * totalmem*sizeof(void*)/64K (eg. 128KB/GB with 8-byte pointers). 939 */ 940 while (hsize * 65536 < physmem * PAGESIZE) 941 hsize <<= 1; 942 retry: 943 buf_hash_table.ht_mask = hsize - 1; 944 buf_hash_table.ht_table = 945 kmem_zalloc(hsize * sizeof (void*), KM_NOSLEEP); 946 if (buf_hash_table.ht_table == NULL) { 947 ASSERT(hsize > (1ULL << 8)); 948 hsize >>= 1; 949 goto retry; 950 } 951 952 hdr_cache = kmem_cache_create("arc_buf_hdr_t", sizeof (arc_buf_hdr_t), 953 0, hdr_cons, hdr_dest, hdr_recl, NULL, NULL, 0); 954 buf_cache = kmem_cache_create("arc_buf_t", sizeof (arc_buf_t), 955 0, buf_cons, buf_dest, NULL, NULL, NULL, 0); 956 957 for (i = 0; i < 256; i++) 958 for (ct = zfs_crc64_table + i, *ct = i, j = 8; j > 0; j--) 959 *ct = (*ct >> 1) ^ (-(*ct & 1) & ZFS_CRC64_POLY); 960 961 for (i = 0; i < BUF_LOCKS; i++) { 962 mutex_init(&buf_hash_table.ht_locks[i].ht_lock, 963 NULL, MUTEX_DEFAULT, NULL); 964 } 965 } 966 967 #define ARC_MINTIME (hz>>4) /* 62 ms */ 968 969 static void 970 arc_cksum_verify(arc_buf_t *buf) 971 { 972 zio_cksum_t zc; 973 974 if (!(zfs_flags & ZFS_DEBUG_MODIFY)) 975 return; 976 977 mutex_enter(&buf->b_hdr->b_freeze_lock); 978 if (buf->b_hdr->b_freeze_cksum == NULL || 979 (buf->b_hdr->b_flags & ARC_IO_ERROR)) { 980 mutex_exit(&buf->b_hdr->b_freeze_lock); 981 return; 982 } 983 fletcher_2_native(buf->b_data, buf->b_hdr->b_size, &zc); 984 if (!ZIO_CHECKSUM_EQUAL(*buf->b_hdr->b_freeze_cksum, zc)) 985 panic("buffer modified while frozen!"); 986 mutex_exit(&buf->b_hdr->b_freeze_lock); 987 } 988 989 static int 990 arc_cksum_equal(arc_buf_t *buf) 991 { 992 zio_cksum_t zc; 993 int equal; 994 995 mutex_enter(&buf->b_hdr->b_freeze_lock); 996 fletcher_2_native(buf->b_data, buf->b_hdr->b_size, &zc); 997 equal = ZIO_CHECKSUM_EQUAL(*buf->b_hdr->b_freeze_cksum, zc); 998 mutex_exit(&buf->b_hdr->b_freeze_lock); 999 1000 return (equal); 1001 } 1002 1003 static void 1004 arc_cksum_compute(arc_buf_t *buf, boolean_t force) 1005 { 1006 if (!force && !(zfs_flags & ZFS_DEBUG_MODIFY)) 1007 return; 1008 1009 mutex_enter(&buf->b_hdr->b_freeze_lock); 1010 if (buf->b_hdr->b_freeze_cksum != NULL) { 1011 mutex_exit(&buf->b_hdr->b_freeze_lock); 1012 return; 1013 } 1014 buf->b_hdr->b_freeze_cksum = kmem_alloc(sizeof (zio_cksum_t), KM_SLEEP); 1015 fletcher_2_native(buf->b_data, buf->b_hdr->b_size, 1016 buf->b_hdr->b_freeze_cksum); 1017 mutex_exit(&buf->b_hdr->b_freeze_lock); 1018 arc_buf_watch(buf); 1019 } 1020 1021 #ifndef _KERNEL 1022 typedef struct procctl { 1023 long cmd; 1024 prwatch_t prwatch; 1025 } procctl_t; 1026 #endif 1027 1028 /* ARGSUSED */ 1029 static void 1030 arc_buf_unwatch(arc_buf_t *buf) 1031 { 1032 #ifndef _KERNEL 1033 if (arc_watch) { 1034 int result; 1035 procctl_t ctl; 1036 ctl.cmd = PCWATCH; 1037 ctl.prwatch.pr_vaddr = (uintptr_t)buf->b_data; 1038 ctl.prwatch.pr_size = 0; 1039 ctl.prwatch.pr_wflags = 0; 1040 result = write(arc_procfd, &ctl, sizeof (ctl)); 1041 ASSERT3U(result, ==, sizeof (ctl)); 1042 } 1043 #endif 1044 } 1045 1046 /* ARGSUSED */ 1047 static void 1048 arc_buf_watch(arc_buf_t *buf) 1049 { 1050 #ifndef _KERNEL 1051 if (arc_watch) { 1052 int result; 1053 procctl_t ctl; 1054 ctl.cmd = PCWATCH; 1055 ctl.prwatch.pr_vaddr = (uintptr_t)buf->b_data; 1056 ctl.prwatch.pr_size = buf->b_hdr->b_size; 1057 ctl.prwatch.pr_wflags = WA_WRITE; 1058 result = write(arc_procfd, &ctl, sizeof (ctl)); 1059 ASSERT3U(result, ==, sizeof (ctl)); 1060 } 1061 #endif 1062 } 1063 1064 void 1065 arc_buf_thaw(arc_buf_t *buf) 1066 { 1067 if (zfs_flags & ZFS_DEBUG_MODIFY) { 1068 if (buf->b_hdr->b_state != arc_anon) 1069 panic("modifying non-anon buffer!"); 1070 if (buf->b_hdr->b_flags & ARC_IO_IN_PROGRESS) 1071 panic("modifying buffer while i/o in progress!"); 1072 arc_cksum_verify(buf); 1073 } 1074 1075 mutex_enter(&buf->b_hdr->b_freeze_lock); 1076 if (buf->b_hdr->b_freeze_cksum != NULL) { 1077 kmem_free(buf->b_hdr->b_freeze_cksum, sizeof (zio_cksum_t)); 1078 buf->b_hdr->b_freeze_cksum = NULL; 1079 } 1080 1081 if (zfs_flags & ZFS_DEBUG_MODIFY) { 1082 if (buf->b_hdr->b_thawed) 1083 kmem_free(buf->b_hdr->b_thawed, 1); 1084 buf->b_hdr->b_thawed = kmem_alloc(1, KM_SLEEP); 1085 } 1086 1087 mutex_exit(&buf->b_hdr->b_freeze_lock); 1088 1089 arc_buf_unwatch(buf); 1090 } 1091 1092 void 1093 arc_buf_freeze(arc_buf_t *buf) 1094 { 1095 kmutex_t *hash_lock; 1096 1097 if (!(zfs_flags & ZFS_DEBUG_MODIFY)) 1098 return; 1099 1100 hash_lock = HDR_LOCK(buf->b_hdr); 1101 mutex_enter(hash_lock); 1102 1103 ASSERT(buf->b_hdr->b_freeze_cksum != NULL || 1104 buf->b_hdr->b_state == arc_anon); 1105 arc_cksum_compute(buf, B_FALSE); 1106 mutex_exit(hash_lock); 1107 1108 } 1109 1110 static void 1111 add_reference(arc_buf_hdr_t *ab, kmutex_t *hash_lock, void *tag) 1112 { 1113 ASSERT(MUTEX_HELD(hash_lock)); 1114 1115 if ((refcount_add(&ab->b_refcnt, tag) == 1) && 1116 (ab->b_state != arc_anon)) { 1117 uint64_t delta = ab->b_size * ab->b_datacnt; 1118 list_t *list = &ab->b_state->arcs_list[ab->b_type]; 1119 uint64_t *size = &ab->b_state->arcs_lsize[ab->b_type]; 1120 1121 ASSERT(!MUTEX_HELD(&ab->b_state->arcs_mtx)); 1122 mutex_enter(&ab->b_state->arcs_mtx); 1123 ASSERT(list_link_active(&ab->b_arc_node)); 1124 list_remove(list, ab); 1125 if (GHOST_STATE(ab->b_state)) { 1126 ASSERT0(ab->b_datacnt); 1127 ASSERT3P(ab->b_buf, ==, NULL); 1128 delta = ab->b_size; 1129 } 1130 ASSERT(delta > 0); 1131 ASSERT3U(*size, >=, delta); 1132 atomic_add_64(size, -delta); 1133 mutex_exit(&ab->b_state->arcs_mtx); 1134 /* remove the prefetch flag if we get a reference */ 1135 if (ab->b_flags & ARC_PREFETCH) 1136 ab->b_flags &= ~ARC_PREFETCH; 1137 } 1138 } 1139 1140 static int 1141 remove_reference(arc_buf_hdr_t *ab, kmutex_t *hash_lock, void *tag) 1142 { 1143 int cnt; 1144 arc_state_t *state = ab->b_state; 1145 1146 ASSERT(state == arc_anon || MUTEX_HELD(hash_lock)); 1147 ASSERT(!GHOST_STATE(state)); 1148 1149 if (((cnt = refcount_remove(&ab->b_refcnt, tag)) == 0) && 1150 (state != arc_anon)) { 1151 uint64_t *size = &state->arcs_lsize[ab->b_type]; 1152 1153 ASSERT(!MUTEX_HELD(&state->arcs_mtx)); 1154 mutex_enter(&state->arcs_mtx); 1155 ASSERT(!list_link_active(&ab->b_arc_node)); 1156 list_insert_head(&state->arcs_list[ab->b_type], ab); 1157 ASSERT(ab->b_datacnt > 0); 1158 atomic_add_64(size, ab->b_size * ab->b_datacnt); 1159 mutex_exit(&state->arcs_mtx); 1160 } 1161 return (cnt); 1162 } 1163 1164 /* 1165 * Move the supplied buffer to the indicated state. The mutex 1166 * for the buffer must be held by the caller. 1167 */ 1168 static void 1169 arc_change_state(arc_state_t *new_state, arc_buf_hdr_t *ab, kmutex_t *hash_lock) 1170 { 1171 arc_state_t *old_state = ab->b_state; 1172 int64_t refcnt = refcount_count(&ab->b_refcnt); 1173 uint64_t from_delta, to_delta; 1174 1175 ASSERT(MUTEX_HELD(hash_lock)); 1176 ASSERT3P(new_state, !=, old_state); 1177 ASSERT(refcnt == 0 || ab->b_datacnt > 0); 1178 ASSERT(ab->b_datacnt == 0 || !GHOST_STATE(new_state)); 1179 ASSERT(ab->b_datacnt <= 1 || old_state != arc_anon); 1180 1181 from_delta = to_delta = ab->b_datacnt * ab->b_size; 1182 1183 /* 1184 * If this buffer is evictable, transfer it from the 1185 * old state list to the new state list. 1186 */ 1187 if (refcnt == 0) { 1188 if (old_state != arc_anon) { 1189 int use_mutex = !MUTEX_HELD(&old_state->arcs_mtx); 1190 uint64_t *size = &old_state->arcs_lsize[ab->b_type]; 1191 1192 if (use_mutex) 1193 mutex_enter(&old_state->arcs_mtx); 1194 1195 ASSERT(list_link_active(&ab->b_arc_node)); 1196 list_remove(&old_state->arcs_list[ab->b_type], ab); 1197 1198 /* 1199 * If prefetching out of the ghost cache, 1200 * we will have a non-zero datacnt. 1201 */ 1202 if (GHOST_STATE(old_state) && ab->b_datacnt == 0) { 1203 /* ghost elements have a ghost size */ 1204 ASSERT(ab->b_buf == NULL); 1205 from_delta = ab->b_size; 1206 } 1207 ASSERT3U(*size, >=, from_delta); 1208 atomic_add_64(size, -from_delta); 1209 1210 if (use_mutex) 1211 mutex_exit(&old_state->arcs_mtx); 1212 } 1213 if (new_state != arc_anon) { 1214 int use_mutex = !MUTEX_HELD(&new_state->arcs_mtx); 1215 uint64_t *size = &new_state->arcs_lsize[ab->b_type]; 1216 1217 if (use_mutex) 1218 mutex_enter(&new_state->arcs_mtx); 1219 1220 list_insert_head(&new_state->arcs_list[ab->b_type], ab); 1221 1222 /* ghost elements have a ghost size */ 1223 if (GHOST_STATE(new_state)) { 1224 ASSERT(ab->b_datacnt == 0); 1225 ASSERT(ab->b_buf == NULL); 1226 to_delta = ab->b_size; 1227 } 1228 atomic_add_64(size, to_delta); 1229 1230 if (use_mutex) 1231 mutex_exit(&new_state->arcs_mtx); 1232 } 1233 } 1234 1235 ASSERT(!BUF_EMPTY(ab)); 1236 if (new_state == arc_anon && HDR_IN_HASH_TABLE(ab)) 1237 buf_hash_remove(ab); 1238 1239 /* adjust state sizes */ 1240 if (to_delta) 1241 atomic_add_64(&new_state->arcs_size, to_delta); 1242 if (from_delta) { 1243 ASSERT3U(old_state->arcs_size, >=, from_delta); 1244 atomic_add_64(&old_state->arcs_size, -from_delta); 1245 } 1246 ab->b_state = new_state; 1247 1248 /* adjust l2arc hdr stats */ 1249 if (new_state == arc_l2c_only) 1250 l2arc_hdr_stat_add(); 1251 else if (old_state == arc_l2c_only) 1252 l2arc_hdr_stat_remove(); 1253 } 1254 1255 void 1256 arc_space_consume(uint64_t space, arc_space_type_t type) 1257 { 1258 ASSERT(type >= 0 && type < ARC_SPACE_NUMTYPES); 1259 1260 switch (type) { 1261 case ARC_SPACE_DATA: 1262 ARCSTAT_INCR(arcstat_data_size, space); 1263 break; 1264 case ARC_SPACE_OTHER: 1265 ARCSTAT_INCR(arcstat_other_size, space); 1266 break; 1267 case ARC_SPACE_HDRS: 1268 ARCSTAT_INCR(arcstat_hdr_size, space); 1269 break; 1270 case ARC_SPACE_L2HDRS: 1271 ARCSTAT_INCR(arcstat_l2_hdr_size, space); 1272 break; 1273 } 1274 1275 ARCSTAT_INCR(arcstat_meta_used, space); 1276 atomic_add_64(&arc_size, space); 1277 } 1278 1279 void 1280 arc_space_return(uint64_t space, arc_space_type_t type) 1281 { 1282 ASSERT(type >= 0 && type < ARC_SPACE_NUMTYPES); 1283 1284 switch (type) { 1285 case ARC_SPACE_DATA: 1286 ARCSTAT_INCR(arcstat_data_size, -space); 1287 break; 1288 case ARC_SPACE_OTHER: 1289 ARCSTAT_INCR(arcstat_other_size, -space); 1290 break; 1291 case ARC_SPACE_HDRS: 1292 ARCSTAT_INCR(arcstat_hdr_size, -space); 1293 break; 1294 case ARC_SPACE_L2HDRS: 1295 ARCSTAT_INCR(arcstat_l2_hdr_size, -space); 1296 break; 1297 } 1298 1299 ASSERT(arc_meta_used >= space); 1300 if (arc_meta_max < arc_meta_used) 1301 arc_meta_max = arc_meta_used; 1302 ARCSTAT_INCR(arcstat_meta_used, -space); 1303 ASSERT(arc_size >= space); 1304 atomic_add_64(&arc_size, -space); 1305 } 1306 1307 void * 1308 arc_data_buf_alloc(uint64_t size) 1309 { 1310 if (arc_evict_needed(ARC_BUFC_DATA)) 1311 cv_signal(&arc_reclaim_thr_cv); 1312 atomic_add_64(&arc_size, size); 1313 return (zio_data_buf_alloc(size)); 1314 } 1315 1316 void 1317 arc_data_buf_free(void *buf, uint64_t size) 1318 { 1319 zio_data_buf_free(buf, size); 1320 ASSERT(arc_size >= size); 1321 atomic_add_64(&arc_size, -size); 1322 } 1323 1324 arc_buf_t * 1325 arc_buf_alloc(spa_t *spa, int size, void *tag, arc_buf_contents_t type) 1326 { 1327 arc_buf_hdr_t *hdr; 1328 arc_buf_t *buf; 1329 1330 ASSERT3U(size, >, 0); 1331 hdr = kmem_cache_alloc(hdr_cache, KM_PUSHPAGE); 1332 ASSERT(BUF_EMPTY(hdr)); 1333 hdr->b_size = size; 1334 hdr->b_type = type; 1335 hdr->b_spa = spa_load_guid(spa); 1336 hdr->b_state = arc_anon; 1337 hdr->b_arc_access = 0; 1338 buf = kmem_cache_alloc(buf_cache, KM_PUSHPAGE); 1339 buf->b_hdr = hdr; 1340 buf->b_data = NULL; 1341 buf->b_efunc = NULL; 1342 buf->b_private = NULL; 1343 buf->b_next = NULL; 1344 hdr->b_buf = buf; 1345 arc_get_data_buf(buf); 1346 hdr->b_datacnt = 1; 1347 hdr->b_flags = 0; 1348 ASSERT(refcount_is_zero(&hdr->b_refcnt)); 1349 (void) refcount_add(&hdr->b_refcnt, tag); 1350 1351 return (buf); 1352 } 1353 1354 static char *arc_onloan_tag = "onloan"; 1355 1356 /* 1357 * Loan out an anonymous arc buffer. Loaned buffers are not counted as in 1358 * flight data by arc_tempreserve_space() until they are "returned". Loaned 1359 * buffers must be returned to the arc before they can be used by the DMU or 1360 * freed. 1361 */ 1362 arc_buf_t * 1363 arc_loan_buf(spa_t *spa, int size) 1364 { 1365 arc_buf_t *buf; 1366 1367 buf = arc_buf_alloc(spa, size, arc_onloan_tag, ARC_BUFC_DATA); 1368 1369 atomic_add_64(&arc_loaned_bytes, size); 1370 return (buf); 1371 } 1372 1373 /* 1374 * Return a loaned arc buffer to the arc. 1375 */ 1376 void 1377 arc_return_buf(arc_buf_t *buf, void *tag) 1378 { 1379 arc_buf_hdr_t *hdr = buf->b_hdr; 1380 1381 ASSERT(buf->b_data != NULL); 1382 (void) refcount_add(&hdr->b_refcnt, tag); 1383 (void) refcount_remove(&hdr->b_refcnt, arc_onloan_tag); 1384 1385 atomic_add_64(&arc_loaned_bytes, -hdr->b_size); 1386 } 1387 1388 /* Detach an arc_buf from a dbuf (tag) */ 1389 void 1390 arc_loan_inuse_buf(arc_buf_t *buf, void *tag) 1391 { 1392 arc_buf_hdr_t *hdr; 1393 1394 ASSERT(buf->b_data != NULL); 1395 hdr = buf->b_hdr; 1396 (void) refcount_add(&hdr->b_refcnt, arc_onloan_tag); 1397 (void) refcount_remove(&hdr->b_refcnt, tag); 1398 buf->b_efunc = NULL; 1399 buf->b_private = NULL; 1400 1401 atomic_add_64(&arc_loaned_bytes, hdr->b_size); 1402 } 1403 1404 static arc_buf_t * 1405 arc_buf_clone(arc_buf_t *from) 1406 { 1407 arc_buf_t *buf; 1408 arc_buf_hdr_t *hdr = from->b_hdr; 1409 uint64_t size = hdr->b_size; 1410 1411 ASSERT(hdr->b_state != arc_anon); 1412 1413 buf = kmem_cache_alloc(buf_cache, KM_PUSHPAGE); 1414 buf->b_hdr = hdr; 1415 buf->b_data = NULL; 1416 buf->b_efunc = NULL; 1417 buf->b_private = NULL; 1418 buf->b_next = hdr->b_buf; 1419 hdr->b_buf = buf; 1420 arc_get_data_buf(buf); 1421 bcopy(from->b_data, buf->b_data, size); 1422 1423 /* 1424 * This buffer already exists in the arc so create a duplicate 1425 * copy for the caller. If the buffer is associated with user data 1426 * then track the size and number of duplicates. These stats will be 1427 * updated as duplicate buffers are created and destroyed. 1428 */ 1429 if (hdr->b_type == ARC_BUFC_DATA) { 1430 ARCSTAT_BUMP(arcstat_duplicate_buffers); 1431 ARCSTAT_INCR(arcstat_duplicate_buffers_size, size); 1432 } 1433 hdr->b_datacnt += 1; 1434 return (buf); 1435 } 1436 1437 void 1438 arc_buf_add_ref(arc_buf_t *buf, void* tag) 1439 { 1440 arc_buf_hdr_t *hdr; 1441 kmutex_t *hash_lock; 1442 1443 /* 1444 * Check to see if this buffer is evicted. Callers 1445 * must verify b_data != NULL to know if the add_ref 1446 * was successful. 1447 */ 1448 mutex_enter(&buf->b_evict_lock); 1449 if (buf->b_data == NULL) { 1450 mutex_exit(&buf->b_evict_lock); 1451 return; 1452 } 1453 hash_lock = HDR_LOCK(buf->b_hdr); 1454 mutex_enter(hash_lock); 1455 hdr = buf->b_hdr; 1456 ASSERT3P(hash_lock, ==, HDR_LOCK(hdr)); 1457 mutex_exit(&buf->b_evict_lock); 1458 1459 ASSERT(hdr->b_state == arc_mru || hdr->b_state == arc_mfu); 1460 add_reference(hdr, hash_lock, tag); 1461 DTRACE_PROBE1(arc__hit, arc_buf_hdr_t *, hdr); 1462 arc_access(hdr, hash_lock); 1463 mutex_exit(hash_lock); 1464 ARCSTAT_BUMP(arcstat_hits); 1465 ARCSTAT_CONDSTAT(!(hdr->b_flags & ARC_PREFETCH), 1466 demand, prefetch, hdr->b_type != ARC_BUFC_METADATA, 1467 data, metadata, hits); 1468 } 1469 1470 /* 1471 * Free the arc data buffer. If it is an l2arc write in progress, 1472 * the buffer is placed on l2arc_free_on_write to be freed later. 1473 */ 1474 static void 1475 arc_buf_data_free(arc_buf_t *buf, void (*free_func)(void *, size_t)) 1476 { 1477 arc_buf_hdr_t *hdr = buf->b_hdr; 1478 1479 if (HDR_L2_WRITING(hdr)) { 1480 l2arc_data_free_t *df; 1481 df = kmem_alloc(sizeof (l2arc_data_free_t), KM_SLEEP); 1482 df->l2df_data = buf->b_data; 1483 df->l2df_size = hdr->b_size; 1484 df->l2df_func = free_func; 1485 mutex_enter(&l2arc_free_on_write_mtx); 1486 list_insert_head(l2arc_free_on_write, df); 1487 mutex_exit(&l2arc_free_on_write_mtx); 1488 ARCSTAT_BUMP(arcstat_l2_free_on_write); 1489 } else { 1490 free_func(buf->b_data, hdr->b_size); 1491 } 1492 } 1493 1494 static void 1495 arc_buf_destroy(arc_buf_t *buf, boolean_t recycle, boolean_t all) 1496 { 1497 arc_buf_t **bufp; 1498 1499 /* free up data associated with the buf */ 1500 if (buf->b_data) { 1501 arc_state_t *state = buf->b_hdr->b_state; 1502 uint64_t size = buf->b_hdr->b_size; 1503 arc_buf_contents_t type = buf->b_hdr->b_type; 1504 1505 arc_cksum_verify(buf); 1506 arc_buf_unwatch(buf); 1507 1508 if (!recycle) { 1509 if (type == ARC_BUFC_METADATA) { 1510 arc_buf_data_free(buf, zio_buf_free); 1511 arc_space_return(size, ARC_SPACE_DATA); 1512 } else { 1513 ASSERT(type == ARC_BUFC_DATA); 1514 arc_buf_data_free(buf, zio_data_buf_free); 1515 ARCSTAT_INCR(arcstat_data_size, -size); 1516 atomic_add_64(&arc_size, -size); 1517 } 1518 } 1519 if (list_link_active(&buf->b_hdr->b_arc_node)) { 1520 uint64_t *cnt = &state->arcs_lsize[type]; 1521 1522 ASSERT(refcount_is_zero(&buf->b_hdr->b_refcnt)); 1523 ASSERT(state != arc_anon); 1524 1525 ASSERT3U(*cnt, >=, size); 1526 atomic_add_64(cnt, -size); 1527 } 1528 ASSERT3U(state->arcs_size, >=, size); 1529 atomic_add_64(&state->arcs_size, -size); 1530 buf->b_data = NULL; 1531 1532 /* 1533 * If we're destroying a duplicate buffer make sure 1534 * that the appropriate statistics are updated. 1535 */ 1536 if (buf->b_hdr->b_datacnt > 1 && 1537 buf->b_hdr->b_type == ARC_BUFC_DATA) { 1538 ARCSTAT_BUMPDOWN(arcstat_duplicate_buffers); 1539 ARCSTAT_INCR(arcstat_duplicate_buffers_size, -size); 1540 } 1541 ASSERT(buf->b_hdr->b_datacnt > 0); 1542 buf->b_hdr->b_datacnt -= 1; 1543 } 1544 1545 /* only remove the buf if requested */ 1546 if (!all) 1547 return; 1548 1549 /* remove the buf from the hdr list */ 1550 for (bufp = &buf->b_hdr->b_buf; *bufp != buf; bufp = &(*bufp)->b_next) 1551 continue; 1552 *bufp = buf->b_next; 1553 buf->b_next = NULL; 1554 1555 ASSERT(buf->b_efunc == NULL); 1556 1557 /* clean up the buf */ 1558 buf->b_hdr = NULL; 1559 kmem_cache_free(buf_cache, buf); 1560 } 1561 1562 static void 1563 arc_hdr_destroy(arc_buf_hdr_t *hdr) 1564 { 1565 ASSERT(refcount_is_zero(&hdr->b_refcnt)); 1566 ASSERT3P(hdr->b_state, ==, arc_anon); 1567 ASSERT(!HDR_IO_IN_PROGRESS(hdr)); 1568 l2arc_buf_hdr_t *l2hdr = hdr->b_l2hdr; 1569 1570 if (l2hdr != NULL) { 1571 boolean_t buflist_held = MUTEX_HELD(&l2arc_buflist_mtx); 1572 /* 1573 * To prevent arc_free() and l2arc_evict() from 1574 * attempting to free the same buffer at the same time, 1575 * a FREE_IN_PROGRESS flag is given to arc_free() to 1576 * give it priority. l2arc_evict() can't destroy this 1577 * header while we are waiting on l2arc_buflist_mtx. 1578 * 1579 * The hdr may be removed from l2ad_buflist before we 1580 * grab l2arc_buflist_mtx, so b_l2hdr is rechecked. 1581 */ 1582 if (!buflist_held) { 1583 mutex_enter(&l2arc_buflist_mtx); 1584 l2hdr = hdr->b_l2hdr; 1585 } 1586 1587 if (l2hdr != NULL) { 1588 list_remove(l2hdr->b_dev->l2ad_buflist, hdr); 1589 ARCSTAT_INCR(arcstat_l2_size, -hdr->b_size); 1590 ARCSTAT_INCR(arcstat_l2_asize, -l2hdr->b_asize); 1591 kmem_free(l2hdr, sizeof (l2arc_buf_hdr_t)); 1592 if (hdr->b_state == arc_l2c_only) 1593 l2arc_hdr_stat_remove(); 1594 hdr->b_l2hdr = NULL; 1595 } 1596 1597 if (!buflist_held) 1598 mutex_exit(&l2arc_buflist_mtx); 1599 } 1600 1601 if (!BUF_EMPTY(hdr)) { 1602 ASSERT(!HDR_IN_HASH_TABLE(hdr)); 1603 buf_discard_identity(hdr); 1604 } 1605 while (hdr->b_buf) { 1606 arc_buf_t *buf = hdr->b_buf; 1607 1608 if (buf->b_efunc) { 1609 mutex_enter(&arc_eviction_mtx); 1610 mutex_enter(&buf->b_evict_lock); 1611 ASSERT(buf->b_hdr != NULL); 1612 arc_buf_destroy(hdr->b_buf, FALSE, FALSE); 1613 hdr->b_buf = buf->b_next; 1614 buf->b_hdr = &arc_eviction_hdr; 1615 buf->b_next = arc_eviction_list; 1616 arc_eviction_list = buf; 1617 mutex_exit(&buf->b_evict_lock); 1618 mutex_exit(&arc_eviction_mtx); 1619 } else { 1620 arc_buf_destroy(hdr->b_buf, FALSE, TRUE); 1621 } 1622 } 1623 if (hdr->b_freeze_cksum != NULL) { 1624 kmem_free(hdr->b_freeze_cksum, sizeof (zio_cksum_t)); 1625 hdr->b_freeze_cksum = NULL; 1626 } 1627 if (hdr->b_thawed) { 1628 kmem_free(hdr->b_thawed, 1); 1629 hdr->b_thawed = NULL; 1630 } 1631 1632 ASSERT(!list_link_active(&hdr->b_arc_node)); 1633 ASSERT3P(hdr->b_hash_next, ==, NULL); 1634 ASSERT3P(hdr->b_acb, ==, NULL); 1635 kmem_cache_free(hdr_cache, hdr); 1636 } 1637 1638 void 1639 arc_buf_free(arc_buf_t *buf, void *tag) 1640 { 1641 arc_buf_hdr_t *hdr = buf->b_hdr; 1642 int hashed = hdr->b_state != arc_anon; 1643 1644 ASSERT(buf->b_efunc == NULL); 1645 ASSERT(buf->b_data != NULL); 1646 1647 if (hashed) { 1648 kmutex_t *hash_lock = HDR_LOCK(hdr); 1649 1650 mutex_enter(hash_lock); 1651 hdr = buf->b_hdr; 1652 ASSERT3P(hash_lock, ==, HDR_LOCK(hdr)); 1653 1654 (void) remove_reference(hdr, hash_lock, tag); 1655 if (hdr->b_datacnt > 1) { 1656 arc_buf_destroy(buf, FALSE, TRUE); 1657 } else { 1658 ASSERT(buf == hdr->b_buf); 1659 ASSERT(buf->b_efunc == NULL); 1660 hdr->b_flags |= ARC_BUF_AVAILABLE; 1661 } 1662 mutex_exit(hash_lock); 1663 } else if (HDR_IO_IN_PROGRESS(hdr)) { 1664 int destroy_hdr; 1665 /* 1666 * We are in the middle of an async write. Don't destroy 1667 * this buffer unless the write completes before we finish 1668 * decrementing the reference count. 1669 */ 1670 mutex_enter(&arc_eviction_mtx); 1671 (void) remove_reference(hdr, NULL, tag); 1672 ASSERT(refcount_is_zero(&hdr->b_refcnt)); 1673 destroy_hdr = !HDR_IO_IN_PROGRESS(hdr); 1674 mutex_exit(&arc_eviction_mtx); 1675 if (destroy_hdr) 1676 arc_hdr_destroy(hdr); 1677 } else { 1678 if (remove_reference(hdr, NULL, tag) > 0) 1679 arc_buf_destroy(buf, FALSE, TRUE); 1680 else 1681 arc_hdr_destroy(hdr); 1682 } 1683 } 1684 1685 boolean_t 1686 arc_buf_remove_ref(arc_buf_t *buf, void* tag) 1687 { 1688 arc_buf_hdr_t *hdr = buf->b_hdr; 1689 kmutex_t *hash_lock = HDR_LOCK(hdr); 1690 boolean_t no_callback = (buf->b_efunc == NULL); 1691 1692 if (hdr->b_state == arc_anon) { 1693 ASSERT(hdr->b_datacnt == 1); 1694 arc_buf_free(buf, tag); 1695 return (no_callback); 1696 } 1697 1698 mutex_enter(hash_lock); 1699 hdr = buf->b_hdr; 1700 ASSERT3P(hash_lock, ==, HDR_LOCK(hdr)); 1701 ASSERT(hdr->b_state != arc_anon); 1702 ASSERT(buf->b_data != NULL); 1703 1704 (void) remove_reference(hdr, hash_lock, tag); 1705 if (hdr->b_datacnt > 1) { 1706 if (no_callback) 1707 arc_buf_destroy(buf, FALSE, TRUE); 1708 } else if (no_callback) { 1709 ASSERT(hdr->b_buf == buf && buf->b_next == NULL); 1710 ASSERT(buf->b_efunc == NULL); 1711 hdr->b_flags |= ARC_BUF_AVAILABLE; 1712 } 1713 ASSERT(no_callback || hdr->b_datacnt > 1 || 1714 refcount_is_zero(&hdr->b_refcnt)); 1715 mutex_exit(hash_lock); 1716 return (no_callback); 1717 } 1718 1719 int 1720 arc_buf_size(arc_buf_t *buf) 1721 { 1722 return (buf->b_hdr->b_size); 1723 } 1724 1725 /* 1726 * Called from the DMU to determine if the current buffer should be 1727 * evicted. In order to ensure proper locking, the eviction must be initiated 1728 * from the DMU. Return true if the buffer is associated with user data and 1729 * duplicate buffers still exist. 1730 */ 1731 boolean_t 1732 arc_buf_eviction_needed(arc_buf_t *buf) 1733 { 1734 arc_buf_hdr_t *hdr; 1735 boolean_t evict_needed = B_FALSE; 1736 1737 if (zfs_disable_dup_eviction) 1738 return (B_FALSE); 1739 1740 mutex_enter(&buf->b_evict_lock); 1741 hdr = buf->b_hdr; 1742 if (hdr == NULL) { 1743 /* 1744 * We are in arc_do_user_evicts(); let that function 1745 * perform the eviction. 1746 */ 1747 ASSERT(buf->b_data == NULL); 1748 mutex_exit(&buf->b_evict_lock); 1749 return (B_FALSE); 1750 } else if (buf->b_data == NULL) { 1751 /* 1752 * We have already been added to the arc eviction list; 1753 * recommend eviction. 1754 */ 1755 ASSERT3P(hdr, ==, &arc_eviction_hdr); 1756 mutex_exit(&buf->b_evict_lock); 1757 return (B_TRUE); 1758 } 1759 1760 if (hdr->b_datacnt > 1 && hdr->b_type == ARC_BUFC_DATA) 1761 evict_needed = B_TRUE; 1762 1763 mutex_exit(&buf->b_evict_lock); 1764 return (evict_needed); 1765 } 1766 1767 /* 1768 * Evict buffers from list until we've removed the specified number of 1769 * bytes. Move the removed buffers to the appropriate evict state. 1770 * If the recycle flag is set, then attempt to "recycle" a buffer: 1771 * - look for a buffer to evict that is `bytes' long. 1772 * - return the data block from this buffer rather than freeing it. 1773 * This flag is used by callers that are trying to make space for a 1774 * new buffer in a full arc cache. 1775 * 1776 * This function makes a "best effort". It skips over any buffers 1777 * it can't get a hash_lock on, and so may not catch all candidates. 1778 * It may also return without evicting as much space as requested. 1779 */ 1780 static void * 1781 arc_evict(arc_state_t *state, uint64_t spa, int64_t bytes, boolean_t recycle, 1782 arc_buf_contents_t type) 1783 { 1784 arc_state_t *evicted_state; 1785 uint64_t bytes_evicted = 0, skipped = 0, missed = 0; 1786 arc_buf_hdr_t *ab, *ab_prev = NULL; 1787 list_t *list = &state->arcs_list[type]; 1788 kmutex_t *hash_lock; 1789 boolean_t have_lock; 1790 void *stolen = NULL; 1791 arc_buf_hdr_t marker = { 0 }; 1792 int count = 0; 1793 1794 ASSERT(state == arc_mru || state == arc_mfu); 1795 1796 evicted_state = (state == arc_mru) ? arc_mru_ghost : arc_mfu_ghost; 1797 1798 mutex_enter(&state->arcs_mtx); 1799 mutex_enter(&evicted_state->arcs_mtx); 1800 1801 for (ab = list_tail(list); ab; ab = ab_prev) { 1802 ab_prev = list_prev(list, ab); 1803 /* prefetch buffers have a minimum lifespan */ 1804 if (HDR_IO_IN_PROGRESS(ab) || 1805 (spa && ab->b_spa != spa) || 1806 (ab->b_flags & (ARC_PREFETCH|ARC_INDIRECT) && 1807 ddi_get_lbolt() - ab->b_arc_access < 1808 arc_min_prefetch_lifespan)) { 1809 skipped++; 1810 continue; 1811 } 1812 /* "lookahead" for better eviction candidate */ 1813 if (recycle && ab->b_size != bytes && 1814 ab_prev && ab_prev->b_size == bytes) 1815 continue; 1816 1817 /* ignore markers */ 1818 if (ab->b_spa == 0) 1819 continue; 1820 1821 /* 1822 * It may take a long time to evict all the bufs requested. 1823 * To avoid blocking all arc activity, periodically drop 1824 * the arcs_mtx and give other threads a chance to run 1825 * before reacquiring the lock. 1826 * 1827 * If we are looking for a buffer to recycle, we are in 1828 * the hot code path, so don't sleep. 1829 */ 1830 if (!recycle && count++ > arc_evict_iterations) { 1831 list_insert_after(list, ab, &marker); 1832 mutex_exit(&evicted_state->arcs_mtx); 1833 mutex_exit(&state->arcs_mtx); 1834 kpreempt(KPREEMPT_SYNC); 1835 mutex_enter(&state->arcs_mtx); 1836 mutex_enter(&evicted_state->arcs_mtx); 1837 ab_prev = list_prev(list, &marker); 1838 list_remove(list, &marker); 1839 count = 0; 1840 continue; 1841 } 1842 1843 hash_lock = HDR_LOCK(ab); 1844 have_lock = MUTEX_HELD(hash_lock); 1845 if (have_lock || mutex_tryenter(hash_lock)) { 1846 ASSERT0(refcount_count(&ab->b_refcnt)); 1847 ASSERT(ab->b_datacnt > 0); 1848 while (ab->b_buf) { 1849 arc_buf_t *buf = ab->b_buf; 1850 if (!mutex_tryenter(&buf->b_evict_lock)) { 1851 missed += 1; 1852 break; 1853 } 1854 if (buf->b_data) { 1855 bytes_evicted += ab->b_size; 1856 if (recycle && ab->b_type == type && 1857 ab->b_size == bytes && 1858 !HDR_L2_WRITING(ab)) { 1859 stolen = buf->b_data; 1860 recycle = FALSE; 1861 } 1862 } 1863 if (buf->b_efunc) { 1864 mutex_enter(&arc_eviction_mtx); 1865 arc_buf_destroy(buf, 1866 buf->b_data == stolen, FALSE); 1867 ab->b_buf = buf->b_next; 1868 buf->b_hdr = &arc_eviction_hdr; 1869 buf->b_next = arc_eviction_list; 1870 arc_eviction_list = buf; 1871 mutex_exit(&arc_eviction_mtx); 1872 mutex_exit(&buf->b_evict_lock); 1873 } else { 1874 mutex_exit(&buf->b_evict_lock); 1875 arc_buf_destroy(buf, 1876 buf->b_data == stolen, TRUE); 1877 } 1878 } 1879 1880 if (ab->b_l2hdr) { 1881 ARCSTAT_INCR(arcstat_evict_l2_cached, 1882 ab->b_size); 1883 } else { 1884 if (l2arc_write_eligible(ab->b_spa, ab)) { 1885 ARCSTAT_INCR(arcstat_evict_l2_eligible, 1886 ab->b_size); 1887 } else { 1888 ARCSTAT_INCR( 1889 arcstat_evict_l2_ineligible, 1890 ab->b_size); 1891 } 1892 } 1893 1894 if (ab->b_datacnt == 0) { 1895 arc_change_state(evicted_state, ab, hash_lock); 1896 ASSERT(HDR_IN_HASH_TABLE(ab)); 1897 ab->b_flags |= ARC_IN_HASH_TABLE; 1898 ab->b_flags &= ~ARC_BUF_AVAILABLE; 1899 DTRACE_PROBE1(arc__evict, arc_buf_hdr_t *, ab); 1900 } 1901 if (!have_lock) 1902 mutex_exit(hash_lock); 1903 if (bytes >= 0 && bytes_evicted >= bytes) 1904 break; 1905 } else { 1906 missed += 1; 1907 } 1908 } 1909 1910 mutex_exit(&evicted_state->arcs_mtx); 1911 mutex_exit(&state->arcs_mtx); 1912 1913 if (bytes_evicted < bytes) 1914 dprintf("only evicted %lld bytes from %x", 1915 (longlong_t)bytes_evicted, state); 1916 1917 if (skipped) 1918 ARCSTAT_INCR(arcstat_evict_skip, skipped); 1919 1920 if (missed) 1921 ARCSTAT_INCR(arcstat_mutex_miss, missed); 1922 1923 /* 1924 * Note: we have just evicted some data into the ghost state, 1925 * potentially putting the ghost size over the desired size. Rather 1926 * that evicting from the ghost list in this hot code path, leave 1927 * this chore to the arc_reclaim_thread(). 1928 */ 1929 1930 return (stolen); 1931 } 1932 1933 /* 1934 * Remove buffers from list until we've removed the specified number of 1935 * bytes. Destroy the buffers that are removed. 1936 */ 1937 static void 1938 arc_evict_ghost(arc_state_t *state, uint64_t spa, int64_t bytes) 1939 { 1940 arc_buf_hdr_t *ab, *ab_prev; 1941 arc_buf_hdr_t marker = { 0 }; 1942 list_t *list = &state->arcs_list[ARC_BUFC_DATA]; 1943 kmutex_t *hash_lock; 1944 uint64_t bytes_deleted = 0; 1945 uint64_t bufs_skipped = 0; 1946 int count = 0; 1947 1948 ASSERT(GHOST_STATE(state)); 1949 top: 1950 mutex_enter(&state->arcs_mtx); 1951 for (ab = list_tail(list); ab; ab = ab_prev) { 1952 ab_prev = list_prev(list, ab); 1953 if (ab->b_type > ARC_BUFC_NUMTYPES) 1954 panic("invalid ab=%p", (void *)ab); 1955 if (spa && ab->b_spa != spa) 1956 continue; 1957 1958 /* ignore markers */ 1959 if (ab->b_spa == 0) 1960 continue; 1961 1962 hash_lock = HDR_LOCK(ab); 1963 /* caller may be trying to modify this buffer, skip it */ 1964 if (MUTEX_HELD(hash_lock)) 1965 continue; 1966 1967 /* 1968 * It may take a long time to evict all the bufs requested. 1969 * To avoid blocking all arc activity, periodically drop 1970 * the arcs_mtx and give other threads a chance to run 1971 * before reacquiring the lock. 1972 */ 1973 if (count++ > arc_evict_iterations) { 1974 list_insert_after(list, ab, &marker); 1975 mutex_exit(&state->arcs_mtx); 1976 kpreempt(KPREEMPT_SYNC); 1977 mutex_enter(&state->arcs_mtx); 1978 ab_prev = list_prev(list, &marker); 1979 list_remove(list, &marker); 1980 count = 0; 1981 continue; 1982 } 1983 if (mutex_tryenter(hash_lock)) { 1984 ASSERT(!HDR_IO_IN_PROGRESS(ab)); 1985 ASSERT(ab->b_buf == NULL); 1986 ARCSTAT_BUMP(arcstat_deleted); 1987 bytes_deleted += ab->b_size; 1988 1989 if (ab->b_l2hdr != NULL) { 1990 /* 1991 * This buffer is cached on the 2nd Level ARC; 1992 * don't destroy the header. 1993 */ 1994 arc_change_state(arc_l2c_only, ab, hash_lock); 1995 mutex_exit(hash_lock); 1996 } else { 1997 arc_change_state(arc_anon, ab, hash_lock); 1998 mutex_exit(hash_lock); 1999 arc_hdr_destroy(ab); 2000 } 2001 2002 DTRACE_PROBE1(arc__delete, arc_buf_hdr_t *, ab); 2003 if (bytes >= 0 && bytes_deleted >= bytes) 2004 break; 2005 } else if (bytes < 0) { 2006 /* 2007 * Insert a list marker and then wait for the 2008 * hash lock to become available. Once its 2009 * available, restart from where we left off. 2010 */ 2011 list_insert_after(list, ab, &marker); 2012 mutex_exit(&state->arcs_mtx); 2013 mutex_enter(hash_lock); 2014 mutex_exit(hash_lock); 2015 mutex_enter(&state->arcs_mtx); 2016 ab_prev = list_prev(list, &marker); 2017 list_remove(list, &marker); 2018 } else { 2019 bufs_skipped += 1; 2020 } 2021 2022 } 2023 mutex_exit(&state->arcs_mtx); 2024 2025 if (list == &state->arcs_list[ARC_BUFC_DATA] && 2026 (bytes < 0 || bytes_deleted < bytes)) { 2027 list = &state->arcs_list[ARC_BUFC_METADATA]; 2028 goto top; 2029 } 2030 2031 if (bufs_skipped) { 2032 ARCSTAT_INCR(arcstat_mutex_miss, bufs_skipped); 2033 ASSERT(bytes >= 0); 2034 } 2035 2036 if (bytes_deleted < bytes) 2037 dprintf("only deleted %lld bytes from %p", 2038 (longlong_t)bytes_deleted, state); 2039 } 2040 2041 static void 2042 arc_adjust(void) 2043 { 2044 int64_t adjustment, delta; 2045 2046 /* 2047 * Adjust MRU size 2048 */ 2049 2050 adjustment = MIN((int64_t)(arc_size - arc_c), 2051 (int64_t)(arc_anon->arcs_size + arc_mru->arcs_size + arc_meta_used - 2052 arc_p)); 2053 2054 if (adjustment > 0 && arc_mru->arcs_lsize[ARC_BUFC_DATA] > 0) { 2055 delta = MIN(arc_mru->arcs_lsize[ARC_BUFC_DATA], adjustment); 2056 (void) arc_evict(arc_mru, NULL, delta, FALSE, ARC_BUFC_DATA); 2057 adjustment -= delta; 2058 } 2059 2060 if (adjustment > 0 && arc_mru->arcs_lsize[ARC_BUFC_METADATA] > 0) { 2061 delta = MIN(arc_mru->arcs_lsize[ARC_BUFC_METADATA], adjustment); 2062 (void) arc_evict(arc_mru, NULL, delta, FALSE, 2063 ARC_BUFC_METADATA); 2064 } 2065 2066 /* 2067 * Adjust MFU size 2068 */ 2069 2070 adjustment = arc_size - arc_c; 2071 2072 if (adjustment > 0 && arc_mfu->arcs_lsize[ARC_BUFC_DATA] > 0) { 2073 delta = MIN(adjustment, arc_mfu->arcs_lsize[ARC_BUFC_DATA]); 2074 (void) arc_evict(arc_mfu, NULL, delta, FALSE, ARC_BUFC_DATA); 2075 adjustment -= delta; 2076 } 2077 2078 if (adjustment > 0 && arc_mfu->arcs_lsize[ARC_BUFC_METADATA] > 0) { 2079 int64_t delta = MIN(adjustment, 2080 arc_mfu->arcs_lsize[ARC_BUFC_METADATA]); 2081 (void) arc_evict(arc_mfu, NULL, delta, FALSE, 2082 ARC_BUFC_METADATA); 2083 } 2084 2085 /* 2086 * Adjust ghost lists 2087 */ 2088 2089 adjustment = arc_mru->arcs_size + arc_mru_ghost->arcs_size - arc_c; 2090 2091 if (adjustment > 0 && arc_mru_ghost->arcs_size > 0) { 2092 delta = MIN(arc_mru_ghost->arcs_size, adjustment); 2093 arc_evict_ghost(arc_mru_ghost, NULL, delta); 2094 } 2095 2096 adjustment = 2097 arc_mru_ghost->arcs_size + arc_mfu_ghost->arcs_size - arc_c; 2098 2099 if (adjustment > 0 && arc_mfu_ghost->arcs_size > 0) { 2100 delta = MIN(arc_mfu_ghost->arcs_size, adjustment); 2101 arc_evict_ghost(arc_mfu_ghost, NULL, delta); 2102 } 2103 } 2104 2105 static void 2106 arc_do_user_evicts(void) 2107 { 2108 mutex_enter(&arc_eviction_mtx); 2109 while (arc_eviction_list != NULL) { 2110 arc_buf_t *buf = arc_eviction_list; 2111 arc_eviction_list = buf->b_next; 2112 mutex_enter(&buf->b_evict_lock); 2113 buf->b_hdr = NULL; 2114 mutex_exit(&buf->b_evict_lock); 2115 mutex_exit(&arc_eviction_mtx); 2116 2117 if (buf->b_efunc != NULL) 2118 VERIFY(buf->b_efunc(buf) == 0); 2119 2120 buf->b_efunc = NULL; 2121 buf->b_private = NULL; 2122 kmem_cache_free(buf_cache, buf); 2123 mutex_enter(&arc_eviction_mtx); 2124 } 2125 mutex_exit(&arc_eviction_mtx); 2126 } 2127 2128 /* 2129 * Flush all *evictable* data from the cache for the given spa. 2130 * NOTE: this will not touch "active" (i.e. referenced) data. 2131 */ 2132 void 2133 arc_flush(spa_t *spa) 2134 { 2135 uint64_t guid = 0; 2136 2137 if (spa) 2138 guid = spa_load_guid(spa); 2139 2140 while (list_head(&arc_mru->arcs_list[ARC_BUFC_DATA])) { 2141 (void) arc_evict(arc_mru, guid, -1, FALSE, ARC_BUFC_DATA); 2142 if (spa) 2143 break; 2144 } 2145 while (list_head(&arc_mru->arcs_list[ARC_BUFC_METADATA])) { 2146 (void) arc_evict(arc_mru, guid, -1, FALSE, ARC_BUFC_METADATA); 2147 if (spa) 2148 break; 2149 } 2150 while (list_head(&arc_mfu->arcs_list[ARC_BUFC_DATA])) { 2151 (void) arc_evict(arc_mfu, guid, -1, FALSE, ARC_BUFC_DATA); 2152 if (spa) 2153 break; 2154 } 2155 while (list_head(&arc_mfu->arcs_list[ARC_BUFC_METADATA])) { 2156 (void) arc_evict(arc_mfu, guid, -1, FALSE, ARC_BUFC_METADATA); 2157 if (spa) 2158 break; 2159 } 2160 2161 arc_evict_ghost(arc_mru_ghost, guid, -1); 2162 arc_evict_ghost(arc_mfu_ghost, guid, -1); 2163 2164 mutex_enter(&arc_reclaim_thr_lock); 2165 arc_do_user_evicts(); 2166 mutex_exit(&arc_reclaim_thr_lock); 2167 ASSERT(spa || arc_eviction_list == NULL); 2168 } 2169 2170 void 2171 arc_shrink(void) 2172 { 2173 if (arc_c > arc_c_min) { 2174 uint64_t to_free; 2175 2176 #ifdef _KERNEL 2177 to_free = MAX(arc_c >> arc_shrink_shift, ptob(needfree)); 2178 #else 2179 to_free = arc_c >> arc_shrink_shift; 2180 #endif 2181 if (arc_c > arc_c_min + to_free) 2182 atomic_add_64(&arc_c, -to_free); 2183 else 2184 arc_c = arc_c_min; 2185 2186 atomic_add_64(&arc_p, -(arc_p >> arc_shrink_shift)); 2187 if (arc_c > arc_size) 2188 arc_c = MAX(arc_size, arc_c_min); 2189 if (arc_p > arc_c) 2190 arc_p = (arc_c >> 1); 2191 ASSERT(arc_c >= arc_c_min); 2192 ASSERT((int64_t)arc_p >= 0); 2193 } 2194 2195 if (arc_size > arc_c) 2196 arc_adjust(); 2197 } 2198 2199 /* 2200 * Determine if the system is under memory pressure and is asking 2201 * to reclaim memory. A return value of 1 indicates that the system 2202 * is under memory pressure and that the arc should adjust accordingly. 2203 */ 2204 static int 2205 arc_reclaim_needed(void) 2206 { 2207 uint64_t extra; 2208 2209 #ifdef _KERNEL 2210 2211 if (needfree) 2212 return (1); 2213 2214 /* 2215 * take 'desfree' extra pages, so we reclaim sooner, rather than later 2216 */ 2217 extra = desfree; 2218 2219 /* 2220 * check that we're out of range of the pageout scanner. It starts to 2221 * schedule paging if freemem is less than lotsfree and needfree. 2222 * lotsfree is the high-water mark for pageout, and needfree is the 2223 * number of needed free pages. We add extra pages here to make sure 2224 * the scanner doesn't start up while we're freeing memory. 2225 */ 2226 if (freemem < lotsfree + needfree + extra) 2227 return (1); 2228 2229 /* 2230 * check to make sure that swapfs has enough space so that anon 2231 * reservations can still succeed. anon_resvmem() checks that the 2232 * availrmem is greater than swapfs_minfree, and the number of reserved 2233 * swap pages. We also add a bit of extra here just to prevent 2234 * circumstances from getting really dire. 2235 */ 2236 if (availrmem < swapfs_minfree + swapfs_reserve + extra) 2237 return (1); 2238 2239 /* 2240 * Check that we have enough availrmem that memory locking (e.g., via 2241 * mlock(3C) or memcntl(2)) can still succeed. (pages_pp_maximum 2242 * stores the number of pages that cannot be locked; when availrmem 2243 * drops below pages_pp_maximum, page locking mechanisms such as 2244 * page_pp_lock() will fail.) 2245 */ 2246 if (availrmem <= pages_pp_maximum) 2247 return (1); 2248 2249 #if defined(__i386) 2250 /* 2251 * If we're on an i386 platform, it's possible that we'll exhaust the 2252 * kernel heap space before we ever run out of available physical 2253 * memory. Most checks of the size of the heap_area compare against 2254 * tune.t_minarmem, which is the minimum available real memory that we 2255 * can have in the system. However, this is generally fixed at 25 pages 2256 * which is so low that it's useless. In this comparison, we seek to 2257 * calculate the total heap-size, and reclaim if more than 3/4ths of the 2258 * heap is allocated. (Or, in the calculation, if less than 1/4th is 2259 * free) 2260 */ 2261 if (vmem_size(heap_arena, VMEM_FREE) < 2262 (vmem_size(heap_arena, VMEM_FREE | VMEM_ALLOC) >> 2)) 2263 return (1); 2264 #endif 2265 2266 /* 2267 * If zio data pages are being allocated out of a separate heap segment, 2268 * then enforce that the size of available vmem for this arena remains 2269 * above about 1/16th free. 2270 * 2271 * Note: The 1/16th arena free requirement was put in place 2272 * to aggressively evict memory from the arc in order to avoid 2273 * memory fragmentation issues. 2274 */ 2275 if (zio_arena != NULL && 2276 vmem_size(zio_arena, VMEM_FREE) < 2277 (vmem_size(zio_arena, VMEM_ALLOC) >> 4)) 2278 return (1); 2279 #else 2280 if (spa_get_random(100) == 0) 2281 return (1); 2282 #endif 2283 return (0); 2284 } 2285 2286 static void 2287 arc_kmem_reap_now(arc_reclaim_strategy_t strat) 2288 { 2289 size_t i; 2290 kmem_cache_t *prev_cache = NULL; 2291 kmem_cache_t *prev_data_cache = NULL; 2292 extern kmem_cache_t *zio_buf_cache[]; 2293 extern kmem_cache_t *zio_data_buf_cache[]; 2294 2295 #ifdef _KERNEL 2296 if (arc_meta_used >= arc_meta_limit) { 2297 /* 2298 * We are exceeding our meta-data cache limit. 2299 * Purge some DNLC entries to release holds on meta-data. 2300 */ 2301 dnlc_reduce_cache((void *)(uintptr_t)arc_reduce_dnlc_percent); 2302 } 2303 #if defined(__i386) 2304 /* 2305 * Reclaim unused memory from all kmem caches. 2306 */ 2307 kmem_reap(); 2308 #endif 2309 #endif 2310 2311 /* 2312 * An aggressive reclamation will shrink the cache size as well as 2313 * reap free buffers from the arc kmem caches. 2314 */ 2315 if (strat == ARC_RECLAIM_AGGR) 2316 arc_shrink(); 2317 2318 for (i = 0; i < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT; i++) { 2319 if (zio_buf_cache[i] != prev_cache) { 2320 prev_cache = zio_buf_cache[i]; 2321 kmem_cache_reap_now(zio_buf_cache[i]); 2322 } 2323 if (zio_data_buf_cache[i] != prev_data_cache) { 2324 prev_data_cache = zio_data_buf_cache[i]; 2325 kmem_cache_reap_now(zio_data_buf_cache[i]); 2326 } 2327 } 2328 kmem_cache_reap_now(buf_cache); 2329 kmem_cache_reap_now(hdr_cache); 2330 2331 /* 2332 * Ask the vmem areana to reclaim unused memory from its 2333 * quantum caches. 2334 */ 2335 if (zio_arena != NULL && strat == ARC_RECLAIM_AGGR) 2336 vmem_qcache_reap(zio_arena); 2337 } 2338 2339 static void 2340 arc_reclaim_thread(void) 2341 { 2342 clock_t growtime = 0; 2343 arc_reclaim_strategy_t last_reclaim = ARC_RECLAIM_CONS; 2344 callb_cpr_t cpr; 2345 2346 CALLB_CPR_INIT(&cpr, &arc_reclaim_thr_lock, callb_generic_cpr, FTAG); 2347 2348 mutex_enter(&arc_reclaim_thr_lock); 2349 while (arc_thread_exit == 0) { 2350 if (arc_reclaim_needed()) { 2351 2352 if (arc_no_grow) { 2353 if (last_reclaim == ARC_RECLAIM_CONS) { 2354 last_reclaim = ARC_RECLAIM_AGGR; 2355 } else { 2356 last_reclaim = ARC_RECLAIM_CONS; 2357 } 2358 } else { 2359 arc_no_grow = TRUE; 2360 last_reclaim = ARC_RECLAIM_AGGR; 2361 membar_producer(); 2362 } 2363 2364 /* reset the growth delay for every reclaim */ 2365 growtime = ddi_get_lbolt() + (arc_grow_retry * hz); 2366 2367 arc_kmem_reap_now(last_reclaim); 2368 arc_warm = B_TRUE; 2369 2370 } else if (arc_no_grow && ddi_get_lbolt() >= growtime) { 2371 arc_no_grow = FALSE; 2372 } 2373 2374 arc_adjust(); 2375 2376 if (arc_eviction_list != NULL) 2377 arc_do_user_evicts(); 2378 2379 /* block until needed, or one second, whichever is shorter */ 2380 CALLB_CPR_SAFE_BEGIN(&cpr); 2381 (void) cv_timedwait(&arc_reclaim_thr_cv, 2382 &arc_reclaim_thr_lock, (ddi_get_lbolt() + hz)); 2383 CALLB_CPR_SAFE_END(&cpr, &arc_reclaim_thr_lock); 2384 } 2385 2386 arc_thread_exit = 0; 2387 cv_broadcast(&arc_reclaim_thr_cv); 2388 CALLB_CPR_EXIT(&cpr); /* drops arc_reclaim_thr_lock */ 2389 thread_exit(); 2390 } 2391 2392 /* 2393 * Adapt arc info given the number of bytes we are trying to add and 2394 * the state that we are comming from. This function is only called 2395 * when we are adding new content to the cache. 2396 */ 2397 static void 2398 arc_adapt(int bytes, arc_state_t *state) 2399 { 2400 int mult; 2401 uint64_t arc_p_min = (arc_c >> arc_p_min_shift); 2402 2403 if (state == arc_l2c_only) 2404 return; 2405 2406 ASSERT(bytes > 0); 2407 /* 2408 * Adapt the target size of the MRU list: 2409 * - if we just hit in the MRU ghost list, then increase 2410 * the target size of the MRU list. 2411 * - if we just hit in the MFU ghost list, then increase 2412 * the target size of the MFU list by decreasing the 2413 * target size of the MRU list. 2414 */ 2415 if (state == arc_mru_ghost) { 2416 mult = ((arc_mru_ghost->arcs_size >= arc_mfu_ghost->arcs_size) ? 2417 1 : (arc_mfu_ghost->arcs_size/arc_mru_ghost->arcs_size)); 2418 mult = MIN(mult, 10); /* avoid wild arc_p adjustment */ 2419 2420 arc_p = MIN(arc_c - arc_p_min, arc_p + bytes * mult); 2421 } else if (state == arc_mfu_ghost) { 2422 uint64_t delta; 2423 2424 mult = ((arc_mfu_ghost->arcs_size >= arc_mru_ghost->arcs_size) ? 2425 1 : (arc_mru_ghost->arcs_size/arc_mfu_ghost->arcs_size)); 2426 mult = MIN(mult, 10); 2427 2428 delta = MIN(bytes * mult, arc_p); 2429 arc_p = MAX(arc_p_min, arc_p - delta); 2430 } 2431 ASSERT((int64_t)arc_p >= 0); 2432 2433 if (arc_reclaim_needed()) { 2434 cv_signal(&arc_reclaim_thr_cv); 2435 return; 2436 } 2437 2438 if (arc_no_grow) 2439 return; 2440 2441 if (arc_c >= arc_c_max) 2442 return; 2443 2444 /* 2445 * If we're within (2 * maxblocksize) bytes of the target 2446 * cache size, increment the target cache size 2447 */ 2448 if (arc_size > arc_c - (2ULL << SPA_MAXBLOCKSHIFT)) { 2449 atomic_add_64(&arc_c, (int64_t)bytes); 2450 if (arc_c > arc_c_max) 2451 arc_c = arc_c_max; 2452 else if (state == arc_anon) 2453 atomic_add_64(&arc_p, (int64_t)bytes); 2454 if (arc_p > arc_c) 2455 arc_p = arc_c; 2456 } 2457 ASSERT((int64_t)arc_p >= 0); 2458 } 2459 2460 /* 2461 * Check if the cache has reached its limits and eviction is required 2462 * prior to insert. 2463 */ 2464 static int 2465 arc_evict_needed(arc_buf_contents_t type) 2466 { 2467 if (type == ARC_BUFC_METADATA && arc_meta_used >= arc_meta_limit) 2468 return (1); 2469 2470 if (arc_reclaim_needed()) 2471 return (1); 2472 2473 return (arc_size > arc_c); 2474 } 2475 2476 /* 2477 * The buffer, supplied as the first argument, needs a data block. 2478 * So, if we are at cache max, determine which cache should be victimized. 2479 * We have the following cases: 2480 * 2481 * 1. Insert for MRU, p > sizeof(arc_anon + arc_mru) -> 2482 * In this situation if we're out of space, but the resident size of the MFU is 2483 * under the limit, victimize the MFU cache to satisfy this insertion request. 2484 * 2485 * 2. Insert for MRU, p <= sizeof(arc_anon + arc_mru) -> 2486 * Here, we've used up all of the available space for the MRU, so we need to 2487 * evict from our own cache instead. Evict from the set of resident MRU 2488 * entries. 2489 * 2490 * 3. Insert for MFU (c - p) > sizeof(arc_mfu) -> 2491 * c minus p represents the MFU space in the cache, since p is the size of the 2492 * cache that is dedicated to the MRU. In this situation there's still space on 2493 * the MFU side, so the MRU side needs to be victimized. 2494 * 2495 * 4. Insert for MFU (c - p) < sizeof(arc_mfu) -> 2496 * MFU's resident set is consuming more space than it has been allotted. In 2497 * this situation, we must victimize our own cache, the MFU, for this insertion. 2498 */ 2499 static void 2500 arc_get_data_buf(arc_buf_t *buf) 2501 { 2502 arc_state_t *state = buf->b_hdr->b_state; 2503 uint64_t size = buf->b_hdr->b_size; 2504 arc_buf_contents_t type = buf->b_hdr->b_type; 2505 2506 arc_adapt(size, state); 2507 2508 /* 2509 * We have not yet reached cache maximum size, 2510 * just allocate a new buffer. 2511 */ 2512 if (!arc_evict_needed(type)) { 2513 if (type == ARC_BUFC_METADATA) { 2514 buf->b_data = zio_buf_alloc(size); 2515 arc_space_consume(size, ARC_SPACE_DATA); 2516 } else { 2517 ASSERT(type == ARC_BUFC_DATA); 2518 buf->b_data = zio_data_buf_alloc(size); 2519 ARCSTAT_INCR(arcstat_data_size, size); 2520 atomic_add_64(&arc_size, size); 2521 } 2522 goto out; 2523 } 2524 2525 /* 2526 * If we are prefetching from the mfu ghost list, this buffer 2527 * will end up on the mru list; so steal space from there. 2528 */ 2529 if (state == arc_mfu_ghost) 2530 state = buf->b_hdr->b_flags & ARC_PREFETCH ? arc_mru : arc_mfu; 2531 else if (state == arc_mru_ghost) 2532 state = arc_mru; 2533 2534 if (state == arc_mru || state == arc_anon) { 2535 uint64_t mru_used = arc_anon->arcs_size + arc_mru->arcs_size; 2536 state = (arc_mfu->arcs_lsize[type] >= size && 2537 arc_p > mru_used) ? arc_mfu : arc_mru; 2538 } else { 2539 /* MFU cases */ 2540 uint64_t mfu_space = arc_c - arc_p; 2541 state = (arc_mru->arcs_lsize[type] >= size && 2542 mfu_space > arc_mfu->arcs_size) ? arc_mru : arc_mfu; 2543 } 2544 if ((buf->b_data = arc_evict(state, NULL, size, TRUE, type)) == NULL) { 2545 if (type == ARC_BUFC_METADATA) { 2546 buf->b_data = zio_buf_alloc(size); 2547 arc_space_consume(size, ARC_SPACE_DATA); 2548 } else { 2549 ASSERT(type == ARC_BUFC_DATA); 2550 buf->b_data = zio_data_buf_alloc(size); 2551 ARCSTAT_INCR(arcstat_data_size, size); 2552 atomic_add_64(&arc_size, size); 2553 } 2554 ARCSTAT_BUMP(arcstat_recycle_miss); 2555 } 2556 ASSERT(buf->b_data != NULL); 2557 out: 2558 /* 2559 * Update the state size. Note that ghost states have a 2560 * "ghost size" and so don't need to be updated. 2561 */ 2562 if (!GHOST_STATE(buf->b_hdr->b_state)) { 2563 arc_buf_hdr_t *hdr = buf->b_hdr; 2564 2565 atomic_add_64(&hdr->b_state->arcs_size, size); 2566 if (list_link_active(&hdr->b_arc_node)) { 2567 ASSERT(refcount_is_zero(&hdr->b_refcnt)); 2568 atomic_add_64(&hdr->b_state->arcs_lsize[type], size); 2569 } 2570 /* 2571 * If we are growing the cache, and we are adding anonymous 2572 * data, and we have outgrown arc_p, update arc_p 2573 */ 2574 if (arc_size < arc_c && hdr->b_state == arc_anon && 2575 arc_anon->arcs_size + arc_mru->arcs_size > arc_p) 2576 arc_p = MIN(arc_c, arc_p + size); 2577 } 2578 } 2579 2580 /* 2581 * This routine is called whenever a buffer is accessed. 2582 * NOTE: the hash lock is dropped in this function. 2583 */ 2584 static void 2585 arc_access(arc_buf_hdr_t *buf, kmutex_t *hash_lock) 2586 { 2587 clock_t now; 2588 2589 ASSERT(MUTEX_HELD(hash_lock)); 2590 2591 if (buf->b_state == arc_anon) { 2592 /* 2593 * This buffer is not in the cache, and does not 2594 * appear in our "ghost" list. Add the new buffer 2595 * to the MRU state. 2596 */ 2597 2598 ASSERT(buf->b_arc_access == 0); 2599 buf->b_arc_access = ddi_get_lbolt(); 2600 DTRACE_PROBE1(new_state__mru, arc_buf_hdr_t *, buf); 2601 arc_change_state(arc_mru, buf, hash_lock); 2602 2603 } else if (buf->b_state == arc_mru) { 2604 now = ddi_get_lbolt(); 2605 2606 /* 2607 * If this buffer is here because of a prefetch, then either: 2608 * - clear the flag if this is a "referencing" read 2609 * (any subsequent access will bump this into the MFU state). 2610 * or 2611 * - move the buffer to the head of the list if this is 2612 * another prefetch (to make it less likely to be evicted). 2613 */ 2614 if ((buf->b_flags & ARC_PREFETCH) != 0) { 2615 if (refcount_count(&buf->b_refcnt) == 0) { 2616 ASSERT(list_link_active(&buf->b_arc_node)); 2617 } else { 2618 buf->b_flags &= ~ARC_PREFETCH; 2619 ARCSTAT_BUMP(arcstat_mru_hits); 2620 } 2621 buf->b_arc_access = now; 2622 return; 2623 } 2624 2625 /* 2626 * This buffer has been "accessed" only once so far, 2627 * but it is still in the cache. Move it to the MFU 2628 * state. 2629 */ 2630 if (now > buf->b_arc_access + ARC_MINTIME) { 2631 /* 2632 * More than 125ms have passed since we 2633 * instantiated this buffer. Move it to the 2634 * most frequently used state. 2635 */ 2636 buf->b_arc_access = now; 2637 DTRACE_PROBE1(new_state__mfu, arc_buf_hdr_t *, buf); 2638 arc_change_state(arc_mfu, buf, hash_lock); 2639 } 2640 ARCSTAT_BUMP(arcstat_mru_hits); 2641 } else if (buf->b_state == arc_mru_ghost) { 2642 arc_state_t *new_state; 2643 /* 2644 * This buffer has been "accessed" recently, but 2645 * was evicted from the cache. Move it to the 2646 * MFU state. 2647 */ 2648 2649 if (buf->b_flags & ARC_PREFETCH) { 2650 new_state = arc_mru; 2651 if (refcount_count(&buf->b_refcnt) > 0) 2652 buf->b_flags &= ~ARC_PREFETCH; 2653 DTRACE_PROBE1(new_state__mru, arc_buf_hdr_t *, buf); 2654 } else { 2655 new_state = arc_mfu; 2656 DTRACE_PROBE1(new_state__mfu, arc_buf_hdr_t *, buf); 2657 } 2658 2659 buf->b_arc_access = ddi_get_lbolt(); 2660 arc_change_state(new_state, buf, hash_lock); 2661 2662 ARCSTAT_BUMP(arcstat_mru_ghost_hits); 2663 } else if (buf->b_state == arc_mfu) { 2664 /* 2665 * This buffer has been accessed more than once and is 2666 * still in the cache. Keep it in the MFU state. 2667 * 2668 * NOTE: an add_reference() that occurred when we did 2669 * the arc_read() will have kicked this off the list. 2670 * If it was a prefetch, we will explicitly move it to 2671 * the head of the list now. 2672 */ 2673 if ((buf->b_flags & ARC_PREFETCH) != 0) { 2674 ASSERT(refcount_count(&buf->b_refcnt) == 0); 2675 ASSERT(list_link_active(&buf->b_arc_node)); 2676 } 2677 ARCSTAT_BUMP(arcstat_mfu_hits); 2678 buf->b_arc_access = ddi_get_lbolt(); 2679 } else if (buf->b_state == arc_mfu_ghost) { 2680 arc_state_t *new_state = arc_mfu; 2681 /* 2682 * This buffer has been accessed more than once but has 2683 * been evicted from the cache. Move it back to the 2684 * MFU state. 2685 */ 2686 2687 if (buf->b_flags & ARC_PREFETCH) { 2688 /* 2689 * This is a prefetch access... 2690 * move this block back to the MRU state. 2691 */ 2692 ASSERT0(refcount_count(&buf->b_refcnt)); 2693 new_state = arc_mru; 2694 } 2695 2696 buf->b_arc_access = ddi_get_lbolt(); 2697 DTRACE_PROBE1(new_state__mfu, arc_buf_hdr_t *, buf); 2698 arc_change_state(new_state, buf, hash_lock); 2699 2700 ARCSTAT_BUMP(arcstat_mfu_ghost_hits); 2701 } else if (buf->b_state == arc_l2c_only) { 2702 /* 2703 * This buffer is on the 2nd Level ARC. 2704 */ 2705 2706 buf->b_arc_access = ddi_get_lbolt(); 2707 DTRACE_PROBE1(new_state__mfu, arc_buf_hdr_t *, buf); 2708 arc_change_state(arc_mfu, buf, hash_lock); 2709 } else { 2710 ASSERT(!"invalid arc state"); 2711 } 2712 } 2713 2714 /* a generic arc_done_func_t which you can use */ 2715 /* ARGSUSED */ 2716 void 2717 arc_bcopy_func(zio_t *zio, arc_buf_t *buf, void *arg) 2718 { 2719 if (zio == NULL || zio->io_error == 0) 2720 bcopy(buf->b_data, arg, buf->b_hdr->b_size); 2721 VERIFY(arc_buf_remove_ref(buf, arg)); 2722 } 2723 2724 /* a generic arc_done_func_t */ 2725 void 2726 arc_getbuf_func(zio_t *zio, arc_buf_t *buf, void *arg) 2727 { 2728 arc_buf_t **bufp = arg; 2729 if (zio && zio->io_error) { 2730 VERIFY(arc_buf_remove_ref(buf, arg)); 2731 *bufp = NULL; 2732 } else { 2733 *bufp = buf; 2734 ASSERT(buf->b_data); 2735 } 2736 } 2737 2738 static void 2739 arc_read_done(zio_t *zio) 2740 { 2741 arc_buf_hdr_t *hdr, *found; 2742 arc_buf_t *buf; 2743 arc_buf_t *abuf; /* buffer we're assigning to callback */ 2744 kmutex_t *hash_lock; 2745 arc_callback_t *callback_list, *acb; 2746 int freeable = FALSE; 2747 2748 buf = zio->io_private; 2749 hdr = buf->b_hdr; 2750 2751 /* 2752 * The hdr was inserted into hash-table and removed from lists 2753 * prior to starting I/O. We should find this header, since 2754 * it's in the hash table, and it should be legit since it's 2755 * not possible to evict it during the I/O. The only possible 2756 * reason for it not to be found is if we were freed during the 2757 * read. 2758 */ 2759 found = buf_hash_find(hdr->b_spa, &hdr->b_dva, hdr->b_birth, 2760 &hash_lock); 2761 2762 ASSERT((found == NULL && HDR_FREED_IN_READ(hdr) && hash_lock == NULL) || 2763 (found == hdr && DVA_EQUAL(&hdr->b_dva, BP_IDENTITY(zio->io_bp))) || 2764 (found == hdr && HDR_L2_READING(hdr))); 2765 2766 hdr->b_flags &= ~ARC_L2_EVICTED; 2767 if (l2arc_noprefetch && (hdr->b_flags & ARC_PREFETCH)) 2768 hdr->b_flags &= ~ARC_L2CACHE; 2769 2770 /* byteswap if necessary */ 2771 callback_list = hdr->b_acb; 2772 ASSERT(callback_list != NULL); 2773 if (BP_SHOULD_BYTESWAP(zio->io_bp) && zio->io_error == 0) { 2774 dmu_object_byteswap_t bswap = 2775 DMU_OT_BYTESWAP(BP_GET_TYPE(zio->io_bp)); 2776 arc_byteswap_func_t *func = BP_GET_LEVEL(zio->io_bp) > 0 ? 2777 byteswap_uint64_array : 2778 dmu_ot_byteswap[bswap].ob_func; 2779 func(buf->b_data, hdr->b_size); 2780 } 2781 2782 arc_cksum_compute(buf, B_FALSE); 2783 arc_buf_watch(buf); 2784 2785 if (hash_lock && zio->io_error == 0 && hdr->b_state == arc_anon) { 2786 /* 2787 * Only call arc_access on anonymous buffers. This is because 2788 * if we've issued an I/O for an evicted buffer, we've already 2789 * called arc_access (to prevent any simultaneous readers from 2790 * getting confused). 2791 */ 2792 arc_access(hdr, hash_lock); 2793 } 2794 2795 /* create copies of the data buffer for the callers */ 2796 abuf = buf; 2797 for (acb = callback_list; acb; acb = acb->acb_next) { 2798 if (acb->acb_done) { 2799 if (abuf == NULL) { 2800 ARCSTAT_BUMP(arcstat_duplicate_reads); 2801 abuf = arc_buf_clone(buf); 2802 } 2803 acb->acb_buf = abuf; 2804 abuf = NULL; 2805 } 2806 } 2807 hdr->b_acb = NULL; 2808 hdr->b_flags &= ~ARC_IO_IN_PROGRESS; 2809 ASSERT(!HDR_BUF_AVAILABLE(hdr)); 2810 if (abuf == buf) { 2811 ASSERT(buf->b_efunc == NULL); 2812 ASSERT(hdr->b_datacnt == 1); 2813 hdr->b_flags |= ARC_BUF_AVAILABLE; 2814 } 2815 2816 ASSERT(refcount_is_zero(&hdr->b_refcnt) || callback_list != NULL); 2817 2818 if (zio->io_error != 0) { 2819 hdr->b_flags |= ARC_IO_ERROR; 2820 if (hdr->b_state != arc_anon) 2821 arc_change_state(arc_anon, hdr, hash_lock); 2822 if (HDR_IN_HASH_TABLE(hdr)) 2823 buf_hash_remove(hdr); 2824 freeable = refcount_is_zero(&hdr->b_refcnt); 2825 } 2826 2827 /* 2828 * Broadcast before we drop the hash_lock to avoid the possibility 2829 * that the hdr (and hence the cv) might be freed before we get to 2830 * the cv_broadcast(). 2831 */ 2832 cv_broadcast(&hdr->b_cv); 2833 2834 if (hash_lock) { 2835 mutex_exit(hash_lock); 2836 } else { 2837 /* 2838 * This block was freed while we waited for the read to 2839 * complete. It has been removed from the hash table and 2840 * moved to the anonymous state (so that it won't show up 2841 * in the cache). 2842 */ 2843 ASSERT3P(hdr->b_state, ==, arc_anon); 2844 freeable = refcount_is_zero(&hdr->b_refcnt); 2845 } 2846 2847 /* execute each callback and free its structure */ 2848 while ((acb = callback_list) != NULL) { 2849 if (acb->acb_done) 2850 acb->acb_done(zio, acb->acb_buf, acb->acb_private); 2851 2852 if (acb->acb_zio_dummy != NULL) { 2853 acb->acb_zio_dummy->io_error = zio->io_error; 2854 zio_nowait(acb->acb_zio_dummy); 2855 } 2856 2857 callback_list = acb->acb_next; 2858 kmem_free(acb, sizeof (arc_callback_t)); 2859 } 2860 2861 if (freeable) 2862 arc_hdr_destroy(hdr); 2863 } 2864 2865 /* 2866 * "Read" the block at the specified DVA (in bp) via the 2867 * cache. If the block is found in the cache, invoke the provided 2868 * callback immediately and return. Note that the `zio' parameter 2869 * in the callback will be NULL in this case, since no IO was 2870 * required. If the block is not in the cache pass the read request 2871 * on to the spa with a substitute callback function, so that the 2872 * requested block will be added to the cache. 2873 * 2874 * If a read request arrives for a block that has a read in-progress, 2875 * either wait for the in-progress read to complete (and return the 2876 * results); or, if this is a read with a "done" func, add a record 2877 * to the read to invoke the "done" func when the read completes, 2878 * and return; or just return. 2879 * 2880 * arc_read_done() will invoke all the requested "done" functions 2881 * for readers of this block. 2882 */ 2883 int 2884 arc_read(zio_t *pio, spa_t *spa, const blkptr_t *bp, arc_done_func_t *done, 2885 void *private, zio_priority_t priority, int zio_flags, uint32_t *arc_flags, 2886 const zbookmark_t *zb) 2887 { 2888 arc_buf_hdr_t *hdr; 2889 arc_buf_t *buf = NULL; 2890 kmutex_t *hash_lock; 2891 zio_t *rzio; 2892 uint64_t guid = spa_load_guid(spa); 2893 2894 top: 2895 hdr = buf_hash_find(guid, BP_IDENTITY(bp), BP_PHYSICAL_BIRTH(bp), 2896 &hash_lock); 2897 if (hdr && hdr->b_datacnt > 0) { 2898 2899 *arc_flags |= ARC_CACHED; 2900 2901 if (HDR_IO_IN_PROGRESS(hdr)) { 2902 2903 if (*arc_flags & ARC_WAIT) { 2904 cv_wait(&hdr->b_cv, hash_lock); 2905 mutex_exit(hash_lock); 2906 goto top; 2907 } 2908 ASSERT(*arc_flags & ARC_NOWAIT); 2909 2910 if (done) { 2911 arc_callback_t *acb = NULL; 2912 2913 acb = kmem_zalloc(sizeof (arc_callback_t), 2914 KM_SLEEP); 2915 acb->acb_done = done; 2916 acb->acb_private = private; 2917 if (pio != NULL) 2918 acb->acb_zio_dummy = zio_null(pio, 2919 spa, NULL, NULL, NULL, zio_flags); 2920 2921 ASSERT(acb->acb_done != NULL); 2922 acb->acb_next = hdr->b_acb; 2923 hdr->b_acb = acb; 2924 add_reference(hdr, hash_lock, private); 2925 mutex_exit(hash_lock); 2926 return (0); 2927 } 2928 mutex_exit(hash_lock); 2929 return (0); 2930 } 2931 2932 ASSERT(hdr->b_state == arc_mru || hdr->b_state == arc_mfu); 2933 2934 if (done) { 2935 add_reference(hdr, hash_lock, private); 2936 /* 2937 * If this block is already in use, create a new 2938 * copy of the data so that we will be guaranteed 2939 * that arc_release() will always succeed. 2940 */ 2941 buf = hdr->b_buf; 2942 ASSERT(buf); 2943 ASSERT(buf->b_data); 2944 if (HDR_BUF_AVAILABLE(hdr)) { 2945 ASSERT(buf->b_efunc == NULL); 2946 hdr->b_flags &= ~ARC_BUF_AVAILABLE; 2947 } else { 2948 buf = arc_buf_clone(buf); 2949 } 2950 2951 } else if (*arc_flags & ARC_PREFETCH && 2952 refcount_count(&hdr->b_refcnt) == 0) { 2953 hdr->b_flags |= ARC_PREFETCH; 2954 } 2955 DTRACE_PROBE1(arc__hit, arc_buf_hdr_t *, hdr); 2956 arc_access(hdr, hash_lock); 2957 if (*arc_flags & ARC_L2CACHE) 2958 hdr->b_flags |= ARC_L2CACHE; 2959 if (*arc_flags & ARC_L2COMPRESS) 2960 hdr->b_flags |= ARC_L2COMPRESS; 2961 mutex_exit(hash_lock); 2962 ARCSTAT_BUMP(arcstat_hits); 2963 ARCSTAT_CONDSTAT(!(hdr->b_flags & ARC_PREFETCH), 2964 demand, prefetch, hdr->b_type != ARC_BUFC_METADATA, 2965 data, metadata, hits); 2966 2967 if (done) 2968 done(NULL, buf, private); 2969 } else { 2970 uint64_t size = BP_GET_LSIZE(bp); 2971 arc_callback_t *acb; 2972 vdev_t *vd = NULL; 2973 uint64_t addr = 0; 2974 boolean_t devw = B_FALSE; 2975 2976 if (hdr == NULL) { 2977 /* this block is not in the cache */ 2978 arc_buf_hdr_t *exists; 2979 arc_buf_contents_t type = BP_GET_BUFC_TYPE(bp); 2980 buf = arc_buf_alloc(spa, size, private, type); 2981 hdr = buf->b_hdr; 2982 hdr->b_dva = *BP_IDENTITY(bp); 2983 hdr->b_birth = BP_PHYSICAL_BIRTH(bp); 2984 hdr->b_cksum0 = bp->blk_cksum.zc_word[0]; 2985 exists = buf_hash_insert(hdr, &hash_lock); 2986 if (exists) { 2987 /* somebody beat us to the hash insert */ 2988 mutex_exit(hash_lock); 2989 buf_discard_identity(hdr); 2990 (void) arc_buf_remove_ref(buf, private); 2991 goto top; /* restart the IO request */ 2992 } 2993 /* if this is a prefetch, we don't have a reference */ 2994 if (*arc_flags & ARC_PREFETCH) { 2995 (void) remove_reference(hdr, hash_lock, 2996 private); 2997 hdr->b_flags |= ARC_PREFETCH; 2998 } 2999 if (*arc_flags & ARC_L2CACHE) 3000 hdr->b_flags |= ARC_L2CACHE; 3001 if (*arc_flags & ARC_L2COMPRESS) 3002 hdr->b_flags |= ARC_L2COMPRESS; 3003 if (BP_GET_LEVEL(bp) > 0) 3004 hdr->b_flags |= ARC_INDIRECT; 3005 } else { 3006 /* this block is in the ghost cache */ 3007 ASSERT(GHOST_STATE(hdr->b_state)); 3008 ASSERT(!HDR_IO_IN_PROGRESS(hdr)); 3009 ASSERT0(refcount_count(&hdr->b_refcnt)); 3010 ASSERT(hdr->b_buf == NULL); 3011 3012 /* if this is a prefetch, we don't have a reference */ 3013 if (*arc_flags & ARC_PREFETCH) 3014 hdr->b_flags |= ARC_PREFETCH; 3015 else 3016 add_reference(hdr, hash_lock, private); 3017 if (*arc_flags & ARC_L2CACHE) 3018 hdr->b_flags |= ARC_L2CACHE; 3019 if (*arc_flags & ARC_L2COMPRESS) 3020 hdr->b_flags |= ARC_L2COMPRESS; 3021 buf = kmem_cache_alloc(buf_cache, KM_PUSHPAGE); 3022 buf->b_hdr = hdr; 3023 buf->b_data = NULL; 3024 buf->b_efunc = NULL; 3025 buf->b_private = NULL; 3026 buf->b_next = NULL; 3027 hdr->b_buf = buf; 3028 ASSERT(hdr->b_datacnt == 0); 3029 hdr->b_datacnt = 1; 3030 arc_get_data_buf(buf); 3031 arc_access(hdr, hash_lock); 3032 } 3033 3034 ASSERT(!GHOST_STATE(hdr->b_state)); 3035 3036 acb = kmem_zalloc(sizeof (arc_callback_t), KM_SLEEP); 3037 acb->acb_done = done; 3038 acb->acb_private = private; 3039 3040 ASSERT(hdr->b_acb == NULL); 3041 hdr->b_acb = acb; 3042 hdr->b_flags |= ARC_IO_IN_PROGRESS; 3043 3044 if (HDR_L2CACHE(hdr) && hdr->b_l2hdr != NULL && 3045 (vd = hdr->b_l2hdr->b_dev->l2ad_vdev) != NULL) { 3046 devw = hdr->b_l2hdr->b_dev->l2ad_writing; 3047 addr = hdr->b_l2hdr->b_daddr; 3048 /* 3049 * Lock out device removal. 3050 */ 3051 if (vdev_is_dead(vd) || 3052 !spa_config_tryenter(spa, SCL_L2ARC, vd, RW_READER)) 3053 vd = NULL; 3054 } 3055 3056 mutex_exit(hash_lock); 3057 3058 /* 3059 * At this point, we have a level 1 cache miss. Try again in 3060 * L2ARC if possible. 3061 */ 3062 ASSERT3U(hdr->b_size, ==, size); 3063 DTRACE_PROBE4(arc__miss, arc_buf_hdr_t *, hdr, blkptr_t *, bp, 3064 uint64_t, size, zbookmark_t *, zb); 3065 ARCSTAT_BUMP(arcstat_misses); 3066 ARCSTAT_CONDSTAT(!(hdr->b_flags & ARC_PREFETCH), 3067 demand, prefetch, hdr->b_type != ARC_BUFC_METADATA, 3068 data, metadata, misses); 3069 3070 if (vd != NULL && l2arc_ndev != 0 && !(l2arc_norw && devw)) { 3071 /* 3072 * Read from the L2ARC if the following are true: 3073 * 1. The L2ARC vdev was previously cached. 3074 * 2. This buffer still has L2ARC metadata. 3075 * 3. This buffer isn't currently writing to the L2ARC. 3076 * 4. The L2ARC entry wasn't evicted, which may 3077 * also have invalidated the vdev. 3078 * 5. This isn't prefetch and l2arc_noprefetch is set. 3079 */ 3080 if (hdr->b_l2hdr != NULL && 3081 !HDR_L2_WRITING(hdr) && !HDR_L2_EVICTED(hdr) && 3082 !(l2arc_noprefetch && HDR_PREFETCH(hdr))) { 3083 l2arc_read_callback_t *cb; 3084 3085 DTRACE_PROBE1(l2arc__hit, arc_buf_hdr_t *, hdr); 3086 ARCSTAT_BUMP(arcstat_l2_hits); 3087 3088 cb = kmem_zalloc(sizeof (l2arc_read_callback_t), 3089 KM_SLEEP); 3090 cb->l2rcb_buf = buf; 3091 cb->l2rcb_spa = spa; 3092 cb->l2rcb_bp = *bp; 3093 cb->l2rcb_zb = *zb; 3094 cb->l2rcb_flags = zio_flags; 3095 cb->l2rcb_compress = hdr->b_l2hdr->b_compress; 3096 3097 ASSERT(addr >= VDEV_LABEL_START_SIZE && 3098 addr + size < vd->vdev_psize - 3099 VDEV_LABEL_END_SIZE); 3100 3101 /* 3102 * l2arc read. The SCL_L2ARC lock will be 3103 * released by l2arc_read_done(). 3104 * Issue a null zio if the underlying buffer 3105 * was squashed to zero size by compression. 3106 */ 3107 if (hdr->b_l2hdr->b_compress == 3108 ZIO_COMPRESS_EMPTY) { 3109 rzio = zio_null(pio, spa, vd, 3110 l2arc_read_done, cb, 3111 zio_flags | ZIO_FLAG_DONT_CACHE | 3112 ZIO_FLAG_CANFAIL | 3113 ZIO_FLAG_DONT_PROPAGATE | 3114 ZIO_FLAG_DONT_RETRY); 3115 } else { 3116 rzio = zio_read_phys(pio, vd, addr, 3117 hdr->b_l2hdr->b_asize, 3118 buf->b_data, ZIO_CHECKSUM_OFF, 3119 l2arc_read_done, cb, priority, 3120 zio_flags | ZIO_FLAG_DONT_CACHE | 3121 ZIO_FLAG_CANFAIL | 3122 ZIO_FLAG_DONT_PROPAGATE | 3123 ZIO_FLAG_DONT_RETRY, B_FALSE); 3124 } 3125 DTRACE_PROBE2(l2arc__read, vdev_t *, vd, 3126 zio_t *, rzio); 3127 ARCSTAT_INCR(arcstat_l2_read_bytes, 3128 hdr->b_l2hdr->b_asize); 3129 3130 if (*arc_flags & ARC_NOWAIT) { 3131 zio_nowait(rzio); 3132 return (0); 3133 } 3134 3135 ASSERT(*arc_flags & ARC_WAIT); 3136 if (zio_wait(rzio) == 0) 3137 return (0); 3138 3139 /* l2arc read error; goto zio_read() */ 3140 } else { 3141 DTRACE_PROBE1(l2arc__miss, 3142 arc_buf_hdr_t *, hdr); 3143 ARCSTAT_BUMP(arcstat_l2_misses); 3144 if (HDR_L2_WRITING(hdr)) 3145 ARCSTAT_BUMP(arcstat_l2_rw_clash); 3146 spa_config_exit(spa, SCL_L2ARC, vd); 3147 } 3148 } else { 3149 if (vd != NULL) 3150 spa_config_exit(spa, SCL_L2ARC, vd); 3151 if (l2arc_ndev != 0) { 3152 DTRACE_PROBE1(l2arc__miss, 3153 arc_buf_hdr_t *, hdr); 3154 ARCSTAT_BUMP(arcstat_l2_misses); 3155 } 3156 } 3157 3158 rzio = zio_read(pio, spa, bp, buf->b_data, size, 3159 arc_read_done, buf, priority, zio_flags, zb); 3160 3161 if (*arc_flags & ARC_WAIT) 3162 return (zio_wait(rzio)); 3163 3164 ASSERT(*arc_flags & ARC_NOWAIT); 3165 zio_nowait(rzio); 3166 } 3167 return (0); 3168 } 3169 3170 void 3171 arc_set_callback(arc_buf_t *buf, arc_evict_func_t *func, void *private) 3172 { 3173 ASSERT(buf->b_hdr != NULL); 3174 ASSERT(buf->b_hdr->b_state != arc_anon); 3175 ASSERT(!refcount_is_zero(&buf->b_hdr->b_refcnt) || func == NULL); 3176 ASSERT(buf->b_efunc == NULL); 3177 ASSERT(!HDR_BUF_AVAILABLE(buf->b_hdr)); 3178 3179 buf->b_efunc = func; 3180 buf->b_private = private; 3181 } 3182 3183 /* 3184 * Notify the arc that a block was freed, and thus will never be used again. 3185 */ 3186 void 3187 arc_freed(spa_t *spa, const blkptr_t *bp) 3188 { 3189 arc_buf_hdr_t *hdr; 3190 kmutex_t *hash_lock; 3191 uint64_t guid = spa_load_guid(spa); 3192 3193 hdr = buf_hash_find(guid, BP_IDENTITY(bp), BP_PHYSICAL_BIRTH(bp), 3194 &hash_lock); 3195 if (hdr == NULL) 3196 return; 3197 if (HDR_BUF_AVAILABLE(hdr)) { 3198 arc_buf_t *buf = hdr->b_buf; 3199 add_reference(hdr, hash_lock, FTAG); 3200 hdr->b_flags &= ~ARC_BUF_AVAILABLE; 3201 mutex_exit(hash_lock); 3202 3203 arc_release(buf, FTAG); 3204 (void) arc_buf_remove_ref(buf, FTAG); 3205 } else { 3206 mutex_exit(hash_lock); 3207 } 3208 3209 } 3210 3211 /* 3212 * This is used by the DMU to let the ARC know that a buffer is 3213 * being evicted, so the ARC should clean up. If this arc buf 3214 * is not yet in the evicted state, it will be put there. 3215 */ 3216 int 3217 arc_buf_evict(arc_buf_t *buf) 3218 { 3219 arc_buf_hdr_t *hdr; 3220 kmutex_t *hash_lock; 3221 arc_buf_t **bufp; 3222 3223 mutex_enter(&buf->b_evict_lock); 3224 hdr = buf->b_hdr; 3225 if (hdr == NULL) { 3226 /* 3227 * We are in arc_do_user_evicts(). 3228 */ 3229 ASSERT(buf->b_data == NULL); 3230 mutex_exit(&buf->b_evict_lock); 3231 return (0); 3232 } else if (buf->b_data == NULL) { 3233 arc_buf_t copy = *buf; /* structure assignment */ 3234 /* 3235 * We are on the eviction list; process this buffer now 3236 * but let arc_do_user_evicts() do the reaping. 3237 */ 3238 buf->b_efunc = NULL; 3239 mutex_exit(&buf->b_evict_lock); 3240 VERIFY(copy.b_efunc(©) == 0); 3241 return (1); 3242 } 3243 hash_lock = HDR_LOCK(hdr); 3244 mutex_enter(hash_lock); 3245 hdr = buf->b_hdr; 3246 ASSERT3P(hash_lock, ==, HDR_LOCK(hdr)); 3247 3248 ASSERT3U(refcount_count(&hdr->b_refcnt), <, hdr->b_datacnt); 3249 ASSERT(hdr->b_state == arc_mru || hdr->b_state == arc_mfu); 3250 3251 /* 3252 * Pull this buffer off of the hdr 3253 */ 3254 bufp = &hdr->b_buf; 3255 while (*bufp != buf) 3256 bufp = &(*bufp)->b_next; 3257 *bufp = buf->b_next; 3258 3259 ASSERT(buf->b_data != NULL); 3260 arc_buf_destroy(buf, FALSE, FALSE); 3261 3262 if (hdr->b_datacnt == 0) { 3263 arc_state_t *old_state = hdr->b_state; 3264 arc_state_t *evicted_state; 3265 3266 ASSERT(hdr->b_buf == NULL); 3267 ASSERT(refcount_is_zero(&hdr->b_refcnt)); 3268 3269 evicted_state = 3270 (old_state == arc_mru) ? arc_mru_ghost : arc_mfu_ghost; 3271 3272 mutex_enter(&old_state->arcs_mtx); 3273 mutex_enter(&evicted_state->arcs_mtx); 3274 3275 arc_change_state(evicted_state, hdr, hash_lock); 3276 ASSERT(HDR_IN_HASH_TABLE(hdr)); 3277 hdr->b_flags |= ARC_IN_HASH_TABLE; 3278 hdr->b_flags &= ~ARC_BUF_AVAILABLE; 3279 3280 mutex_exit(&evicted_state->arcs_mtx); 3281 mutex_exit(&old_state->arcs_mtx); 3282 } 3283 mutex_exit(hash_lock); 3284 mutex_exit(&buf->b_evict_lock); 3285 3286 VERIFY(buf->b_efunc(buf) == 0); 3287 buf->b_efunc = NULL; 3288 buf->b_private = NULL; 3289 buf->b_hdr = NULL; 3290 buf->b_next = NULL; 3291 kmem_cache_free(buf_cache, buf); 3292 return (1); 3293 } 3294 3295 /* 3296 * Release this buffer from the cache, making it an anonymous buffer. This 3297 * must be done after a read and prior to modifying the buffer contents. 3298 * If the buffer has more than one reference, we must make 3299 * a new hdr for the buffer. 3300 */ 3301 void 3302 arc_release(arc_buf_t *buf, void *tag) 3303 { 3304 arc_buf_hdr_t *hdr; 3305 kmutex_t *hash_lock = NULL; 3306 l2arc_buf_hdr_t *l2hdr; 3307 uint64_t buf_size; 3308 3309 /* 3310 * It would be nice to assert that if it's DMU metadata (level > 3311 * 0 || it's the dnode file), then it must be syncing context. 3312 * But we don't know that information at this level. 3313 */ 3314 3315 mutex_enter(&buf->b_evict_lock); 3316 hdr = buf->b_hdr; 3317 3318 /* this buffer is not on any list */ 3319 ASSERT(refcount_count(&hdr->b_refcnt) > 0); 3320 3321 if (hdr->b_state == arc_anon) { 3322 /* this buffer is already released */ 3323 ASSERT(buf->b_efunc == NULL); 3324 } else { 3325 hash_lock = HDR_LOCK(hdr); 3326 mutex_enter(hash_lock); 3327 hdr = buf->b_hdr; 3328 ASSERT3P(hash_lock, ==, HDR_LOCK(hdr)); 3329 } 3330 3331 l2hdr = hdr->b_l2hdr; 3332 if (l2hdr) { 3333 mutex_enter(&l2arc_buflist_mtx); 3334 hdr->b_l2hdr = NULL; 3335 } 3336 buf_size = hdr->b_size; 3337 3338 /* 3339 * Do we have more than one buf? 3340 */ 3341 if (hdr->b_datacnt > 1) { 3342 arc_buf_hdr_t *nhdr; 3343 arc_buf_t **bufp; 3344 uint64_t blksz = hdr->b_size; 3345 uint64_t spa = hdr->b_spa; 3346 arc_buf_contents_t type = hdr->b_type; 3347 uint32_t flags = hdr->b_flags; 3348 3349 ASSERT(hdr->b_buf != buf || buf->b_next != NULL); 3350 /* 3351 * Pull the data off of this hdr and attach it to 3352 * a new anonymous hdr. 3353 */ 3354 (void) remove_reference(hdr, hash_lock, tag); 3355 bufp = &hdr->b_buf; 3356 while (*bufp != buf) 3357 bufp = &(*bufp)->b_next; 3358 *bufp = buf->b_next; 3359 buf->b_next = NULL; 3360 3361 ASSERT3U(hdr->b_state->arcs_size, >=, hdr->b_size); 3362 atomic_add_64(&hdr->b_state->arcs_size, -hdr->b_size); 3363 if (refcount_is_zero(&hdr->b_refcnt)) { 3364 uint64_t *size = &hdr->b_state->arcs_lsize[hdr->b_type]; 3365 ASSERT3U(*size, >=, hdr->b_size); 3366 atomic_add_64(size, -hdr->b_size); 3367 } 3368 3369 /* 3370 * We're releasing a duplicate user data buffer, update 3371 * our statistics accordingly. 3372 */ 3373 if (hdr->b_type == ARC_BUFC_DATA) { 3374 ARCSTAT_BUMPDOWN(arcstat_duplicate_buffers); 3375 ARCSTAT_INCR(arcstat_duplicate_buffers_size, 3376 -hdr->b_size); 3377 } 3378 hdr->b_datacnt -= 1; 3379 arc_cksum_verify(buf); 3380 arc_buf_unwatch(buf); 3381 3382 mutex_exit(hash_lock); 3383 3384 nhdr = kmem_cache_alloc(hdr_cache, KM_PUSHPAGE); 3385 nhdr->b_size = blksz; 3386 nhdr->b_spa = spa; 3387 nhdr->b_type = type; 3388 nhdr->b_buf = buf; 3389 nhdr->b_state = arc_anon; 3390 nhdr->b_arc_access = 0; 3391 nhdr->b_flags = flags & ARC_L2_WRITING; 3392 nhdr->b_l2hdr = NULL; 3393 nhdr->b_datacnt = 1; 3394 nhdr->b_freeze_cksum = NULL; 3395 (void) refcount_add(&nhdr->b_refcnt, tag); 3396 buf->b_hdr = nhdr; 3397 mutex_exit(&buf->b_evict_lock); 3398 atomic_add_64(&arc_anon->arcs_size, blksz); 3399 } else { 3400 mutex_exit(&buf->b_evict_lock); 3401 ASSERT(refcount_count(&hdr->b_refcnt) == 1); 3402 ASSERT(!list_link_active(&hdr->b_arc_node)); 3403 ASSERT(!HDR_IO_IN_PROGRESS(hdr)); 3404 if (hdr->b_state != arc_anon) 3405 arc_change_state(arc_anon, hdr, hash_lock); 3406 hdr->b_arc_access = 0; 3407 if (hash_lock) 3408 mutex_exit(hash_lock); 3409 3410 buf_discard_identity(hdr); 3411 arc_buf_thaw(buf); 3412 } 3413 buf->b_efunc = NULL; 3414 buf->b_private = NULL; 3415 3416 if (l2hdr) { 3417 ARCSTAT_INCR(arcstat_l2_asize, -l2hdr->b_asize); 3418 list_remove(l2hdr->b_dev->l2ad_buflist, hdr); 3419 kmem_free(l2hdr, sizeof (l2arc_buf_hdr_t)); 3420 ARCSTAT_INCR(arcstat_l2_size, -buf_size); 3421 mutex_exit(&l2arc_buflist_mtx); 3422 } 3423 } 3424 3425 int 3426 arc_released(arc_buf_t *buf) 3427 { 3428 int released; 3429 3430 mutex_enter(&buf->b_evict_lock); 3431 released = (buf->b_data != NULL && buf->b_hdr->b_state == arc_anon); 3432 mutex_exit(&buf->b_evict_lock); 3433 return (released); 3434 } 3435 3436 int 3437 arc_has_callback(arc_buf_t *buf) 3438 { 3439 int callback; 3440 3441 mutex_enter(&buf->b_evict_lock); 3442 callback = (buf->b_efunc != NULL); 3443 mutex_exit(&buf->b_evict_lock); 3444 return (callback); 3445 } 3446 3447 #ifdef ZFS_DEBUG 3448 int 3449 arc_referenced(arc_buf_t *buf) 3450 { 3451 int referenced; 3452 3453 mutex_enter(&buf->b_evict_lock); 3454 referenced = (refcount_count(&buf->b_hdr->b_refcnt)); 3455 mutex_exit(&buf->b_evict_lock); 3456 return (referenced); 3457 } 3458 #endif 3459 3460 static void 3461 arc_write_ready(zio_t *zio) 3462 { 3463 arc_write_callback_t *callback = zio->io_private; 3464 arc_buf_t *buf = callback->awcb_buf; 3465 arc_buf_hdr_t *hdr = buf->b_hdr; 3466 3467 ASSERT(!refcount_is_zero(&buf->b_hdr->b_refcnt)); 3468 callback->awcb_ready(zio, buf, callback->awcb_private); 3469 3470 /* 3471 * If the IO is already in progress, then this is a re-write 3472 * attempt, so we need to thaw and re-compute the cksum. 3473 * It is the responsibility of the callback to handle the 3474 * accounting for any re-write attempt. 3475 */ 3476 if (HDR_IO_IN_PROGRESS(hdr)) { 3477 mutex_enter(&hdr->b_freeze_lock); 3478 if (hdr->b_freeze_cksum != NULL) { 3479 kmem_free(hdr->b_freeze_cksum, sizeof (zio_cksum_t)); 3480 hdr->b_freeze_cksum = NULL; 3481 } 3482 mutex_exit(&hdr->b_freeze_lock); 3483 } 3484 arc_cksum_compute(buf, B_FALSE); 3485 hdr->b_flags |= ARC_IO_IN_PROGRESS; 3486 } 3487 3488 /* 3489 * The SPA calls this callback for each physical write that happens on behalf 3490 * of a logical write. See the comment in dbuf_write_physdone() for details. 3491 */ 3492 static void 3493 arc_write_physdone(zio_t *zio) 3494 { 3495 arc_write_callback_t *cb = zio->io_private; 3496 if (cb->awcb_physdone != NULL) 3497 cb->awcb_physdone(zio, cb->awcb_buf, cb->awcb_private); 3498 } 3499 3500 static void 3501 arc_write_done(zio_t *zio) 3502 { 3503 arc_write_callback_t *callback = zio->io_private; 3504 arc_buf_t *buf = callback->awcb_buf; 3505 arc_buf_hdr_t *hdr = buf->b_hdr; 3506 3507 ASSERT(hdr->b_acb == NULL); 3508 3509 if (zio->io_error == 0) { 3510 hdr->b_dva = *BP_IDENTITY(zio->io_bp); 3511 hdr->b_birth = BP_PHYSICAL_BIRTH(zio->io_bp); 3512 hdr->b_cksum0 = zio->io_bp->blk_cksum.zc_word[0]; 3513 } else { 3514 ASSERT(BUF_EMPTY(hdr)); 3515 } 3516 3517 /* 3518 * If the block to be written was all-zero, we may have 3519 * compressed it away. In this case no write was performed 3520 * so there will be no dva/birth/checksum. The buffer must 3521 * therefore remain anonymous (and uncached). 3522 */ 3523 if (!BUF_EMPTY(hdr)) { 3524 arc_buf_hdr_t *exists; 3525 kmutex_t *hash_lock; 3526 3527 ASSERT(zio->io_error == 0); 3528 3529 arc_cksum_verify(buf); 3530 3531 exists = buf_hash_insert(hdr, &hash_lock); 3532 if (exists) { 3533 /* 3534 * This can only happen if we overwrite for 3535 * sync-to-convergence, because we remove 3536 * buffers from the hash table when we arc_free(). 3537 */ 3538 if (zio->io_flags & ZIO_FLAG_IO_REWRITE) { 3539 if (!BP_EQUAL(&zio->io_bp_orig, zio->io_bp)) 3540 panic("bad overwrite, hdr=%p exists=%p", 3541 (void *)hdr, (void *)exists); 3542 ASSERT(refcount_is_zero(&exists->b_refcnt)); 3543 arc_change_state(arc_anon, exists, hash_lock); 3544 mutex_exit(hash_lock); 3545 arc_hdr_destroy(exists); 3546 exists = buf_hash_insert(hdr, &hash_lock); 3547 ASSERT3P(exists, ==, NULL); 3548 } else if (zio->io_flags & ZIO_FLAG_NOPWRITE) { 3549 /* nopwrite */ 3550 ASSERT(zio->io_prop.zp_nopwrite); 3551 if (!BP_EQUAL(&zio->io_bp_orig, zio->io_bp)) 3552 panic("bad nopwrite, hdr=%p exists=%p", 3553 (void *)hdr, (void *)exists); 3554 } else { 3555 /* Dedup */ 3556 ASSERT(hdr->b_datacnt == 1); 3557 ASSERT(hdr->b_state == arc_anon); 3558 ASSERT(BP_GET_DEDUP(zio->io_bp)); 3559 ASSERT(BP_GET_LEVEL(zio->io_bp) == 0); 3560 } 3561 } 3562 hdr->b_flags &= ~ARC_IO_IN_PROGRESS; 3563 /* if it's not anon, we are doing a scrub */ 3564 if (!exists && hdr->b_state == arc_anon) 3565 arc_access(hdr, hash_lock); 3566 mutex_exit(hash_lock); 3567 } else { 3568 hdr->b_flags &= ~ARC_IO_IN_PROGRESS; 3569 } 3570 3571 ASSERT(!refcount_is_zero(&hdr->b_refcnt)); 3572 callback->awcb_done(zio, buf, callback->awcb_private); 3573 3574 kmem_free(callback, sizeof (arc_write_callback_t)); 3575 } 3576 3577 zio_t * 3578 arc_write(zio_t *pio, spa_t *spa, uint64_t txg, 3579 blkptr_t *bp, arc_buf_t *buf, boolean_t l2arc, boolean_t l2arc_compress, 3580 const zio_prop_t *zp, arc_done_func_t *ready, arc_done_func_t *physdone, 3581 arc_done_func_t *done, void *private, zio_priority_t priority, 3582 int zio_flags, const zbookmark_t *zb) 3583 { 3584 arc_buf_hdr_t *hdr = buf->b_hdr; 3585 arc_write_callback_t *callback; 3586 zio_t *zio; 3587 3588 ASSERT(ready != NULL); 3589 ASSERT(done != NULL); 3590 ASSERT(!HDR_IO_ERROR(hdr)); 3591 ASSERT((hdr->b_flags & ARC_IO_IN_PROGRESS) == 0); 3592 ASSERT(hdr->b_acb == NULL); 3593 if (l2arc) 3594 hdr->b_flags |= ARC_L2CACHE; 3595 if (l2arc_compress) 3596 hdr->b_flags |= ARC_L2COMPRESS; 3597 callback = kmem_zalloc(sizeof (arc_write_callback_t), KM_SLEEP); 3598 callback->awcb_ready = ready; 3599 callback->awcb_physdone = physdone; 3600 callback->awcb_done = done; 3601 callback->awcb_private = private; 3602 callback->awcb_buf = buf; 3603 3604 zio = zio_write(pio, spa, txg, bp, buf->b_data, hdr->b_size, zp, 3605 arc_write_ready, arc_write_physdone, arc_write_done, callback, 3606 priority, zio_flags, zb); 3607 3608 return (zio); 3609 } 3610 3611 static int 3612 arc_memory_throttle(uint64_t reserve, uint64_t txg) 3613 { 3614 #ifdef _KERNEL 3615 uint64_t available_memory = ptob(freemem); 3616 static uint64_t page_load = 0; 3617 static uint64_t last_txg = 0; 3618 3619 #if defined(__i386) 3620 available_memory = 3621 MIN(available_memory, vmem_size(heap_arena, VMEM_FREE)); 3622 #endif 3623 3624 if (freemem > physmem * arc_lotsfree_percent / 100) 3625 return (0); 3626 3627 if (txg > last_txg) { 3628 last_txg = txg; 3629 page_load = 0; 3630 } 3631 /* 3632 * If we are in pageout, we know that memory is already tight, 3633 * the arc is already going to be evicting, so we just want to 3634 * continue to let page writes occur as quickly as possible. 3635 */ 3636 if (curproc == proc_pageout) { 3637 if (page_load > MAX(ptob(minfree), available_memory) / 4) 3638 return (SET_ERROR(ERESTART)); 3639 /* Note: reserve is inflated, so we deflate */ 3640 page_load += reserve / 8; 3641 return (0); 3642 } else if (page_load > 0 && arc_reclaim_needed()) { 3643 /* memory is low, delay before restarting */ 3644 ARCSTAT_INCR(arcstat_memory_throttle_count, 1); 3645 return (SET_ERROR(EAGAIN)); 3646 } 3647 page_load = 0; 3648 #endif 3649 return (0); 3650 } 3651 3652 void 3653 arc_tempreserve_clear(uint64_t reserve) 3654 { 3655 atomic_add_64(&arc_tempreserve, -reserve); 3656 ASSERT((int64_t)arc_tempreserve >= 0); 3657 } 3658 3659 int 3660 arc_tempreserve_space(uint64_t reserve, uint64_t txg) 3661 { 3662 int error; 3663 uint64_t anon_size; 3664 3665 if (reserve > arc_c/4 && !arc_no_grow) 3666 arc_c = MIN(arc_c_max, reserve * 4); 3667 if (reserve > arc_c) 3668 return (SET_ERROR(ENOMEM)); 3669 3670 /* 3671 * Don't count loaned bufs as in flight dirty data to prevent long 3672 * network delays from blocking transactions that are ready to be 3673 * assigned to a txg. 3674 */ 3675 anon_size = MAX((int64_t)(arc_anon->arcs_size - arc_loaned_bytes), 0); 3676 3677 /* 3678 * Writes will, almost always, require additional memory allocations 3679 * in order to compress/encrypt/etc the data. We therefore need to 3680 * make sure that there is sufficient available memory for this. 3681 */ 3682 error = arc_memory_throttle(reserve, txg); 3683 if (error != 0) 3684 return (error); 3685 3686 /* 3687 * Throttle writes when the amount of dirty data in the cache 3688 * gets too large. We try to keep the cache less than half full 3689 * of dirty blocks so that our sync times don't grow too large. 3690 * Note: if two requests come in concurrently, we might let them 3691 * both succeed, when one of them should fail. Not a huge deal. 3692 */ 3693 3694 if (reserve + arc_tempreserve + anon_size > arc_c / 2 && 3695 anon_size > arc_c / 4) { 3696 dprintf("failing, arc_tempreserve=%lluK anon_meta=%lluK " 3697 "anon_data=%lluK tempreserve=%lluK arc_c=%lluK\n", 3698 arc_tempreserve>>10, 3699 arc_anon->arcs_lsize[ARC_BUFC_METADATA]>>10, 3700 arc_anon->arcs_lsize[ARC_BUFC_DATA]>>10, 3701 reserve>>10, arc_c>>10); 3702 return (SET_ERROR(ERESTART)); 3703 } 3704 atomic_add_64(&arc_tempreserve, reserve); 3705 return (0); 3706 } 3707 3708 void 3709 arc_init(void) 3710 { 3711 mutex_init(&arc_reclaim_thr_lock, NULL, MUTEX_DEFAULT, NULL); 3712 cv_init(&arc_reclaim_thr_cv, NULL, CV_DEFAULT, NULL); 3713 3714 /* Convert seconds to clock ticks */ 3715 arc_min_prefetch_lifespan = 1 * hz; 3716 3717 /* Start out with 1/8 of all memory */ 3718 arc_c = physmem * PAGESIZE / 8; 3719 3720 #ifdef _KERNEL 3721 /* 3722 * On architectures where the physical memory can be larger 3723 * than the addressable space (intel in 32-bit mode), we may 3724 * need to limit the cache to 1/8 of VM size. 3725 */ 3726 arc_c = MIN(arc_c, vmem_size(heap_arena, VMEM_ALLOC | VMEM_FREE) / 8); 3727 #endif 3728 3729 /* set min cache to 1/32 of all memory, or 64MB, whichever is more */ 3730 arc_c_min = MAX(arc_c / 4, 64<<20); 3731 /* set max to 3/4 of all memory, or all but 1GB, whichever is more */ 3732 if (arc_c * 8 >= 1<<30) 3733 arc_c_max = (arc_c * 8) - (1<<30); 3734 else 3735 arc_c_max = arc_c_min; 3736 arc_c_max = MAX(arc_c * 6, arc_c_max); 3737 3738 /* 3739 * Allow the tunables to override our calculations if they are 3740 * reasonable (ie. over 64MB) 3741 */ 3742 if (zfs_arc_max > 64<<20 && zfs_arc_max < physmem * PAGESIZE) 3743 arc_c_max = zfs_arc_max; 3744 if (zfs_arc_min > 64<<20 && zfs_arc_min <= arc_c_max) 3745 arc_c_min = zfs_arc_min; 3746 3747 arc_c = arc_c_max; 3748 arc_p = (arc_c >> 1); 3749 3750 /* limit meta-data to 1/4 of the arc capacity */ 3751 arc_meta_limit = arc_c_max / 4; 3752 3753 /* Allow the tunable to override if it is reasonable */ 3754 if (zfs_arc_meta_limit > 0 && zfs_arc_meta_limit <= arc_c_max) 3755 arc_meta_limit = zfs_arc_meta_limit; 3756 3757 if (arc_c_min < arc_meta_limit / 2 && zfs_arc_min == 0) 3758 arc_c_min = arc_meta_limit / 2; 3759 3760 if (zfs_arc_grow_retry > 0) 3761 arc_grow_retry = zfs_arc_grow_retry; 3762 3763 if (zfs_arc_shrink_shift > 0) 3764 arc_shrink_shift = zfs_arc_shrink_shift; 3765 3766 if (zfs_arc_p_min_shift > 0) 3767 arc_p_min_shift = zfs_arc_p_min_shift; 3768 3769 /* if kmem_flags are set, lets try to use less memory */ 3770 if (kmem_debugging()) 3771 arc_c = arc_c / 2; 3772 if (arc_c < arc_c_min) 3773 arc_c = arc_c_min; 3774 3775 arc_anon = &ARC_anon; 3776 arc_mru = &ARC_mru; 3777 arc_mru_ghost = &ARC_mru_ghost; 3778 arc_mfu = &ARC_mfu; 3779 arc_mfu_ghost = &ARC_mfu_ghost; 3780 arc_l2c_only = &ARC_l2c_only; 3781 arc_size = 0; 3782 3783 mutex_init(&arc_anon->arcs_mtx, NULL, MUTEX_DEFAULT, NULL); 3784 mutex_init(&arc_mru->arcs_mtx, NULL, MUTEX_DEFAULT, NULL); 3785 mutex_init(&arc_mru_ghost->arcs_mtx, NULL, MUTEX_DEFAULT, NULL); 3786 mutex_init(&arc_mfu->arcs_mtx, NULL, MUTEX_DEFAULT, NULL); 3787 mutex_init(&arc_mfu_ghost->arcs_mtx, NULL, MUTEX_DEFAULT, NULL); 3788 mutex_init(&arc_l2c_only->arcs_mtx, NULL, MUTEX_DEFAULT, NULL); 3789 3790 list_create(&arc_mru->arcs_list[ARC_BUFC_METADATA], 3791 sizeof (arc_buf_hdr_t), offsetof(arc_buf_hdr_t, b_arc_node)); 3792 list_create(&arc_mru->arcs_list[ARC_BUFC_DATA], 3793 sizeof (arc_buf_hdr_t), offsetof(arc_buf_hdr_t, b_arc_node)); 3794 list_create(&arc_mru_ghost->arcs_list[ARC_BUFC_METADATA], 3795 sizeof (arc_buf_hdr_t), offsetof(arc_buf_hdr_t, b_arc_node)); 3796 list_create(&arc_mru_ghost->arcs_list[ARC_BUFC_DATA], 3797 sizeof (arc_buf_hdr_t), offsetof(arc_buf_hdr_t, b_arc_node)); 3798 list_create(&arc_mfu->arcs_list[ARC_BUFC_METADATA], 3799 sizeof (arc_buf_hdr_t), offsetof(arc_buf_hdr_t, b_arc_node)); 3800 list_create(&arc_mfu->arcs_list[ARC_BUFC_DATA], 3801 sizeof (arc_buf_hdr_t), offsetof(arc_buf_hdr_t, b_arc_node)); 3802 list_create(&arc_mfu_ghost->arcs_list[ARC_BUFC_METADATA], 3803 sizeof (arc_buf_hdr_t), offsetof(arc_buf_hdr_t, b_arc_node)); 3804 list_create(&arc_mfu_ghost->arcs_list[ARC_BUFC_DATA], 3805 sizeof (arc_buf_hdr_t), offsetof(arc_buf_hdr_t, b_arc_node)); 3806 list_create(&arc_l2c_only->arcs_list[ARC_BUFC_METADATA], 3807 sizeof (arc_buf_hdr_t), offsetof(arc_buf_hdr_t, b_arc_node)); 3808 list_create(&arc_l2c_only->arcs_list[ARC_BUFC_DATA], 3809 sizeof (arc_buf_hdr_t), offsetof(arc_buf_hdr_t, b_arc_node)); 3810 3811 buf_init(); 3812 3813 arc_thread_exit = 0; 3814 arc_eviction_list = NULL; 3815 mutex_init(&arc_eviction_mtx, NULL, MUTEX_DEFAULT, NULL); 3816 bzero(&arc_eviction_hdr, sizeof (arc_buf_hdr_t)); 3817 3818 arc_ksp = kstat_create("zfs", 0, "arcstats", "misc", KSTAT_TYPE_NAMED, 3819 sizeof (arc_stats) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL); 3820 3821 if (arc_ksp != NULL) { 3822 arc_ksp->ks_data = &arc_stats; 3823 kstat_install(arc_ksp); 3824 } 3825 3826 (void) thread_create(NULL, 0, arc_reclaim_thread, NULL, 0, &p0, 3827 TS_RUN, minclsyspri); 3828 3829 arc_dead = FALSE; 3830 arc_warm = B_FALSE; 3831 3832 /* 3833 * Calculate maximum amount of dirty data per pool. 3834 * 3835 * If it has been set by /etc/system, take that. 3836 * Otherwise, use a percentage of physical memory defined by 3837 * zfs_dirty_data_max_percent (default 10%) with a cap at 3838 * zfs_dirty_data_max_max (default 4GB). 3839 */ 3840 if (zfs_dirty_data_max == 0) { 3841 zfs_dirty_data_max = physmem * PAGESIZE * 3842 zfs_dirty_data_max_percent / 100; 3843 zfs_dirty_data_max = MIN(zfs_dirty_data_max, 3844 zfs_dirty_data_max_max); 3845 } 3846 } 3847 3848 void 3849 arc_fini(void) 3850 { 3851 mutex_enter(&arc_reclaim_thr_lock); 3852 arc_thread_exit = 1; 3853 while (arc_thread_exit != 0) 3854 cv_wait(&arc_reclaim_thr_cv, &arc_reclaim_thr_lock); 3855 mutex_exit(&arc_reclaim_thr_lock); 3856 3857 arc_flush(NULL); 3858 3859 arc_dead = TRUE; 3860 3861 if (arc_ksp != NULL) { 3862 kstat_delete(arc_ksp); 3863 arc_ksp = NULL; 3864 } 3865 3866 mutex_destroy(&arc_eviction_mtx); 3867 mutex_destroy(&arc_reclaim_thr_lock); 3868 cv_destroy(&arc_reclaim_thr_cv); 3869 3870 list_destroy(&arc_mru->arcs_list[ARC_BUFC_METADATA]); 3871 list_destroy(&arc_mru_ghost->arcs_list[ARC_BUFC_METADATA]); 3872 list_destroy(&arc_mfu->arcs_list[ARC_BUFC_METADATA]); 3873 list_destroy(&arc_mfu_ghost->arcs_list[ARC_BUFC_METADATA]); 3874 list_destroy(&arc_mru->arcs_list[ARC_BUFC_DATA]); 3875 list_destroy(&arc_mru_ghost->arcs_list[ARC_BUFC_DATA]); 3876 list_destroy(&arc_mfu->arcs_list[ARC_BUFC_DATA]); 3877 list_destroy(&arc_mfu_ghost->arcs_list[ARC_BUFC_DATA]); 3878 3879 mutex_destroy(&arc_anon->arcs_mtx); 3880 mutex_destroy(&arc_mru->arcs_mtx); 3881 mutex_destroy(&arc_mru_ghost->arcs_mtx); 3882 mutex_destroy(&arc_mfu->arcs_mtx); 3883 mutex_destroy(&arc_mfu_ghost->arcs_mtx); 3884 mutex_destroy(&arc_l2c_only->arcs_mtx); 3885 3886 buf_fini(); 3887 3888 ASSERT(arc_loaned_bytes == 0); 3889 } 3890 3891 /* 3892 * Level 2 ARC 3893 * 3894 * The level 2 ARC (L2ARC) is a cache layer in-between main memory and disk. 3895 * It uses dedicated storage devices to hold cached data, which are populated 3896 * using large infrequent writes. The main role of this cache is to boost 3897 * the performance of random read workloads. The intended L2ARC devices 3898 * include short-stroked disks, solid state disks, and other media with 3899 * substantially faster read latency than disk. 3900 * 3901 * +-----------------------+ 3902 * | ARC | 3903 * +-----------------------+ 3904 * | ^ ^ 3905 * | | | 3906 * l2arc_feed_thread() arc_read() 3907 * | | | 3908 * | l2arc read | 3909 * V | | 3910 * +---------------+ | 3911 * | L2ARC | | 3912 * +---------------+ | 3913 * | ^ | 3914 * l2arc_write() | | 3915 * | | | 3916 * V | | 3917 * +-------+ +-------+ 3918 * | vdev | | vdev | 3919 * | cache | | cache | 3920 * +-------+ +-------+ 3921 * +=========+ .-----. 3922 * : L2ARC : |-_____-| 3923 * : devices : | Disks | 3924 * +=========+ `-_____-' 3925 * 3926 * Read requests are satisfied from the following sources, in order: 3927 * 3928 * 1) ARC 3929 * 2) vdev cache of L2ARC devices 3930 * 3) L2ARC devices 3931 * 4) vdev cache of disks 3932 * 5) disks 3933 * 3934 * Some L2ARC device types exhibit extremely slow write performance. 3935 * To accommodate for this there are some significant differences between 3936 * the L2ARC and traditional cache design: 3937 * 3938 * 1. There is no eviction path from the ARC to the L2ARC. Evictions from 3939 * the ARC behave as usual, freeing buffers and placing headers on ghost 3940 * lists. The ARC does not send buffers to the L2ARC during eviction as 3941 * this would add inflated write latencies for all ARC memory pressure. 3942 * 3943 * 2. The L2ARC attempts to cache data from the ARC before it is evicted. 3944 * It does this by periodically scanning buffers from the eviction-end of 3945 * the MFU and MRU ARC lists, copying them to the L2ARC devices if they are 3946 * not already there. It scans until a headroom of buffers is satisfied, 3947 * which itself is a buffer for ARC eviction. If a compressible buffer is 3948 * found during scanning and selected for writing to an L2ARC device, we 3949 * temporarily boost scanning headroom during the next scan cycle to make 3950 * sure we adapt to compression effects (which might significantly reduce 3951 * the data volume we write to L2ARC). The thread that does this is 3952 * l2arc_feed_thread(), illustrated below; example sizes are included to 3953 * provide a better sense of ratio than this diagram: 3954 * 3955 * head --> tail 3956 * +---------------------+----------+ 3957 * ARC_mfu |:::::#:::::::::::::::|o#o###o###|-->. # already on L2ARC 3958 * +---------------------+----------+ | o L2ARC eligible 3959 * ARC_mru |:#:::::::::::::::::::|#o#ooo####|-->| : ARC buffer 3960 * +---------------------+----------+ | 3961 * 15.9 Gbytes ^ 32 Mbytes | 3962 * headroom | 3963 * l2arc_feed_thread() 3964 * | 3965 * l2arc write hand <--[oooo]--' 3966 * | 8 Mbyte 3967 * | write max 3968 * V 3969 * +==============================+ 3970 * L2ARC dev |####|#|###|###| |####| ... | 3971 * +==============================+ 3972 * 32 Gbytes 3973 * 3974 * 3. If an ARC buffer is copied to the L2ARC but then hit instead of 3975 * evicted, then the L2ARC has cached a buffer much sooner than it probably 3976 * needed to, potentially wasting L2ARC device bandwidth and storage. It is 3977 * safe to say that this is an uncommon case, since buffers at the end of 3978 * the ARC lists have moved there due to inactivity. 3979 * 3980 * 4. If the ARC evicts faster than the L2ARC can maintain a headroom, 3981 * then the L2ARC simply misses copying some buffers. This serves as a 3982 * pressure valve to prevent heavy read workloads from both stalling the ARC 3983 * with waits and clogging the L2ARC with writes. This also helps prevent 3984 * the potential for the L2ARC to churn if it attempts to cache content too 3985 * quickly, such as during backups of the entire pool. 3986 * 3987 * 5. After system boot and before the ARC has filled main memory, there are 3988 * no evictions from the ARC and so the tails of the ARC_mfu and ARC_mru 3989 * lists can remain mostly static. Instead of searching from tail of these 3990 * lists as pictured, the l2arc_feed_thread() will search from the list heads 3991 * for eligible buffers, greatly increasing its chance of finding them. 3992 * 3993 * The L2ARC device write speed is also boosted during this time so that 3994 * the L2ARC warms up faster. Since there have been no ARC evictions yet, 3995 * there are no L2ARC reads, and no fear of degrading read performance 3996 * through increased writes. 3997 * 3998 * 6. Writes to the L2ARC devices are grouped and sent in-sequence, so that 3999 * the vdev queue can aggregate them into larger and fewer writes. Each 4000 * device is written to in a rotor fashion, sweeping writes through 4001 * available space then repeating. 4002 * 4003 * 7. The L2ARC does not store dirty content. It never needs to flush 4004 * write buffers back to disk based storage. 4005 * 4006 * 8. If an ARC buffer is written (and dirtied) which also exists in the 4007 * L2ARC, the now stale L2ARC buffer is immediately dropped. 4008 * 4009 * The performance of the L2ARC can be tweaked by a number of tunables, which 4010 * may be necessary for different workloads: 4011 * 4012 * l2arc_write_max max write bytes per interval 4013 * l2arc_write_boost extra write bytes during device warmup 4014 * l2arc_noprefetch skip caching prefetched buffers 4015 * l2arc_headroom number of max device writes to precache 4016 * l2arc_headroom_boost when we find compressed buffers during ARC 4017 * scanning, we multiply headroom by this 4018 * percentage factor for the next scan cycle, 4019 * since more compressed buffers are likely to 4020 * be present 4021 * l2arc_feed_secs seconds between L2ARC writing 4022 * 4023 * Tunables may be removed or added as future performance improvements are 4024 * integrated, and also may become zpool properties. 4025 * 4026 * There are three key functions that control how the L2ARC warms up: 4027 * 4028 * l2arc_write_eligible() check if a buffer is eligible to cache 4029 * l2arc_write_size() calculate how much to write 4030 * l2arc_write_interval() calculate sleep delay between writes 4031 * 4032 * These three functions determine what to write, how much, and how quickly 4033 * to send writes. 4034 */ 4035 4036 static boolean_t 4037 l2arc_write_eligible(uint64_t spa_guid, arc_buf_hdr_t *ab) 4038 { 4039 /* 4040 * A buffer is *not* eligible for the L2ARC if it: 4041 * 1. belongs to a different spa. 4042 * 2. is already cached on the L2ARC. 4043 * 3. has an I/O in progress (it may be an incomplete read). 4044 * 4. is flagged not eligible (zfs property). 4045 */ 4046 if (ab->b_spa != spa_guid || ab->b_l2hdr != NULL || 4047 HDR_IO_IN_PROGRESS(ab) || !HDR_L2CACHE(ab)) 4048 return (B_FALSE); 4049 4050 return (B_TRUE); 4051 } 4052 4053 static uint64_t 4054 l2arc_write_size(void) 4055 { 4056 uint64_t size; 4057 4058 /* 4059 * Make sure our globals have meaningful values in case the user 4060 * altered them. 4061 */ 4062 size = l2arc_write_max; 4063 if (size == 0) { 4064 cmn_err(CE_NOTE, "Bad value for l2arc_write_max, value must " 4065 "be greater than zero, resetting it to the default (%d)", 4066 L2ARC_WRITE_SIZE); 4067 size = l2arc_write_max = L2ARC_WRITE_SIZE; 4068 } 4069 4070 if (arc_warm == B_FALSE) 4071 size += l2arc_write_boost; 4072 4073 return (size); 4074 4075 } 4076 4077 static clock_t 4078 l2arc_write_interval(clock_t began, uint64_t wanted, uint64_t wrote) 4079 { 4080 clock_t interval, next, now; 4081 4082 /* 4083 * If the ARC lists are busy, increase our write rate; if the 4084 * lists are stale, idle back. This is achieved by checking 4085 * how much we previously wrote - if it was more than half of 4086 * what we wanted, schedule the next write much sooner. 4087 */ 4088 if (l2arc_feed_again && wrote > (wanted / 2)) 4089 interval = (hz * l2arc_feed_min_ms) / 1000; 4090 else 4091 interval = hz * l2arc_feed_secs; 4092 4093 now = ddi_get_lbolt(); 4094 next = MAX(now, MIN(now + interval, began + interval)); 4095 4096 return (next); 4097 } 4098 4099 static void 4100 l2arc_hdr_stat_add(void) 4101 { 4102 ARCSTAT_INCR(arcstat_l2_hdr_size, HDR_SIZE + L2HDR_SIZE); 4103 ARCSTAT_INCR(arcstat_hdr_size, -HDR_SIZE); 4104 } 4105 4106 static void 4107 l2arc_hdr_stat_remove(void) 4108 { 4109 ARCSTAT_INCR(arcstat_l2_hdr_size, -(HDR_SIZE + L2HDR_SIZE)); 4110 ARCSTAT_INCR(arcstat_hdr_size, HDR_SIZE); 4111 } 4112 4113 /* 4114 * Cycle through L2ARC devices. This is how L2ARC load balances. 4115 * If a device is returned, this also returns holding the spa config lock. 4116 */ 4117 static l2arc_dev_t * 4118 l2arc_dev_get_next(void) 4119 { 4120 l2arc_dev_t *first, *next = NULL; 4121 4122 /* 4123 * Lock out the removal of spas (spa_namespace_lock), then removal 4124 * of cache devices (l2arc_dev_mtx). Once a device has been selected, 4125 * both locks will be dropped and a spa config lock held instead. 4126 */ 4127 mutex_enter(&spa_namespace_lock); 4128 mutex_enter(&l2arc_dev_mtx); 4129 4130 /* if there are no vdevs, there is nothing to do */ 4131 if (l2arc_ndev == 0) 4132 goto out; 4133 4134 first = NULL; 4135 next = l2arc_dev_last; 4136 do { 4137 /* loop around the list looking for a non-faulted vdev */ 4138 if (next == NULL) { 4139 next = list_head(l2arc_dev_list); 4140 } else { 4141 next = list_next(l2arc_dev_list, next); 4142 if (next == NULL) 4143 next = list_head(l2arc_dev_list); 4144 } 4145 4146 /* if we have come back to the start, bail out */ 4147 if (first == NULL) 4148 first = next; 4149 else if (next == first) 4150 break; 4151 4152 } while (vdev_is_dead(next->l2ad_vdev)); 4153 4154 /* if we were unable to find any usable vdevs, return NULL */ 4155 if (vdev_is_dead(next->l2ad_vdev)) 4156 next = NULL; 4157 4158 l2arc_dev_last = next; 4159 4160 out: 4161 mutex_exit(&l2arc_dev_mtx); 4162 4163 /* 4164 * Grab the config lock to prevent the 'next' device from being 4165 * removed while we are writing to it. 4166 */ 4167 if (next != NULL) 4168 spa_config_enter(next->l2ad_spa, SCL_L2ARC, next, RW_READER); 4169 mutex_exit(&spa_namespace_lock); 4170 4171 return (next); 4172 } 4173 4174 /* 4175 * Free buffers that were tagged for destruction. 4176 */ 4177 static void 4178 l2arc_do_free_on_write() 4179 { 4180 list_t *buflist; 4181 l2arc_data_free_t *df, *df_prev; 4182 4183 mutex_enter(&l2arc_free_on_write_mtx); 4184 buflist = l2arc_free_on_write; 4185 4186 for (df = list_tail(buflist); df; df = df_prev) { 4187 df_prev = list_prev(buflist, df); 4188 ASSERT(df->l2df_data != NULL); 4189 ASSERT(df->l2df_func != NULL); 4190 df->l2df_func(df->l2df_data, df->l2df_size); 4191 list_remove(buflist, df); 4192 kmem_free(df, sizeof (l2arc_data_free_t)); 4193 } 4194 4195 mutex_exit(&l2arc_free_on_write_mtx); 4196 } 4197 4198 /* 4199 * A write to a cache device has completed. Update all headers to allow 4200 * reads from these buffers to begin. 4201 */ 4202 static void 4203 l2arc_write_done(zio_t *zio) 4204 { 4205 l2arc_write_callback_t *cb; 4206 l2arc_dev_t *dev; 4207 list_t *buflist; 4208 arc_buf_hdr_t *head, *ab, *ab_prev; 4209 l2arc_buf_hdr_t *abl2; 4210 kmutex_t *hash_lock; 4211 4212 cb = zio->io_private; 4213 ASSERT(cb != NULL); 4214 dev = cb->l2wcb_dev; 4215 ASSERT(dev != NULL); 4216 head = cb->l2wcb_head; 4217 ASSERT(head != NULL); 4218 buflist = dev->l2ad_buflist; 4219 ASSERT(buflist != NULL); 4220 DTRACE_PROBE2(l2arc__iodone, zio_t *, zio, 4221 l2arc_write_callback_t *, cb); 4222 4223 if (zio->io_error != 0) 4224 ARCSTAT_BUMP(arcstat_l2_writes_error); 4225 4226 mutex_enter(&l2arc_buflist_mtx); 4227 4228 /* 4229 * All writes completed, or an error was hit. 4230 */ 4231 for (ab = list_prev(buflist, head); ab; ab = ab_prev) { 4232 ab_prev = list_prev(buflist, ab); 4233 4234 hash_lock = HDR_LOCK(ab); 4235 if (!mutex_tryenter(hash_lock)) { 4236 /* 4237 * This buffer misses out. It may be in a stage 4238 * of eviction. Its ARC_L2_WRITING flag will be 4239 * left set, denying reads to this buffer. 4240 */ 4241 ARCSTAT_BUMP(arcstat_l2_writes_hdr_miss); 4242 continue; 4243 } 4244 4245 abl2 = ab->b_l2hdr; 4246 4247 /* 4248 * Release the temporary compressed buffer as soon as possible. 4249 */ 4250 if (abl2->b_compress != ZIO_COMPRESS_OFF) 4251 l2arc_release_cdata_buf(ab); 4252 4253 if (zio->io_error != 0) { 4254 /* 4255 * Error - drop L2ARC entry. 4256 */ 4257 list_remove(buflist, ab); 4258 ARCSTAT_INCR(arcstat_l2_asize, -abl2->b_asize); 4259 ab->b_l2hdr = NULL; 4260 kmem_free(abl2, sizeof (l2arc_buf_hdr_t)); 4261 ARCSTAT_INCR(arcstat_l2_size, -ab->b_size); 4262 } 4263 4264 /* 4265 * Allow ARC to begin reads to this L2ARC entry. 4266 */ 4267 ab->b_flags &= ~ARC_L2_WRITING; 4268 4269 mutex_exit(hash_lock); 4270 } 4271 4272 atomic_inc_64(&l2arc_writes_done); 4273 list_remove(buflist, head); 4274 kmem_cache_free(hdr_cache, head); 4275 mutex_exit(&l2arc_buflist_mtx); 4276 4277 l2arc_do_free_on_write(); 4278 4279 kmem_free(cb, sizeof (l2arc_write_callback_t)); 4280 } 4281 4282 /* 4283 * A read to a cache device completed. Validate buffer contents before 4284 * handing over to the regular ARC routines. 4285 */ 4286 static void 4287 l2arc_read_done(zio_t *zio) 4288 { 4289 l2arc_read_callback_t *cb; 4290 arc_buf_hdr_t *hdr; 4291 arc_buf_t *buf; 4292 kmutex_t *hash_lock; 4293 int equal; 4294 4295 ASSERT(zio->io_vd != NULL); 4296 ASSERT(zio->io_flags & ZIO_FLAG_DONT_PROPAGATE); 4297 4298 spa_config_exit(zio->io_spa, SCL_L2ARC, zio->io_vd); 4299 4300 cb = zio->io_private; 4301 ASSERT(cb != NULL); 4302 buf = cb->l2rcb_buf; 4303 ASSERT(buf != NULL); 4304 4305 hash_lock = HDR_LOCK(buf->b_hdr); 4306 mutex_enter(hash_lock); 4307 hdr = buf->b_hdr; 4308 ASSERT3P(hash_lock, ==, HDR_LOCK(hdr)); 4309 4310 /* 4311 * If the buffer was compressed, decompress it first. 4312 */ 4313 if (cb->l2rcb_compress != ZIO_COMPRESS_OFF) 4314 l2arc_decompress_zio(zio, hdr, cb->l2rcb_compress); 4315 ASSERT(zio->io_data != NULL); 4316 4317 /* 4318 * Check this survived the L2ARC journey. 4319 */ 4320 equal = arc_cksum_equal(buf); 4321 if (equal && zio->io_error == 0 && !HDR_L2_EVICTED(hdr)) { 4322 mutex_exit(hash_lock); 4323 zio->io_private = buf; 4324 zio->io_bp_copy = cb->l2rcb_bp; /* XXX fix in L2ARC 2.0 */ 4325 zio->io_bp = &zio->io_bp_copy; /* XXX fix in L2ARC 2.0 */ 4326 arc_read_done(zio); 4327 } else { 4328 mutex_exit(hash_lock); 4329 /* 4330 * Buffer didn't survive caching. Increment stats and 4331 * reissue to the original storage device. 4332 */ 4333 if (zio->io_error != 0) { 4334 ARCSTAT_BUMP(arcstat_l2_io_error); 4335 } else { 4336 zio->io_error = SET_ERROR(EIO); 4337 } 4338 if (!equal) 4339 ARCSTAT_BUMP(arcstat_l2_cksum_bad); 4340 4341 /* 4342 * If there's no waiter, issue an async i/o to the primary 4343 * storage now. If there *is* a waiter, the caller must 4344 * issue the i/o in a context where it's OK to block. 4345 */ 4346 if (zio->io_waiter == NULL) { 4347 zio_t *pio = zio_unique_parent(zio); 4348 4349 ASSERT(!pio || pio->io_child_type == ZIO_CHILD_LOGICAL); 4350 4351 zio_nowait(zio_read(pio, cb->l2rcb_spa, &cb->l2rcb_bp, 4352 buf->b_data, zio->io_size, arc_read_done, buf, 4353 zio->io_priority, cb->l2rcb_flags, &cb->l2rcb_zb)); 4354 } 4355 } 4356 4357 kmem_free(cb, sizeof (l2arc_read_callback_t)); 4358 } 4359 4360 /* 4361 * This is the list priority from which the L2ARC will search for pages to 4362 * cache. This is used within loops (0..3) to cycle through lists in the 4363 * desired order. This order can have a significant effect on cache 4364 * performance. 4365 * 4366 * Currently the metadata lists are hit first, MFU then MRU, followed by 4367 * the data lists. This function returns a locked list, and also returns 4368 * the lock pointer. 4369 */ 4370 static list_t * 4371 l2arc_list_locked(int list_num, kmutex_t **lock) 4372 { 4373 list_t *list = NULL; 4374 4375 ASSERT(list_num >= 0 && list_num <= 3); 4376 4377 switch (list_num) { 4378 case 0: 4379 list = &arc_mfu->arcs_list[ARC_BUFC_METADATA]; 4380 *lock = &arc_mfu->arcs_mtx; 4381 break; 4382 case 1: 4383 list = &arc_mru->arcs_list[ARC_BUFC_METADATA]; 4384 *lock = &arc_mru->arcs_mtx; 4385 break; 4386 case 2: 4387 list = &arc_mfu->arcs_list[ARC_BUFC_DATA]; 4388 *lock = &arc_mfu->arcs_mtx; 4389 break; 4390 case 3: 4391 list = &arc_mru->arcs_list[ARC_BUFC_DATA]; 4392 *lock = &arc_mru->arcs_mtx; 4393 break; 4394 } 4395 4396 ASSERT(!(MUTEX_HELD(*lock))); 4397 mutex_enter(*lock); 4398 return (list); 4399 } 4400 4401 /* 4402 * Evict buffers from the device write hand to the distance specified in 4403 * bytes. This distance may span populated buffers, it may span nothing. 4404 * This is clearing a region on the L2ARC device ready for writing. 4405 * If the 'all' boolean is set, every buffer is evicted. 4406 */ 4407 static void 4408 l2arc_evict(l2arc_dev_t *dev, uint64_t distance, boolean_t all) 4409 { 4410 list_t *buflist; 4411 l2arc_buf_hdr_t *abl2; 4412 arc_buf_hdr_t *ab, *ab_prev; 4413 kmutex_t *hash_lock; 4414 uint64_t taddr; 4415 4416 buflist = dev->l2ad_buflist; 4417 4418 if (buflist == NULL) 4419 return; 4420 4421 if (!all && dev->l2ad_first) { 4422 /* 4423 * This is the first sweep through the device. There is 4424 * nothing to evict. 4425 */ 4426 return; 4427 } 4428 4429 if (dev->l2ad_hand >= (dev->l2ad_end - (2 * distance))) { 4430 /* 4431 * When nearing the end of the device, evict to the end 4432 * before the device write hand jumps to the start. 4433 */ 4434 taddr = dev->l2ad_end; 4435 } else { 4436 taddr = dev->l2ad_hand + distance; 4437 } 4438 DTRACE_PROBE4(l2arc__evict, l2arc_dev_t *, dev, list_t *, buflist, 4439 uint64_t, taddr, boolean_t, all); 4440 4441 top: 4442 mutex_enter(&l2arc_buflist_mtx); 4443 for (ab = list_tail(buflist); ab; ab = ab_prev) { 4444 ab_prev = list_prev(buflist, ab); 4445 4446 hash_lock = HDR_LOCK(ab); 4447 if (!mutex_tryenter(hash_lock)) { 4448 /* 4449 * Missed the hash lock. Retry. 4450 */ 4451 ARCSTAT_BUMP(arcstat_l2_evict_lock_retry); 4452 mutex_exit(&l2arc_buflist_mtx); 4453 mutex_enter(hash_lock); 4454 mutex_exit(hash_lock); 4455 goto top; 4456 } 4457 4458 if (HDR_L2_WRITE_HEAD(ab)) { 4459 /* 4460 * We hit a write head node. Leave it for 4461 * l2arc_write_done(). 4462 */ 4463 list_remove(buflist, ab); 4464 mutex_exit(hash_lock); 4465 continue; 4466 } 4467 4468 if (!all && ab->b_l2hdr != NULL && 4469 (ab->b_l2hdr->b_daddr > taddr || 4470 ab->b_l2hdr->b_daddr < dev->l2ad_hand)) { 4471 /* 4472 * We've evicted to the target address, 4473 * or the end of the device. 4474 */ 4475 mutex_exit(hash_lock); 4476 break; 4477 } 4478 4479 if (HDR_FREE_IN_PROGRESS(ab)) { 4480 /* 4481 * Already on the path to destruction. 4482 */ 4483 mutex_exit(hash_lock); 4484 continue; 4485 } 4486 4487 if (ab->b_state == arc_l2c_only) { 4488 ASSERT(!HDR_L2_READING(ab)); 4489 /* 4490 * This doesn't exist in the ARC. Destroy. 4491 * arc_hdr_destroy() will call list_remove() 4492 * and decrement arcstat_l2_size. 4493 */ 4494 arc_change_state(arc_anon, ab, hash_lock); 4495 arc_hdr_destroy(ab); 4496 } else { 4497 /* 4498 * Invalidate issued or about to be issued 4499 * reads, since we may be about to write 4500 * over this location. 4501 */ 4502 if (HDR_L2_READING(ab)) { 4503 ARCSTAT_BUMP(arcstat_l2_evict_reading); 4504 ab->b_flags |= ARC_L2_EVICTED; 4505 } 4506 4507 /* 4508 * Tell ARC this no longer exists in L2ARC. 4509 */ 4510 if (ab->b_l2hdr != NULL) { 4511 abl2 = ab->b_l2hdr; 4512 ARCSTAT_INCR(arcstat_l2_asize, -abl2->b_asize); 4513 ab->b_l2hdr = NULL; 4514 kmem_free(abl2, sizeof (l2arc_buf_hdr_t)); 4515 ARCSTAT_INCR(arcstat_l2_size, -ab->b_size); 4516 } 4517 list_remove(buflist, ab); 4518 4519 /* 4520 * This may have been leftover after a 4521 * failed write. 4522 */ 4523 ab->b_flags &= ~ARC_L2_WRITING; 4524 } 4525 mutex_exit(hash_lock); 4526 } 4527 mutex_exit(&l2arc_buflist_mtx); 4528 4529 vdev_space_update(dev->l2ad_vdev, -(taddr - dev->l2ad_evict), 0, 0); 4530 dev->l2ad_evict = taddr; 4531 } 4532 4533 /* 4534 * Find and write ARC buffers to the L2ARC device. 4535 * 4536 * An ARC_L2_WRITING flag is set so that the L2ARC buffers are not valid 4537 * for reading until they have completed writing. 4538 * The headroom_boost is an in-out parameter used to maintain headroom boost 4539 * state between calls to this function. 4540 * 4541 * Returns the number of bytes actually written (which may be smaller than 4542 * the delta by which the device hand has changed due to alignment). 4543 */ 4544 static uint64_t 4545 l2arc_write_buffers(spa_t *spa, l2arc_dev_t *dev, uint64_t target_sz, 4546 boolean_t *headroom_boost) 4547 { 4548 arc_buf_hdr_t *ab, *ab_prev, *head; 4549 list_t *list; 4550 uint64_t write_asize, write_psize, write_sz, headroom, 4551 buf_compress_minsz; 4552 void *buf_data; 4553 kmutex_t *list_lock; 4554 boolean_t full; 4555 l2arc_write_callback_t *cb; 4556 zio_t *pio, *wzio; 4557 uint64_t guid = spa_load_guid(spa); 4558 const boolean_t do_headroom_boost = *headroom_boost; 4559 4560 ASSERT(dev->l2ad_vdev != NULL); 4561 4562 /* Lower the flag now, we might want to raise it again later. */ 4563 *headroom_boost = B_FALSE; 4564 4565 pio = NULL; 4566 write_sz = write_asize = write_psize = 0; 4567 full = B_FALSE; 4568 head = kmem_cache_alloc(hdr_cache, KM_PUSHPAGE); 4569 head->b_flags |= ARC_L2_WRITE_HEAD; 4570 4571 /* 4572 * We will want to try to compress buffers that are at least 2x the 4573 * device sector size. 4574 */ 4575 buf_compress_minsz = 2 << dev->l2ad_vdev->vdev_ashift; 4576 4577 /* 4578 * Copy buffers for L2ARC writing. 4579 */ 4580 mutex_enter(&l2arc_buflist_mtx); 4581 for (int try = 0; try <= 3; try++) { 4582 uint64_t passed_sz = 0; 4583 4584 list = l2arc_list_locked(try, &list_lock); 4585 4586 /* 4587 * L2ARC fast warmup. 4588 * 4589 * Until the ARC is warm and starts to evict, read from the 4590 * head of the ARC lists rather than the tail. 4591 */ 4592 if (arc_warm == B_FALSE) 4593 ab = list_head(list); 4594 else 4595 ab = list_tail(list); 4596 4597 headroom = target_sz * l2arc_headroom; 4598 if (do_headroom_boost) 4599 headroom = (headroom * l2arc_headroom_boost) / 100; 4600 4601 for (; ab; ab = ab_prev) { 4602 l2arc_buf_hdr_t *l2hdr; 4603 kmutex_t *hash_lock; 4604 uint64_t buf_sz; 4605 4606 if (arc_warm == B_FALSE) 4607 ab_prev = list_next(list, ab); 4608 else 4609 ab_prev = list_prev(list, ab); 4610 4611 hash_lock = HDR_LOCK(ab); 4612 if (!mutex_tryenter(hash_lock)) { 4613 /* 4614 * Skip this buffer rather than waiting. 4615 */ 4616 continue; 4617 } 4618 4619 passed_sz += ab->b_size; 4620 if (passed_sz > headroom) { 4621 /* 4622 * Searched too far. 4623 */ 4624 mutex_exit(hash_lock); 4625 break; 4626 } 4627 4628 if (!l2arc_write_eligible(guid, ab)) { 4629 mutex_exit(hash_lock); 4630 continue; 4631 } 4632 4633 if ((write_sz + ab->b_size) > target_sz) { 4634 full = B_TRUE; 4635 mutex_exit(hash_lock); 4636 break; 4637 } 4638 4639 if (pio == NULL) { 4640 /* 4641 * Insert a dummy header on the buflist so 4642 * l2arc_write_done() can find where the 4643 * write buffers begin without searching. 4644 */ 4645 list_insert_head(dev->l2ad_buflist, head); 4646 4647 cb = kmem_alloc( 4648 sizeof (l2arc_write_callback_t), KM_SLEEP); 4649 cb->l2wcb_dev = dev; 4650 cb->l2wcb_head = head; 4651 pio = zio_root(spa, l2arc_write_done, cb, 4652 ZIO_FLAG_CANFAIL); 4653 } 4654 4655 /* 4656 * Create and add a new L2ARC header. 4657 */ 4658 l2hdr = kmem_zalloc(sizeof (l2arc_buf_hdr_t), KM_SLEEP); 4659 l2hdr->b_dev = dev; 4660 ab->b_flags |= ARC_L2_WRITING; 4661 4662 /* 4663 * Temporarily stash the data buffer in b_tmp_cdata. 4664 * The subsequent write step will pick it up from 4665 * there. This is because can't access ab->b_buf 4666 * without holding the hash_lock, which we in turn 4667 * can't access without holding the ARC list locks 4668 * (which we want to avoid during compression/writing). 4669 */ 4670 l2hdr->b_compress = ZIO_COMPRESS_OFF; 4671 l2hdr->b_asize = ab->b_size; 4672 l2hdr->b_tmp_cdata = ab->b_buf->b_data; 4673 4674 buf_sz = ab->b_size; 4675 ab->b_l2hdr = l2hdr; 4676 4677 list_insert_head(dev->l2ad_buflist, ab); 4678 4679 /* 4680 * Compute and store the buffer cksum before 4681 * writing. On debug the cksum is verified first. 4682 */ 4683 arc_cksum_verify(ab->b_buf); 4684 arc_cksum_compute(ab->b_buf, B_TRUE); 4685 4686 mutex_exit(hash_lock); 4687 4688 write_sz += buf_sz; 4689 } 4690 4691 mutex_exit(list_lock); 4692 4693 if (full == B_TRUE) 4694 break; 4695 } 4696 4697 /* No buffers selected for writing? */ 4698 if (pio == NULL) { 4699 ASSERT0(write_sz); 4700 mutex_exit(&l2arc_buflist_mtx); 4701 kmem_cache_free(hdr_cache, head); 4702 return (0); 4703 } 4704 4705 /* 4706 * Now start writing the buffers. We're starting at the write head 4707 * and work backwards, retracing the course of the buffer selector 4708 * loop above. 4709 */ 4710 for (ab = list_prev(dev->l2ad_buflist, head); ab; 4711 ab = list_prev(dev->l2ad_buflist, ab)) { 4712 l2arc_buf_hdr_t *l2hdr; 4713 uint64_t buf_sz; 4714 4715 /* 4716 * We shouldn't need to lock the buffer here, since we flagged 4717 * it as ARC_L2_WRITING in the previous step, but we must take 4718 * care to only access its L2 cache parameters. In particular, 4719 * ab->b_buf may be invalid by now due to ARC eviction. 4720 */ 4721 l2hdr = ab->b_l2hdr; 4722 l2hdr->b_daddr = dev->l2ad_hand; 4723 4724 if ((ab->b_flags & ARC_L2COMPRESS) && 4725 l2hdr->b_asize >= buf_compress_minsz) { 4726 if (l2arc_compress_buf(l2hdr)) { 4727 /* 4728 * If compression succeeded, enable headroom 4729 * boost on the next scan cycle. 4730 */ 4731 *headroom_boost = B_TRUE; 4732 } 4733 } 4734 4735 /* 4736 * Pick up the buffer data we had previously stashed away 4737 * (and now potentially also compressed). 4738 */ 4739 buf_data = l2hdr->b_tmp_cdata; 4740 buf_sz = l2hdr->b_asize; 4741 4742 /* Compression may have squashed the buffer to zero length. */ 4743 if (buf_sz != 0) { 4744 uint64_t buf_p_sz; 4745 4746 wzio = zio_write_phys(pio, dev->l2ad_vdev, 4747 dev->l2ad_hand, buf_sz, buf_data, ZIO_CHECKSUM_OFF, 4748 NULL, NULL, ZIO_PRIORITY_ASYNC_WRITE, 4749 ZIO_FLAG_CANFAIL, B_FALSE); 4750 4751 DTRACE_PROBE2(l2arc__write, vdev_t *, dev->l2ad_vdev, 4752 zio_t *, wzio); 4753 (void) zio_nowait(wzio); 4754 4755 write_asize += buf_sz; 4756 /* 4757 * Keep the clock hand suitably device-aligned. 4758 */ 4759 buf_p_sz = vdev_psize_to_asize(dev->l2ad_vdev, buf_sz); 4760 write_psize += buf_p_sz; 4761 dev->l2ad_hand += buf_p_sz; 4762 } 4763 } 4764 4765 mutex_exit(&l2arc_buflist_mtx); 4766 4767 ASSERT3U(write_asize, <=, target_sz); 4768 ARCSTAT_BUMP(arcstat_l2_writes_sent); 4769 ARCSTAT_INCR(arcstat_l2_write_bytes, write_asize); 4770 ARCSTAT_INCR(arcstat_l2_size, write_sz); 4771 ARCSTAT_INCR(arcstat_l2_asize, write_asize); 4772 vdev_space_update(dev->l2ad_vdev, write_psize, 0, 0); 4773 4774 /* 4775 * Bump device hand to the device start if it is approaching the end. 4776 * l2arc_evict() will already have evicted ahead for this case. 4777 */ 4778 if (dev->l2ad_hand >= (dev->l2ad_end - target_sz)) { 4779 vdev_space_update(dev->l2ad_vdev, 4780 dev->l2ad_end - dev->l2ad_hand, 0, 0); 4781 dev->l2ad_hand = dev->l2ad_start; 4782 dev->l2ad_evict = dev->l2ad_start; 4783 dev->l2ad_first = B_FALSE; 4784 } 4785 4786 dev->l2ad_writing = B_TRUE; 4787 (void) zio_wait(pio); 4788 dev->l2ad_writing = B_FALSE; 4789 4790 return (write_asize); 4791 } 4792 4793 /* 4794 * Compresses an L2ARC buffer. 4795 * The data to be compressed must be prefilled in l2hdr->b_tmp_cdata and its 4796 * size in l2hdr->b_asize. This routine tries to compress the data and 4797 * depending on the compression result there are three possible outcomes: 4798 * *) The buffer was incompressible. The original l2hdr contents were left 4799 * untouched and are ready for writing to an L2 device. 4800 * *) The buffer was all-zeros, so there is no need to write it to an L2 4801 * device. To indicate this situation b_tmp_cdata is NULL'ed, b_asize is 4802 * set to zero and b_compress is set to ZIO_COMPRESS_EMPTY. 4803 * *) Compression succeeded and b_tmp_cdata was replaced with a temporary 4804 * data buffer which holds the compressed data to be written, and b_asize 4805 * tells us how much data there is. b_compress is set to the appropriate 4806 * compression algorithm. Once writing is done, invoke 4807 * l2arc_release_cdata_buf on this l2hdr to free this temporary buffer. 4808 * 4809 * Returns B_TRUE if compression succeeded, or B_FALSE if it didn't (the 4810 * buffer was incompressible). 4811 */ 4812 static boolean_t 4813 l2arc_compress_buf(l2arc_buf_hdr_t *l2hdr) 4814 { 4815 void *cdata; 4816 size_t csize, len; 4817 4818 ASSERT(l2hdr->b_compress == ZIO_COMPRESS_OFF); 4819 ASSERT(l2hdr->b_tmp_cdata != NULL); 4820 4821 len = l2hdr->b_asize; 4822 cdata = zio_data_buf_alloc(len); 4823 csize = zio_compress_data(ZIO_COMPRESS_LZ4, l2hdr->b_tmp_cdata, 4824 cdata, l2hdr->b_asize); 4825 4826 if (csize == 0) { 4827 /* zero block, indicate that there's nothing to write */ 4828 zio_data_buf_free(cdata, len); 4829 l2hdr->b_compress = ZIO_COMPRESS_EMPTY; 4830 l2hdr->b_asize = 0; 4831 l2hdr->b_tmp_cdata = NULL; 4832 ARCSTAT_BUMP(arcstat_l2_compress_zeros); 4833 return (B_TRUE); 4834 } else if (csize > 0 && csize < len) { 4835 /* 4836 * Compression succeeded, we'll keep the cdata around for 4837 * writing and release it afterwards. 4838 */ 4839 l2hdr->b_compress = ZIO_COMPRESS_LZ4; 4840 l2hdr->b_asize = csize; 4841 l2hdr->b_tmp_cdata = cdata; 4842 ARCSTAT_BUMP(arcstat_l2_compress_successes); 4843 return (B_TRUE); 4844 } else { 4845 /* 4846 * Compression failed, release the compressed buffer. 4847 * l2hdr will be left unmodified. 4848 */ 4849 zio_data_buf_free(cdata, len); 4850 ARCSTAT_BUMP(arcstat_l2_compress_failures); 4851 return (B_FALSE); 4852 } 4853 } 4854 4855 /* 4856 * Decompresses a zio read back from an l2arc device. On success, the 4857 * underlying zio's io_data buffer is overwritten by the uncompressed 4858 * version. On decompression error (corrupt compressed stream), the 4859 * zio->io_error value is set to signal an I/O error. 4860 * 4861 * Please note that the compressed data stream is not checksummed, so 4862 * if the underlying device is experiencing data corruption, we may feed 4863 * corrupt data to the decompressor, so the decompressor needs to be 4864 * able to handle this situation (LZ4 does). 4865 */ 4866 static void 4867 l2arc_decompress_zio(zio_t *zio, arc_buf_hdr_t *hdr, enum zio_compress c) 4868 { 4869 ASSERT(L2ARC_IS_VALID_COMPRESS(c)); 4870 4871 if (zio->io_error != 0) { 4872 /* 4873 * An io error has occured, just restore the original io 4874 * size in preparation for a main pool read. 4875 */ 4876 zio->io_orig_size = zio->io_size = hdr->b_size; 4877 return; 4878 } 4879 4880 if (c == ZIO_COMPRESS_EMPTY) { 4881 /* 4882 * An empty buffer results in a null zio, which means we 4883 * need to fill its io_data after we're done restoring the 4884 * buffer's contents. 4885 */ 4886 ASSERT(hdr->b_buf != NULL); 4887 bzero(hdr->b_buf->b_data, hdr->b_size); 4888 zio->io_data = zio->io_orig_data = hdr->b_buf->b_data; 4889 } else { 4890 ASSERT(zio->io_data != NULL); 4891 /* 4892 * We copy the compressed data from the start of the arc buffer 4893 * (the zio_read will have pulled in only what we need, the 4894 * rest is garbage which we will overwrite at decompression) 4895 * and then decompress back to the ARC data buffer. This way we 4896 * can minimize copying by simply decompressing back over the 4897 * original compressed data (rather than decompressing to an 4898 * aux buffer and then copying back the uncompressed buffer, 4899 * which is likely to be much larger). 4900 */ 4901 uint64_t csize; 4902 void *cdata; 4903 4904 csize = zio->io_size; 4905 cdata = zio_data_buf_alloc(csize); 4906 bcopy(zio->io_data, cdata, csize); 4907 if (zio_decompress_data(c, cdata, zio->io_data, csize, 4908 hdr->b_size) != 0) 4909 zio->io_error = EIO; 4910 zio_data_buf_free(cdata, csize); 4911 } 4912 4913 /* Restore the expected uncompressed IO size. */ 4914 zio->io_orig_size = zio->io_size = hdr->b_size; 4915 } 4916 4917 /* 4918 * Releases the temporary b_tmp_cdata buffer in an l2arc header structure. 4919 * This buffer serves as a temporary holder of compressed data while 4920 * the buffer entry is being written to an l2arc device. Once that is 4921 * done, we can dispose of it. 4922 */ 4923 static void 4924 l2arc_release_cdata_buf(arc_buf_hdr_t *ab) 4925 { 4926 l2arc_buf_hdr_t *l2hdr = ab->b_l2hdr; 4927 4928 if (l2hdr->b_compress == ZIO_COMPRESS_LZ4) { 4929 /* 4930 * If the data was compressed, then we've allocated a 4931 * temporary buffer for it, so now we need to release it. 4932 */ 4933 ASSERT(l2hdr->b_tmp_cdata != NULL); 4934 zio_data_buf_free(l2hdr->b_tmp_cdata, ab->b_size); 4935 } 4936 l2hdr->b_tmp_cdata = NULL; 4937 } 4938 4939 /* 4940 * This thread feeds the L2ARC at regular intervals. This is the beating 4941 * heart of the L2ARC. 4942 */ 4943 static void 4944 l2arc_feed_thread(void) 4945 { 4946 callb_cpr_t cpr; 4947 l2arc_dev_t *dev; 4948 spa_t *spa; 4949 uint64_t size, wrote; 4950 clock_t begin, next = ddi_get_lbolt(); 4951 boolean_t headroom_boost = B_FALSE; 4952 4953 CALLB_CPR_INIT(&cpr, &l2arc_feed_thr_lock, callb_generic_cpr, FTAG); 4954 4955 mutex_enter(&l2arc_feed_thr_lock); 4956 4957 while (l2arc_thread_exit == 0) { 4958 CALLB_CPR_SAFE_BEGIN(&cpr); 4959 (void) cv_timedwait(&l2arc_feed_thr_cv, &l2arc_feed_thr_lock, 4960 next); 4961 CALLB_CPR_SAFE_END(&cpr, &l2arc_feed_thr_lock); 4962 next = ddi_get_lbolt() + hz; 4963 4964 /* 4965 * Quick check for L2ARC devices. 4966 */ 4967 mutex_enter(&l2arc_dev_mtx); 4968 if (l2arc_ndev == 0) { 4969 mutex_exit(&l2arc_dev_mtx); 4970 continue; 4971 } 4972 mutex_exit(&l2arc_dev_mtx); 4973 begin = ddi_get_lbolt(); 4974 4975 /* 4976 * This selects the next l2arc device to write to, and in 4977 * doing so the next spa to feed from: dev->l2ad_spa. This 4978 * will return NULL if there are now no l2arc devices or if 4979 * they are all faulted. 4980 * 4981 * If a device is returned, its spa's config lock is also 4982 * held to prevent device removal. l2arc_dev_get_next() 4983 * will grab and release l2arc_dev_mtx. 4984 */ 4985 if ((dev = l2arc_dev_get_next()) == NULL) 4986 continue; 4987 4988 spa = dev->l2ad_spa; 4989 ASSERT(spa != NULL); 4990 4991 /* 4992 * If the pool is read-only then force the feed thread to 4993 * sleep a little longer. 4994 */ 4995 if (!spa_writeable(spa)) { 4996 next = ddi_get_lbolt() + 5 * l2arc_feed_secs * hz; 4997 spa_config_exit(spa, SCL_L2ARC, dev); 4998 continue; 4999 } 5000 5001 /* 5002 * Avoid contributing to memory pressure. 5003 */ 5004 if (arc_reclaim_needed()) { 5005 ARCSTAT_BUMP(arcstat_l2_abort_lowmem); 5006 spa_config_exit(spa, SCL_L2ARC, dev); 5007 continue; 5008 } 5009 5010 ARCSTAT_BUMP(arcstat_l2_feeds); 5011 5012 size = l2arc_write_size(); 5013 5014 /* 5015 * Evict L2ARC buffers that will be overwritten. 5016 */ 5017 l2arc_evict(dev, size, B_FALSE); 5018 5019 /* 5020 * Write ARC buffers. 5021 */ 5022 wrote = l2arc_write_buffers(spa, dev, size, &headroom_boost); 5023 5024 /* 5025 * Calculate interval between writes. 5026 */ 5027 next = l2arc_write_interval(begin, size, wrote); 5028 spa_config_exit(spa, SCL_L2ARC, dev); 5029 } 5030 5031 l2arc_thread_exit = 0; 5032 cv_broadcast(&l2arc_feed_thr_cv); 5033 CALLB_CPR_EXIT(&cpr); /* drops l2arc_feed_thr_lock */ 5034 thread_exit(); 5035 } 5036 5037 boolean_t 5038 l2arc_vdev_present(vdev_t *vd) 5039 { 5040 l2arc_dev_t *dev; 5041 5042 mutex_enter(&l2arc_dev_mtx); 5043 for (dev = list_head(l2arc_dev_list); dev != NULL; 5044 dev = list_next(l2arc_dev_list, dev)) { 5045 if (dev->l2ad_vdev == vd) 5046 break; 5047 } 5048 mutex_exit(&l2arc_dev_mtx); 5049 5050 return (dev != NULL); 5051 } 5052 5053 /* 5054 * Add a vdev for use by the L2ARC. By this point the spa has already 5055 * validated the vdev and opened it. 5056 */ 5057 void 5058 l2arc_add_vdev(spa_t *spa, vdev_t *vd) 5059 { 5060 l2arc_dev_t *adddev; 5061 5062 ASSERT(!l2arc_vdev_present(vd)); 5063 5064 /* 5065 * Create a new l2arc device entry. 5066 */ 5067 adddev = kmem_zalloc(sizeof (l2arc_dev_t), KM_SLEEP); 5068 adddev->l2ad_spa = spa; 5069 adddev->l2ad_vdev = vd; 5070 adddev->l2ad_start = VDEV_LABEL_START_SIZE; 5071 adddev->l2ad_end = VDEV_LABEL_START_SIZE + vdev_get_min_asize(vd); 5072 adddev->l2ad_hand = adddev->l2ad_start; 5073 adddev->l2ad_evict = adddev->l2ad_start; 5074 adddev->l2ad_first = B_TRUE; 5075 adddev->l2ad_writing = B_FALSE; 5076 5077 /* 5078 * This is a list of all ARC buffers that are still valid on the 5079 * device. 5080 */ 5081 adddev->l2ad_buflist = kmem_zalloc(sizeof (list_t), KM_SLEEP); 5082 list_create(adddev->l2ad_buflist, sizeof (arc_buf_hdr_t), 5083 offsetof(arc_buf_hdr_t, b_l2node)); 5084 5085 vdev_space_update(vd, 0, 0, adddev->l2ad_end - adddev->l2ad_hand); 5086 5087 /* 5088 * Add device to global list 5089 */ 5090 mutex_enter(&l2arc_dev_mtx); 5091 list_insert_head(l2arc_dev_list, adddev); 5092 atomic_inc_64(&l2arc_ndev); 5093 mutex_exit(&l2arc_dev_mtx); 5094 } 5095 5096 /* 5097 * Remove a vdev from the L2ARC. 5098 */ 5099 void 5100 l2arc_remove_vdev(vdev_t *vd) 5101 { 5102 l2arc_dev_t *dev, *nextdev, *remdev = NULL; 5103 5104 /* 5105 * Find the device by vdev 5106 */ 5107 mutex_enter(&l2arc_dev_mtx); 5108 for (dev = list_head(l2arc_dev_list); dev; dev = nextdev) { 5109 nextdev = list_next(l2arc_dev_list, dev); 5110 if (vd == dev->l2ad_vdev) { 5111 remdev = dev; 5112 break; 5113 } 5114 } 5115 ASSERT(remdev != NULL); 5116 5117 /* 5118 * Remove device from global list 5119 */ 5120 list_remove(l2arc_dev_list, remdev); 5121 l2arc_dev_last = NULL; /* may have been invalidated */ 5122 atomic_dec_64(&l2arc_ndev); 5123 mutex_exit(&l2arc_dev_mtx); 5124 5125 /* 5126 * Clear all buflists and ARC references. L2ARC device flush. 5127 */ 5128 l2arc_evict(remdev, 0, B_TRUE); 5129 list_destroy(remdev->l2ad_buflist); 5130 kmem_free(remdev->l2ad_buflist, sizeof (list_t)); 5131 kmem_free(remdev, sizeof (l2arc_dev_t)); 5132 } 5133 5134 void 5135 l2arc_init(void) 5136 { 5137 l2arc_thread_exit = 0; 5138 l2arc_ndev = 0; 5139 l2arc_writes_sent = 0; 5140 l2arc_writes_done = 0; 5141 5142 mutex_init(&l2arc_feed_thr_lock, NULL, MUTEX_DEFAULT, NULL); 5143 cv_init(&l2arc_feed_thr_cv, NULL, CV_DEFAULT, NULL); 5144 mutex_init(&l2arc_dev_mtx, NULL, MUTEX_DEFAULT, NULL); 5145 mutex_init(&l2arc_buflist_mtx, NULL, MUTEX_DEFAULT, NULL); 5146 mutex_init(&l2arc_free_on_write_mtx, NULL, MUTEX_DEFAULT, NULL); 5147 5148 l2arc_dev_list = &L2ARC_dev_list; 5149 l2arc_free_on_write = &L2ARC_free_on_write; 5150 list_create(l2arc_dev_list, sizeof (l2arc_dev_t), 5151 offsetof(l2arc_dev_t, l2ad_node)); 5152 list_create(l2arc_free_on_write, sizeof (l2arc_data_free_t), 5153 offsetof(l2arc_data_free_t, l2df_list_node)); 5154 } 5155 5156 void 5157 l2arc_fini(void) 5158 { 5159 /* 5160 * This is called from dmu_fini(), which is called from spa_fini(); 5161 * Because of this, we can assume that all l2arc devices have 5162 * already been removed when the pools themselves were removed. 5163 */ 5164 5165 l2arc_do_free_on_write(); 5166 5167 mutex_destroy(&l2arc_feed_thr_lock); 5168 cv_destroy(&l2arc_feed_thr_cv); 5169 mutex_destroy(&l2arc_dev_mtx); 5170 mutex_destroy(&l2arc_buflist_mtx); 5171 mutex_destroy(&l2arc_free_on_write_mtx); 5172 5173 list_destroy(l2arc_dev_list); 5174 list_destroy(l2arc_free_on_write); 5175 } 5176 5177 void 5178 l2arc_start(void) 5179 { 5180 if (!(spa_mode_global & FWRITE)) 5181 return; 5182 5183 (void) thread_create(NULL, 0, l2arc_feed_thread, NULL, 0, &p0, 5184 TS_RUN, minclsyspri); 5185 } 5186 5187 void 5188 l2arc_stop(void) 5189 { 5190 if (!(spa_mode_global & FWRITE)) 5191 return; 5192 5193 mutex_enter(&l2arc_feed_thr_lock); 5194 cv_signal(&l2arc_feed_thr_cv); /* kick thread out of startup */ 5195 l2arc_thread_exit = 1; 5196 while (l2arc_thread_exit != 0) 5197 cv_wait(&l2arc_feed_thr_cv, &l2arc_feed_thr_lock); 5198 mutex_exit(&l2arc_feed_thr_lock); 5199 }