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