initial commit
[freebsd-arm:freebsd-arm.git] / cddl / contrib / opensolaris / uts / common / fs / zfs / arc.c
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 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25
26 /*
27  * DVA-based Adjustable Replacement Cache
28  *
29  * While much of the theory of operation used here is
30  * based on the self-tuning, low overhead replacement cache
31  * presented by Megiddo and Modha at FAST 2003, there are some
32  * significant differences:
33  *
34  * 1. The Megiddo and Modha model assumes any page is evictable.
35  * Pages in its cache cannot be "locked" into memory.  This makes
36  * the eviction algorithm simple: evict the last page in the list.
37  * This also make the performance characteristics easy to reason
38  * about.  Our cache is not so simple.  At any given moment, some
39  * subset of the blocks in the cache are un-evictable because we
40  * have handed out a reference to them.  Blocks are only evictable
41  * when there are no external references active.  This makes
42  * eviction far more problematic:  we choose to evict the evictable
43  * blocks that are the "lowest" in the list.
44  *
45  * There are times when it is not possible to evict the requested
46  * space.  In these circumstances we are unable to adjust the cache
47  * size.  To prevent the cache growing unbounded at these times we
48  * implement a "cache throttle" that slows the flow of new data
49  * into the cache until we can make space available.
50  *
51  * 2. The Megiddo and Modha model assumes a fixed cache size.
52  * Pages are evicted when the cache is full and there is a cache
53  * miss.  Our model has a variable sized cache.  It grows with
54  * high use, but also tries to react to memory pressure from the
55  * operating system: decreasing its size when system memory is
56  * tight.
57  *
58  * 3. The Megiddo and Modha model assumes a fixed page size. All
59  * elements of the cache are therefor exactly the same size.  So
60  * when adjusting the cache size following a cache miss, its simply
61  * a matter of choosing a single page to evict.  In our model, we
62  * have variable sized cache blocks (rangeing from 512 bytes to
63  * 128K bytes).  We therefor choose a set of blocks to evict to make
64  * space for a cache miss that approximates as closely as possible
65  * the space used by the new block.
66  *
67  * See also:  "ARC: A Self-Tuning, Low Overhead Replacement Cache"
68  * by N. Megiddo & D. Modha, FAST 2003
69  */
70
71 /*
72  * The locking model:
73  *
74  * A new reference to a cache buffer can be obtained in two
75  * ways: 1) via a hash table lookup using the DVA as a key,
76  * or 2) via one of the ARC lists.  The arc_read() interface
77  * uses method 1, while the internal arc algorithms for
78  * adjusting the cache use method 2.  We therefor provide two
79  * types of locks: 1) the hash table lock array, and 2) the
80  * arc list locks.
81  *
82  * Buffers do not have their own mutexs, rather they rely on the
83  * hash table mutexs for the bulk of their protection (i.e. most
84  * fields in the arc_buf_hdr_t are protected by these mutexs).
85  *
86  * buf_hash_find() returns the appropriate mutex (held) when it
87  * locates the requested buffer in the hash table.  It returns
88  * NULL for the mutex if the buffer was not in the table.
89  *
90  * buf_hash_remove() expects the appropriate hash mutex to be
91  * already held before it is invoked.
92  *
93  * Each arc state also has a mutex which is used to protect the
94  * buffer list associated with the state.  When attempting to
95  * obtain a hash table lock while holding an arc list lock you
96  * must use: mutex_tryenter() to avoid deadlock.  Also note that
97  * the active state mutex must be held before the ghost state mutex.
98  *
99  * Arc buffers may have an associated eviction callback function.
100  * This function will be invoked prior to removing the buffer (e.g.
101  * in arc_do_user_evicts()).  Note however that the data associated
102  * with the buffer may be evicted prior to the callback.  The callback
103  * must be made with *no locks held* (to prevent deadlock).  Additionally,
104  * the users of callbacks must ensure that their private data is
105  * protected from simultaneous callbacks from arc_buf_evict()
106  * and arc_do_user_evicts().
107  *
108  * Note that the majority of the performance stats are manipulated
109  * with atomic operations.
110  *
111  * The L2ARC uses the l2arc_buflist_mtx global mutex for the following:
112  *
113  *      - L2ARC buflist creation
114  *      - L2ARC buflist eviction
115  *      - L2ARC write completion, which walks L2ARC buflists
116  *      - ARC header destruction, as it removes from L2ARC buflists
117  *      - ARC header release, as it removes from L2ARC buflists
118  */
119
120 #include <sys/spa.h>
121 #include <sys/zio.h>
122 #include <sys/zio_checksum.h>
123 #include <sys/zfs_context.h>
124 #include <sys/arc.h>
125 #include <sys/refcount.h>
126 #include <sys/vdev.h>
127 #ifdef _KERNEL
128 #include <sys/dnlc.h>
129 #endif
130 #include <sys/callb.h>
131 #include <sys/kstat.h>
132 #include <sys/sdt.h>
133
134 #include <vm/vm_pageout.h>
135
136 static kmutex_t         arc_reclaim_thr_lock;
137 static kcondvar_t       arc_reclaim_thr_cv;     /* used to signal reclaim thr */
138 static uint8_t          arc_thread_exit;
139
140 extern int zfs_write_limit_shift;
141 extern uint64_t zfs_write_limit_max;
142 extern kmutex_t zfs_write_limit_lock;
143
144 #define ARC_REDUCE_DNLC_PERCENT 3
145 uint_t arc_reduce_dnlc_percent = ARC_REDUCE_DNLC_PERCENT;
146
147 typedef enum arc_reclaim_strategy {
148         ARC_RECLAIM_AGGR,               /* Aggressive reclaim strategy */
149         ARC_RECLAIM_CONS                /* Conservative reclaim strategy */
150 } arc_reclaim_strategy_t;
151
152 /* number of seconds before growing cache again */
153 static int              arc_grow_retry = 60;
154
155 /*
156  * minimum lifespan of a prefetch block in clock ticks
157  * (initialized in arc_init())
158  */
159 static int              arc_min_prefetch_lifespan;
160
161 extern int zfs_prefetch_disable;
162 static int arc_dead;
163
164 /*
165  * The arc has filled available memory and has now warmed up.
166  */
167 static boolean_t arc_warm;
168
169 /*
170  * These tunables are for performance analysis.
171  */
172 uint64_t zfs_arc_max;
173 uint64_t zfs_arc_min;
174 uint64_t zfs_arc_meta_limit = 0;
175 int zfs_mdcomp_disable = 0;
176
177 TUNABLE_QUAD("vfs.zfs.arc_max", &zfs_arc_max);
178 TUNABLE_QUAD("vfs.zfs.arc_min", &zfs_arc_min);
179 TUNABLE_QUAD("vfs.zfs.arc_meta_limit", &zfs_arc_meta_limit);
180 TUNABLE_INT("vfs.zfs.mdcomp_disable", &zfs_mdcomp_disable);
181 SYSCTL_DECL(_vfs_zfs);
182 SYSCTL_QUAD(_vfs_zfs, OID_AUTO, arc_max, CTLFLAG_RDTUN, &zfs_arc_max, 0,
183     "Maximum ARC size");
184 SYSCTL_QUAD(_vfs_zfs, OID_AUTO, arc_min, CTLFLAG_RDTUN, &zfs_arc_min, 0,
185     "Minimum ARC size");
186 SYSCTL_INT(_vfs_zfs, OID_AUTO, mdcomp_disable, CTLFLAG_RDTUN,
187     &zfs_mdcomp_disable, 0, "Disable metadata compression");
188
189 /*
190  * Note that buffers can be in one of 6 states:
191  *      ARC_anon        - anonymous (discussed below)
192  *      ARC_mru         - recently used, currently cached
193  *      ARC_mru_ghost   - recentely used, no longer in cache
194  *      ARC_mfu         - frequently used, currently cached
195  *      ARC_mfu_ghost   - frequently used, no longer in cache
196  *      ARC_l2c_only    - exists in L2ARC but not other states
197  * When there are no active references to the buffer, they are
198  * are linked onto a list in one of these arc states.  These are
199  * the only buffers that can be evicted or deleted.  Within each
200  * state there are multiple lists, one for meta-data and one for
201  * non-meta-data.  Meta-data (indirect blocks, blocks of dnodes,
202  * etc.) is tracked separately so that it can be managed more
203  * explicitly: favored over data, limited explicitly.
204  *
205  * Anonymous buffers are buffers that are not associated with
206  * a DVA.  These are buffers that hold dirty block copies
207  * before they are written to stable storage.  By definition,
208  * they are "ref'd" and are considered part of arc_mru
209  * that cannot be freed.  Generally, they will aquire a DVA
210  * as they are written and migrate onto the arc_mru list.
211  *
212  * The ARC_l2c_only state is for buffers that are in the second
213  * level ARC but no longer in any of the ARC_m* lists.  The second
214  * level ARC itself may also contain buffers that are in any of
215  * the ARC_m* states - meaning that a buffer can exist in two
216  * places.  The reason for the ARC_l2c_only state is to keep the
217  * buffer header in the hash table, so that reads that hit the
218  * second level ARC benefit from these fast lookups.
219  */
220
221 typedef struct arc_state {
222         list_t  arcs_list[ARC_BUFC_NUMTYPES];   /* list of evictable buffers */
223         uint64_t arcs_lsize[ARC_BUFC_NUMTYPES]; /* amount of evictable data */
224         uint64_t arcs_size;     /* total amount of data in this state */
225         kmutex_t arcs_mtx;
226 } arc_state_t;
227
228 /* The 6 states: */
229 static arc_state_t ARC_anon;
230 static arc_state_t ARC_mru;
231 static arc_state_t ARC_mru_ghost;
232 static arc_state_t ARC_mfu;
233 static arc_state_t ARC_mfu_ghost;
234 static arc_state_t ARC_l2c_only;
235
236 typedef struct arc_stats {
237         kstat_named_t arcstat_hits;
238         kstat_named_t arcstat_misses;
239         kstat_named_t arcstat_demand_data_hits;
240         kstat_named_t arcstat_demand_data_misses;
241         kstat_named_t arcstat_demand_metadata_hits;
242         kstat_named_t arcstat_demand_metadata_misses;
243         kstat_named_t arcstat_prefetch_data_hits;
244         kstat_named_t arcstat_prefetch_data_misses;
245         kstat_named_t arcstat_prefetch_metadata_hits;
246         kstat_named_t arcstat_prefetch_metadata_misses;
247         kstat_named_t arcstat_mru_hits;
248         kstat_named_t arcstat_mru_ghost_hits;
249         kstat_named_t arcstat_mfu_hits;
250         kstat_named_t arcstat_mfu_ghost_hits;
251         kstat_named_t arcstat_deleted;
252         kstat_named_t arcstat_recycle_miss;
253         kstat_named_t arcstat_mutex_miss;
254         kstat_named_t arcstat_evict_skip;
255         kstat_named_t arcstat_hash_elements;
256         kstat_named_t arcstat_hash_elements_max;
257         kstat_named_t arcstat_hash_collisions;
258         kstat_named_t arcstat_hash_chains;
259         kstat_named_t arcstat_hash_chain_max;
260         kstat_named_t arcstat_p;
261         kstat_named_t arcstat_c;
262         kstat_named_t arcstat_c_min;
263         kstat_named_t arcstat_c_max;
264         kstat_named_t arcstat_size;
265         kstat_named_t arcstat_hdr_size;
266         kstat_named_t arcstat_l2_hits;
267         kstat_named_t arcstat_l2_misses;
268         kstat_named_t arcstat_l2_feeds;
269         kstat_named_t arcstat_l2_rw_clash;
270         kstat_named_t arcstat_l2_writes_sent;
271         kstat_named_t arcstat_l2_writes_done;
272         kstat_named_t arcstat_l2_writes_error;
273         kstat_named_t arcstat_l2_writes_hdr_miss;
274         kstat_named_t arcstat_l2_evict_lock_retry;
275         kstat_named_t arcstat_l2_evict_reading;
276         kstat_named_t arcstat_l2_free_on_write;
277         kstat_named_t arcstat_l2_abort_lowmem;
278         kstat_named_t arcstat_l2_cksum_bad;
279         kstat_named_t arcstat_l2_io_error;
280         kstat_named_t arcstat_l2_size;
281         kstat_named_t arcstat_l2_hdr_size;
282         kstat_named_t arcstat_memory_throttle_count;
283 } arc_stats_t;
284
285 static arc_stats_t arc_stats = {
286         { "hits",                       KSTAT_DATA_UINT64 },
287         { "misses",                     KSTAT_DATA_UINT64 },
288         { "demand_data_hits",           KSTAT_DATA_UINT64 },
289         { "demand_data_misses",         KSTAT_DATA_UINT64 },
290         { "demand_metadata_hits",       KSTAT_DATA_UINT64 },
291         { "demand_metadata_misses",     KSTAT_DATA_UINT64 },
292         { "prefetch_data_hits",         KSTAT_DATA_UINT64 },
293         { "prefetch_data_misses",       KSTAT_DATA_UINT64 },
294         { "prefetch_metadata_hits",     KSTAT_DATA_UINT64 },
295         { "prefetch_metadata_misses",   KSTAT_DATA_UINT64 },
296         { "mru_hits",                   KSTAT_DATA_UINT64 },
297         { "mru_ghost_hits",             KSTAT_DATA_UINT64 },
298         { "mfu_hits",                   KSTAT_DATA_UINT64 },
299         { "mfu_ghost_hits",             KSTAT_DATA_UINT64 },
300         { "deleted",                    KSTAT_DATA_UINT64 },
301         { "recycle_miss",               KSTAT_DATA_UINT64 },
302         { "mutex_miss",                 KSTAT_DATA_UINT64 },
303         { "evict_skip",                 KSTAT_DATA_UINT64 },
304         { "hash_elements",              KSTAT_DATA_UINT64 },
305         { "hash_elements_max",          KSTAT_DATA_UINT64 },
306         { "hash_collisions",            KSTAT_DATA_UINT64 },
307         { "hash_chains",                KSTAT_DATA_UINT64 },
308         { "hash_chain_max",             KSTAT_DATA_UINT64 },
309         { "p",                          KSTAT_DATA_UINT64 },
310         { "c",                          KSTAT_DATA_UINT64 },
311         { "c_min",                      KSTAT_DATA_UINT64 },
312         { "c_max",                      KSTAT_DATA_UINT64 },
313         { "size",                       KSTAT_DATA_UINT64 },
314         { "hdr_size",                   KSTAT_DATA_UINT64 },
315         { "l2_hits",                    KSTAT_DATA_UINT64 },
316         { "l2_misses",                  KSTAT_DATA_UINT64 },
317         { "l2_feeds",                   KSTAT_DATA_UINT64 },
318         { "l2_rw_clash",                KSTAT_DATA_UINT64 },
319         { "l2_writes_sent",             KSTAT_DATA_UINT64 },
320         { "l2_writes_done",             KSTAT_DATA_UINT64 },
321         { "l2_writes_error",            KSTAT_DATA_UINT64 },
322         { "l2_writes_hdr_miss",         KSTAT_DATA_UINT64 },
323         { "l2_evict_lock_retry",        KSTAT_DATA_UINT64 },
324         { "l2_evict_reading",           KSTAT_DATA_UINT64 },
325         { "l2_free_on_write",           KSTAT_DATA_UINT64 },
326         { "l2_abort_lowmem",            KSTAT_DATA_UINT64 },
327         { "l2_cksum_bad",               KSTAT_DATA_UINT64 },
328         { "l2_io_error",                KSTAT_DATA_UINT64 },
329         { "l2_size",                    KSTAT_DATA_UINT64 },
330         { "l2_hdr_size",                KSTAT_DATA_UINT64 },
331         { "memory_throttle_count",      KSTAT_DATA_UINT64 }
332 };
333
334 #define ARCSTAT(stat)   (arc_stats.stat.value.ui64)
335
336 #define ARCSTAT_INCR(stat, val) \
337         atomic_add_64(&arc_stats.stat.value.ui64, (val));
338
339 #define ARCSTAT_BUMP(stat)      ARCSTAT_INCR(stat, 1)
340 #define ARCSTAT_BUMPDOWN(stat)  ARCSTAT_INCR(stat, -1)
341
342 #define ARCSTAT_MAX(stat, val) {                                        \
343         uint64_t m;                                                     \
344         while ((val) > (m = arc_stats.stat.value.ui64) &&               \
345             (m != atomic_cas_64(&arc_stats.stat.value.ui64, m, (val)))) \
346                 continue;                                               \
347 }
348
349 #define ARCSTAT_MAXSTAT(stat) \
350         ARCSTAT_MAX(stat##_max, arc_stats.stat.value.ui64)
351
352 /*
353  * We define a macro to allow ARC hits/misses to be easily broken down by
354  * two separate conditions, giving a total of four different subtypes for
355  * each of hits and misses (so eight statistics total).
356  */
357 #define ARCSTAT_CONDSTAT(cond1, stat1, notstat1, cond2, stat2, notstat2, stat) \
358         if (cond1) {                                                    \
359                 if (cond2) {                                            \
360                         ARCSTAT_BUMP(arcstat_##stat1##_##stat2##_##stat); \
361                 } else {                                                \
362                         ARCSTAT_BUMP(arcstat_##stat1##_##notstat2##_##stat); \
363                 }                                                       \
364         } else {                                                        \
365                 if (cond2) {                                            \
366                         ARCSTAT_BUMP(arcstat_##notstat1##_##stat2##_##stat); \
367                 } else {                                                \
368                         ARCSTAT_BUMP(arcstat_##notstat1##_##notstat2##_##stat);\
369                 }                                                       \
370         }
371
372 kstat_t                 *arc_ksp;
373 static arc_state_t      *arc_anon;
374 static arc_state_t      *arc_mru;
375 static arc_state_t      *arc_mru_ghost;
376 static arc_state_t      *arc_mfu;
377 static arc_state_t      *arc_mfu_ghost;
378 static arc_state_t      *arc_l2c_only;
379
380 /*
381  * There are several ARC variables that are critical to export as kstats --
382  * but we don't want to have to grovel around in the kstat whenever we wish to
383  * manipulate them.  For these variables, we therefore define them to be in
384  * terms of the statistic variable.  This assures that we are not introducing
385  * the possibility of inconsistency by having shadow copies of the variables,
386  * while still allowing the code to be readable.
387  */
388 #define arc_size        ARCSTAT(arcstat_size)   /* actual total arc size */
389 #define arc_p           ARCSTAT(arcstat_p)      /* target size of MRU */
390 #define arc_c           ARCSTAT(arcstat_c)      /* target size of cache */
391 #define arc_c_min       ARCSTAT(arcstat_c_min)  /* min target cache size */
392 #define arc_c_max       ARCSTAT(arcstat_c_max)  /* max target cache size */
393
394 static int              arc_no_grow;    /* Don't try to grow cache size */
395 static uint64_t         arc_tempreserve;
396 static uint64_t         arc_meta_used;
397 static uint64_t         arc_meta_limit;
398 static uint64_t         arc_meta_max = 0;
399 SYSCTL_QUAD(_vfs_zfs, OID_AUTO, arc_meta_used, CTLFLAG_RDTUN,
400     &arc_meta_used, 0, "ARC metadata used");
401 SYSCTL_QUAD(_vfs_zfs, OID_AUTO, arc_meta_limit, CTLFLAG_RDTUN,
402     &arc_meta_limit, 0, "ARC metadata limit");
403
404 typedef struct l2arc_buf_hdr l2arc_buf_hdr_t;
405
406 typedef struct arc_callback arc_callback_t;
407
408 struct arc_callback {
409         void                    *acb_private;
410         arc_done_func_t         *acb_done;
411         arc_buf_t               *acb_buf;
412         zio_t                   *acb_zio_dummy;
413         arc_callback_t          *acb_next;
414 };
415
416 typedef struct arc_write_callback arc_write_callback_t;
417
418 struct arc_write_callback {
419         void            *awcb_private;
420         arc_done_func_t *awcb_ready;
421         arc_done_func_t *awcb_done;
422         arc_buf_t       *awcb_buf;
423 };
424
425 struct arc_buf_hdr {
426         /* protected by hash lock */
427         dva_t                   b_dva;
428         uint64_t                b_birth;
429         uint64_t                b_cksum0;
430
431         kmutex_t                b_freeze_lock;
432         zio_cksum_t             *b_freeze_cksum;
433
434         arc_buf_hdr_t           *b_hash_next;
435         arc_buf_t               *b_buf;
436         uint32_t                b_flags;
437         uint32_t                b_datacnt;
438
439         arc_callback_t          *b_acb;
440         kcondvar_t              b_cv;
441
442         /* immutable */
443         arc_buf_contents_t      b_type;
444         uint64_t                b_size;
445         spa_t                   *b_spa;
446
447         /* protected by arc state mutex */
448         arc_state_t             *b_state;
449         list_node_t             b_arc_node;
450
451         /* updated atomically */
452         clock_t                 b_arc_access;
453
454         /* self protecting */
455         refcount_t              b_refcnt;
456
457         l2arc_buf_hdr_t         *b_l2hdr;
458         list_node_t             b_l2node;
459 };
460
461 static arc_buf_t *arc_eviction_list;
462 static kmutex_t arc_eviction_mtx;
463 static arc_buf_hdr_t arc_eviction_hdr;
464 static void arc_get_data_buf(arc_buf_t *buf);
465 static void arc_access(arc_buf_hdr_t *buf, kmutex_t *hash_lock);
466 static int arc_evict_needed(arc_buf_contents_t type);
467 static void arc_evict_ghost(arc_state_t *state, spa_t *spa, int64_t bytes);
468
469 #define GHOST_STATE(state)      \
470         ((state) == arc_mru_ghost || (state) == arc_mfu_ghost ||        \
471         (state) == arc_l2c_only)
472
473 /*
474  * Private ARC flags.  These flags are private ARC only flags that will show up
475  * in b_flags in the arc_hdr_buf_t.  Some flags are publicly declared, and can
476  * be passed in as arc_flags in things like arc_read.  However, these flags
477  * should never be passed and should only be set by ARC code.  When adding new
478  * public flags, make sure not to smash the private ones.
479  */
480
481 #define ARC_IN_HASH_TABLE       (1 << 9)        /* this buffer is hashed */
482 #define ARC_IO_IN_PROGRESS      (1 << 10)       /* I/O in progress for buf */
483 #define ARC_IO_ERROR            (1 << 11)       /* I/O failed for buf */
484 #define ARC_FREED_IN_READ       (1 << 12)       /* buf freed while in read */
485 #define ARC_BUF_AVAILABLE       (1 << 13)       /* block not in active use */
486 #define ARC_INDIRECT            (1 << 14)       /* this is an indirect block */
487 #define ARC_FREE_IN_PROGRESS    (1 << 15)       /* hdr about to be freed */
488 #define ARC_L2_WRITING          (1 << 16)       /* L2ARC write in progress */
489 #define ARC_L2_EVICTED          (1 << 17)       /* evicted during I/O */
490 #define ARC_L2_WRITE_HEAD       (1 << 18)       /* head of write list */
491 #define ARC_STORED              (1 << 19)       /* has been store()d to */
492
493 #define HDR_IN_HASH_TABLE(hdr)  ((hdr)->b_flags & ARC_IN_HASH_TABLE)
494 #define HDR_IO_IN_PROGRESS(hdr) ((hdr)->b_flags & ARC_IO_IN_PROGRESS)
495 #define HDR_IO_ERROR(hdr)       ((hdr)->b_flags & ARC_IO_ERROR)
496 #define HDR_FREED_IN_READ(hdr)  ((hdr)->b_flags & ARC_FREED_IN_READ)
497 #define HDR_BUF_AVAILABLE(hdr)  ((hdr)->b_flags & ARC_BUF_AVAILABLE)
498 #define HDR_FREE_IN_PROGRESS(hdr)       ((hdr)->b_flags & ARC_FREE_IN_PROGRESS)
499 #define HDR_L2CACHE(hdr)        ((hdr)->b_flags & ARC_L2CACHE)
500 #define HDR_L2_READING(hdr)     ((hdr)->b_flags & ARC_IO_IN_PROGRESS && \
501                                     (hdr)->b_l2hdr != NULL)
502 #define HDR_L2_WRITING(hdr)     ((hdr)->b_flags & ARC_L2_WRITING)
503 #define HDR_L2_EVICTED(hdr)     ((hdr)->b_flags & ARC_L2_EVICTED)
504 #define HDR_L2_WRITE_HEAD(hdr)  ((hdr)->b_flags & ARC_L2_WRITE_HEAD)
505
506 /*
507  * Other sizes
508  */
509
510 #define HDR_SIZE ((int64_t)sizeof (arc_buf_hdr_t))
511 #define L2HDR_SIZE ((int64_t)sizeof (l2arc_buf_hdr_t))
512
513 /*
514  * Hash table routines
515  */
516
517 #define HT_LOCK_PAD     128
518
519 struct ht_lock {
520         kmutex_t        ht_lock;
521 #ifdef _KERNEL
522         unsigned char   pad[(HT_LOCK_PAD - sizeof (kmutex_t))];
523 #endif
524 };
525
526 #define BUF_LOCKS 256
527 typedef struct buf_hash_table {
528         uint64_t ht_mask;
529         arc_buf_hdr_t **ht_table;
530         struct ht_lock ht_locks[BUF_LOCKS];
531 } buf_hash_table_t;
532
533 static buf_hash_table_t buf_hash_table;
534
535 #define BUF_HASH_INDEX(spa, dva, birth) \
536         (buf_hash(spa, dva, birth) & buf_hash_table.ht_mask)
537 #define BUF_HASH_LOCK_NTRY(idx) (buf_hash_table.ht_locks[idx & (BUF_LOCKS-1)])
538 #define BUF_HASH_LOCK(idx)      (&(BUF_HASH_LOCK_NTRY(idx).ht_lock))
539 #define HDR_LOCK(buf) \
540         (BUF_HASH_LOCK(BUF_HASH_INDEX(buf->b_spa, &buf->b_dva, buf->b_birth)))
541
542 uint64_t zfs_crc64_table[256];
543
544 /*
545  * Level 2 ARC
546  */
547
548 #define L2ARC_WRITE_SIZE        (8 * 1024 * 1024)       /* initial write max */
549 #define L2ARC_HEADROOM          4               /* num of writes */
550 #define L2ARC_FEED_SECS         1               /* caching interval */
551
552 #define l2arc_writes_sent       ARCSTAT(arcstat_l2_writes_sent)
553 #define l2arc_writes_done       ARCSTAT(arcstat_l2_writes_done)
554
555 /*
556  * L2ARC Performance Tunables
557  */
558 uint64_t l2arc_write_max = L2ARC_WRITE_SIZE;    /* default max write size */
559 uint64_t l2arc_write_boost = L2ARC_WRITE_SIZE;  /* extra write during warmup */
560 uint64_t l2arc_headroom = L2ARC_HEADROOM;       /* number of dev writes */
561 uint64_t l2arc_feed_secs = L2ARC_FEED_SECS;     /* interval seconds */
562 boolean_t l2arc_noprefetch = B_TRUE;            /* don't cache prefetch bufs */
563
564 /*
565  * L2ARC Internals
566  */
567 typedef struct l2arc_dev {
568         vdev_t                  *l2ad_vdev;     /* vdev */
569         spa_t                   *l2ad_spa;      /* spa */
570         uint64_t                l2ad_hand;      /* next write location */
571         uint64_t                l2ad_write;     /* desired write size, bytes */
572         uint64_t                l2ad_boost;     /* warmup write boost, bytes */
573         uint64_t                l2ad_start;     /* first addr on device */
574         uint64_t                l2ad_end;       /* last addr on device */
575         uint64_t                l2ad_evict;     /* last addr eviction reached */
576         boolean_t               l2ad_first;     /* first sweep through */
577         list_t                  *l2ad_buflist;  /* buffer list */
578         list_node_t             l2ad_node;      /* device list node */
579 } l2arc_dev_t;
580
581 static list_t L2ARC_dev_list;                   /* device list */
582 static list_t *l2arc_dev_list;                  /* device list pointer */
583 static kmutex_t l2arc_dev_mtx;                  /* device list mutex */
584 static l2arc_dev_t *l2arc_dev_last;             /* last device used */
585 static kmutex_t l2arc_buflist_mtx;              /* mutex for all buflists */
586 static list_t L2ARC_free_on_write;              /* free after write buf list */
587 static list_t *l2arc_free_on_write;             /* free after write list ptr */
588 static kmutex_t l2arc_free_on_write_mtx;        /* mutex for list */
589 static uint64_t l2arc_ndev;                     /* number of devices */
590
591 typedef struct l2arc_read_callback {
592         arc_buf_t       *l2rcb_buf;             /* read buffer */
593         spa_t           *l2rcb_spa;             /* spa */
594         blkptr_t        l2rcb_bp;               /* original blkptr */
595         zbookmark_t     l2rcb_zb;               /* original bookmark */
596         int             l2rcb_flags;            /* original flags */
597 } l2arc_read_callback_t;
598
599 typedef struct l2arc_write_callback {
600         l2arc_dev_t     *l2wcb_dev;             /* device info */
601         arc_buf_hdr_t   *l2wcb_head;            /* head of write buflist */
602 } l2arc_write_callback_t;
603
604 struct l2arc_buf_hdr {
605         /* protected by arc_buf_hdr  mutex */
606         l2arc_dev_t     *b_dev;                 /* L2ARC device */
607         daddr_t         b_daddr;                /* disk address, offset byte */
608 };
609
610 typedef struct l2arc_data_free {
611         /* protected by l2arc_free_on_write_mtx */
612         void            *l2df_data;
613         size_t          l2df_size;
614         void            (*l2df_func)(void *, size_t);
615         list_node_t     l2df_list_node;
616 } l2arc_data_free_t;
617
618 static kmutex_t l2arc_feed_thr_lock;
619 static kcondvar_t l2arc_feed_thr_cv;
620 static uint8_t l2arc_thread_exit;
621
622 static void l2arc_read_done(zio_t *zio);
623 static void l2arc_hdr_stat_add(void);
624 static void l2arc_hdr_stat_remove(void);
625
626 static uint64_t
627 buf_hash(spa_t *spa, const dva_t *dva, uint64_t birth)
628 {
629         uintptr_t spav = (uintptr_t)spa;
630         uint8_t *vdva = (uint8_t *)dva;
631         uint64_t crc = -1ULL;
632         int i;
633
634         ASSERT(zfs_crc64_table[128] == ZFS_CRC64_POLY);
635
636         for (i = 0; i < sizeof (dva_t); i++)
637                 crc = (crc >> 8) ^ zfs_crc64_table[(crc ^ vdva[i]) & 0xFF];
638
639         crc ^= (spav>>8) ^ birth;
640
641         return (crc);
642 }
643
644 #define BUF_EMPTY(buf)                                          \
645         ((buf)->b_dva.dva_word[0] == 0 &&                       \
646         (buf)->b_dva.dva_word[1] == 0 &&                        \
647         (buf)->b_birth == 0)
648
649 #define BUF_EQUAL(spa, dva, birth, buf)                         \
650         ((buf)->b_dva.dva_word[0] == (dva)->dva_word[0]) &&     \
651         ((buf)->b_dva.dva_word[1] == (dva)->dva_word[1]) &&     \
652         ((buf)->b_birth == birth) && ((buf)->b_spa == spa)
653
654 static arc_buf_hdr_t *
655 buf_hash_find(spa_t *spa, const dva_t *dva, uint64_t birth, kmutex_t **lockp)
656 {
657         uint64_t idx = BUF_HASH_INDEX(spa, dva, birth);
658         kmutex_t *hash_lock = BUF_HASH_LOCK(idx);
659         arc_buf_hdr_t *buf;
660
661         mutex_enter(hash_lock);
662         for (buf = buf_hash_table.ht_table[idx]; buf != NULL;
663             buf = buf->b_hash_next) {
664                 if (BUF_EQUAL(spa, dva, birth, buf)) {
665                         *lockp = hash_lock;
666                         return (buf);
667                 }
668         }
669         mutex_exit(hash_lock);
670         *lockp = NULL;
671         return (NULL);
672 }
673
674 /*
675  * Insert an entry into the hash table.  If there is already an element
676  * equal to elem in the hash table, then the already existing element
677  * will be returned and the new element will not be inserted.
678  * Otherwise returns NULL.
679  */
680 static arc_buf_hdr_t *
681 buf_hash_insert(arc_buf_hdr_t *buf, kmutex_t **lockp)
682 {
683         uint64_t idx = BUF_HASH_INDEX(buf->b_spa, &buf->b_dva, buf->b_birth);
684         kmutex_t *hash_lock = BUF_HASH_LOCK(idx);
685         arc_buf_hdr_t *fbuf;
686         uint32_t i;
687
688         ASSERT(!HDR_IN_HASH_TABLE(buf));
689         *lockp = hash_lock;
690         mutex_enter(hash_lock);
691         for (fbuf = buf_hash_table.ht_table[idx], i = 0; fbuf != NULL;
692             fbuf = fbuf->b_hash_next, i++) {
693                 if (BUF_EQUAL(buf->b_spa, &buf->b_dva, buf->b_birth, fbuf))
694                         return (fbuf);
695         }
696
697         buf->b_hash_next = buf_hash_table.ht_table[idx];
698         buf_hash_table.ht_table[idx] = buf;
699         buf->b_flags |= ARC_IN_HASH_TABLE;
700
701         /* collect some hash table performance data */
702         if (i > 0) {
703                 ARCSTAT_BUMP(arcstat_hash_collisions);
704                 if (i == 1)
705                         ARCSTAT_BUMP(arcstat_hash_chains);
706
707                 ARCSTAT_MAX(arcstat_hash_chain_max, i);
708         }
709
710         ARCSTAT_BUMP(arcstat_hash_elements);
711         ARCSTAT_MAXSTAT(arcstat_hash_elements);
712
713         return (NULL);
714 }
715
716 static void
717 buf_hash_remove(arc_buf_hdr_t *buf)
718 {
719         arc_buf_hdr_t *fbuf, **bufp;
720         uint64_t idx = BUF_HASH_INDEX(buf->b_spa, &buf->b_dva, buf->b_birth);
721
722         ASSERT(MUTEX_HELD(BUF_HASH_LOCK(idx)));
723         ASSERT(HDR_IN_HASH_TABLE(buf));
724
725         bufp = &buf_hash_table.ht_table[idx];
726         while ((fbuf = *bufp) != buf) {
727                 ASSERT(fbuf != NULL);
728                 bufp = &fbuf->b_hash_next;
729         }
730         *bufp = buf->b_hash_next;
731         buf->b_hash_next = NULL;
732         buf->b_flags &= ~ARC_IN_HASH_TABLE;
733
734         /* collect some hash table performance data */
735         ARCSTAT_BUMPDOWN(arcstat_hash_elements);
736
737         if (buf_hash_table.ht_table[idx] &&
738             buf_hash_table.ht_table[idx]->b_hash_next == NULL)
739                 ARCSTAT_BUMPDOWN(arcstat_hash_chains);
740 }
741
742 /*
743  * Global data structures and functions for the buf kmem cache.
744  */
745 static kmem_cache_t *hdr_cache;
746 static kmem_cache_t *buf_cache;
747
748 static void
749 buf_fini(void)
750 {
751         int i;
752
753         kmem_free(buf_hash_table.ht_table,
754             (buf_hash_table.ht_mask + 1) * sizeof (void *));
755         for (i = 0; i < BUF_LOCKS; i++)
756                 mutex_destroy(&buf_hash_table.ht_locks[i].ht_lock);
757         kmem_cache_destroy(hdr_cache);
758         kmem_cache_destroy(buf_cache);
759 }
760
761 /*
762  * Constructor callback - called when the cache is empty
763  * and a new buf is requested.
764  */
765 /* ARGSUSED */
766 static int
767 hdr_cons(void *vbuf, void *unused, int kmflag)
768 {
769         arc_buf_hdr_t *buf = vbuf;
770
771         bzero(buf, sizeof (arc_buf_hdr_t));
772         refcount_create(&buf->b_refcnt);
773         cv_init(&buf->b_cv, NULL, CV_DEFAULT, NULL);
774         mutex_init(&buf->b_freeze_lock, NULL, MUTEX_DEFAULT, NULL);
775
776         ARCSTAT_INCR(arcstat_hdr_size, HDR_SIZE);
777         return (0);
778 }
779
780 /* ARGSUSED */
781 static int
782 buf_cons(void *vbuf, void *unused, int kmflag)
783 {
784         arc_buf_t *buf = vbuf;
785
786         bzero(buf, sizeof (arc_buf_t));
787         rw_init(&buf->b_lock, NULL, RW_DEFAULT, NULL);
788         return (0);
789 }
790
791 /*
792  * Destructor callback - called when a cached buf is
793  * no longer required.
794  */
795 /* ARGSUSED */
796 static void
797 hdr_dest(void *vbuf, void *unused)
798 {
799         arc_buf_hdr_t *buf = vbuf;
800
801         refcount_destroy(&buf->b_refcnt);
802         cv_destroy(&buf->b_cv);
803         mutex_destroy(&buf->b_freeze_lock);
804
805         ARCSTAT_INCR(arcstat_hdr_size, -HDR_SIZE);
806 }
807
808 /* ARGSUSED */
809 static void
810 buf_dest(void *vbuf, void *unused)
811 {
812         arc_buf_t *buf = vbuf;
813
814         rw_destroy(&buf->b_lock);
815 }
816
817 /*
818  * Reclaim callback -- invoked when memory is low.
819  */
820 /* ARGSUSED */
821 static void
822 hdr_recl(void *unused)
823 {
824         dprintf("hdr_recl called\n");
825         /*
826          * umem calls the reclaim func when we destroy the buf cache,
827          * which is after we do arc_fini().
828          */
829         if (!arc_dead)
830                 cv_signal(&arc_reclaim_thr_cv);
831 }
832
833 static void
834 buf_init(void)
835 {
836         uint64_t *ct;
837         uint64_t hsize = 1ULL << 12;
838         int i, j;
839
840         /*
841          * The hash table is big enough to fill all of physical memory
842          * with an average 64K block size.  The table will take up
843          * totalmem*sizeof(void*)/64K (eg. 128KB/GB with 8-byte pointers).
844          */
845         while (hsize * 65536 < (uint64_t)physmem * PAGESIZE)
846                 hsize <<= 1;
847 retry:
848         buf_hash_table.ht_mask = hsize - 1;
849         buf_hash_table.ht_table =
850             kmem_zalloc(hsize * sizeof (void*), KM_NOSLEEP);
851         if (buf_hash_table.ht_table == NULL) {
852                 ASSERT(hsize > (1ULL << 8));
853                 hsize >>= 1;
854                 goto retry;
855         }
856
857         hdr_cache = kmem_cache_create("arc_buf_hdr_t", sizeof (arc_buf_hdr_t),
858             0, hdr_cons, hdr_dest, hdr_recl, NULL, NULL, 0);
859         buf_cache = kmem_cache_create("arc_buf_t", sizeof (arc_buf_t),
860             0, buf_cons, buf_dest, NULL, NULL, NULL, 0);
861
862         for (i = 0; i < 256; i++)
863                 for (ct = zfs_crc64_table + i, *ct = i, j = 8; j > 0; j--)
864                         *ct = (*ct >> 1) ^ (-(*ct & 1) & ZFS_CRC64_POLY);
865
866         for (i = 0; i < BUF_LOCKS; i++) {
867                 mutex_init(&buf_hash_table.ht_locks[i].ht_lock,
868                     NULL, MUTEX_DEFAULT, NULL);
869         }
870 }
871
872 #define ARC_MINTIME     (hz>>4) /* 62 ms */
873
874 static void
875 arc_cksum_verify(arc_buf_t *buf)
876 {
877         zio_cksum_t zc;
878
879         if (!(zfs_flags & ZFS_DEBUG_MODIFY))
880                 return;
881
882         mutex_enter(&buf->b_hdr->b_freeze_lock);
883         if (buf->b_hdr->b_freeze_cksum == NULL ||
884             (buf->b_hdr->b_flags & ARC_IO_ERROR)) {
885                 mutex_exit(&buf->b_hdr->b_freeze_lock);
886                 return;
887         }
888         fletcher_2_native(buf->b_data, buf->b_hdr->b_size, &zc);
889         if (!ZIO_CHECKSUM_EQUAL(*buf->b_hdr->b_freeze_cksum, zc))
890                 panic("buffer modified while frozen!");
891         mutex_exit(&buf->b_hdr->b_freeze_lock);
892 }
893
894 static int
895 arc_cksum_equal(arc_buf_t *buf)
896 {
897         zio_cksum_t zc;
898         int equal;
899
900         mutex_enter(&buf->b_hdr->b_freeze_lock);
901         fletcher_2_native(buf->b_data, buf->b_hdr->b_size, &zc);
902         equal = ZIO_CHECKSUM_EQUAL(*buf->b_hdr->b_freeze_cksum, zc);
903         mutex_exit(&buf->b_hdr->b_freeze_lock);
904
905         return (equal);
906 }
907
908 static void
909 arc_cksum_compute(arc_buf_t *buf, boolean_t force)
910 {
911         if (!force && !(zfs_flags & ZFS_DEBUG_MODIFY))
912                 return;
913
914         mutex_enter(&buf->b_hdr->b_freeze_lock);
915         if (buf->b_hdr->b_freeze_cksum != NULL) {
916                 mutex_exit(&buf->b_hdr->b_freeze_lock);
917                 return;
918         }
919         buf->b_hdr->b_freeze_cksum = kmem_alloc(sizeof (zio_cksum_t), KM_SLEEP);
920         fletcher_2_native(buf->b_data, buf->b_hdr->b_size,
921             buf->b_hdr->b_freeze_cksum);
922         mutex_exit(&buf->b_hdr->b_freeze_lock);
923 }
924
925 void
926 arc_buf_thaw(arc_buf_t *buf)
927 {
928         if (zfs_flags & ZFS_DEBUG_MODIFY) {
929                 if (buf->b_hdr->b_state != arc_anon)
930                         panic("modifying non-anon buffer!");
931                 if (buf->b_hdr->b_flags & ARC_IO_IN_PROGRESS)
932                         panic("modifying buffer while i/o in progress!");
933                 arc_cksum_verify(buf);
934         }
935
936         mutex_enter(&buf->b_hdr->b_freeze_lock);
937         if (buf->b_hdr->b_freeze_cksum != NULL) {
938                 kmem_free(buf->b_hdr->b_freeze_cksum, sizeof (zio_cksum_t));
939                 buf->b_hdr->b_freeze_cksum = NULL;
940         }
941         mutex_exit(&buf->b_hdr->b_freeze_lock);
942 }
943
944 void
945 arc_buf_freeze(arc_buf_t *buf)
946 {
947         if (!(zfs_flags & ZFS_DEBUG_MODIFY))
948                 return;
949
950         ASSERT(buf->b_hdr->b_freeze_cksum != NULL ||
951             buf->b_hdr->b_state == arc_anon);
952         arc_cksum_compute(buf, B_FALSE);
953 }
954
955 static void
956 add_reference(arc_buf_hdr_t *ab, kmutex_t *hash_lock, void *tag)
957 {
958         ASSERT(MUTEX_HELD(hash_lock));
959
960         if ((refcount_add(&ab->b_refcnt, tag) == 1) &&
961             (ab->b_state != arc_anon)) {
962                 uint64_t delta = ab->b_size * ab->b_datacnt;
963                 list_t *list = &ab->b_state->arcs_list[ab->b_type];
964                 uint64_t *size = &ab->b_state->arcs_lsize[ab->b_type];
965
966                 ASSERT(!MUTEX_HELD(&ab->b_state->arcs_mtx));
967                 mutex_enter(&ab->b_state->arcs_mtx);
968                 ASSERT(list_link_active(&ab->b_arc_node));
969                 list_remove(list, ab);
970                 if (GHOST_STATE(ab->b_state)) {
971                         ASSERT3U(ab->b_datacnt, ==, 0);
972                         ASSERT3P(ab->b_buf, ==, NULL);
973                         delta = ab->b_size;
974                 }
975                 ASSERT(delta > 0);
976                 ASSERT3U(*size, >=, delta);
977                 atomic_add_64(size, -delta);
978                 mutex_exit(&ab->b_state->arcs_mtx);
979                 /* remove the prefetch flag if we get a reference */
980                 if (ab->b_flags & ARC_PREFETCH)
981                         ab->b_flags &= ~ARC_PREFETCH;
982         }
983 }
984
985 static int
986 remove_reference(arc_buf_hdr_t *ab, kmutex_t *hash_lock, void *tag)
987 {
988         int cnt;
989         arc_state_t *state = ab->b_state;
990
991         ASSERT(state == arc_anon || MUTEX_HELD(hash_lock));
992         ASSERT(!GHOST_STATE(state));
993
994         if (((cnt = refcount_remove(&ab->b_refcnt, tag)) == 0) &&
995             (state != arc_anon)) {
996                 uint64_t *size = &state->arcs_lsize[ab->b_type];
997
998                 ASSERT(!MUTEX_HELD(&state->arcs_mtx));
999                 mutex_enter(&state->arcs_mtx);
1000                 ASSERT(!list_link_active(&ab->b_arc_node));
1001                 list_insert_head(&state->arcs_list[ab->b_type], ab);
1002                 ASSERT(ab->b_datacnt > 0);
1003                 atomic_add_64(size, ab->b_size * ab->b_datacnt);
1004                 mutex_exit(&state->arcs_mtx);
1005         }
1006         return (cnt);
1007 }
1008
1009 /*
1010  * Move the supplied buffer to the indicated state.  The mutex
1011  * for the buffer must be held by the caller.
1012  */
1013 static void
1014 arc_change_state(arc_state_t *new_state, arc_buf_hdr_t *ab, kmutex_t *hash_lock)
1015 {
1016         arc_state_t *old_state = ab->b_state;
1017         int64_t refcnt = refcount_count(&ab->b_refcnt);
1018         uint64_t from_delta, to_delta;
1019
1020         ASSERT(MUTEX_HELD(hash_lock));
1021         ASSERT(new_state != old_state);
1022         ASSERT(refcnt == 0 || ab->b_datacnt > 0);
1023         ASSERT(ab->b_datacnt == 0 || !GHOST_STATE(new_state));
1024
1025         from_delta = to_delta = ab->b_datacnt * ab->b_size;
1026
1027         /*
1028          * If this buffer is evictable, transfer it from the
1029          * old state list to the new state list.
1030          */
1031         if (refcnt == 0) {
1032                 if (old_state != arc_anon) {
1033                         int use_mutex = !MUTEX_HELD(&old_state->arcs_mtx);
1034                         uint64_t *size = &old_state->arcs_lsize[ab->b_type];
1035
1036                         if (use_mutex)
1037                                 mutex_enter(&old_state->arcs_mtx);
1038
1039                         ASSERT(list_link_active(&ab->b_arc_node));
1040                         list_remove(&old_state->arcs_list[ab->b_type], ab);
1041
1042                         /*
1043                          * If prefetching out of the ghost cache,
1044                          * we will have a non-null datacnt.
1045                          */
1046                         if (GHOST_STATE(old_state) && ab->b_datacnt == 0) {
1047                                 /* ghost elements have a ghost size */
1048                                 ASSERT(ab->b_buf == NULL);
1049                                 from_delta = ab->b_size;
1050                         }
1051                         ASSERT3U(*size, >=, from_delta);
1052                         atomic_add_64(size, -from_delta);
1053
1054                         if (use_mutex)
1055                                 mutex_exit(&old_state->arcs_mtx);
1056                 }
1057                 if (new_state != arc_anon) {
1058                         int use_mutex = !MUTEX_HELD(&new_state->arcs_mtx);
1059                         uint64_t *size = &new_state->arcs_lsize[ab->b_type];
1060
1061                         if (use_mutex)
1062                                 mutex_enter(&new_state->arcs_mtx);
1063
1064                         list_insert_head(&new_state->arcs_list[ab->b_type], ab);
1065
1066                         /* ghost elements have a ghost size */
1067                         if (GHOST_STATE(new_state)) {
1068                                 ASSERT(ab->b_datacnt == 0);
1069                                 ASSERT(ab->b_buf == NULL);
1070                                 to_delta = ab->b_size;
1071                         }
1072                         atomic_add_64(size, to_delta);
1073
1074                         if (use_mutex)
1075                                 mutex_exit(&new_state->arcs_mtx);
1076                 }
1077         }
1078
1079         ASSERT(!BUF_EMPTY(ab));
1080         if (new_state == arc_anon) {
1081                 buf_hash_remove(ab);
1082         }
1083
1084         /* adjust state sizes */
1085         if (to_delta)
1086                 atomic_add_64(&new_state->arcs_size, to_delta);
1087         if (from_delta) {
1088                 ASSERT3U(old_state->arcs_size, >=, from_delta);
1089                 atomic_add_64(&old_state->arcs_size, -from_delta);
1090         }
1091         ab->b_state = new_state;
1092
1093         /* adjust l2arc hdr stats */
1094         if (new_state == arc_l2c_only)
1095                 l2arc_hdr_stat_add();
1096         else if (old_state == arc_l2c_only)
1097                 l2arc_hdr_stat_remove();
1098 }
1099
1100 void
1101 arc_space_consume(uint64_t space)
1102 {
1103         atomic_add_64(&arc_meta_used, space);
1104         atomic_add_64(&arc_size, space);
1105 }
1106
1107 void
1108 arc_space_return(uint64_t space)
1109 {
1110         ASSERT(arc_meta_used >= space);
1111         if (arc_meta_max < arc_meta_used)
1112                 arc_meta_max = arc_meta_used;
1113         atomic_add_64(&arc_meta_used, -space);
1114         ASSERT(arc_size >= space);
1115         atomic_add_64(&arc_size, -space);
1116 }
1117
1118 void *
1119 arc_data_buf_alloc(uint64_t size)
1120 {
1121         if (arc_evict_needed(ARC_BUFC_DATA))
1122                 cv_signal(&arc_reclaim_thr_cv);
1123         atomic_add_64(&arc_size, size);
1124         return (zio_data_buf_alloc(size));
1125 }
1126
1127 void
1128 arc_data_buf_free(void *buf, uint64_t size)
1129 {
1130         zio_data_buf_free(buf, size);
1131         ASSERT(arc_size >= size);
1132         atomic_add_64(&arc_size, -size);
1133 }
1134
1135 arc_buf_t *
1136 arc_buf_alloc(spa_t *spa, int size, void *tag, arc_buf_contents_t type)
1137 {
1138         arc_buf_hdr_t *hdr;
1139         arc_buf_t *buf;
1140
1141         ASSERT3U(size, >, 0);
1142         hdr = kmem_cache_alloc(hdr_cache, KM_PUSHPAGE);
1143         ASSERT(BUF_EMPTY(hdr));
1144         hdr->b_size = size;
1145         hdr->b_type = type;
1146         hdr->b_spa = spa;
1147         hdr->b_state = arc_anon;
1148         hdr->b_arc_access = 0;
1149         buf = kmem_cache_alloc(buf_cache, KM_PUSHPAGE);
1150         buf->b_hdr = hdr;
1151         buf->b_data = NULL;
1152         buf->b_efunc = NULL;
1153         buf->b_private = NULL;
1154         buf->b_next = NULL;
1155         hdr->b_buf = buf;
1156         arc_get_data_buf(buf);
1157         hdr->b_datacnt = 1;
1158         hdr->b_flags = 0;
1159         ASSERT(refcount_is_zero(&hdr->b_refcnt));
1160         (void) refcount_add(&hdr->b_refcnt, tag);
1161
1162         return (buf);
1163 }
1164
1165 static arc_buf_t *
1166 arc_buf_clone(arc_buf_t *from)
1167 {
1168         arc_buf_t *buf;
1169         arc_buf_hdr_t *hdr = from->b_hdr;
1170         uint64_t size = hdr->b_size;
1171
1172         buf = kmem_cache_alloc(buf_cache, KM_PUSHPAGE);
1173         buf->b_hdr = hdr;
1174         buf->b_data = NULL;
1175         buf->b_efunc = NULL;
1176         buf->b_private = NULL;
1177         buf->b_next = hdr->b_buf;
1178         hdr->b_buf = buf;
1179         arc_get_data_buf(buf);
1180         bcopy(from->b_data, buf->b_data, size);
1181         hdr->b_datacnt += 1;
1182         return (buf);
1183 }
1184
1185 void
1186 arc_buf_add_ref(arc_buf_t *buf, void* tag)
1187 {
1188         arc_buf_hdr_t *hdr;
1189         kmutex_t *hash_lock;
1190
1191         /*
1192          * Check to see if this buffer is evicted.  Callers
1193          * must verify b_data != NULL to know if the add_ref
1194          * was successful.
1195          */
1196         rw_enter(&buf->b_lock, RW_READER);
1197         if (buf->b_data == NULL) {
1198                 rw_exit(&buf->b_lock);
1199                 return;
1200         }
1201         hdr = buf->b_hdr;
1202         ASSERT(hdr != NULL);
1203         hash_lock = HDR_LOCK(hdr);
1204         mutex_enter(hash_lock);
1205         rw_exit(&buf->b_lock);
1206
1207         ASSERT(hdr->b_state == arc_mru || hdr->b_state == arc_mfu);
1208         add_reference(hdr, hash_lock, tag);
1209         arc_access(hdr, hash_lock);
1210         mutex_exit(hash_lock);
1211         ARCSTAT_BUMP(arcstat_hits);
1212         ARCSTAT_CONDSTAT(!(hdr->b_flags & ARC_PREFETCH),
1213             demand, prefetch, hdr->b_type != ARC_BUFC_METADATA,
1214             data, metadata, hits);
1215 }
1216
1217 /*
1218  * Free the arc data buffer.  If it is an l2arc write in progress,
1219  * the buffer is placed on l2arc_free_on_write to be freed later.
1220  */
1221 static void
1222 arc_buf_data_free(arc_buf_hdr_t *hdr, void (*free_func)(void *, size_t),
1223     void *data, size_t size)
1224 {
1225         if (HDR_L2_WRITING(hdr)) {
1226                 l2arc_data_free_t *df;
1227                 df = kmem_alloc(sizeof (l2arc_data_free_t), KM_SLEEP);
1228                 df->l2df_data = data;
1229                 df->l2df_size = size;
1230                 df->l2df_func = free_func;
1231                 mutex_enter(&l2arc_free_on_write_mtx);
1232                 list_insert_head(l2arc_free_on_write, df);
1233                 mutex_exit(&l2arc_free_on_write_mtx);
1234                 ARCSTAT_BUMP(arcstat_l2_free_on_write);
1235         } else {
1236                 free_func(data, size);
1237         }
1238 }
1239
1240 static void
1241 arc_buf_destroy(arc_buf_t *buf, boolean_t recycle, boolean_t all)
1242 {
1243         arc_buf_t **bufp;
1244
1245         /* free up data associated with the buf */
1246         if (buf->b_data) {
1247                 arc_state_t *state = buf->b_hdr->b_state;
1248                 uint64_t size = buf->b_hdr->b_size;
1249                 arc_buf_contents_t type = buf->b_hdr->b_type;
1250
1251                 arc_cksum_verify(buf);
1252                 if (!recycle) {
1253                         if (type == ARC_BUFC_METADATA) {
1254                                 arc_buf_data_free(buf->b_hdr, zio_buf_free,
1255                                     buf->b_data, size);
1256                                 arc_space_return(size);
1257                         } else {
1258                                 ASSERT(type == ARC_BUFC_DATA);
1259                                 arc_buf_data_free(buf->b_hdr,
1260                                     zio_data_buf_free, buf->b_data, size);
1261                                 atomic_add_64(&arc_size, -size);
1262                         }
1263                 }
1264                 if (list_link_active(&buf->b_hdr->b_arc_node)) {
1265                         uint64_t *cnt = &state->arcs_lsize[type];
1266
1267                         ASSERT(refcount_is_zero(&buf->b_hdr->b_refcnt));
1268                         ASSERT(state != arc_anon);
1269
1270                         ASSERT3U(*cnt, >=, size);
1271                         atomic_add_64(cnt, -size);
1272                 }
1273                 ASSERT3U(state->arcs_size, >=, size);
1274                 atomic_add_64(&state->arcs_size, -size);
1275                 buf->b_data = NULL;
1276                 ASSERT(buf->b_hdr->b_datacnt > 0);
1277                 buf->b_hdr->b_datacnt -= 1;
1278         }
1279
1280         /* only remove the buf if requested */
1281         if (!all)
1282                 return;
1283
1284         /* remove the buf from the hdr list */
1285         for (bufp = &buf->b_hdr->b_buf; *bufp != buf; bufp = &(*bufp)->b_next)
1286                 continue;
1287         *bufp = buf->b_next;
1288
1289         ASSERT(buf->b_efunc == NULL);
1290
1291         /* clean up the buf */
1292         buf->b_hdr = NULL;
1293         kmem_cache_free(buf_cache, buf);
1294 }
1295
1296 static void
1297 arc_hdr_destroy(arc_buf_hdr_t *hdr)
1298 {
1299         ASSERT(refcount_is_zero(&hdr->b_refcnt));
1300         ASSERT3P(hdr->b_state, ==, arc_anon);
1301         ASSERT(!HDR_IO_IN_PROGRESS(hdr));
1302         ASSERT(!(hdr->b_flags & ARC_STORED));
1303
1304         if (hdr->b_l2hdr != NULL) {
1305                 if (!MUTEX_HELD(&l2arc_buflist_mtx)) {
1306                         /*
1307                          * To prevent arc_free() and l2arc_evict() from
1308                          * attempting to free the same buffer at the same time,
1309                          * a FREE_IN_PROGRESS flag is given to arc_free() to
1310                          * give it priority.  l2arc_evict() can't destroy this
1311                          * header while we are waiting on l2arc_buflist_mtx.
1312                          *
1313                          * The hdr may be removed from l2ad_buflist before we
1314                          * grab l2arc_buflist_mtx, so b_l2hdr is rechecked.
1315                          */
1316                         mutex_enter(&l2arc_buflist_mtx);
1317                         if (hdr->b_l2hdr != NULL) {
1318                                 list_remove(hdr->b_l2hdr->b_dev->l2ad_buflist,
1319                                     hdr);
1320                         }
1321                         mutex_exit(&l2arc_buflist_mtx);
1322                 } else {
1323                         list_remove(hdr->b_l2hdr->b_dev->l2ad_buflist, hdr);
1324                 }
1325                 ARCSTAT_INCR(arcstat_l2_size, -hdr->b_size);
1326                 kmem_free(hdr->b_l2hdr, sizeof (l2arc_buf_hdr_t));
1327                 if (hdr->b_state == arc_l2c_only)
1328                         l2arc_hdr_stat_remove();
1329                 hdr->b_l2hdr = NULL;
1330         }
1331
1332         if (!BUF_EMPTY(hdr)) {
1333                 ASSERT(!HDR_IN_HASH_TABLE(hdr));
1334                 bzero(&hdr->b_dva, sizeof (dva_t));
1335                 hdr->b_birth = 0;
1336                 hdr->b_cksum0 = 0;
1337         }
1338         while (hdr->b_buf) {
1339                 arc_buf_t *buf = hdr->b_buf;
1340
1341                 if (buf->b_efunc) {
1342                         mutex_enter(&arc_eviction_mtx);
1343                         rw_enter(&buf->b_lock, RW_WRITER);
1344                         ASSERT(buf->b_hdr != NULL);
1345                         arc_buf_destroy(hdr->b_buf, FALSE, FALSE);
1346                         hdr->b_buf = buf->b_next;
1347                         buf->b_hdr = &arc_eviction_hdr;
1348                         buf->b_next = arc_eviction_list;
1349                         arc_eviction_list = buf;
1350                         rw_exit(&buf->b_lock);
1351                         mutex_exit(&arc_eviction_mtx);
1352                 } else {
1353                         arc_buf_destroy(hdr->b_buf, FALSE, TRUE);
1354                 }
1355         }
1356         if (hdr->b_freeze_cksum != NULL) {
1357                 kmem_free(hdr->b_freeze_cksum, sizeof (zio_cksum_t));
1358                 hdr->b_freeze_cksum = NULL;
1359         }
1360
1361         ASSERT(!list_link_active(&hdr->b_arc_node));
1362         ASSERT3P(hdr->b_hash_next, ==, NULL);
1363         ASSERT3P(hdr->b_acb, ==, NULL);
1364         kmem_cache_free(hdr_cache, hdr);
1365 }
1366
1367 void
1368 arc_buf_free(arc_buf_t *buf, void *tag)
1369 {
1370         arc_buf_hdr_t *hdr = buf->b_hdr;
1371         int hashed = hdr->b_state != arc_anon;
1372
1373         ASSERT(buf->b_efunc == NULL);
1374         ASSERT(buf->b_data != NULL);
1375
1376         if (hashed) {
1377                 kmutex_t *hash_lock = HDR_LOCK(hdr);
1378
1379                 mutex_enter(hash_lock);
1380                 (void) remove_reference(hdr, hash_lock, tag);
1381                 if (hdr->b_datacnt > 1)
1382                         arc_buf_destroy(buf, FALSE, TRUE);
1383                 else
1384                         hdr->b_flags |= ARC_BUF_AVAILABLE;
1385                 mutex_exit(hash_lock);
1386         } else if (HDR_IO_IN_PROGRESS(hdr)) {
1387                 int destroy_hdr;
1388                 /*
1389                  * We are in the middle of an async write.  Don't destroy
1390                  * this buffer unless the write completes before we finish
1391                  * decrementing the reference count.
1392                  */
1393                 mutex_enter(&arc_eviction_mtx);
1394                 (void) remove_reference(hdr, NULL, tag);
1395                 ASSERT(refcount_is_zero(&hdr->b_refcnt));
1396                 destroy_hdr = !HDR_IO_IN_PROGRESS(hdr);
1397                 mutex_exit(&arc_eviction_mtx);
1398                 if (destroy_hdr)
1399                         arc_hdr_destroy(hdr);
1400         } else {
1401                 if (remove_reference(hdr, NULL, tag) > 0) {
1402                         ASSERT(HDR_IO_ERROR(hdr));
1403                         arc_buf_destroy(buf, FALSE, TRUE);
1404                 } else {
1405                         arc_hdr_destroy(hdr);
1406                 }
1407         }
1408 }
1409
1410 int
1411 arc_buf_remove_ref(arc_buf_t *buf, void* tag)
1412 {
1413         arc_buf_hdr_t *hdr = buf->b_hdr;
1414         kmutex_t *hash_lock = HDR_LOCK(hdr);
1415         int no_callback = (buf->b_efunc == NULL);
1416
1417         if (hdr->b_state == arc_anon) {
1418                 arc_buf_free(buf, tag);
1419                 return (no_callback);
1420         }
1421
1422         mutex_enter(hash_lock);
1423         ASSERT(hdr->b_state != arc_anon);
1424         ASSERT(buf->b_data != NULL);
1425
1426         (void) remove_reference(hdr, hash_lock, tag);
1427         if (hdr->b_datacnt > 1) {
1428                 if (no_callback)
1429                         arc_buf_destroy(buf, FALSE, TRUE);
1430         } else if (no_callback) {
1431                 ASSERT(hdr->b_buf == buf && buf->b_next == NULL);
1432                 hdr->b_flags |= ARC_BUF_AVAILABLE;
1433         }
1434         ASSERT(no_callback || hdr->b_datacnt > 1 ||
1435             refcount_is_zero(&hdr->b_refcnt));
1436         mutex_exit(hash_lock);
1437         return (no_callback);
1438 }
1439
1440 int
1441 arc_buf_size(arc_buf_t *buf)
1442 {
1443         return (buf->b_hdr->b_size);
1444 }
1445
1446 /*
1447  * Evict buffers from list until we've removed the specified number of
1448  * bytes.  Move the removed buffers to the appropriate evict state.
1449  * If the recycle flag is set, then attempt to "recycle" a buffer:
1450  * - look for a buffer to evict that is `bytes' long.
1451  * - return the data block from this buffer rather than freeing it.
1452  * This flag is used by callers that are trying to make space for a
1453  * new buffer in a full arc cache.
1454  *
1455  * This function makes a "best effort".  It skips over any buffers
1456  * it can't get a hash_lock on, and so may not catch all candidates.
1457  * It may also return without evicting as much space as requested.
1458  */
1459 static void *
1460 arc_evict(arc_state_t *state, spa_t *spa, int64_t bytes, boolean_t recycle,
1461     arc_buf_contents_t type)
1462 {
1463         arc_state_t *evicted_state;
1464         uint64_t bytes_evicted = 0, skipped = 0, missed = 0;
1465         arc_buf_hdr_t *ab, *ab_prev = NULL;
1466         list_t *list = &state->arcs_list[type];
1467         kmutex_t *hash_lock;
1468         boolean_t have_lock;
1469         void *stolen = NULL;
1470
1471         ASSERT(state == arc_mru || state == arc_mfu);
1472
1473         evicted_state = (state == arc_mru) ? arc_mru_ghost : arc_mfu_ghost;
1474
1475         mutex_enter(&state->arcs_mtx);
1476         mutex_enter(&evicted_state->arcs_mtx);
1477
1478         for (ab = list_tail(list); ab; ab = ab_prev) {
1479                 ab_prev = list_prev(list, ab);
1480                 /* prefetch buffers have a minimum lifespan */
1481                 if (HDR_IO_IN_PROGRESS(ab) ||
1482                     (spa && ab->b_spa != spa) ||
1483                     (ab->b_flags & (ARC_PREFETCH|ARC_INDIRECT) &&
1484                     LBOLT - ab->b_arc_access < arc_min_prefetch_lifespan)) {
1485                         skipped++;
1486                         continue;
1487                 }
1488                 /* "lookahead" for better eviction candidate */
1489                 if (recycle && ab->b_size != bytes &&
1490                     ab_prev && ab_prev->b_size == bytes)
1491                         continue;
1492                 hash_lock = HDR_LOCK(ab);
1493                 have_lock = MUTEX_HELD(hash_lock);
1494                 if (have_lock || mutex_tryenter(hash_lock)) {
1495                         ASSERT3U(refcount_count(&ab->b_refcnt), ==, 0);
1496                         ASSERT(ab->b_datacnt > 0);
1497                         while (ab->b_buf) {
1498                                 arc_buf_t *buf = ab->b_buf;
1499                                 if (!rw_tryenter(&buf->b_lock, RW_WRITER)) {
1500                                         missed += 1;
1501                                         break;
1502                                 }
1503                                 if (buf->b_data) {
1504                                         bytes_evicted += ab->b_size;
1505                                         if (recycle && ab->b_type == type &&
1506                                             ab->b_size == bytes &&
1507                                             !HDR_L2_WRITING(ab)) {
1508                                                 stolen = buf->b_data;
1509                                                 recycle = FALSE;
1510                                         }
1511                                 }
1512                                 if (buf->b_efunc) {
1513                                         mutex_enter(&arc_eviction_mtx);
1514                                         arc_buf_destroy(buf,
1515                                             buf->b_data == stolen, FALSE);
1516                                         ab->b_buf = buf->b_next;
1517                                         buf->b_hdr = &arc_eviction_hdr;
1518                                         buf->b_next = arc_eviction_list;
1519                                         arc_eviction_list = buf;
1520                                         mutex_exit(&arc_eviction_mtx);
1521                                         rw_exit(&buf->b_lock);
1522                                 } else {
1523                                         rw_exit(&buf->b_lock);
1524                                         arc_buf_destroy(buf,
1525                                             buf->b_data == stolen, TRUE);
1526                                 }
1527                         }
1528                         if (ab->b_datacnt == 0) {
1529                                 arc_change_state(evicted_state, ab, hash_lock);
1530                                 ASSERT(HDR_IN_HASH_TABLE(ab));
1531                                 ab->b_flags |= ARC_IN_HASH_TABLE;
1532                                 ab->b_flags &= ~ARC_BUF_AVAILABLE;
1533                                 DTRACE_PROBE1(arc__evict, arc_buf_hdr_t *, ab);
1534                         }
1535                         if (!have_lock)
1536                                 mutex_exit(hash_lock);
1537                         if (bytes >= 0 && bytes_evicted >= bytes)
1538                                 break;
1539                 } else {
1540                         missed += 1;
1541                 }
1542         }
1543
1544         mutex_exit(&evicted_state->arcs_mtx);
1545         mutex_exit(&state->arcs_mtx);
1546
1547         if (bytes_evicted < bytes)
1548                 dprintf("only evicted %lld bytes from %x",
1549                     (longlong_t)bytes_evicted, state);
1550
1551         if (skipped)
1552                 ARCSTAT_INCR(arcstat_evict_skip, skipped);
1553
1554         if (missed)
1555                 ARCSTAT_INCR(arcstat_mutex_miss, missed);
1556
1557         /*
1558          * We have just evicted some date into the ghost state, make
1559          * sure we also adjust the ghost state size if necessary.
1560          */
1561         if (arc_no_grow &&
1562             arc_mru_ghost->arcs_size + arc_mfu_ghost->arcs_size > arc_c) {
1563                 int64_t mru_over = arc_anon->arcs_size + arc_mru->arcs_size +
1564                     arc_mru_ghost->arcs_size - arc_c;
1565
1566                 if (mru_over > 0 && arc_mru_ghost->arcs_lsize[type] > 0) {
1567                         int64_t todelete =
1568                             MIN(arc_mru_ghost->arcs_lsize[type], mru_over);
1569                         arc_evict_ghost(arc_mru_ghost, NULL, todelete);
1570                 } else if (arc_mfu_ghost->arcs_lsize[type] > 0) {
1571                         int64_t todelete = MIN(arc_mfu_ghost->arcs_lsize[type],
1572                             arc_mru_ghost->arcs_size +
1573                             arc_mfu_ghost->arcs_size - arc_c);
1574                         arc_evict_ghost(arc_mfu_ghost, NULL, todelete);
1575                 }
1576         }
1577
1578         return (stolen);
1579 }
1580
1581 /*
1582  * Remove buffers from list until we've removed the specified number of
1583  * bytes.  Destroy the buffers that are removed.
1584  */
1585 static void
1586 arc_evict_ghost(arc_state_t *state, spa_t *spa, int64_t bytes)
1587 {
1588         arc_buf_hdr_t *ab, *ab_prev;
1589         list_t *list = &state->arcs_list[ARC_BUFC_DATA];
1590         kmutex_t *hash_lock;
1591         uint64_t bytes_deleted = 0;
1592         uint64_t bufs_skipped = 0;
1593
1594         ASSERT(GHOST_STATE(state));
1595 top:
1596         mutex_enter(&state->arcs_mtx);
1597         for (ab = list_tail(list); ab; ab = ab_prev) {
1598                 ab_prev = list_prev(list, ab);
1599                 if (spa && ab->b_spa != spa)
1600                         continue;
1601                 hash_lock = HDR_LOCK(ab);
1602                 if (mutex_tryenter(hash_lock)) {
1603                         ASSERT(!HDR_IO_IN_PROGRESS(ab));
1604                         ASSERT(ab->b_buf == NULL);
1605                         ARCSTAT_BUMP(arcstat_deleted);
1606                         bytes_deleted += ab->b_size;
1607
1608                         if (ab->b_l2hdr != NULL) {
1609                                 /*
1610                                  * This buffer is cached on the 2nd Level ARC;
1611                                  * don't destroy the header.
1612                                  */
1613                                 arc_change_state(arc_l2c_only, ab, hash_lock);
1614                                 mutex_exit(hash_lock);
1615                         } else {
1616                                 arc_change_state(arc_anon, ab, hash_lock);
1617                                 mutex_exit(hash_lock);
1618                                 arc_hdr_destroy(ab);
1619                         }
1620
1621                         DTRACE_PROBE1(arc__delete, arc_buf_hdr_t *, ab);
1622                         if (bytes >= 0 && bytes_deleted >= bytes)
1623                                 break;
1624                 } else {
1625                         if (bytes < 0) {
1626                                 mutex_exit(&state->arcs_mtx);
1627                                 mutex_enter(hash_lock);
1628                                 mutex_exit(hash_lock);
1629                                 goto top;
1630                         }
1631                         bufs_skipped += 1;
1632                 }
1633         }
1634         mutex_exit(&state->arcs_mtx);
1635
1636         if (list == &state->arcs_list[ARC_BUFC_DATA] &&
1637             (bytes < 0 || bytes_deleted < bytes)) {
1638                 list = &state->arcs_list[ARC_BUFC_METADATA];
1639                 goto top;
1640         }
1641
1642         if (bufs_skipped) {
1643                 ARCSTAT_INCR(arcstat_mutex_miss, bufs_skipped);
1644                 ASSERT(bytes >= 0);
1645         }
1646
1647         if (bytes_deleted < bytes)
1648                 dprintf("only deleted %lld bytes from %p",
1649                     (longlong_t)bytes_deleted, state);
1650 }
1651
1652 static void
1653 arc_adjust(void)
1654 {
1655         int64_t top_sz, mru_over, arc_over, todelete;
1656
1657         top_sz = arc_anon->arcs_size + arc_mru->arcs_size + arc_meta_used;
1658
1659         if (top_sz > arc_p && arc_mru->arcs_lsize[ARC_BUFC_DATA] > 0) {
1660                 int64_t toevict =
1661                     MIN(arc_mru->arcs_lsize[ARC_BUFC_DATA], top_sz - arc_p);
1662                 (void) arc_evict(arc_mru, NULL, toevict, FALSE, ARC_BUFC_DATA);
1663                 top_sz = arc_anon->arcs_size + arc_mru->arcs_size;
1664         }
1665
1666         if (top_sz > arc_p && arc_mru->arcs_lsize[ARC_BUFC_METADATA] > 0) {
1667                 int64_t toevict =
1668                     MIN(arc_mru->arcs_lsize[ARC_BUFC_METADATA], top_sz - arc_p);
1669                 (void) arc_evict(arc_mru, NULL, toevict, FALSE,
1670                     ARC_BUFC_METADATA);
1671                 top_sz = arc_anon->arcs_size + arc_mru->arcs_size;
1672         }
1673
1674         mru_over = top_sz + arc_mru_ghost->arcs_size - arc_c;
1675
1676         if (mru_over > 0) {
1677                 if (arc_mru_ghost->arcs_size > 0) {
1678                         todelete = MIN(arc_mru_ghost->arcs_size, mru_over);
1679                         arc_evict_ghost(arc_mru_ghost, NULL, todelete);
1680                 }
1681         }
1682
1683         if ((arc_over = arc_size - arc_c) > 0) {
1684                 int64_t tbl_over;
1685
1686                 if (arc_mfu->arcs_lsize[ARC_BUFC_DATA] > 0) {
1687                         int64_t toevict =
1688                             MIN(arc_mfu->arcs_lsize[ARC_BUFC_DATA], arc_over);
1689                         (void) arc_evict(arc_mfu, NULL, toevict, FALSE,
1690                             ARC_BUFC_DATA);
1691                         arc_over = arc_size - arc_c;
1692                 }
1693
1694                 if (arc_over > 0 &&
1695                     arc_mfu->arcs_lsize[ARC_BUFC_METADATA] > 0) {
1696                         int64_t toevict =
1697                             MIN(arc_mfu->arcs_lsize[ARC_BUFC_METADATA],
1698                             arc_over);
1699                         (void) arc_evict(arc_mfu, NULL, toevict, FALSE,
1700                             ARC_BUFC_METADATA);
1701                 }
1702
1703                 tbl_over = arc_size + arc_mru_ghost->arcs_size +
1704                     arc_mfu_ghost->arcs_size - arc_c * 2;
1705
1706                 if (tbl_over > 0 && arc_mfu_ghost->arcs_size > 0) {
1707                         todelete = MIN(arc_mfu_ghost->arcs_size, tbl_over);
1708                         arc_evict_ghost(arc_mfu_ghost, NULL, todelete);
1709                 }
1710         }
1711 }
1712
1713 static void
1714 arc_do_user_evicts(void)
1715 {
1716         static arc_buf_t *tmp_arc_eviction_list;
1717
1718         /*
1719          * Move list over to avoid LOR
1720          */
1721 restart:        
1722         mutex_enter(&arc_eviction_mtx);
1723         tmp_arc_eviction_list = arc_eviction_list;
1724         arc_eviction_list = NULL;
1725         mutex_exit(&arc_eviction_mtx);
1726
1727         while (tmp_arc_eviction_list != NULL) {
1728                 arc_buf_t *buf = tmp_arc_eviction_list;
1729                 tmp_arc_eviction_list = buf->b_next;
1730                 rw_enter(&buf->b_lock, RW_WRITER);
1731                 buf->b_hdr = NULL;
1732                 rw_exit(&buf->b_lock);
1733
1734                 if (buf->b_efunc != NULL)
1735                         VERIFY(buf->b_efunc(buf) == 0);
1736
1737                 buf->b_efunc = NULL;
1738                 buf->b_private = NULL;
1739                 kmem_cache_free(buf_cache, buf);
1740         }
1741
1742         if (arc_eviction_list != NULL)
1743                 goto restart;
1744 }
1745
1746 /*
1747  * Flush all *evictable* data from the cache for the given spa.
1748  * NOTE: this will not touch "active" (i.e. referenced) data.
1749  */
1750 void
1751 arc_flush(spa_t *spa)
1752 {
1753         while (list_head(&arc_mru->arcs_list[ARC_BUFC_DATA])) {
1754                 (void) arc_evict(arc_mru, spa, -1, FALSE, ARC_BUFC_DATA);
1755                 if (spa)
1756                         break;
1757         }
1758         while (list_head(&arc_mru->arcs_list[ARC_BUFC_METADATA])) {
1759                 (void) arc_evict(arc_mru, spa, -1, FALSE, ARC_BUFC_METADATA);
1760                 if (spa)
1761                         break;
1762         }
1763         while (list_head(&arc_mfu->arcs_list[ARC_BUFC_DATA])) {
1764                 (void) arc_evict(arc_mfu, spa, -1, FALSE, ARC_BUFC_DATA);
1765                 if (spa)
1766                         break;
1767         }
1768         while (list_head(&arc_mfu->arcs_list[ARC_BUFC_METADATA])) {
1769                 (void) arc_evict(arc_mfu, spa, -1, FALSE, ARC_BUFC_METADATA);
1770                 if (spa)
1771                         break;
1772         }
1773
1774         arc_evict_ghost(arc_mru_ghost, spa, -1);
1775         arc_evict_ghost(arc_mfu_ghost, spa, -1);
1776
1777         mutex_enter(&arc_reclaim_thr_lock);
1778         arc_do_user_evicts();
1779         mutex_exit(&arc_reclaim_thr_lock);
1780         ASSERT(spa || arc_eviction_list == NULL);
1781 }
1782
1783 int arc_shrink_shift = 5;               /* log2(fraction of arc to reclaim) */
1784
1785 void
1786 arc_shrink(void)
1787 {
1788         if (arc_c > arc_c_min) {
1789                 uint64_t to_free;
1790
1791 #ifdef _KERNEL
1792                 to_free = arc_c >> arc_shrink_shift;
1793 #else
1794                 to_free = arc_c >> arc_shrink_shift;
1795 #endif
1796                 if (arc_c > arc_c_min + to_free)
1797                         atomic_add_64(&arc_c, -to_free);
1798                 else
1799                         arc_c = arc_c_min;
1800
1801                 atomic_add_64(&arc_p, -(arc_p >> arc_shrink_shift));
1802                 if (arc_c > arc_size)
1803                         arc_c = MAX(arc_size, arc_c_min);
1804                 if (arc_p > arc_c)
1805                         arc_p = (arc_c >> 1);
1806                 ASSERT(arc_c >= arc_c_min);
1807                 ASSERT((int64_t)arc_p >= 0);
1808         }
1809
1810         if (arc_size > arc_c)
1811                 arc_adjust();
1812 }
1813
1814 static int needfree = 0;
1815
1816 static int
1817 arc_reclaim_needed(void)
1818 {
1819 #if 0
1820         uint64_t extra;
1821 #endif
1822
1823 #ifdef _KERNEL
1824         if (needfree)
1825                 return (1);
1826         if (arc_size > arc_c_max)
1827                 return (1);
1828         if (arc_size <= arc_c_min)
1829                 return (0);
1830
1831         /*
1832          * If pages are needed or we're within 2048 pages 
1833          * of needing to page need to reclaim
1834          */
1835         if (vm_pages_needed || (vm_paging_target() > -2048))
1836                 return (1);
1837
1838 #if 0
1839         /*
1840          * take 'desfree' extra pages, so we reclaim sooner, rather than later
1841          */
1842         extra = desfree;
1843
1844         /*
1845          * check that we're out of range of the pageout scanner.  It starts to
1846          * schedule paging if freemem is less than lotsfree and needfree.
1847          * lotsfree is the high-water mark for pageout, and needfree is the
1848          * number of needed free pages.  We add extra pages here to make sure
1849          * the scanner doesn't start up while we're freeing memory.
1850          */
1851         if (freemem < lotsfree + needfree + extra)
1852                 return (1);
1853
1854         /*
1855          * check to make sure that swapfs has enough space so that anon
1856          * reservations can still succeed. anon_resvmem() checks that the
1857          * availrmem is greater than swapfs_minfree, and the number of reserved
1858          * swap pages.  We also add a bit of extra here just to prevent
1859          * circumstances from getting really dire.
1860          */
1861         if (availrmem < swapfs_minfree + swapfs_reserve + extra)
1862                 return (1);
1863
1864 #if defined(__i386)
1865         /*
1866          * If we're on an i386 platform, it's possible that we'll exhaust the
1867          * kernel heap space before we ever run out of available physical
1868          * memory.  Most checks of the size of the heap_area compare against
1869          * tune.t_minarmem, which is the minimum available real memory that we
1870          * can have in the system.  However, this is generally fixed at 25 pages
1871          * which is so low that it's useless.  In this comparison, we seek to
1872          * calculate the total heap-size, and reclaim if more than 3/4ths of the
1873          * heap is allocated.  (Or, in the calculation, if less than 1/4th is
1874          * free)
1875          */
1876         if (btop(vmem_size(heap_arena, VMEM_FREE)) <
1877             (btop(vmem_size(heap_arena, VMEM_FREE | VMEM_ALLOC)) >> 2))
1878                 return (1);
1879 #endif
1880 #else
1881         if (kmem_used() > (kmem_size() * 3) / 4)
1882                 return (1);
1883 #endif
1884
1885 #else
1886         if (spa_get_random(100) == 0)
1887                 return (1);
1888 #endif
1889         return (0);
1890 }
1891
1892 static void
1893 arc_kmem_reap_now(arc_reclaim_strategy_t strat)
1894 {
1895 #ifdef ZIO_USE_UMA
1896         size_t                  i;
1897         kmem_cache_t            *prev_cache = NULL;
1898         kmem_cache_t            *prev_data_cache = NULL;
1899         extern kmem_cache_t     *zio_buf_cache[];
1900         extern kmem_cache_t     *zio_data_buf_cache[];
1901 #endif
1902
1903 #ifdef _KERNEL
1904         if (arc_meta_used >= arc_meta_limit) {
1905                 /*
1906                  * We are exceeding our meta-data cache limit.
1907                  * Purge some DNLC entries to release holds on meta-data.
1908                  */
1909                 dnlc_reduce_cache((void *)(uintptr_t)arc_reduce_dnlc_percent);
1910         }
1911 #if defined(__i386)
1912         /*
1913          * Reclaim unused memory from all kmem caches.
1914          */
1915         kmem_reap();
1916 #endif
1917 #endif
1918
1919         /*
1920          * An aggressive reclamation will shrink the cache size as well as
1921          * reap free buffers from the arc kmem caches.
1922          */
1923         if (strat == ARC_RECLAIM_AGGR)
1924                 arc_shrink();
1925
1926 #ifdef ZIO_USE_UMA
1927         for (i = 0; i < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT; i++) {
1928                 if (zio_buf_cache[i] != prev_cache) {
1929                         prev_cache = zio_buf_cache[i];
1930                         kmem_cache_reap_now(zio_buf_cache[i]);
1931                 }
1932                 if (zio_data_buf_cache[i] != prev_data_cache) {
1933                         prev_data_cache = zio_data_buf_cache[i];
1934                         kmem_cache_reap_now(zio_data_buf_cache[i]);
1935                 }
1936         }
1937 #endif
1938         kmem_cache_reap_now(buf_cache);
1939         kmem_cache_reap_now(hdr_cache);
1940 }
1941
1942 static void
1943 arc_reclaim_thread(void *dummy __unused)
1944 {
1945         clock_t                 growtime = 0;
1946         arc_reclaim_strategy_t  last_reclaim = ARC_RECLAIM_CONS;
1947         callb_cpr_t             cpr;
1948
1949         CALLB_CPR_INIT(&cpr, &arc_reclaim_thr_lock, callb_generic_cpr, FTAG);
1950
1951         mutex_enter(&arc_reclaim_thr_lock);
1952         while (arc_thread_exit == 0) {
1953                 if (arc_reclaim_needed()) {
1954
1955                         if (arc_no_grow) {
1956                                 if (last_reclaim == ARC_RECLAIM_CONS) {
1957                                         last_reclaim = ARC_RECLAIM_AGGR;
1958                                 } else {
1959                                         last_reclaim = ARC_RECLAIM_CONS;
1960                                 }
1961                         } else {
1962                                 arc_no_grow = TRUE;
1963                                 last_reclaim = ARC_RECLAIM_AGGR;
1964                                 membar_producer();
1965                         }
1966
1967                         /* reset the growth delay for every reclaim */
1968                         growtime = LBOLT + (arc_grow_retry * hz);
1969
1970                         if (needfree && last_reclaim == ARC_RECLAIM_CONS) {
1971                                 /*
1972                                  * If needfree is TRUE our vm_lowmem hook
1973                                  * was called and in that case we must free some
1974                                  * memory, so switch to aggressive mode.
1975                                  */
1976                                 arc_no_grow = TRUE;
1977                                 last_reclaim = ARC_RECLAIM_AGGR;
1978                         }
1979                         arc_kmem_reap_now(last_reclaim);
1980                         arc_warm = B_TRUE;
1981
1982                 } else if (arc_no_grow && LBOLT >= growtime) {
1983                         arc_no_grow = FALSE;
1984                 }
1985
1986                 if (needfree ||
1987                     (2 * arc_c < arc_size +
1988                     arc_mru_ghost->arcs_size + arc_mfu_ghost->arcs_size))
1989                         arc_adjust();
1990
1991                 if (arc_eviction_list != NULL)
1992                         arc_do_user_evicts();
1993
1994                 if (arc_reclaim_needed()) {
1995                         needfree = 0;
1996 #ifdef _KERNEL
1997                         wakeup(&needfree);
1998 #endif
1999                 }
2000
2001                 /* block until needed, or one second, whichever is shorter */
2002                 CALLB_CPR_SAFE_BEGIN(&cpr);
2003                 (void) cv_timedwait(&arc_reclaim_thr_cv,
2004                     &arc_reclaim_thr_lock, hz);
2005                 CALLB_CPR_SAFE_END(&cpr, &arc_reclaim_thr_lock);
2006         }
2007
2008         arc_thread_exit = 0;
2009         cv_broadcast(&arc_reclaim_thr_cv);
2010         CALLB_CPR_EXIT(&cpr);           /* drops arc_reclaim_thr_lock */
2011         thread_exit();
2012 }
2013
2014 /*
2015  * Adapt arc info given the number of bytes we are trying to add and
2016  * the state that we are comming from.  This function is only called
2017  * when we are adding new content to the cache.
2018  */
2019 static void
2020 arc_adapt(int bytes, arc_state_t *state)
2021 {
2022         int mult;
2023
2024         if (state == arc_l2c_only)
2025                 return;
2026
2027         ASSERT(bytes > 0);
2028         /*
2029          * Adapt the target size of the MRU list:
2030          *      - if we just hit in the MRU ghost list, then increase
2031          *        the target size of the MRU list.
2032          *      - if we just hit in the MFU ghost list, then increase
2033          *        the target size of the MFU list by decreasing the
2034          *        target size of the MRU list.
2035          */
2036         if (state == arc_mru_ghost) {
2037                 mult = ((arc_mru_ghost->arcs_size >= arc_mfu_ghost->arcs_size) ?
2038                     1 : (arc_mfu_ghost->arcs_size/arc_mru_ghost->arcs_size));
2039
2040                 arc_p = MIN(arc_c, arc_p + bytes * mult);
2041         } else if (state == arc_mfu_ghost) {
2042                 mult = ((arc_mfu_ghost->arcs_size >= arc_mru_ghost->arcs_size) ?
2043                     1 : (arc_mru_ghost->arcs_size/arc_mfu_ghost->arcs_size));
2044
2045                 arc_p = MAX(0, (int64_t)arc_p - bytes * mult);
2046         }
2047         ASSERT((int64_t)arc_p >= 0);
2048
2049         if (arc_reclaim_needed()) {
2050                 cv_signal(&arc_reclaim_thr_cv);
2051                 return;
2052         }
2053
2054         if (arc_no_grow)
2055                 return;
2056
2057         if (arc_c >= arc_c_max)
2058                 return;
2059
2060         /*
2061          * If we're within (2 * maxblocksize) bytes of the target
2062          * cache size, increment the target cache size
2063          */
2064         if (arc_size > arc_c - (2ULL << SPA_MAXBLOCKSHIFT)) {
2065                 atomic_add_64(&arc_c, (int64_t)bytes);
2066                 if (arc_c > arc_c_max)
2067                         arc_c = arc_c_max;
2068                 else if (state == arc_anon)
2069                         atomic_add_64(&arc_p, (int64_t)bytes);
2070                 if (arc_p > arc_c)
2071                         arc_p = arc_c;
2072         }
2073         ASSERT((int64_t)arc_p >= 0);
2074 }
2075
2076 /*
2077  * Check if the cache has reached its limits and eviction is required
2078  * prior to insert.
2079  */
2080 static int
2081 arc_evict_needed(arc_buf_contents_t type)
2082 {
2083         if (type == ARC_BUFC_METADATA && arc_meta_used >= arc_meta_limit)
2084                 return (1);
2085
2086 #if 0
2087 #ifdef _KERNEL
2088         /*
2089          * If zio data pages are being allocated out of a separate heap segment,
2090          * then enforce that the size of available vmem for this area remains
2091          * above about 1/32nd free.
2092          */
2093         if (type == ARC_BUFC_DATA && zio_arena != NULL &&
2094             vmem_size(zio_arena, VMEM_FREE) <
2095             (vmem_size(zio_arena, VMEM_ALLOC) >> 5))
2096                 return (1);
2097 #endif
2098 #endif
2099
2100         if (arc_reclaim_needed())
2101                 return (1);
2102
2103         return (arc_size > arc_c);
2104 }
2105
2106 /*
2107  * The buffer, supplied as the first argument, needs a data block.
2108  * So, if we are at cache max, determine which cache should be victimized.
2109  * We have the following cases:
2110  *
2111  * 1. Insert for MRU, p > sizeof(arc_anon + arc_mru) ->
2112  * In this situation if we're out of space, but the resident size of the MFU is
2113  * under the limit, victimize the MFU cache to satisfy this insertion request.
2114  *
2115  * 2. Insert for MRU, p <= sizeof(arc_anon + arc_mru) ->
2116  * Here, we've used up all of the available space for the MRU, so we need to
2117  * evict from our own cache instead.  Evict from the set of resident MRU
2118  * entries.
2119  *
2120  * 3. Insert for MFU (c - p) > sizeof(arc_mfu) ->
2121  * c minus p represents the MFU space in the cache, since p is the size of the
2122  * cache that is dedicated to the MRU.  In this situation there's still space on
2123  * the MFU side, so the MRU side needs to be victimized.
2124  *
2125  * 4. Insert for MFU (c - p) < sizeof(arc_mfu) ->
2126  * MFU's resident set is consuming more space than it has been allotted.  In
2127  * this situation, we must victimize our own cache, the MFU, for this insertion.
2128  */
2129 static void
2130 arc_get_data_buf(arc_buf_t *buf)
2131 {
2132         arc_state_t             *state = buf->b_hdr->b_state;
2133         uint64_t                size = buf->b_hdr->b_size;
2134         arc_buf_contents_t      type = buf->b_hdr->b_type;
2135
2136         arc_adapt(size, state);
2137
2138         /*
2139          * We have not yet reached cache maximum size,
2140          * just allocate a new buffer.
2141          */
2142         if (!arc_evict_needed(type)) {
2143                 if (type == ARC_BUFC_METADATA) {
2144                         buf->b_data = zio_buf_alloc(size);
2145                         arc_space_consume(size);
2146                 } else {
2147                         ASSERT(type == ARC_BUFC_DATA);
2148                         buf->b_data = zio_data_buf_alloc(size);
2149                         atomic_add_64(&arc_size, size);
2150                 }
2151                 goto out;
2152         }
2153
2154         /*
2155          * If we are prefetching from the mfu ghost list, this buffer
2156          * will end up on the mru list; so steal space from there.
2157          */
2158         if (state == arc_mfu_ghost)
2159                 state = buf->b_hdr->b_flags & ARC_PREFETCH ? arc_mru : arc_mfu;
2160         else if (state == arc_mru_ghost)
2161                 state = arc_mru;
2162
2163         if (state == arc_mru || state == arc_anon) {
2164                 uint64_t mru_used = arc_anon->arcs_size + arc_mru->arcs_size;
2165                 state = (arc_mfu->arcs_lsize[type] > 0 &&
2166                     arc_p > mru_used) ? arc_mfu : arc_mru;
2167         } else {
2168                 /* MFU cases */
2169                 uint64_t mfu_space = arc_c - arc_p;
2170                 state =  (arc_mru->arcs_lsize[type] > 0 &&
2171                     mfu_space > arc_mfu->arcs_size) ? arc_mru : arc_mfu;
2172         }
2173         if ((buf->b_data = arc_evict(state, NULL, size, TRUE, type)) == NULL) {
2174                 if (type == ARC_BUFC_METADATA) {
2175                         buf->b_data = zio_buf_alloc(size);
2176                         arc_space_consume(size);
2177                 } else {
2178                         ASSERT(type == ARC_BUFC_DATA);
2179                         buf->b_data = zio_data_buf_alloc(size);
2180                         atomic_add_64(&arc_size, size);
2181                 }
2182                 ARCSTAT_BUMP(arcstat_recycle_miss);
2183         }
2184         ASSERT(buf->b_data != NULL);
2185 out:
2186         /*
2187          * Update the state size.  Note that ghost states have a
2188          * "ghost size" and so don't need to be updated.
2189          */
2190         if (!GHOST_STATE(buf->b_hdr->b_state)) {
2191                 arc_buf_hdr_t *hdr = buf->b_hdr;
2192
2193                 atomic_add_64(&hdr->b_state->arcs_size, size);
2194                 if (list_link_active(&hdr->b_arc_node)) {
2195                         ASSERT(refcount_is_zero(&hdr->b_refcnt));
2196                         atomic_add_64(&hdr->b_state->arcs_lsize[type], size);
2197                 }
2198                 /*
2199                  * If we are growing the cache, and we are adding anonymous
2200                  * data, and we have outgrown arc_p, update arc_p
2201                  */
2202                 if (arc_size < arc_c && hdr->b_state == arc_anon &&
2203                     arc_anon->arcs_size + arc_mru->arcs_size > arc_p)
2204                         arc_p = MIN(arc_c, arc_p + size);
2205         }
2206 }
2207
2208 /*
2209  * This routine is called whenever a buffer is accessed.
2210  * NOTE: the hash lock is dropped in this function.
2211  */
2212 static void
2213 arc_access(arc_buf_hdr_t *buf, kmutex_t *hash_lock)
2214 {
2215         ASSERT(MUTEX_HELD(hash_lock));
2216
2217         if (buf->b_state == arc_anon) {
2218                 /*
2219                  * This buffer is not in the cache, and does not
2220                  * appear in our "ghost" list.  Add the new buffer
2221                  * to the MRU state.
2222                  */
2223
2224                 ASSERT(buf->b_arc_access == 0);
2225                 buf->b_arc_access = LBOLT;
2226                 DTRACE_PROBE1(new_state__mru, arc_buf_hdr_t *, buf);
2227                 arc_change_state(arc_mru, buf, hash_lock);
2228
2229         } else if (buf->b_state == arc_mru) {
2230                 /*
2231                  * If this buffer is here because of a prefetch, then either:
2232                  * - clear the flag if this is a "referencing" read
2233                  *   (any subsequent access will bump this into the MFU state).
2234                  * or
2235                  * - move the buffer to the head of the list if this is
2236                  *   another prefetch (to make it less likely to be evicted).
2237                  */
2238                 if ((buf->b_flags & ARC_PREFETCH) != 0) {
2239                         if (refcount_count(&buf->b_refcnt) == 0) {
2240                                 ASSERT(list_link_active(&buf->b_arc_node));
2241                         } else {
2242                                 buf->b_flags &= ~ARC_PREFETCH;
2243                                 ARCSTAT_BUMP(arcstat_mru_hits);
2244                         }
2245                         buf->b_arc_access = LBOLT;
2246                         return;
2247                 }
2248
2249                 /*
2250                  * This buffer has been "accessed" only once so far,
2251                  * but it is still in the cache. Move it to the MFU
2252                  * state.
2253                  */
2254                 if (LBOLT > buf->b_arc_access + ARC_MINTIME) {
2255                         /*
2256                          * More than 125ms have passed since we
2257                          * instantiated this buffer.  Move it to the
2258                          * most frequently used state.
2259                          */
2260                         buf->b_arc_access = LBOLT;
2261                         DTRACE_PROBE1(new_state__mfu, arc_buf_hdr_t *, buf);
2262                         arc_change_state(arc_mfu, buf, hash_lock);
2263                 }
2264                 ARCSTAT_BUMP(arcstat_mru_hits);
2265         } else if (buf->b_state == arc_mru_ghost) {
2266                 arc_state_t     *new_state;
2267                 /*
2268                  * This buffer has been "accessed" recently, but
2269                  * was evicted from the cache.  Move it to the
2270                  * MFU state.
2271                  */
2272
2273                 if (buf->b_flags & ARC_PREFETCH) {
2274                         new_state = arc_mru;
2275                         if (refcount_count(&buf->b_refcnt) > 0)
2276                                 buf->b_flags &= ~ARC_PREFETCH;
2277                         DTRACE_PROBE1(new_state__mru, arc_buf_hdr_t *, buf);
2278                 } else {
2279                         new_state = arc_mfu;
2280                         DTRACE_PROBE1(new_state__mfu, arc_buf_hdr_t *, buf);
2281                 }
2282
2283                 buf->b_arc_access = LBOLT;
2284                 arc_change_state(new_state, buf, hash_lock);
2285
2286                 ARCSTAT_BUMP(arcstat_mru_ghost_hits);
2287         } else if (buf->b_state == arc_mfu) {
2288                 /*
2289                  * This buffer has been accessed more than once and is
2290                  * still in the cache.  Keep it in the MFU state.
2291                  *
2292                  * NOTE: an add_reference() that occurred when we did
2293                  * the arc_read() will have kicked this off the list.
2294                  * If it was a prefetch, we will explicitly move it to
2295                  * the head of the list now.
2296                  */
2297                 if ((buf->b_flags & ARC_PREFETCH) != 0) {
2298                         ASSERT(refcount_count(&buf->b_refcnt) == 0);
2299                         ASSERT(list_link_active(&buf->b_arc_node));
2300                 }
2301                 ARCSTAT_BUMP(arcstat_mfu_hits);
2302                 buf->b_arc_access = LBOLT;
2303         } else if (buf->b_state == arc_mfu_ghost) {
2304                 arc_state_t     *new_state = arc_mfu;
2305                 /*
2306                  * This buffer has been accessed more than once but has
2307                  * been evicted from the cache.  Move it back to the
2308                  * MFU state.
2309                  */
2310
2311                 if (buf->b_flags & ARC_PREFETCH) {
2312                         /*
2313                          * This is a prefetch access...
2314                          * move this block back to the MRU state.
2315                          */
2316                         ASSERT3U(refcount_count(&buf->b_refcnt), ==, 0);
2317                         new_state = arc_mru;
2318                 }
2319
2320                 buf->b_arc_access = LBOLT;
2321                 DTRACE_PROBE1(new_state__mfu, arc_buf_hdr_t *, buf);
2322                 arc_change_state(new_state, buf, hash_lock);
2323
2324                 ARCSTAT_BUMP(arcstat_mfu_ghost_hits);
2325         } else if (buf->b_state == arc_l2c_only) {
2326                 /*
2327                  * This buffer is on the 2nd Level ARC.
2328                  */
2329
2330                 buf->b_arc_access = LBOLT;
2331                 DTRACE_PROBE1(new_state__mfu, arc_buf_hdr_t *, buf);
2332                 arc_change_state(arc_mfu, buf, hash_lock);
2333         } else {
2334                 ASSERT(!"invalid arc state");
2335         }
2336 }
2337
2338 /* a generic arc_done_func_t which you can use */
2339 /* ARGSUSED */
2340 void
2341 arc_bcopy_func(zio_t *zio, arc_buf_t *buf, void *arg)
2342 {
2343         bcopy(buf->b_data, arg, buf->b_hdr->b_size);
2344         VERIFY(arc_buf_remove_ref(buf, arg) == 1);
2345 }
2346
2347 /* a generic arc_done_func_t */
2348 void
2349 arc_getbuf_func(zio_t *zio, arc_buf_t *buf, void *arg)
2350 {
2351         arc_buf_t **bufp = arg;
2352         if (zio && zio->io_error) {
2353                 VERIFY(arc_buf_remove_ref(buf, arg) == 1);
2354                 *bufp = NULL;
2355         } else {
2356                 *bufp = buf;
2357         }
2358 }
2359
2360 static void
2361 arc_read_done(zio_t *zio)
2362 {
2363         arc_buf_hdr_t   *hdr, *found;
2364         arc_buf_t       *buf;
2365         arc_buf_t       *abuf;  /* buffer we're assigning to callback */
2366         kmutex_t        *hash_lock;
2367         arc_callback_t  *callback_list, *acb;
2368         int             freeable = FALSE;
2369
2370         buf = zio->io_private;
2371         hdr = buf->b_hdr;
2372
2373         /*
2374          * The hdr was inserted into hash-table and removed from lists
2375          * prior to starting I/O.  We should find this header, since
2376          * it's in the hash table, and it should be legit since it's
2377          * not possible to evict it during the I/O.  The only possible
2378          * reason for it not to be found is if we were freed during the
2379          * read.
2380          */
2381         found = buf_hash_find(zio->io_spa, &hdr->b_dva, hdr->b_birth,
2382             &hash_lock);
2383
2384         ASSERT((found == NULL && HDR_FREED_IN_READ(hdr) && hash_lock == NULL) ||
2385             (found == hdr && DVA_EQUAL(&hdr->b_dva, BP_IDENTITY(zio->io_bp))) ||
2386             (found == hdr && HDR_L2_READING(hdr)));
2387
2388         hdr->b_flags &= ~ARC_L2_EVICTED;
2389         if (l2arc_noprefetch && (hdr->b_flags & ARC_PREFETCH))
2390                 hdr->b_flags &= ~ARC_L2CACHE;
2391
2392         /* byteswap if necessary */
2393         callback_list = hdr->b_acb;
2394         ASSERT(callback_list != NULL);
2395         if (BP_SHOULD_BYTESWAP(zio->io_bp)) {
2396                 arc_byteswap_func_t *func = BP_GET_LEVEL(zio->io_bp) > 0 ?
2397                     byteswap_uint64_array :
2398                     dmu_ot[BP_GET_TYPE(zio->io_bp)].ot_byteswap;
2399                 func(buf->b_data, hdr->b_size);
2400         }
2401
2402         arc_cksum_compute(buf, B_FALSE);
2403
2404         /* create copies of the data buffer for the callers */
2405         abuf = buf;
2406         for (acb = callback_list; acb; acb = acb->acb_next) {
2407                 if (acb->acb_done) {
2408                         if (abuf == NULL)
2409                                 abuf = arc_buf_clone(buf);
2410                         acb->acb_buf = abuf;
2411                         abuf = NULL;
2412                 }
2413         }
2414         hdr->b_acb = NULL;
2415         hdr->b_flags &= ~ARC_IO_IN_PROGRESS;
2416         ASSERT(!HDR_BUF_AVAILABLE(hdr));
2417         if (abuf == buf)
2418                 hdr->b_flags |= ARC_BUF_AVAILABLE;
2419
2420         ASSERT(refcount_is_zero(&hdr->b_refcnt) || callback_list != NULL);
2421
2422         if (zio->io_error != 0) {
2423                 hdr->b_flags |= ARC_IO_ERROR;
2424                 if (hdr->b_state != arc_anon)
2425                         arc_change_state(arc_anon, hdr, hash_lock);
2426                 if (HDR_IN_HASH_TABLE(hdr))
2427                         buf_hash_remove(hdr);
2428                 freeable = refcount_is_zero(&hdr->b_refcnt);
2429         }
2430
2431         /*
2432          * Broadcast before we drop the hash_lock to avoid the possibility
2433          * that the hdr (and hence the cv) might be freed before we get to
2434          * the cv_broadcast().
2435          */
2436         cv_broadcast(&hdr->b_cv);
2437
2438         if (hash_lock) {
2439                 /*
2440                  * Only call arc_access on anonymous buffers.  This is because
2441                  * if we've issued an I/O for an evicted buffer, we've already
2442                  * called arc_access (to prevent any simultaneous readers from
2443                  * getting confused).
2444                  */
2445                 if (zio->io_error == 0 && hdr->b_state == arc_anon)
2446                         arc_access(hdr, hash_lock);
2447                 mutex_exit(hash_lock);
2448         } else {
2449                 /*
2450                  * This block was freed while we waited for the read to