* debugging facilities.
*/
const char *
-_umem_debug_init()
+_umem_debug_init(void)
{
return ("default,verbose"); /* $UMEM_DEBUG setting */
}
char *types[4] = { "ditto", "single", "double", "triple" };
char blkbuf[BP_SPRINTF_LEN];
blkptr_t blk;
+ int p;
- for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
+ for (p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
if (ddp->ddp_phys_birth == 0)
continue;
ddt_bp_create(ddt->ddt_checksum, ddk, ddp, &blk);
static void
dump_all_ddts(spa_t *spa)
{
- ddt_histogram_t ddh_total = { 0 };
- ddt_stat_t dds_total = { 0 };
+ ddt_histogram_t ddh_total;
+ ddt_stat_t dds_total;
+ enum zio_checksum c;
+ enum ddt_type type;
+ enum ddt_class class;
- for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
+ bzero(&ddh_total, sizeof (ddt_histogram_t));
+ bzero(&dds_total, sizeof (ddt_stat_t));
+
+ for (c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
ddt_t *ddt = spa->spa_ddt[c];
- for (enum ddt_type type = 0; type < DDT_TYPES; type++) {
- for (enum ddt_class class = 0; class < DDT_CLASSES;
+ for (type = 0; type < DDT_TYPES; type++) {
+ for (class = 0; class < DDT_CLASSES;
class++) {
dump_ddt(ddt, type, class);
}
boolean_t required;
char *name[DTL_TYPES] = { "missing", "partial", "scrub", "outage" };
char prefix[256];
+ int c, t;
spa_vdev_state_enter(spa, SCL_NONE);
required = vdev_dtl_required(vd);
vd->vdev_parent ? vd->vdev_ops->vdev_op_type : spa_name(spa),
required ? "DTL-required" : "DTL-expendable");
- for (int t = 0; t < DTL_TYPES; t++) {
+ for (t = 0; t < DTL_TYPES; t++) {
space_map_t *sm = &vd->vdev_dtl[t];
if (sm->sm_space == 0)
continue;
&vd->vdev_dtl_smo, sm);
}
- for (int c = 0; c < vd->vdev_children; c++)
+ for (c = 0; c < vd->vdev_children; c++)
dump_dtl(vd->vdev_child[c], indent + 4);
}
struct tm t;
char tbuf[30];
char internalstr[MAXPATHLEN];
+ int i;
do {
len = sizeof (buf);
} while (len != 0);
(void) printf("\nHistory:\n");
- for (int i = 0; i < num; i++) {
+ for (i = 0; i < num; i++) {
uint64_t time, txg, ievent;
char *cmd, *intstr;
(void) snprintf(internalstr,
sizeof (internalstr),
"[internal %s txg:%lld] %s",
- zfs_history_event_names[ievent], txg,
- intstr);
+ zfs_history_event_names[ievent],
+ (longlong_t)txg, intstr);
cmd = internalstr;
}
tsec = time;
{
const dva_t *dva = bp->blk_dva;
int ndvas = dump_opt['d'] > 5 ? BP_GET_NDVAS(bp) : 1;
+ int i;
if (dump_opt['b'] >= 5) {
sprintf_blkptr(blkbuf, bp);
blkbuf[0] = '\0';
- for (int i = 0; i < ndvas; i++)
+ for (i = 0; i < ndvas; i++)
(void) sprintf(blkbuf + strlen(blkbuf), "%llu:%llx:%llx ",
(u_longlong_t)DVA_GET_VDEV(&dva[i]),
(u_longlong_t)DVA_GET_OFFSET(&dva[i]),
sa_attr_type_t *sa_attr_table;
static void
-fuid_table_destroy()
+fuid_table_destroy(void)
{
if (fuid_table_loaded) {
zfs_fuid_table_destroy(&idx_tree, &domain_tree);
{
time_t timestamp = ub->ub_timestamp;
- (void) printf(header ? header : "");
+ (void) printf("%s", header ? header : "");
(void) printf("\tmagic = %016llx\n", (u_longlong_t)ub->ub_magic);
(void) printf("\tversion = %llu\n", (u_longlong_t)ub->ub_version);
(void) printf("\ttxg = %llu\n", (u_longlong_t)ub->ub_txg);
sprintf_blkptr(blkbuf, &ub->ub_rootbp);
(void) printf("\trootbp = %s\n", blkbuf);
}
- (void) printf(footer ? footer : "");
+ (void) printf("%s", footer ? footer : "");
}
static void
vdev_t vd;
vdev_t *vdp = &vd;
char header[ZDB_MAX_UB_HEADER_SIZE];
+ int i;
vd.vdev_ashift = ashift;
vdp->vdev_top = vdp;
- for (int i = 0; i < VDEV_UBERBLOCK_COUNT(vdp); i++) {
+ for (i = 0; i < VDEV_UBERBLOCK_COUNT(vdp); i++) {
uint64_t uoff = VDEV_UBERBLOCK_OFFSET(vdp, i);
uberblock_t *ub = (void *)((char *)lbl + uoff);
struct stat64 statbuf;
uint64_t psize, ashift;
int len = strlen(dev) + 1;
+ int l;
if (strncmp(dev, "/dev/dsk/", 9) == 0) {
len++;
psize = statbuf.st_size;
psize = P2ALIGN(psize, (uint64_t)sizeof (vdev_label_t));
- for (int l = 0; l < VDEV_LABELS; l++) {
+ for (l = 0; l < VDEV_LABELS; l++) {
nvlist_t *config = NULL;
(void) printf("--------------------------------------------\n");
dmu_object_type_t type)
{
uint64_t refcnt = 0;
+ int i;
ASSERT(type < ZDB_OT_TOTAL);
if (zilog && zil_bp_tree_add(zilog, bp) != 0)
return;
- for (int i = 0; i < 4; i++) {
+ for (i = 0; i < 4; i++) {
int l = (i < 2) ? BP_GET_LEVEL(bp) : ZB_TOTAL;
int t = (i & 1) ? type : ZDB_OT_TOTAL;
zdb_blkstats_t *zb = &zcb->zcb_type[l][t];
ddt_bookmark_t ddb = { 0 };
ddt_entry_t dde;
int error;
+ int p;
while ((error = ddt_walk(spa, &ddb, &dde)) == 0) {
blkptr_t blk;
ASSERT(ddt_phys_total_refcnt(&dde) > 1);
- for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
+ for (p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
if (ddp->ddp_phys_birth == 0)
continue;
ddt_bp_create(ddb.ddb_checksum,
zdb_leak_init(spa_t *spa, zdb_cb_t *zcb)
{
zcb->zcb_spa = spa;
+ int c, m;
if (!dump_opt['L']) {
vdev_t *rvd = spa->spa_root_vdev;
- for (int c = 0; c < rvd->vdev_children; c++) {
+ for (c = 0; c < rvd->vdev_children; c++) {
vdev_t *vd = rvd->vdev_child[c];
- for (int m = 0; m < vd->vdev_ms_count; m++) {
+ for (m = 0; m < vd->vdev_ms_count; m++) {
metaslab_t *msp = vd->vdev_ms[m];
mutex_enter(&msp->ms_lock);
space_map_unload(&msp->ms_map);
static void
zdb_leak_fini(spa_t *spa)
{
+ int c, m;
+
if (!dump_opt['L']) {
vdev_t *rvd = spa->spa_root_vdev;
- for (int c = 0; c < rvd->vdev_children; c++) {
+ for (c = 0; c < rvd->vdev_children; c++) {
vdev_t *vd = rvd->vdev_child[c];
- for (int m = 0; m < vd->vdev_ms_count; m++) {
+ for (m = 0; m < vd->vdev_ms_count; m++) {
metaslab_t *msp = vd->vdev_ms[m];
mutex_enter(&msp->ms_lock);
space_map_unload(&msp->ms_map);
static int
dump_block_stats(spa_t *spa)
{
- zdb_cb_t zcb = { 0 };
+ zdb_cb_t zcb;
zdb_blkstats_t *zb, *tzb;
uint64_t norm_alloc, norm_space, total_alloc, total_found;
int flags = TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA | TRAVERSE_HARD;
int leaks = 0;
+ int e;
(void) printf("\nTraversing all blocks %s%s%s%s%s...\n",
(dump_opt['c'] || !dump_opt['L']) ? "to verify " : "",
* it's not part of any space map) is a double allocation,
* reference to a freed block, or an unclaimed log block.
*/
+ bzero(&zcb, sizeof(zdb_cb_t));
zdb_leak_init(spa, &zcb);
/*
if (zcb.zcb_haderrors) {
(void) printf("\nError counts:\n\n");
(void) printf("\t%5s %s\n", "errno", "count");
- for (int e = 0; e < 256; e++) {
+ for (e = 0; e < 256; e++) {
if (zcb.zcb_errors[e] != 0) {
(void) printf("\t%5d %llu\n",
e, (u_longlong_t)zcb.zcb_errors[e]);
avl_tree_t t;
void *cookie = NULL;
zdb_ddt_entry_t *zdde;
- ddt_histogram_t ddh_total = { 0 };
- ddt_stat_t dds_total = { 0 };
+ ddt_histogram_t ddh_total;
+ ddt_stat_t dds_total;
+
+ bzero(&ddh_total, sizeof (ddt_histogram_t));
+ bzero(&dds_total, sizeof (ddt_stat_t));
avl_create(&t, ddt_entry_compare,
sizeof (zdb_ddt_entry_t), offsetof(zdb_ddt_entry_t, zdde_node));
{
if (flags & ZDB_FLAG_BSWAP)
byteswap_uint64_array(buf, size);
- (void) write(1, buf, size);
+ VERIFY(write(fileno(stdout), buf, size) == size);
}
static void
nvlist_t *match = NULL;
char *name = NULL;
char *sepp = NULL;
- char sep;
+ char sep = 0;
int count = 0;
importargs_t args = { 0 };