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 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * This file contains the functions which analyze the status of a pool.  This
28  * include both the status of an active pool, as well as the status exported
29  * pools.  Returns one of the ZPOOL_STATUS_* defines describing the status of
30  * the pool.  This status is independent (to a certain degree) from the state of
31  * the pool.  A pool's state describes only whether or not it is capable of
32  * providing the necessary fault tolerance for data.  The status describes the
33  * overall status of devices.  A pool that is online can still have a device
34  * that is experiencing errors.
35  *
36  * Only a subset of the possible faults can be detected using 'zpool status',
37  * and not all possible errors correspond to a FMA message ID.  The explanation
38  * is left up to the caller, depending on whether it is a live pool or an
39  * import.
40  */
41 
42 #include <libzfs.h>
43 #include <string.h>
44 #include <unistd.h>
45 #include "libzfs_impl.h"
46 
47 /*
48  * Message ID table.  This must be kept in sync with the ZPOOL_STATUS_* defines
49  * in libzfs.h.  Note that there are some status results which go past the end
50  * of this table, and hence have no associated message ID.
51  */
52 static char *zfs_msgid_table[] = {
53 	"ZFS-8000-14",
54 	"ZFS-8000-2Q",
55 	"ZFS-8000-3C",
56 	"ZFS-8000-4J",
57 	"ZFS-8000-5E",
58 	"ZFS-8000-6X",
59 	"ZFS-8000-72",
60 	"ZFS-8000-8A",
61 	"ZFS-8000-9P",
62 	"ZFS-8000-A5",
63 	"ZFS-8000-EY",
64 	"ZFS-8000-HC",
65 	"ZFS-8000-JQ",
66 	"ZFS-8000-K4",
67 };
68 
69 #define	NMSGID	(sizeof (zfs_msgid_table) / sizeof (zfs_msgid_table[0]))
70 
71 /* ARGSUSED */
72 static int
73 vdev_missing(uint64_t state, uint64_t aux, uint64_t errs)
74 {
75 	return (state == VDEV_STATE_CANT_OPEN &&
76 	    aux == VDEV_AUX_OPEN_FAILED);
77 }
78 
79 /* ARGSUSED */
80 static int
81 vdev_faulted(uint64_t state, uint64_t aux, uint64_t errs)
82 {
83 	return (state == VDEV_STATE_FAULTED);
84 }
85 
86 /* ARGSUSED */
87 static int
88 vdev_errors(uint64_t state, uint64_t aux, uint64_t errs)
89 {
90 	return (state == VDEV_STATE_DEGRADED || errs != 0);
91 }
92 
93 /* ARGSUSED */
94 static int
95 vdev_broken(uint64_t state, uint64_t aux, uint64_t errs)
96 {
97 	return (state == VDEV_STATE_CANT_OPEN);
98 }
99 
100 /* ARGSUSED */
101 static int
102 vdev_offlined(uint64_t state, uint64_t aux, uint64_t errs)
103 {
104 	return (state == VDEV_STATE_OFFLINE);
105 }
106 
107 /* ARGSUSED */
108 static int
109 vdev_removed(uint64_t state, uint64_t aux, uint64_t errs)
110 {
111 	return (state == VDEV_STATE_REMOVED);
112 }
113 
114 /*
115  * Detect if any leaf devices that have seen errors or could not be opened.
116  */
117 static boolean_t
118 find_vdev_problem(nvlist_t *vdev, int (*func)(uint64_t, uint64_t, uint64_t))
119 {
120 	nvlist_t **child;
121 	vdev_stat_t *vs;
122 	uint_t c, children;
123 	char *type;
124 
125 	/*
126 	 * Ignore problems within a 'replacing' vdev, since we're presumably in
127 	 * the process of repairing any such errors, and don't want to call them
128 	 * out again.  We'll pick up the fact that a resilver is happening
129 	 * later.
130 	 */
131 	verify(nvlist_lookup_string(vdev, ZPOOL_CONFIG_TYPE, &type) == 0);
132 	if (strcmp(type, VDEV_TYPE_REPLACING) == 0)
133 		return (B_FALSE);
134 
135 	if (nvlist_lookup_nvlist_array(vdev, ZPOOL_CONFIG_CHILDREN, &child,
136 	    &children) == 0) {
137 		for (c = 0; c < children; c++)
138 			if (find_vdev_problem(child[c], func))
139 				return (B_TRUE);
140 	} else {
141 		verify(nvlist_lookup_uint64_array(vdev, ZPOOL_CONFIG_STATS,
142 		    (uint64_t **)&vs, &c) == 0);
143 
144 		if (func(vs->vs_state, vs->vs_aux,
145 		    vs->vs_read_errors +
146 		    vs->vs_write_errors +
147 		    vs->vs_checksum_errors))
148 			return (B_TRUE);
149 	}
150 
151 	return (B_FALSE);
152 }
153 
154 /*
155  * Active pool health status.
156  *
157  * To determine the status for a pool, we make several passes over the config,
158  * picking the most egregious error we find.  In order of importance, we do the
159  * following:
160  *
161  *	- Check for a complete and valid configuration
162  *	- Look for any faulted or missing devices in a non-replicated config
163  *	- Check for any data errors
164  *	- Check for any faulted or missing devices in a replicated config
165  *	- Look for any devices showing errors
166  *	- Check for any resilvering devices
167  *
168  * There can obviously be multiple errors within a single pool, so this routine
169  * only picks the most damaging of all the current errors to report.
170  */
171 static zpool_status_t
172 check_status(nvlist_t *config, boolean_t isimport)
173 {
174 	nvlist_t *nvroot;
175 	vdev_stat_t *vs;
176 	uint_t vsc;
177 	uint64_t nerr;
178 	uint64_t version;
179 	uint64_t stateval;
180 	uint64_t suspended;
181 	uint64_t hostid = 0;
182 
183 	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
184 	    &version) == 0);
185 	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
186 	    &nvroot) == 0);
187 	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS,
188 	    (uint64_t **)&vs, &vsc) == 0);
189 	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
190 	    &stateval) == 0);
191 	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_HOSTID, &hostid);
192 
193 	/*
194 	 * Pool last accessed by another system.
195 	 */
196 	if (hostid != 0 && (unsigned long)hostid != gethostid() &&
197 	    stateval == POOL_STATE_ACTIVE)
198 		return (ZPOOL_STATUS_HOSTID_MISMATCH);
199 
200 	/*
201 	 * Newer on-disk version.
202 	 */
203 	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
204 	    vs->vs_aux == VDEV_AUX_VERSION_NEWER)
205 		return (ZPOOL_STATUS_VERSION_NEWER);
206 
207 	/*
208 	 * Check that the config is complete.
209 	 */
210 	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
211 	    vs->vs_aux == VDEV_AUX_BAD_GUID_SUM)
212 		return (ZPOOL_STATUS_BAD_GUID_SUM);
213 
214 	/*
215 	 * Check whether the pool has suspended due to failed I/O.
216 	 */
217 	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_SUSPENDED,
218 	    &suspended) == 0) {
219 		if (suspended == ZIO_FAILURE_MODE_CONTINUE)
220 			return (ZPOOL_STATUS_IO_FAILURE_CONTINUE);
221 		return (ZPOOL_STATUS_IO_FAILURE_WAIT);
222 	}
223 
224 	/*
225 	 * Could not read a log.
226 	 */
227 	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
228 	    vs->vs_aux == VDEV_AUX_BAD_LOG) {
229 		return (ZPOOL_STATUS_BAD_LOG);
230 	}
231 
232 	/*
233 	 * Bad devices in non-replicated config.
234 	 */
235 	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
236 	    find_vdev_problem(nvroot, vdev_faulted))
237 		return (ZPOOL_STATUS_FAULTED_DEV_NR);
238 
239 	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
240 	    find_vdev_problem(nvroot, vdev_missing))
241 		return (ZPOOL_STATUS_MISSING_DEV_NR);
242 
243 	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
244 	    find_vdev_problem(nvroot, vdev_broken))
245 		return (ZPOOL_STATUS_CORRUPT_LABEL_NR);
246 
247 	/*
248 	 * Corrupted pool metadata
249 	 */
250 	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
251 	    vs->vs_aux == VDEV_AUX_CORRUPT_DATA)
252 		return (ZPOOL_STATUS_CORRUPT_POOL);
253 
254 	/*
255 	 * Persistent data errors.
256 	 */
257 	if (!isimport) {
258 		if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT,
259 		    &nerr) == 0 && nerr != 0)
260 			return (ZPOOL_STATUS_CORRUPT_DATA);
261 	}
262 
263 	/*
264 	 * Missing devices in a replicated config.
265 	 */
266 	if (find_vdev_problem(nvroot, vdev_faulted))
267 		return (ZPOOL_STATUS_FAULTED_DEV_R);
268 	if (find_vdev_problem(nvroot, vdev_missing))
269 		return (ZPOOL_STATUS_MISSING_DEV_R);
270 	if (find_vdev_problem(nvroot, vdev_broken))
271 		return (ZPOOL_STATUS_CORRUPT_LABEL_R);
272 
273 	/*
274 	 * Devices with errors
275 	 */
276 	if (!isimport && find_vdev_problem(nvroot, vdev_errors))
277 		return (ZPOOL_STATUS_FAILING_DEV);
278 
279 	/*
280 	 * Offlined devices
281 	 */
282 	if (find_vdev_problem(nvroot, vdev_offlined))
283 		return (ZPOOL_STATUS_OFFLINE_DEV);
284 
285 	/*
286 	 * Removed device
287 	 */
288 	if (find_vdev_problem(nvroot, vdev_removed))
289 		return (ZPOOL_STATUS_REMOVED_DEV);
290 
291 	/*
292 	 * Currently resilvering
293 	 */
294 	if (!vs->vs_scrub_complete && vs->vs_scrub_type == POOL_SCRUB_RESILVER)
295 		return (ZPOOL_STATUS_RESILVERING);
296 
297 	/*
298 	 * Outdated, but usable, version
299 	 */
300 	if (version < SPA_VERSION)
301 		return (ZPOOL_STATUS_VERSION_OLDER);
302 
303 	return (ZPOOL_STATUS_OK);
304 }
305 
306 zpool_status_t
307 zpool_get_status(zpool_handle_t *zhp, char **msgid)
308 {
309 	zpool_status_t ret = check_status(zhp->zpool_config, B_FALSE);
310 
311 	if (ret >= NMSGID)
312 		*msgid = NULL;
313 	else
314 		*msgid = zfs_msgid_table[ret];
315 
316 	return (ret);
317 }
318 
319 zpool_status_t
320 zpool_import_status(nvlist_t *config, char **msgid)
321 {
322 	zpool_status_t ret = check_status(config, B_TRUE);
323 
324 	if (ret >= NMSGID)
325 		*msgid = NULL;
326 	else
327 		*msgid = zfs_msgid_table[ret];
328 
329 	return (ret);
330 }
331 
332 static void
333 dump_ddt_stat(const ddt_stat_t *dds, int h)
334 {
335 	char refcnt[6];
336 	char blocks[6], lsize[6], psize[6], dsize[6];
337 	char ref_blocks[6], ref_lsize[6], ref_psize[6], ref_dsize[6];
338 
339 	if (dds == NULL || dds->dds_blocks == 0)
340 		return;
341 
342 	if (h == -1)
343 		(void) strcpy(refcnt, "Total");
344 	else
345 		zfs_nicenum(1ULL << h, refcnt, sizeof (refcnt));
346 
347 	zfs_nicenum(dds->dds_blocks, blocks, sizeof (blocks));
348 	zfs_nicenum(dds->dds_lsize, lsize, sizeof (lsize));
349 	zfs_nicenum(dds->dds_psize, psize, sizeof (psize));
350 	zfs_nicenum(dds->dds_dsize, dsize, sizeof (dsize));
351 	zfs_nicenum(dds->dds_ref_blocks, ref_blocks, sizeof (ref_blocks));
352 	zfs_nicenum(dds->dds_ref_lsize, ref_lsize, sizeof (ref_lsize));
353 	zfs_nicenum(dds->dds_ref_psize, ref_psize, sizeof (ref_psize));
354 	zfs_nicenum(dds->dds_ref_dsize, ref_dsize, sizeof (ref_dsize));
355 
356 	(void) printf("%6s   %6s   %5s   %5s   %5s   %6s   %5s   %5s   %5s\n",
357 	    refcnt,
358 	    blocks, lsize, psize, dsize,
359 	    ref_blocks, ref_lsize, ref_psize, ref_dsize);
360 }
361 
362 /*
363  * Print the DDT histogram and the column totals.
364  */
365 void
366 zpool_dump_ddt(const ddt_stat_t *dds_total, const ddt_histogram_t *ddh)
367 {
368 	int h;
369 
370 	(void) printf("\n");
371 
372 	(void) printf("bucket   "
373 	    "           allocated             "
374 	    "          referenced          \n");
375 	(void) printf("______   "
376 	    "______________________________   "
377 	    "______________________________\n");
378 
379 	(void) printf("%6s   %6s   %5s   %5s   %5s   %6s   %5s   %5s   %5s\n",
380 	    "refcnt",
381 	    "blocks", "LSIZE", "PSIZE", "DSIZE",
382 	    "blocks", "LSIZE", "PSIZE", "DSIZE");
383 
384 	(void) printf("%6s   %6s   %5s   %5s   %5s   %6s   %5s   %5s   %5s\n",
385 	    "------",
386 	    "------", "-----", "-----", "-----",
387 	    "------", "-----", "-----", "-----");
388 
389 	for (h = 0; h < 64; h++)
390 		dump_ddt_stat(&ddh->ddh_stat[h], h);
391 
392 	dump_ddt_stat(dds_total, -1);
393 
394 	(void) printf("\n");
395 }
396