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