]>
Commit | Line | Data |
---|---|---|
e0b0ca98 BB |
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 | #include <sys/zfs_context.h> | |
23 | #include <sys/dbuf.h> | |
24 | #include <sys/dmu_objset.h> | |
25 | ||
26 | /* | |
27 | * Calculate the index of the arc header for the state, disabled by default. | |
28 | */ | |
29 | int zfs_dbuf_state_index = 0; | |
30 | ||
31 | /* | |
32 | * ========================================================================== | |
33 | * Dbuf Hash Read Routines | |
34 | * ========================================================================== | |
35 | */ | |
36 | typedef struct dbuf_stats_t { | |
37 | kmutex_t lock; | |
38 | kstat_t *kstat; | |
39 | dbuf_hash_table_t *hash; | |
40 | int idx; | |
41 | } dbuf_stats_t; | |
42 | ||
43 | static dbuf_stats_t dbuf_stats_hash_table; | |
44 | ||
45 | static int | |
46 | dbuf_stats_hash_table_headers(char *buf, size_t size) | |
47 | { | |
7b2d78a0 | 48 | (void) snprintf(buf, size, |
e0b0ca98 BB |
49 | "%-88s | %-124s | %s\n" |
50 | "%-16s %-8s %-8s %-8s %-8s %-8s %-8s %-5s %-5s %5s | " | |
ca0bf58d | 51 | "%-5s %-5s %-8s %-6s %-8s %-12s " |
e0b0ca98 BB |
52 | "%-6s %-6s %-6s %-6s %-6s %-8s %-8s %-8s %-5s | " |
53 | "%-6s %-6s %-8s %-8s %-6s %-6s %-5s %-8s %-8s\n", | |
54 | "dbuf", "arcbuf", "dnode", "pool", "objset", "object", "level", | |
55 | "blkid", "offset", "dbsize", "meta", "state", "dbholds", "list", | |
ca0bf58d | 56 | "atype", "flags", "count", "asize", "access", |
d1d7e268 MK |
57 | "mru", "gmru", "mfu", "gmfu", "l2", "l2_dattr", "l2_asize", |
58 | "l2_comp", "aholds", "dtype", "btype", "data_bs", "meta_bs", | |
59 | "bsize", "lvls", "dholds", "blocks", "dsize"); | |
e0b0ca98 BB |
60 | |
61 | return (0); | |
62 | } | |
63 | ||
64 | int | |
65 | __dbuf_stats_hash_table_data(char *buf, size_t size, dmu_buf_impl_t *db) | |
66 | { | |
67 | arc_buf_info_t abi = { 0 }; | |
68 | dmu_object_info_t doi = { 0 }; | |
69 | dnode_t *dn = DB_DNODE(db); | |
aa2ef419 | 70 | size_t nwritten; |
e0b0ca98 BB |
71 | |
72 | if (db->db_buf) | |
73 | arc_buf_info(db->db_buf, &abi, zfs_dbuf_state_index); | |
74 | ||
75 | if (dn) | |
76 | __dmu_object_info_from_dnode(dn, &doi); | |
77 | ||
aa2ef419 | 78 | nwritten = snprintf(buf, size, |
e0b0ca98 | 79 | "%-16s %-8llu %-8lld %-8lld %-8lld %-8llu %-8llu %-5d %-5d %-5lu | " |
ca0bf58d | 80 | "%-5d %-5d 0x%-6x %-6lu %-8llu %-12llu " |
e0b0ca98 BB |
81 | "%-6lu %-6lu %-6lu %-6lu %-6lu %-8llu %-8llu %-8d %-5lu | " |
82 | "%-6d %-6d %-8lu %-8lu %-6llu %-6lu %-5lu %-8llu %-8llu\n", | |
83 | /* dmu_buf_impl_t */ | |
84 | spa_name(dn->dn_objset->os_spa), | |
85 | (u_longlong_t)dmu_objset_id(db->db_objset), | |
86 | (longlong_t)db->db.db_object, | |
87 | (longlong_t)db->db_level, | |
88 | (longlong_t)db->db_blkid, | |
89 | (u_longlong_t)db->db.db_offset, | |
90 | (u_longlong_t)db->db.db_size, | |
91 | !!dbuf_is_metadata(db), | |
92 | db->db_state, | |
93 | (ulong_t)refcount_count(&db->db_holds), | |
94 | /* arc_buf_info_t */ | |
95 | abi.abi_state_type, | |
96 | abi.abi_state_contents, | |
e0b0ca98 | 97 | abi.abi_flags, |
d3c2ae1c | 98 | (ulong_t)abi.abi_bufcnt, |
e0b0ca98 BB |
99 | (u_longlong_t)abi.abi_size, |
100 | (u_longlong_t)abi.abi_access, | |
101 | (ulong_t)abi.abi_mru_hits, | |
102 | (ulong_t)abi.abi_mru_ghost_hits, | |
103 | (ulong_t)abi.abi_mfu_hits, | |
104 | (ulong_t)abi.abi_mfu_ghost_hits, | |
105 | (ulong_t)abi.abi_l2arc_hits, | |
106 | (u_longlong_t)abi.abi_l2arc_dattr, | |
107 | (u_longlong_t)abi.abi_l2arc_asize, | |
108 | abi.abi_l2arc_compress, | |
109 | (ulong_t)abi.abi_holds, | |
110 | /* dmu_object_info_t */ | |
111 | doi.doi_type, | |
112 | doi.doi_bonus_type, | |
113 | (ulong_t)doi.doi_data_block_size, | |
114 | (ulong_t)doi.doi_metadata_block_size, | |
115 | (u_longlong_t)doi.doi_bonus_size, | |
116 | (ulong_t)doi.doi_indirection, | |
117 | (ulong_t)refcount_count(&dn->dn_holds), | |
118 | (u_longlong_t)doi.doi_fill_count, | |
119 | (u_longlong_t)doi.doi_max_offset); | |
e0b0ca98 | 120 | |
aa2ef419 TC |
121 | if (nwritten >= size) |
122 | return (size); | |
123 | ||
124 | return (nwritten + 1); | |
e0b0ca98 BB |
125 | } |
126 | ||
127 | static int | |
128 | dbuf_stats_hash_table_data(char *buf, size_t size, void *data) | |
129 | { | |
130 | dbuf_stats_t *dsh = (dbuf_stats_t *)data; | |
131 | dbuf_hash_table_t *h = dsh->hash; | |
132 | dmu_buf_impl_t *db; | |
133 | int length, error = 0; | |
134 | ||
135 | ASSERT3S(dsh->idx, >=, 0); | |
136 | ASSERT3S(dsh->idx, <=, h->hash_table_mask); | |
137 | memset(buf, 0, size); | |
138 | ||
139 | mutex_enter(DBUF_HASH_MUTEX(h, dsh->idx)); | |
140 | for (db = h->hash_table[dsh->idx]; db != NULL; db = db->db_hash_next) { | |
141 | /* | |
142 | * Returning ENOMEM will cause the data and header functions | |
143 | * to be called with a larger scratch buffers. | |
144 | */ | |
145 | if (size < 512) { | |
146 | error = ENOMEM; | |
147 | break; | |
148 | } | |
149 | ||
150 | mutex_enter(&db->db_mtx); | |
e0b0ca98 | 151 | |
e2c4acde BB |
152 | if (db->db_state != DB_EVICTING) { |
153 | length = __dbuf_stats_hash_table_data(buf, size, db); | |
154 | buf += length; | |
155 | size -= length; | |
156 | } | |
e0b0ca98 BB |
157 | |
158 | mutex_exit(&db->db_mtx); | |
e0b0ca98 BB |
159 | } |
160 | mutex_exit(DBUF_HASH_MUTEX(h, dsh->idx)); | |
161 | ||
162 | return (error); | |
163 | } | |
164 | ||
165 | static void * | |
166 | dbuf_stats_hash_table_addr(kstat_t *ksp, loff_t n) | |
167 | { | |
168 | dbuf_stats_t *dsh = ksp->ks_private; | |
169 | ||
d1d7e268 | 170 | ASSERT(MUTEX_HELD(&dsh->lock)); |
e0b0ca98 BB |
171 | |
172 | if (n <= dsh->hash->hash_table_mask) { | |
173 | dsh->idx = n; | |
174 | return (dsh); | |
175 | } | |
176 | ||
177 | return (NULL); | |
178 | } | |
179 | ||
180 | static void | |
181 | dbuf_stats_hash_table_init(dbuf_hash_table_t *hash) | |
182 | { | |
183 | dbuf_stats_t *dsh = &dbuf_stats_hash_table; | |
184 | kstat_t *ksp; | |
185 | ||
186 | mutex_init(&dsh->lock, NULL, MUTEX_DEFAULT, NULL); | |
187 | dsh->hash = hash; | |
188 | ||
189 | ksp = kstat_create("zfs", 0, "dbufs", "misc", | |
190 | KSTAT_TYPE_RAW, 0, KSTAT_FLAG_VIRTUAL); | |
191 | dsh->kstat = ksp; | |
192 | ||
193 | if (ksp) { | |
194 | ksp->ks_lock = &dsh->lock; | |
195 | ksp->ks_ndata = UINT32_MAX; | |
196 | ksp->ks_private = dsh; | |
197 | kstat_set_raw_ops(ksp, dbuf_stats_hash_table_headers, | |
198 | dbuf_stats_hash_table_data, dbuf_stats_hash_table_addr); | |
199 | kstat_install(ksp); | |
200 | } | |
201 | } | |
202 | ||
203 | static void | |
204 | dbuf_stats_hash_table_destroy(void) | |
205 | { | |
206 | dbuf_stats_t *dsh = &dbuf_stats_hash_table; | |
207 | kstat_t *ksp; | |
208 | ||
209 | ksp = dsh->kstat; | |
210 | if (ksp) | |
211 | kstat_delete(ksp); | |
212 | ||
213 | mutex_destroy(&dsh->lock); | |
214 | } | |
215 | ||
216 | void | |
217 | dbuf_stats_init(dbuf_hash_table_t *hash) | |
218 | { | |
219 | dbuf_stats_hash_table_init(hash); | |
220 | } | |
221 | ||
222 | void | |
223 | dbuf_stats_destroy(void) | |
224 | { | |
225 | dbuf_stats_hash_table_destroy(); | |
226 | } | |
227 | ||
228 | #if defined(_KERNEL) && defined(HAVE_SPL) | |
229 | module_param(zfs_dbuf_state_index, int, 0644); | |
230 | MODULE_PARM_DESC(zfs_dbuf_state_index, "Calculate arc header index"); | |
231 | #endif |