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