usr/src/lib/libzfs_jni/common/libzfs_jni_pool.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 /*
  23  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 #include "libzfs_jni_util.h"
  27 #include "libzfs_jni_pool.h"
  28 #include <strings.h>
  29
  30 /*
  31  * Types
  32  */
  33
  34 typedef struct ImportablePoolBean {
  35         zjni_Object_t super;
  36         PoolStatsBean_t interface_PoolStats;
  37
  38         jmethodID method_setName;
  39         jmethodID method_setId;
  40 } ImportablePoolBean_t;
  41
  42 typedef struct VirtualDeviceBean {
  43         zjni_Object_t super;
  44         DeviceStatsBean_t interface_DeviceStats;
  45
  46         jmethodID method_setPoolName;
  47         jmethodID method_setParentIndex;
  48         jmethodID method_setIndex;
  49 } VirtualDeviceBean_t;
  50
  51 typedef struct LeafVirtualDeviceBean {
  52         VirtualDeviceBean_t super;
  53
  54         jmethodID method_setName;
  55 } LeafVirtualDeviceBean_t;
  56
  57 typedef struct DiskVirtualDeviceBean {
  58         LeafVirtualDeviceBean_t super;
  59 } DiskVirtualDeviceBean_t;
  60
  61 typedef struct SliceVirtualDeviceBean {
  62         LeafVirtualDeviceBean_t super;
  63 } SliceVirtualDeviceBean_t;
  64
  65 typedef struct FileVirtualDeviceBean {
  66         LeafVirtualDeviceBean_t super;
  67 } FileVirtualDeviceBean_t;
  68
  69 typedef struct RAIDVirtualDeviceBean {
  70         VirtualDeviceBean_t super;
  71
  72         jmethodID method_setParity;
  73 } RAIDVirtualDeviceBean_t;
  74
  75 typedef struct MirrorVirtualDeviceBean {
  76         VirtualDeviceBean_t super;
  77 } MirrorVirtualDeviceBean_t;
  78
  79 /*
  80  * Data
  81  */
  82
  83 /* vdev_state_t to DeviceStats$DeviceState map */
  84 static zjni_field_mapping_t vdev_state_map[] = {
  85         { VDEV_STATE_CANT_OPEN, "VDEV_STATE_CANT_OPEN" },
  86         { VDEV_STATE_CLOSED, "VDEV_STATE_CLOSED" },
  87         { VDEV_STATE_DEGRADED, "VDEV_STATE_DEGRADED" },
  88         { VDEV_STATE_HEALTHY, "VDEV_STATE_HEALTHY" },
  89         { VDEV_STATE_OFFLINE, "VDEV_STATE_OFFLINE" },
  90         { VDEV_STATE_UNKNOWN, "VDEV_STATE_UNKNOWN" },
  91         { -1, NULL },
  92 };
  93
  94 /* vdev_aux_t to DeviceStats$DeviceStatus map */
  95 static zjni_field_mapping_t vdev_aux_map[] = {
  96         { VDEV_AUX_NONE, "VDEV_AUX_NONE" },
  97         { VDEV_AUX_OPEN_FAILED, "VDEV_AUX_OPEN_FAILED" },
  98         { VDEV_AUX_CORRUPT_DATA, "VDEV_AUX_CORRUPT_DATA" },
  99         { VDEV_AUX_NO_REPLICAS, "VDEV_AUX_NO_REPLICAS" },
 100         { VDEV_AUX_BAD_GUID_SUM, "VDEV_AUX_BAD_GUID_SUM" },
 101         { VDEV_AUX_TOO_SMALL, "VDEV_AUX_TOO_SMALL" },
 102         { VDEV_AUX_BAD_LABEL, "VDEV_AUX_BAD_LABEL" },
 103         { -1, NULL },
 104 };
 105
 106 /* zpool_state_t to PoolStats$PoolState map */
 107 static zjni_field_mapping_t pool_state_map[] = {
 108         { POOL_STATE_ACTIVE, "POOL_STATE_ACTIVE" },
 109         { POOL_STATE_EXPORTED, "POOL_STATE_EXPORTED" },
 110         { POOL_STATE_DESTROYED, "POOL_STATE_DESTROYED" },
 111         { POOL_STATE_SPARE, "POOL_STATE_SPARE" },
 112         { POOL_STATE_UNINITIALIZED, "POOL_STATE_UNINITIALIZED" },
 113         { POOL_STATE_UNAVAIL, "POOL_STATE_UNAVAIL" },
 114         { POOL_STATE_POTENTIALLY_ACTIVE, "POOL_STATE_POTENTIALLY_ACTIVE" },
 115         { -1, NULL },
 116 };
 117
 118 /* zpool_status_t to PoolStats$PoolStatus map */
 119 static zjni_field_mapping_t zpool_status_map[] = {
 120         { ZPOOL_STATUS_CORRUPT_CACHE, "ZPOOL_STATUS_CORRUPT_CACHE" },
 121         { ZPOOL_STATUS_MISSING_DEV_R, "ZPOOL_STATUS_MISSING_DEV_R" },
 122         { ZPOOL_STATUS_MISSING_DEV_NR, "ZPOOL_STATUS_MISSING_DEV_NR" },
 123         { ZPOOL_STATUS_CORRUPT_LABEL_R, "ZPOOL_STATUS_CORRUPT_LABEL_R" },
 124         { ZPOOL_STATUS_CORRUPT_LABEL_NR, "ZPOOL_STATUS_CORRUPT_LABEL_NR" },
 125         { ZPOOL_STATUS_BAD_GUID_SUM, "ZPOOL_STATUS_BAD_GUID_SUM" },
 126         { ZPOOL_STATUS_CORRUPT_POOL, "ZPOOL_STATUS_CORRUPT_POOL" },
 127         { ZPOOL_STATUS_CORRUPT_DATA, "ZPOOL_STATUS_CORRUPT_DATA" },
 128         { ZPOOL_STATUS_FAILING_DEV, "ZPOOL_STATUS_FAILING_DEV" },
 129         { ZPOOL_STATUS_VERSION_NEWER, "ZPOOL_STATUS_VERSION_NEWER" },
 130         { ZPOOL_STATUS_HOSTID_MISMATCH, "ZPOOL_STATUS_HOSTID_MISMATCH" },
 131         { ZPOOL_STATUS_FAULTED_DEV_R, "ZPOOL_STATUS_FAULTED_DEV_R" },
 132         { ZPOOL_STATUS_FAULTED_DEV_NR, "ZPOOL_STATUS_FAULTED_DEV_NR" },
 133         { ZPOOL_STATUS_BAD_LOG, "ZPOOL_STATUS_BAD_LOG" },
 134         { ZPOOL_STATUS_VERSION_OLDER, "ZPOOL_STATUS_VERSION_OLDER" },
 135         { ZPOOL_STATUS_RESILVERING, "ZPOOL_STATUS_RESILVERING" },
 136         { ZPOOL_STATUS_OFFLINE_DEV, "ZPOOL_STATUS_OFFLINE_DEV" },
 137         { ZPOOL_STATUS_REMOVED_DEV, "ZPOOL_STATUS_REMOVED_DEV" },
 138         { ZPOOL_STATUS_OK, "ZPOOL_STATUS_OK" },
 139         { -1, NULL }
 140 };
 141
 142 /*
 143  * Function prototypes
 144  */
 145
 146 static void new_ImportablePoolBean(JNIEnv *, ImportablePoolBean_t *);
 147 static void new_VirtualDevice(JNIEnv *, VirtualDeviceBean_t *);
 148 static void new_LeafVirtualDevice(JNIEnv *, LeafVirtualDeviceBean_t *);
 149 static void new_DiskVirtualDeviceBean(JNIEnv *, DiskVirtualDeviceBean_t *);
 150 static void new_SliceVirtualDeviceBean(JNIEnv *, SliceVirtualDeviceBean_t *);
 151 static void new_FileVirtualDeviceBean(JNIEnv *, FileVirtualDeviceBean_t *);
 152 static void new_RAIDVirtualDeviceBean(JNIEnv *, RAIDVirtualDeviceBean_t *);
 153 static void new_MirrorVirtualDeviceBean(JNIEnv *, MirrorVirtualDeviceBean_t *);
 154 static int populate_ImportablePoolBean(
 155     JNIEnv *, ImportablePoolBean_t *, nvlist_t *);
 156 static int populate_VirtualDeviceBean(JNIEnv *, zpool_handle_t *,
 157     nvlist_t *, uint64_t *p_vdev_id, VirtualDeviceBean_t *);
 158 static int populate_LeafVirtualDeviceBean(JNIEnv *, zpool_handle_t *,
 159     nvlist_t *, uint64_t *p_vdev_id, LeafVirtualDeviceBean_t *);
 160 static int populate_DiskVirtualDeviceBean(JNIEnv *, zpool_handle_t *,
 161     nvlist_t *, uint64_t *p_vdev_id, DiskVirtualDeviceBean_t *);
 162 static int populate_SliceVirtualDeviceBean(JNIEnv *, zpool_handle_t *,
 163     nvlist_t *, uint64_t *p_vdev_id, SliceVirtualDeviceBean_t *);
 164 static int populate_FileVirtualDeviceBean(JNIEnv *, zpool_handle_t *,
 165     nvlist_t *, uint64_t *p_vdev_id, FileVirtualDeviceBean_t *);
 166 static int populate_RAIDVirtualDeviceBean(JNIEnv *, zpool_handle_t *,
 167     nvlist_t *, uint64_t *p_vdev_id, RAIDVirtualDeviceBean_t *);
 168 static int populate_MirrorVirtualDeviceBean(JNIEnv *, zpool_handle_t *,
 169     nvlist_t *, uint64_t *p_vdev_id, MirrorVirtualDeviceBean_t *);
 170 static jobject create_ImportablePoolBean(JNIEnv *, nvlist_t *);
 171 static jobject create_DiskVirtualDeviceBean(
 172     JNIEnv *, zpool_handle_t *, nvlist_t *, uint64_t *p_vdev_id);
 173 static jobject create_SliceVirtualDeviceBean(
 174     JNIEnv *, zpool_handle_t *, nvlist_t *, uint64_t *p_vdev_id);
 175 static jobject create_FileVirtualDeviceBean(
 176     JNIEnv *, zpool_handle_t *, nvlist_t *, uint64_t *p_vdev_id);
 177 static jobject create_RAIDVirtualDeviceBean(
 178     JNIEnv *, zpool_handle_t *, nvlist_t *, uint64_t *p_vdev_id);
 179 static jobject create_MirrorVirtualDeviceBean(
 180     JNIEnv *, zpool_handle_t *, nvlist_t *, uint64_t *p_vdev_id);
 181 static char *find_field(const zjni_field_mapping_t *, int);
 182 static jobject zjni_vdev_state_to_obj(JNIEnv *, vdev_state_t);
 183 static jobject zjni_vdev_aux_to_obj(JNIEnv *, vdev_aux_t);
 184
 185 /*
 186  * Static functions
 187  */
 188
 189 /* Create a ImportablePoolBean */
 190 static void
 191 new_ImportablePoolBean(JNIEnv *env, ImportablePoolBean_t *bean)
 192 {
 193         zjni_Object_t *object = (zjni_Object_t *)bean;
 194
 195         if (object->object == NULL) {
 196                 object->class =
 197                     (*env)->FindClass(env,
 198                     ZFSJNI_PACKAGE_DATA "ImportablePoolBean");
 199
 200                 object->constructor =
 201                     (*env)->GetMethodID(env, object->class, "<init>", "()V");
 202
 203                 object->object =
 204                     (*env)->NewObject(env, object->class, object->constructor);
 205         }
 206
 207         new_PoolStats(env, &(bean->interface_PoolStats), object);
 208
 209         bean->method_setName = (*env)->GetMethodID(
 210             env, object->class, "setName", "(Ljava/lang/String;)V");
 211
 212         bean->method_setId = (*env)->GetMethodID(
 213             env, object->class, "setId", "(J)V");
 214 }
 215
 216 /* Create a VirtualDeviceBean */
 217 static void
 218 new_VirtualDevice(JNIEnv *env, VirtualDeviceBean_t *bean)
 219 {
 220         zjni_Object_t *object = (zjni_Object_t *)bean;
 221
 222         if (object->object == NULL) {
 223                 object->class =
 224                     (*env)->FindClass(env,
 225                     ZFSJNI_PACKAGE_DATA "VirtualDeviceBean");
 226
 227                 object->constructor =
 228                     (*env)->GetMethodID(env, object->class, "<init>", "()V");
 229
 230                 object->object =
 231                     (*env)->NewObject(env, object->class, object->constructor);
 232         }
 233
 234         new_DeviceStats(env, &(bean->interface_DeviceStats), object);
 235
 236         bean->method_setPoolName = (*env)->GetMethodID(
 237             env, object->class, "setPoolName", "(Ljava/lang/String;)V");
 238
 239         bean->method_setParentIndex = (*env)->GetMethodID(
 240             env, object->class, "setParentIndex", "(Ljava/lang/Long;)V");
 241
 242         bean->method_setIndex = (*env)->GetMethodID(
 243             env, object->class, "setIndex", "(J)V");
 244 }
 245
 246 /* Create a LeafVirtualDeviceBean */
 247 static void
 248 new_LeafVirtualDevice(JNIEnv *env, LeafVirtualDeviceBean_t *bean)
 249 {
 250         zjni_Object_t *object = (zjni_Object_t *)bean;
 251
 252         if (object->object == NULL) {
 253                 object->class =
 254                     (*env)->FindClass(env,
 255                     ZFSJNI_PACKAGE_DATA "LeafVirtualDeviceBean");
 256
 257                 object->constructor =
 258                     (*env)->GetMethodID(env, object->class, "<init>", "()V");
 259
 260                 object->object =
 261                     (*env)->NewObject(env, object->class, object->constructor);
 262         }
 263
 264         new_VirtualDevice(env, (VirtualDeviceBean_t *)bean);
 265
 266         bean->method_setName = (*env)->GetMethodID(
 267             env, object->class, "setName", "(Ljava/lang/String;)V");
 268 }
 269
 270 /* Create a DiskVirtualDeviceBean */
 271 static void
 272 new_DiskVirtualDeviceBean(JNIEnv *env, DiskVirtualDeviceBean_t *bean)
 273 {
 274         zjni_Object_t *object = (zjni_Object_t *)bean;
 275
 276         if (object->object == NULL) {
 277                 object->class = (*env)->FindClass(
 278                     env, ZFSJNI_PACKAGE_DATA "DiskVirtualDeviceBean");
 279
 280                 object->constructor =
 281                     (*env)->GetMethodID(env, object->class, "<init>", "()V");
 282
 283                 object->object =
 284                     (*env)->NewObject(env, object->class, object->constructor);
 285         }
 286
 287         new_LeafVirtualDevice(env, (LeafVirtualDeviceBean_t *)bean);
 288 }
 289
 290 /* Create a SliceVirtualDeviceBean */
 291 static void
 292 new_SliceVirtualDeviceBean(JNIEnv *env, SliceVirtualDeviceBean_t *bean)
 293 {
 294         zjni_Object_t *object = (zjni_Object_t *)bean;
 295
 296         if (object->object == NULL) {
 297                 object->class = (*env)->FindClass(
 298                     env, ZFSJNI_PACKAGE_DATA "SliceVirtualDeviceBean");
 299
 300                 object->constructor =
 301                     (*env)->GetMethodID(env, object->class, "<init>", "()V");
 302
 303                 object->object =
 304                     (*env)->NewObject(env, object->class, object->constructor);
 305         }
 306
 307         new_LeafVirtualDevice(env, (LeafVirtualDeviceBean_t *)bean);
 308 }
 309
 310 /* Create a FileVirtualDeviceBean */
 311 static void
 312 new_FileVirtualDeviceBean(JNIEnv *env, FileVirtualDeviceBean_t *bean)
 313 {
 314         zjni_Object_t *object = (zjni_Object_t *)bean;
 315
 316         if (object->object == NULL) {
 317                 object->class = (*env)->FindClass(
 318                     env, ZFSJNI_PACKAGE_DATA "FileVirtualDeviceBean");
 319
 320                 object->constructor =
 321                     (*env)->GetMethodID(env, object->class, "<init>", "()V");
 322
 323                 object->object =
 324                     (*env)->NewObject(env, object->class, object->constructor);
 325         }
 326
 327         new_LeafVirtualDevice(env, (LeafVirtualDeviceBean_t *)bean);
 328 }
 329
 330 /* Create a RAIDVirtualDeviceBean */
 331 static void
 332 new_RAIDVirtualDeviceBean(JNIEnv *env, RAIDVirtualDeviceBean_t *bean)
 333 {
 334         zjni_Object_t *object = (zjni_Object_t *)bean;
 335
 336         if (object->object == NULL) {
 337
 338                 object->class = (*env)->FindClass(
 339                     env, ZFSJNI_PACKAGE_DATA "RAIDVirtualDeviceBean");
 340
 341                 object->constructor =
 342                     (*env)->GetMethodID(env, object->class, "<init>", "()V");
 343
 344                 object->object =
 345                     (*env)->NewObject(env, object->class, object->constructor);
 346         }
 347
 348         new_VirtualDevice(env, (VirtualDeviceBean_t *)bean);
 349
 350         bean->method_setParity = (*env)->GetMethodID(
 351             env, object->class, "setParity", "(J)V");
 352 }
 353
 354 /* Create a MirrorVirtualDeviceBean */
 355 static void
 356 new_MirrorVirtualDeviceBean(JNIEnv *env, MirrorVirtualDeviceBean_t *bean)
 357 {
 358         zjni_Object_t *object = (zjni_Object_t *)bean;
 359
 360         if (object->object == NULL) {
 361                 object->class = (*env)->FindClass(
 362                     env, ZFSJNI_PACKAGE_DATA "MirrorVirtualDeviceBean");
 363
 364                 object->constructor =
 365                     (*env)->GetMethodID(env, object->class, "<init>", "()V");
 366
 367                 object->object =
 368                     (*env)->NewObject(env, object->class, object->constructor);
 369         }
 370
 371         new_VirtualDevice(env, (VirtualDeviceBean_t *)bean);
 372 }
 373
 374 static int
 375 populate_ImportablePoolBean(JNIEnv *env, ImportablePoolBean_t *bean,
 376     nvlist_t *config)
 377 {
 378         char *c;
 379         char *name;
 380         uint64_t guid;
 381         uint64_t state;
 382         uint64_t version;
 383         nvlist_t *devices;
 384
 385         zjni_Object_t *object = (zjni_Object_t *)bean;
 386         PoolStatsBean_t *pool_stats = &(bean->interface_PoolStats);
 387         DeviceStatsBean_t *dev_stats = (DeviceStatsBean_t *)pool_stats;
 388
 389         if (nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, &name) ||
 390             nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &guid) ||
 391             nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, &state) ||
 392             nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, &version) ||
 393             nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &devices) ||
 394             populate_DeviceStatsBean(env, devices, dev_stats, object)) {
 395                 return (-1);
 396         }
 397
 398         (*env)->CallVoidMethod(env, object->object,
 399             bean->method_setName, (*env)->NewStringUTF(env, name));
 400
 401         (*env)->CallVoidMethod(env, object->object,
 402             bean->method_setId, (jlong)guid);
 403
 404         (*env)->CallVoidMethod(env, object->object,
 405             pool_stats->method_setPoolState,
 406             zjni_pool_state_to_obj(env, (pool_state_t)state));
 407
 408         (*env)->CallVoidMethod(env, object->object,
 409             pool_stats->method_setPoolStatus,
 410             zjni_pool_status_to_obj(env, zpool_import_status(config, &c)));
 411
 412         (*env)->CallVoidMethod(env, object->object,
 413             pool_stats->method_setPoolVersion, (jlong)version);
 414
 415         return (0);
 416 }
 417
 418 static int
 419 populate_VirtualDeviceBean(JNIEnv *env, zpool_handle_t *zhp,
 420     nvlist_t *vdev, uint64_t *p_vdev_id, VirtualDeviceBean_t *bean)
 421 {
 422         int result;
 423         uint64_t vdev_id;
 424         jstring poolUTF;
 425
 426         zjni_Object_t *object = (zjni_Object_t *)bean;
 427         DeviceStatsBean_t *stats = &(bean->interface_DeviceStats);
 428
 429         result = populate_DeviceStatsBean(env, vdev, stats, object);
 430         if (result != 0) {
 431                 return (1);
 432         }
 433
 434         /* Set pool name */
 435         poolUTF = (*env)->NewStringUTF(env, zpool_get_name(zhp));
 436         (*env)->CallVoidMethod(
 437             env, object->object, bean->method_setPoolName, poolUTF);
 438
 439         /* Set parent vdev index */
 440         (*env)->CallVoidMethod(
 441             env, object->object, bean->method_setParentIndex,
 442             p_vdev_id == NULL ? NULL :
 443             zjni_long_to_Long(env, *p_vdev_id));
 444
 445         /* Get index */
 446         result = nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_GUID, &vdev_id);
 447         if (result != 0) {
 448                 zjni_throw_exception(env,
 449                     "could not retrieve virtual device ID (pool %s)",
 450                     zpool_get_name(zhp));
 451                 return (1);
 452         }
 453
 454         (*env)->CallVoidMethod(
 455             env, object->object, bean->method_setIndex, (jlong)vdev_id);
 456
 457         return (0);
 458 }
 459
 460 static int
 461 populate_LeafVirtualDeviceBean(JNIEnv *env, zpool_handle_t *zhp,
 462     nvlist_t *vdev, uint64_t *p_vdev_id, LeafVirtualDeviceBean_t *bean)
 463 {
 464         return (populate_VirtualDeviceBean(
 465             env, zhp, vdev, p_vdev_id, (VirtualDeviceBean_t *)bean));
 466 }
 467
 468 static int
 469 populate_DiskVirtualDeviceBean(JNIEnv *env, zpool_handle_t *zhp,
 470     nvlist_t *vdev, uint64_t *p_vdev_id, DiskVirtualDeviceBean_t *bean)
 471 {
 472         char *path;
 473         int result = populate_LeafVirtualDeviceBean(
 474             env, zhp, vdev, p_vdev_id, (LeafVirtualDeviceBean_t *)bean);
 475
 476         if (result) {
 477                 /* Must not call any more Java methods to preserve exception */
 478                 return (-1);
 479         }
 480
 481         /* Set path */
 482         result = nvlist_lookup_string(vdev, ZPOOL_CONFIG_PATH, &path);
 483         if (result != 0) {
 484                 zjni_throw_exception(env,
 485                     "could not retrieve path from disk virtual device "
 486                     "(pool %s)", zpool_get_name(zhp));
 487         } else {
 488
 489                 regex_t re;
 490                 regmatch_t matches[2];
 491                 jstring pathUTF = NULL;
 492
 493                 /* Strip off slice portion of name, if applicable */
 494                 if (regcomp(&re, "^(/dev/dsk/.*)s[0-9]+$", REG_EXTENDED) == 0) {
 495                         if (regexec(&re, path, 2, matches, 0) == 0) {
 496                                 regmatch_t *match = matches + 1;
 497                                 if (match->rm_so != -1 && match->rm_eo != -1) {
 498                                         char *tmp = strdup(path);
 499                                         if (tmp != NULL) {
 500                                                 char *end = tmp + match->rm_eo;
 501                                                 *end = '\0';
 502                                                 pathUTF = (*env)->NewStringUTF(
 503                                                     env, tmp);
 504                                                 free(tmp);
 505                                         }
 506                                 }
 507                         }
 508                         regfree(&re);
 509                 }
 510                 if (regcomp(&re, "^(/dev/dsk/.*)s[0-9]+/old$", REG_EXTENDED) ==
 511                     0) {
 512                         if (regexec(&re, path, 2, matches, 0) == 0) {
 513                                 regmatch_t *match = matches + 1;
 514                                 if (match->rm_so != -1 && match->rm_eo != -1) {
 515                                         char *tmp = strdup(path);
 516                                         if (tmp != NULL) {
 517                                                 (void) strcpy(tmp +
 518                                                     match->rm_eo, "/old");
 519                                                 pathUTF = (*env)->NewStringUTF(
 520                                                     env, tmp);
 521                                                 free(tmp);
 522                                         }
 523                                 }
 524                         }
 525                         regfree(&re);
 526                 }
 527
 528                 if (pathUTF == NULL) {
 529                         pathUTF = (*env)->NewStringUTF(env, path);
 530                 }
 531
 532                 (*env)->CallVoidMethod(env, ((zjni_Object_t *)bean)->object,
 533                     ((LeafVirtualDeviceBean_t *)bean)->method_setName, pathUTF);
 534         }
 535
 536         return (result != 0);
 537 }
 538
 539 static int
 540 populate_SliceVirtualDeviceBean(JNIEnv *env, zpool_handle_t *zhp,
 541     nvlist_t *vdev, uint64_t *p_vdev_id, SliceVirtualDeviceBean_t *bean)
 542 {
 543         char *path;
 544         int result = populate_LeafVirtualDeviceBean(
 545             env, zhp, vdev, p_vdev_id, (LeafVirtualDeviceBean_t *)bean);
 546
 547         if (result) {
 548                 /* Must not call any more Java methods to preserve exception */
 549                 return (-1);
 550         }
 551
 552         /* Set path */
 553         result = nvlist_lookup_string(vdev, ZPOOL_CONFIG_PATH, &path);
 554         if (result != 0) {
 555                 zjni_throw_exception(env,
 556                     "could not retrieve path from slice virtual device (pool "
 557                     "%s)", zpool_get_name(zhp));
 558         } else {
 559
 560                 jstring pathUTF = (*env)->NewStringUTF(env, path);
 561                 (*env)->CallVoidMethod(env, ((zjni_Object_t *)bean)->object,
 562                     ((LeafVirtualDeviceBean_t *)bean)->method_setName,
 563                     pathUTF);
 564         }
 565
 566         return (result != 0);
 567 }
 568
 569 static int
 570 populate_FileVirtualDeviceBean(JNIEnv *env, zpool_handle_t *zhp,
 571     nvlist_t *vdev, uint64_t *p_vdev_id, FileVirtualDeviceBean_t *bean)
 572 {
 573         char *path;
 574         int result = populate_LeafVirtualDeviceBean(
 575             env, zhp, vdev, p_vdev_id, (LeafVirtualDeviceBean_t *)bean);
 576
 577         if (result) {
 578                 /* Must not call any more Java methods to preserve exception */
 579                 return (-1);
 580         }
 581
 582         /* Set path */
 583         result = nvlist_lookup_string(vdev, ZPOOL_CONFIG_PATH, &path);
 584         if (result != 0) {
 585                 zjni_throw_exception(env,
 586                     "could not retrieve path from disk virtual device "
 587                     "(pool %s)", zpool_get_name(zhp));
 588         } else {
 589
 590                 jstring pathUTF = (*env)->NewStringUTF(env, path);
 591                 (*env)->CallVoidMethod(env, ((zjni_Object_t *)bean)->object,
 592                     ((LeafVirtualDeviceBean_t *)bean)->method_setName, pathUTF);
 593         }
 594
 595         return (result != 0);
 596 }
 597
 598 static int
 599 populate_RAIDVirtualDeviceBean(JNIEnv *env, zpool_handle_t *zhp,
 600     nvlist_t *vdev, uint64_t *p_vdev_id, RAIDVirtualDeviceBean_t *bean)
 601 {
 602         return (populate_VirtualDeviceBean(env, zhp, vdev, p_vdev_id,
 603             (VirtualDeviceBean_t *)bean));
 604 }
 605
 606 static int
 607 populate_MirrorVirtualDeviceBean(JNIEnv *env, zpool_handle_t *zhp,
 608     nvlist_t *vdev, uint64_t *p_vdev_id, MirrorVirtualDeviceBean_t *bean)
 609 {
 610         return (populate_VirtualDeviceBean(env, zhp, vdev, p_vdev_id,
 611             (VirtualDeviceBean_t *)bean));
 612 }
 613
 614 static jobject
 615 create_ImportablePoolBean(JNIEnv *env, nvlist_t *config)
 616 {
 617         int result;
 618         ImportablePoolBean_t bean_obj = {0};
 619         ImportablePoolBean_t *bean = &bean_obj;
 620
 621         /* Construct ImportablePoolBean */
 622         new_ImportablePoolBean(env, bean);
 623
 624         result = populate_ImportablePoolBean(env, bean, config);
 625         if (result) {
 626                 /* Must not call any more Java methods to preserve exception */
 627                 return (NULL);
 628         }
 629
 630         return (((zjni_Object_t *)bean)->object);
 631 }
 632
 633 static jobject
 634 create_DiskVirtualDeviceBean(JNIEnv *env, zpool_handle_t *zhp,
 635     nvlist_t *vdev, uint64_t *p_vdev_id)
 636 {
 637         int result;
 638         DiskVirtualDeviceBean_t bean_obj = {0};
 639         DiskVirtualDeviceBean_t *bean = &bean_obj;
 640
 641         /* Construct DiskVirtualDeviceBean */
 642         new_DiskVirtualDeviceBean(env, bean);
 643
 644         result = populate_DiskVirtualDeviceBean(
 645             env, zhp, vdev, p_vdev_id, bean);
 646         if (result) {
 647                 /* Must not call any more Java methods to preserve exception */
 648                 return (NULL);
 649         }
 650
 651         return (((zjni_Object_t *)bean)->object);
 652 }
 653
 654 static jobject
 655 create_SliceVirtualDeviceBean(JNIEnv *env, zpool_handle_t *zhp,
 656     nvlist_t *vdev, uint64_t *p_vdev_id)
 657 {
 658         int result;
 659         SliceVirtualDeviceBean_t bean_obj = {0};
 660         SliceVirtualDeviceBean_t *bean = &bean_obj;
 661
 662         /* Construct SliceVirtualDeviceBean */
 663         new_SliceVirtualDeviceBean(env, bean);
 664
 665         result = populate_SliceVirtualDeviceBean(
 666             env, zhp, vdev, p_vdev_id, bean);
 667         if (result) {
 668                 /* Must not call any more Java methods to preserve exception */
 669                 return (NULL);
 670         }
 671
 672         return (((zjni_Object_t *)bean)->object);
 673 }
 674
 675 static jobject
 676 create_FileVirtualDeviceBean(JNIEnv *env, zpool_handle_t *zhp,
 677     nvlist_t *vdev, uint64_t *p_vdev_id)
 678 {
 679         int result;
 680         FileVirtualDeviceBean_t bean_obj = {0};
 681         FileVirtualDeviceBean_t *bean = &bean_obj;
 682
 683         /* Construct FileVirtualDeviceBean */
 684         new_FileVirtualDeviceBean(env, bean);
 685
 686         result = populate_FileVirtualDeviceBean(
 687             env, zhp, vdev, p_vdev_id, bean);
 688         if (result) {
 689                 /* Must not call any more Java methods to preserve exception */
 690                 return (NULL);
 691         }
 692
 693         return (((zjni_Object_t *)bean)->object);
 694 }
 695
 696 static jobject
 697 create_RAIDVirtualDeviceBean(JNIEnv *env, zpool_handle_t *zhp,
 698     nvlist_t *vdev, uint64_t *p_vdev_id)
 699 {
 700         int result;
 701         uint64_t parity;
 702         RAIDVirtualDeviceBean_t bean_obj = {0};
 703         RAIDVirtualDeviceBean_t *bean = &bean_obj;
 704
 705         ((zjni_Object_t *)bean)->object = NULL;
 706
 707         /* Construct RAIDVirtualDeviceBean */
 708         new_RAIDVirtualDeviceBean(env, bean);
 709
 710         /* Set parity bit */
 711         result = nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_NPARITY,
 712             &parity);
 713         if (result) {
 714                 /* Default to RAID-Z1 in case of error */
 715                 parity = 1;
 716         }
 717
 718         (*env)->CallVoidMethod(
 719             env, ((zjni_Object_t *)bean)->object, bean->method_setParity,
 720             (jlong)parity);
 721
 722
 723         result = populate_RAIDVirtualDeviceBean(
 724             env, zhp, vdev, p_vdev_id, bean);
 725         if (result) {
 726                 /* Must not call any more Java methods to preserve exception */
 727                 return (NULL);
 728         }
 729
 730         return (((zjni_Object_t *)bean)->object);
 731 }
 732
 733 static jobject
 734 create_MirrorVirtualDeviceBean(JNIEnv *env, zpool_handle_t *zhp,
 735     nvlist_t *vdev, uint64_t *p_vdev_id)
 736 {
 737         int result;
 738         MirrorVirtualDeviceBean_t bean_obj = {0};
 739         MirrorVirtualDeviceBean_t *bean = &bean_obj;
 740
 741         /* Construct MirrorVirtualDeviceBean */
 742         new_MirrorVirtualDeviceBean(env, bean);
 743
 744         result = populate_MirrorVirtualDeviceBean(
 745             env, zhp, vdev, p_vdev_id, bean);
 746         if (result) {
 747                 /* Must not call any more Java methods to preserve exception */
 748                 return (NULL);
 749         }
 750
 751         return (((zjni_Object_t *)bean)->object);
 752 }
 753
 754 static char *
 755 find_field(const zjni_field_mapping_t *mapping, int value) {
 756         int i;
 757         for (i = 0; mapping[i].name != NULL; i++) {
 758                 if (value == mapping[i].value) {
 759                         return (mapping[i].name);
 760                 }
 761         }
 762         return (NULL);
 763 }
 764
 765 /*
 766  * Converts a vdev_state_t to a Java DeviceStats$DeviceState object.
 767  */
 768 static jobject
 769 zjni_vdev_state_to_obj(JNIEnv *env, vdev_state_t state)
 770 {
 771         return (zjni_int_to_enum(env, state,
 772             ZFSJNI_PACKAGE_DATA "DeviceStats$DeviceState",
 773             "VDEV_STATE_UNKNOWN", vdev_state_map));
 774 }
 775
 776 /*
 777  * Converts a vdev_aux_t to a Java DeviceStats$DeviceStatus object.
 778  */
 779 static jobject
 780 zjni_vdev_aux_to_obj(JNIEnv *env, vdev_aux_t aux)
 781 {
 782         return (zjni_int_to_enum(env, aux,
 783             ZFSJNI_PACKAGE_DATA "DeviceStats$DeviceStatus",
 784             "VDEV_AUX_NONE", vdev_aux_map));
 785 }
 786
 787 /*
 788  * Package-private functions
 789  */
 790
 791 /* Create a DeviceStatsBean */
 792 void
 793 new_DeviceStats(JNIEnv *env, DeviceStatsBean_t *bean, zjni_Object_t *object)
 794 {
 795         bean->method_setSize = (*env)->GetMethodID(
 796             env, object->class, "setSize", "(J)V");
 797
 798         bean->method_setReplacementSize = (*env)->GetMethodID(
 799             env, object->class, "setReplacementSize", "(J)V");
 800
 801         bean->method_setUsed = (*env)->GetMethodID(
 802             env, object->class, "setUsed", "(J)V");
 803
 804         bean->method_setReadBytes = (*env)->GetMethodID(
 805             env, object->class, "setReadBytes", "(J)V");
 806
 807         bean->method_setWriteBytes = (*env)->GetMethodID(
 808             env, object->class, "setWriteBytes", "(J)V");
 809
 810         bean->method_setReadOperations = (*env)->GetMethodID(
 811             env, object->class, "setReadOperations", "(J)V");
 812
 813         bean->method_setWriteOperations = (*env)->GetMethodID(
 814             env, object->class, "setWriteOperations", "(J)V");
 815
 816         bean->method_setReadErrors = (*env)->GetMethodID(
 817             env, object->class, "setReadErrors", "(J)V");
 818
 819         bean->method_setWriteErrors = (*env)->GetMethodID(
 820             env, object->class, "setWriteErrors", "(J)V");
 821
 822         bean->method_setChecksumErrors = (*env)->GetMethodID(
 823             env, object->class, "setChecksumErrors", "(J)V");
 824
 825         bean->method_setDeviceState = (*env)->GetMethodID(
 826             env, object->class, "setDeviceState",
 827             "(L" ZFSJNI_PACKAGE_DATA "DeviceStats$DeviceState;)V");
 828
 829         bean->method_setDeviceStatus = (*env)->GetMethodID(
 830             env, object->class, "setDeviceStatus",
 831             "(L" ZFSJNI_PACKAGE_DATA "DeviceStats$DeviceStatus;)V");
 832 }
 833
 834 /* Create a PoolStatsBean */
 835 void
 836 new_PoolStats(JNIEnv *env, PoolStatsBean_t *bean, zjni_Object_t *object)
 837 {
 838         new_DeviceStats(env, (DeviceStatsBean_t *)bean, object);
 839
 840         bean->method_setPoolState = (*env)->GetMethodID(
 841             env, object->class, "setPoolState",
 842             "(L" ZFSJNI_PACKAGE_DATA "PoolStats$PoolState;)V");
 843
 844         bean->method_setPoolStatus = (*env)->GetMethodID(
 845             env, object->class, "setPoolStatus",
 846             "(L" ZFSJNI_PACKAGE_DATA "PoolStats$PoolStatus;)V");
 847
 848         bean->method_setPoolVersion = (*env)->GetMethodID(
 849             env, object->class, "setPoolVersion", "(J)V");
 850 }
 851
 852 /*
 853  * Gets the root vdev (an nvlist_t *) for the given pool.
 854  */
 855 nvlist_t *
 856 zjni_get_root_vdev(zpool_handle_t *zhp)
 857 {
 858         nvlist_t *root = NULL;
 859
 860         if (zhp != NULL) {
 861                 nvlist_t *attrs = zpool_get_config(zhp, NULL);
 862
 863                 if (attrs != NULL) {
 864                         int result = nvlist_lookup_nvlist(
 865                             attrs, ZPOOL_CONFIG_VDEV_TREE, &root);
 866                         if (result != 0) {
 867                                 root = NULL;
 868                         }
 869                 }
 870         }
 871
 872         return (root);
 873 }
 874
 875 /*
 876  * Gets the vdev (an nvlist_t *) with the given vdev_id, below the
 877  * given vdev.  If the given vdev is NULL, all vdevs within the given
 878  * pool are searched.
 879  *
 880  * If p_vdev_id is not NULL, it will be set to the ID of the parent
 881  * vdev, if any, or to vdev_id_to_find if the searched-for vdev is a
 882  * toplevel vdev.
 883  */
 884 nvlist_t *
 885 zjni_get_vdev(zpool_handle_t *zhp, nvlist_t *vdev_parent,
 886     uint64_t vdev_id_to_find, uint64_t *p_vdev_id)
 887 {
 888         int result;
 889         uint64_t id = vdev_id_to_find;
 890
 891         /* Was a vdev specified? */
 892         if (vdev_parent == NULL) {
 893                 /* No -- retrieve the top-level pool vdev */
 894                 vdev_parent = zjni_get_root_vdev(zhp);
 895         } else {
 896                 /* Get index of this vdev and compare with vdev_id_to_find */
 897                 result = nvlist_lookup_uint64(
 898                     vdev_parent, ZPOOL_CONFIG_GUID, &id);
 899                 if (result == 0 && id == vdev_id_to_find) {
 900                         return (vdev_parent);
 901                 }
 902         }
 903
 904         if (vdev_parent != NULL) {
 905
 906                 nvlist_t **children;
 907                 uint_t nelem = 0;
 908
 909                 /* Get the vdevs under this vdev */
 910                 result = nvlist_lookup_nvlist_array(
 911                     vdev_parent, ZPOOL_CONFIG_CHILDREN, &children, &nelem);
 912
 913                 if (result == 0) {
 914
 915                         int i;
 916                         nvlist_t *child;
 917
 918                         /* For each vdev child... */
 919                         for (i = 0; i < nelem; i++) {
 920                                 if (p_vdev_id != NULL) {
 921                                         /* Save parent vdev id */
 922                                         *p_vdev_id = id;
 923                                 }
 924
 925                                 child = zjni_get_vdev(zhp, children[i],
 926                                     vdev_id_to_find, p_vdev_id);
 927                                 if (child != NULL) {
 928                                         return (child);
 929                                 }
 930                         }
 931                 }
 932         }
 933
 934         return (NULL);
 935 }
 936
 937 jobject
 938 zjni_get_VirtualDevice_from_vdev(JNIEnv *env, zpool_handle_t *zhp,
 939     nvlist_t *vdev, uint64_t *p_vdev_id)
 940 {
 941         jobject obj = NULL;
 942         char *type = NULL;
 943         int result = nvlist_lookup_string(vdev, ZPOOL_CONFIG_TYPE, &type);
 944
 945         if (result == 0) {
 946                 if (strcmp(type, VDEV_TYPE_DISK) == 0) {
 947                         uint64_t wholedisk;
 948                         if (nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_WHOLE_DISK,
 949                             &wholedisk) == 0 && wholedisk) {
 950                                 obj = create_DiskVirtualDeviceBean(
 951                                     env, zhp, vdev, p_vdev_id);
 952                         } else {
 953                                 obj = create_SliceVirtualDeviceBean(
 954                                     env, zhp, vdev, p_vdev_id);
 955                         }
 956                 } else if (strcmp(type, VDEV_TYPE_FILE) == 0) {
 957                         obj = create_FileVirtualDeviceBean(
 958                             env, zhp, vdev, p_vdev_id);
 959                 } else if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) {
 960                         obj = create_RAIDVirtualDeviceBean(
 961                             env, zhp, vdev, p_vdev_id);
 962                 } else if (strcmp(type, VDEV_TYPE_MIRROR) == 0) {
 963                         obj = create_MirrorVirtualDeviceBean(
 964                             env, zhp, vdev, p_vdev_id);
 965                 } else if (strcmp(type, VDEV_TYPE_REPLACING) == 0) {
 966
 967                         /* Get the vdevs under this vdev */
 968                         nvlist_t **children;
 969                         uint_t nelem = 0;
 970                         int result = nvlist_lookup_nvlist_array(
 971                             vdev, ZPOOL_CONFIG_CHILDREN, &children, &nelem);
 972
 973                         if (result == 0 && nelem > 0) {
 974
 975                                 /* Get last vdev child (replacement device) */
 976                                 nvlist_t *child = children[nelem - 1];
 977
 978                                 obj = zjni_get_VirtualDevice_from_vdev(env,
 979                                     zhp, child, p_vdev_id);
 980                         }
 981                 }
 982         }
 983
 984         return (obj);
 985 }
 986
 987 jobject
 988 zjni_get_VirtualDevices_from_vdev(JNIEnv *env, zpool_handle_t *zhp,
 989     nvlist_t *vdev_parent, uint64_t *p_vdev_id)
 990 {
 991         /* Create an array list for the vdevs */
 992         zjni_ArrayList_t list_class = {0};
 993         zjni_ArrayList_t *list_class_p = &list_class;
 994         zjni_new_ArrayList(env, list_class_p);
 995
 996         /* Was a vdev specified? */
 997         if (vdev_parent == NULL) {
 998                 /* No -- retrieve the top-level pool vdev */
 999                 vdev_parent = zjni_get_root_vdev(zhp);
1000         }
1001
1002         if (vdev_parent != NULL) {
1003
1004                 /* Get the vdevs under this vdev */
1005                 nvlist_t **children;
1006                 uint_t nelem = 0;
1007                 int result = nvlist_lookup_nvlist_array(
1008                     vdev_parent, ZPOOL_CONFIG_CHILDREN, &children, &nelem);
1009
1010                 if (result == 0) {
1011
1012                         /* For each vdev child... */
1013                         int i;
1014                         for (i = 0; i < nelem; i++) {
1015                                 nvlist_t *child = children[i];
1016
1017                                 /* Create a Java object from this vdev */
1018                                 jobject obj =
1019                                     zjni_get_VirtualDevice_from_vdev(env,
1020                                     zhp, child, p_vdev_id);
1021
1022                                 if ((*env)->ExceptionOccurred(env) != NULL) {
1023                                         /*
1024                                          * Must not call any more Java methods
1025                                          * to preserve exception
1026                                          */
1027                                         return (NULL);
1028                                 }
1029
1030                                 if (obj != NULL) {
1031                                     /* Add child to child vdev list */
1032                                         (*env)->CallBooleanMethod(env,
1033                                             ((zjni_Object_t *)
1034                                             list_class_p)->object,
1035                                             ((zjni_Collection_t *)
1036                                             list_class_p)->method_add, obj);
1037                                 }
1038                         }
1039                 }
1040         }
1041
1042         return (zjni_Collection_to_array(
1043             env, (zjni_Collection_t *)list_class_p,
1044             ZFSJNI_PACKAGE_DATA "VirtualDevice"));
1045 }
1046
1047 int
1048 zjni_create_add_ImportablePool(nvlist_t *config, void *data) {
1049
1050         JNIEnv *env = ((zjni_ArrayCallbackData_t *)data)->env;
1051         zjni_Collection_t *list = ((zjni_ArrayCallbackData_t *)data)->list;
1052
1053         /* Construct ImportablePool object */
1054         jobject bean = create_ImportablePoolBean(env, config);
1055         if (bean == NULL) {
1056                 return (-1);
1057         }
1058
1059         /* Add bean to list */
1060         (*env)->CallBooleanMethod(env, ((zjni_Object_t *)list)->object,
1061             ((zjni_Collection_t *)list)->method_add, bean);
1062
1063         return (0);
1064 }
1065
1066 int
1067 populate_DeviceStatsBean(JNIEnv *env, nvlist_t *vdev,
1068     DeviceStatsBean_t *bean, zjni_Object_t *object)
1069 {
1070         uint_t c;
1071         vdev_stat_t *vs;
1072
1073         int result = nvlist_lookup_uint64_array(
1074             vdev, ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&vs, &c);
1075         if (result != 0) {
1076                 zjni_throw_exception(env,
1077                     "could not retrieve virtual device statistics");
1078                 return (1);
1079         }
1080
1081         (*env)->CallVoidMethod(env, object->object,
1082             bean->method_setUsed, (jlong)vs->vs_alloc);
1083
1084         (*env)->CallVoidMethod(env, object->object,
1085             bean->method_setSize, (jlong)vs->vs_space);
1086
1087         (*env)->CallVoidMethod(env, object->object,
1088             bean->method_setReplacementSize, (jlong)vs->vs_rsize);
1089
1090         (*env)->CallVoidMethod(env, object->object,
1091             bean->method_setReadBytes, (jlong)vs->vs_bytes[ZIO_TYPE_READ]);
1092
1093         (*env)->CallVoidMethod(env, object->object,
1094             bean->method_setWriteBytes, (jlong)vs->vs_bytes[ZIO_TYPE_WRITE]);
1095
1096         (*env)->CallVoidMethod(env, object->object,
1097             bean->method_setReadOperations, (jlong)vs->vs_ops[ZIO_TYPE_READ]);
1098
1099         (*env)->CallVoidMethod(env, object->object,
1100             bean->method_setWriteOperations, (jlong)vs->vs_ops[ZIO_TYPE_WRITE]);
1101
1102         (*env)->CallVoidMethod(env, object->object,
1103             bean->method_setReadErrors, (jlong)vs->vs_read_errors);
1104
1105         (*env)->CallVoidMethod(env, object->object,
1106             bean->method_setWriteErrors, (jlong)vs->vs_write_errors);
1107
1108         (*env)->CallVoidMethod(env, object->object,
1109             bean->method_setChecksumErrors, (jlong)vs->vs_checksum_errors);
1110
1111         (*env)->CallVoidMethod(env, object->object,
1112             bean->method_setDeviceState,
1113             zjni_vdev_state_to_obj(env, vs->vs_state));
1114
1115         (*env)->CallVoidMethod(env, object->object,
1116             bean->method_setDeviceStatus,
1117             zjni_vdev_aux_to_obj(env, vs->vs_aux));
1118
1119         return (0);
1120 }
1121
1122 /*
1123  * Converts a pool_state_t to a Java PoolStats$PoolState object.
1124  */
1125 jobject
1126 zjni_pool_state_to_obj(JNIEnv *env, pool_state_t state)
1127 {
1128         return (zjni_int_to_enum(env, state,
1129             ZFSJNI_PACKAGE_DATA "PoolStats$PoolState",
1130             "POOL_STATE_ACTIVE", pool_state_map));
1131 }
1132
1133 /*
1134  * Converts a zpool_status_t to a Java PoolStats$PoolStatus object.
1135  */
1136 jobject
1137 zjni_pool_status_to_obj(JNIEnv *env, zpool_status_t status)
1138 {
1139         return (zjni_int_to_enum(env, status,
1140             ZFSJNI_PACKAGE_DATA "PoolStats$PoolStatus",
1141             "ZPOOL_STATUS_OK", zpool_status_map));
1142 }
1143
1144 /*
1145  * Extern functions
1146  */
1147
1148 /*
1149  * Iterates through each importable pool on the system.  For each
1150  * importable pool, runs the given function with the given void as the
1151  * last arg.
1152  */
1153 int
1154 zjni_ipool_iter(int argc, char **argv, zjni_ipool_iter_f func, void *data)
1155 {
1156         nvlist_t *pools = zpool_find_import(g_zfs, argc, argv);
1157
1158         if (pools != NULL) {
1159                 nvpair_t *elem = NULL;
1160
1161                 while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) {
1162                         nvlist_t *config;
1163
1164                         if (nvpair_value_nvlist(elem, &config) != 0 ||
1165                             func(config, data)) {
1166                                 return (-1);
1167                         }
1168                 }
1169         }
1170
1171         return (0);
1172 }
1173
1174 char *
1175 zjni_vdev_state_to_str(vdev_state_t state) {
1176         return (find_field(vdev_state_map, state));
1177 }
1178
1179 char *
1180 zjni_vdev_aux_to_str(vdev_aux_t aux) {
1181         return (find_field(vdev_aux_map, aux));
1182 }
1183
1184 char *
1185 zjni_pool_state_to_str(pool_state_t state) {
1186         return (find_field(pool_state_map, state));
1187 }
1188
1189 char *
1190 zjni_pool_status_to_str(zpool_status_t status) {
1191         return (find_field(zpool_status_map, status));
1192 }