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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <errno.h> 30 #include <jni.h> 31 #include <pool.h> 32 #include <stdlib.h> 33 #include <string.h> 34 35 #include <sys/time.h> 36 37 #include "jpool.h" 38 39 struct pool_callback { 40 jobject pc_user; 41 jobject pc_handler; 42 jobject pc_elem; 43 JNIEnv *pc_env; 44 }; 45 46 static void throwException(JNIEnv *, const char *, const char *); 47 static void throw_pe(JNIEnv *); 48 static jobject makeUnsignedInt64(JNIEnv *, uint64_t); 49 static int pool_property_walker(pool_conf_t *, pool_elem_t *p, const char *, 50 pool_value_t *, void *); 51 static jobject copyArray(JNIEnv *, void **); 52 53 /* 54 * Cached class, method, and field IDs. 55 */ 56 static jclass ui64class; 57 static jmethodID ui64cons_mid; 58 59 /* 60 * Throw an exception of the specified class with the specified message. 61 */ 62 void 63 throwException(JNIEnv *env, const char *class, const char *msg) 64 { 65 jclass clazz; 66 67 clazz = (*env)->FindClass(env, class); 68 69 (*env)->ThrowNew(env, clazz, msg); 70 } 71 72 /* 73 * Throw a PoolsException. 74 */ 75 void 76 throw_pe(JNIEnv *jenv) 77 { 78 jclass clazz; 79 jmethodID mid; 80 jthrowable throwObj; 81 82 clazz = (*jenv)->FindClass(jenv, 83 "com/sun/solaris/service/pools/PoolsException"); 84 mid = (*jenv)->GetMethodID(jenv, clazz, "<init>", "()V"); 85 throwObj = (*jenv)->NewObject(jenv, clazz, mid); 86 (*jenv)->Throw(jenv, throwObj); 87 } 88 89 /* 90 * Return an instance of an UnsignedInt64 class which encapsulates the 91 * supplied value. 92 */ 93 jobject 94 makeUnsignedInt64(JNIEnv *env, uint64_t value) 95 { 96 jobject valueObj; 97 jobject byteArray; 98 jbyte *bytes; 99 int i; 100 101 if (!(byteArray = (*env)->NewByteArray(env, 9))) 102 return (NULL); /* OutOfMemoryError thrown */ 103 if (!(bytes = (*env)->GetByteArrayElements(env, byteArray, NULL))) 104 return (NULL); /* OutOfMemoryError thrown */ 105 106 /* 107 * Interpret the uint64_t as a 9-byte big-endian signed quantity 108 * suitable for constructing an UnsignedInt64 or BigInteger. 109 */ 110 for (i = 8; i >= 1; i--) { 111 bytes[i] = value & 0xff; 112 value >>= 8; 113 } 114 bytes[0] = 0; 115 (*env)->ReleaseByteArrayElements(env, byteArray, bytes, 0); 116 117 if (!(valueObj = (*env)->NewObject(env, ui64class, ui64cons_mid, 118 byteArray))) 119 return (NULL); /* exception thrown */ 120 121 return (valueObj); 122 } 123 124 /* 125 * Create an array list and then copy the native array into it 126 */ 127 jobject 128 copyArray(JNIEnv *jenv, void **nativeArray) 129 { 130 int i; 131 jobject jresult = NULL; 132 133 if (nativeArray != NULL) { 134 jclass ALclazz; 135 jmethodID ALinit, ALadd; 136 jclass Lclazz; 137 jmethodID Linit; 138 139 ALclazz = (*jenv)->FindClass(jenv, 140 "java/util/ArrayList"); 141 ALinit = (*jenv)->GetMethodID(jenv, 142 ALclazz, "<init>", "()V"); 143 ALadd = (*jenv)->GetMethodID(jenv, 144 ALclazz, "add", "(Ljava/lang/Object;)Z"); 145 jresult = (*jenv)->NewObject(jenv, ALclazz, ALinit); 146 Lclazz = (*jenv)->FindClass(jenv, "java/lang/Long"); 147 Linit = (*jenv)->GetMethodID(jenv, 148 Lclazz, "<init>", "(J)V"); 149 for (i = 0; nativeArray[i] != NULL; i++) { 150 jobject L; 151 /* Build longs and add them */ 152 L = (*jenv)->NewObject(jenv, 153 Lclazz, Linit, (jlong)(uintptr_t)nativeArray[i]); 154 (*jenv)->CallBooleanMethod(jenv, 155 jresult, ALadd, L); 156 } 157 free(nativeArray); 158 } 159 return (jresult); 160 } 161 162 /* 163 * pool_version(3pool) wrapper 164 */ 165 /*ARGSUSED*/ 166 JNIEXPORT jlong JNICALL 167 Java_com_sun_solaris_service_pools_PoolInternal_pool_1version(JNIEnv *jenv, 168 jclass jcls, jlong jver) { 169 return ((jlong)pool_version((uint_t)jver)); 170 } 171 172 /* 173 * native constant accessor 174 */ 175 /*ARGSUSED*/ 176 JNIEXPORT jint JNICALL 177 Java_com_sun_solaris_service_pools_PoolInternal_get_1POX_1NATIVE(JNIEnv *jenv, 178 jclass jcls) { 179 return ((jint)POX_NATIVE); 180 } 181 182 /* 183 * native constant accessor 184 */ 185 /*ARGSUSED*/ 186 JNIEXPORT jint JNICALL 187 Java_com_sun_solaris_service_pools_PoolInternal_get_1POX_1TEXT(JNIEnv *jenv, 188 jclass jcls) { 189 return ((jint)POX_TEXT); 190 } 191 192 /* 193 * native constant accessor 194 */ 195 /*ARGSUSED*/ 196 JNIEXPORT jint JNICALL 197 Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1INVAL(JNIEnv *jenv, 198 jclass jcls) { 199 return ((jint)POC_INVAL); 200 } 201 202 /* 203 * native constant accessor 204 */ 205 /*ARGSUSED*/ 206 JNIEXPORT jint JNICALL 207 Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1UINT(JNIEnv *jenv, 208 jclass jcls) { 209 return ((jint)POC_UINT); 210 } 211 212 /* 213 * native constant accessor 214 */ 215 /*ARGSUSED*/ 216 JNIEXPORT jint JNICALL 217 Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1INT(JNIEnv *jenv, 218 jclass jcls) { 219 return ((jint)POC_INT); 220 } 221 222 /* 223 * native constant accessor 224 */ 225 /*ARGSUSED*/ 226 JNIEXPORT jint JNICALL 227 Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1DOUBLE(JNIEnv *jenv, 228 jclass jcls) { 229 return ((jint)POC_DOUBLE); 230 } 231 232 /* 233 * native constant accessor 234 */ 235 /*ARGSUSED*/ 236 JNIEXPORT jint JNICALL 237 Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1BOOL(JNIEnv *jenv, 238 jclass jcls) { 239 return ((jint)POC_BOOL); 240 } 241 242 /* 243 * native constant accessor 244 */ 245 /*ARGSUSED*/ 246 JNIEXPORT jint JNICALL 247 Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1STRING(JNIEnv *jenv, 248 jclass jcls) { 249 return ((jint)POC_STRING); 250 } 251 252 /* 253 * native constant accessor 254 */ 255 /*ARGSUSED*/ 256 JNIEXPORT jint JNICALL 257 Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1NONE(JNIEnv *jenv, 258 jclass jcls) { 259 return ((jint)POV_NONE); 260 } 261 262 /* 263 * native constant accessor 264 */ 265 /*ARGSUSED*/ 266 JNIEXPORT jint JNICALL 267 Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1LOOSE(JNIEnv *jenv, 268 jclass jcls) { 269 return ((jint)POV_LOOSE); 270 } 271 272 /* 273 * native constant accessor 274 */ 275 /*ARGSUSED*/ 276 JNIEXPORT jint JNICALL 277 Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1STRICT(JNIEnv *jenv, 278 jclass jcls) { 279 return ((jint)POV_STRICT); 280 } 281 282 /* 283 * native constant accessor 284 */ 285 /*ARGSUSED*/ 286 JNIEXPORT jint JNICALL 287 Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1RUNTIME(JNIEnv *jenv, 288 jclass jcls) { 289 return ((jint)POV_RUNTIME); 290 } 291 292 /* 293 * native constant accessor 294 */ 295 /*ARGSUSED*/ 296 JNIEXPORT jint JNICALL 297 Java_com_sun_solaris_service_pools_PoolInternal_get_1POF_1INVALID(JNIEnv *jenv, 298 jclass jcls) { 299 return ((jint)POF_INVALID); 300 } 301 302 /* 303 * native constant accessor 304 */ 305 /*ARGSUSED*/ 306 JNIEXPORT jint JNICALL 307 Java_com_sun_solaris_service_pools_PoolInternal_get_1POF_1VALID(JNIEnv *jenv, 308 jclass jcls) { 309 return ((jint)POF_VALID); 310 } 311 312 /* 313 * native constant accessor 314 */ 315 /*ARGSUSED*/ 316 JNIEXPORT jint JNICALL 317 Java_com_sun_solaris_service_pools_PoolInternal_get_1POF_1DESTROY(JNIEnv *jenv, 318 jclass jcls) { 319 return ((jint)POF_DESTROY); 320 } 321 322 /* 323 * pool_error(3pool) wrapper 324 */ 325 /*ARGSUSED*/ 326 JNIEXPORT jint JNICALL 327 Java_com_sun_solaris_service_pools_PoolInternal_pool_1error(JNIEnv *jenv, 328 jclass jcls) { 329 return ((jint)pool_error()); 330 } 331 332 /* 333 * pool_strerror(3pool) wrapper 334 */ 335 /*ARGSUSED*/ 336 JNIEXPORT jstring JNICALL 337 Java_com_sun_solaris_service_pools_PoolInternal_pool_1strerror(JNIEnv *jenv, 338 jclass jcls, jint jperr) { 339 jstring jresult = NULL; 340 char *result; 341 342 result = (char *)pool_strerror((int)jperr); 343 344 if (result) 345 jresult = (*jenv)->NewStringUTF(jenv, result); 346 return (jresult); 347 } 348 349 /* 350 * strerror(3c) wrapper 351 */ 352 /*ARGSUSED*/ 353 JNIEXPORT jstring JNICALL 354 Java_com_sun_solaris_service_pools_PoolInternal_pool_1strerror_1sys(JNIEnv * 355 jenv, jclass jcls) { 356 jstring jresult = NULL; 357 char *result; 358 359 result = (char *)strerror(errno); 360 361 if (result) 362 jresult = (*jenv)->NewStringUTF(jenv, result); 363 return (jresult); 364 } 365 366 /* 367 * errno(3c) accessor 368 */ 369 /*ARGSUSED*/ 370 JNIEXPORT jint JNICALL 371 Java_com_sun_solaris_service_pools_PoolsException_getErrno(JNIEnv *jenv, 372 jclass jcls) { 373 return ((jint)errno); 374 } 375 376 /* 377 * pool_resource_type_list(3pool) wrapper 378 */ 379 /*ARGSUSED*/ 380 JNIEXPORT jint JNICALL 381 Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1type_1list( 382 JNIEnv *jenv, jclass jcls, jlong jreslist, jlong jnumres) { 383 char **reslist = (char **)(uintptr_t)jreslist; 384 uint_t *numres = (uint_t *)(uintptr_t)jnumres; 385 386 return ((jint)pool_resource_type_list((char const **)reslist, numres)); 387 } 388 389 /* 390 * pool_get_status(3pool) wrapper 391 */ 392 /*ARGSUSED*/ 393 JNIEXPORT jint JNICALL 394 Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1status(JNIEnv *jenv, 395 jclass jcls) { 396 int status; 397 int err; 398 399 err = pool_get_status(&status); 400 if (err == -1) 401 return ((jint)PO_FAIL); 402 else 403 return ((jint)status); 404 } 405 406 /* 407 * pool_set_status(3pool) wrapper 408 */ 409 /*ARGSUSED*/ 410 JNIEXPORT jint JNICALL 411 Java_com_sun_solaris_service_pools_PoolInternal_pool_1set_1status(JNIEnv *jenv, 412 jclass jcls, jint jstate) { 413 return ((jint)pool_set_status((int)jstate)); 414 } 415 416 /* 417 * pool_conf_alloc(3pool) wrapper 418 */ 419 /*ARGSUSED*/ 420 JNIEXPORT jlong JNICALL 421 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1alloc(JNIEnv *jenv, 422 jclass jcls) { 423 return ((jlong)(uintptr_t)pool_conf_alloc()); 424 } 425 426 /* 427 * pool_conf_free(3pool) wrapper 428 */ 429 /*ARGSUSED*/ 430 JNIEXPORT void JNICALL 431 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1free(JNIEnv *jenv, 432 jclass jcls, jlong jconf) { 433 pool_conf_free((pool_conf_t *)(uintptr_t)jconf); 434 } 435 436 /* 437 * pool_conf_status(3pool) wrapper 438 */ 439 /*ARGSUSED*/ 440 JNIEXPORT jint JNICALL 441 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1status(JNIEnv *jenv, 442 jclass jcls, jlong jconf) { 443 return ((jint)pool_conf_status((pool_conf_t *)(uintptr_t)jconf)); 444 } 445 446 /* 447 * pool_conf_close(3pool) wrapper 448 */ 449 /*ARGSUSED*/ 450 JNIEXPORT jint JNICALL 451 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1close(JNIEnv *jenv, 452 jclass jcls, jlong jconf) { 453 return ((jint)pool_conf_close((pool_conf_t *)(uintptr_t)jconf)); 454 } 455 456 /* 457 * pool_conf_remove(3pool) wrapper 458 */ 459 /*ARGSUSED*/ 460 JNIEXPORT jint JNICALL 461 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1remove(JNIEnv *jenv, 462 jclass jcls, jlong jconf) { 463 return ((jint)pool_conf_remove((pool_conf_t *)(uintptr_t)jconf)); 464 } 465 466 /* 467 * pool_conf_open(3pool) wrapper 468 */ 469 /*ARGSUSED*/ 470 JNIEXPORT jint JNICALL 471 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1open(JNIEnv *jenv, 472 jclass jcls, jlong jconf, jstring jlocation, jint jflags) { 473 const char *location; 474 int result; 475 476 location = (jlocation) ? (*jenv)->GetStringUTFChars(jenv, 477 jlocation, 0) : NULL; 478 result = (int)pool_conf_open((pool_conf_t *)(uintptr_t)jconf, location, 479 (int)jflags); 480 481 if (location) 482 (*jenv)->ReleaseStringUTFChars(jenv, jlocation, location); 483 return ((jint)result); 484 } 485 486 /* 487 * pool_conf_rollback(3pool) wrapper 488 */ 489 /*ARGSUSED*/ 490 JNIEXPORT jint JNICALL 491 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1rollback( 492 JNIEnv *jenv, jclass jcls, jlong jconf) { 493 return ((jint)pool_conf_rollback((pool_conf_t *)(uintptr_t)jconf)); 494 } 495 496 /* 497 * pool_conf_commit(3pool) wrapper 498 */ 499 /*ARGSUSED*/ 500 JNIEXPORT jint JNICALL 501 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1commit(JNIEnv *jenv, 502 jclass jcls, jlong jconf, jint jactive) { 503 return ((jint)pool_conf_commit( 504 (pool_conf_t *)(uintptr_t)jconf, (int)jactive)); 505 } 506 507 /* 508 * pool_conf_export(3pool) wrapper 509 */ 510 /*ARGSUSED*/ 511 JNIEXPORT jint JNICALL 512 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1export(JNIEnv *jenv, 513 jclass jcls, jlong jconf, jstring jlocation, jint jformat) { 514 const char *location; 515 int result; 516 517 location = (jlocation) ? (*jenv)->GetStringUTFChars(jenv, 518 jlocation, 0) : NULL; 519 result = (int)pool_conf_export((pool_conf_t *)(uintptr_t)jconf, 520 location, (pool_export_format_t)jformat); 521 522 if (location) 523 (*jenv)->ReleaseStringUTFChars(jenv, jlocation, location); 524 return ((jint)result); 525 } 526 527 /* 528 * pool_conf_validate(3pool) wrapper 529 */ 530 /*ARGSUSED*/ 531 JNIEXPORT jint JNICALL 532 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1validate( 533 JNIEnv *jenv, jclass jcls, jlong jconf, jint jlevel) { 534 return ((jint)pool_conf_validate((pool_conf_t *)(uintptr_t)jconf, 535 (pool_valid_level_t)jlevel)); 536 } 537 538 /* 539 * pool_conf_update(3pool) wrapper 540 */ 541 /*ARGSUSED*/ 542 JNIEXPORT jint JNICALL 543 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1update(JNIEnv *jenv, 544 jclass jcls, jlong jconf) { 545 int changed; 546 int result; 547 548 result = pool_conf_update((pool_conf_t *)(uintptr_t)jconf, &changed); 549 550 if (result != PO_SUCCESS) { 551 throw_pe(jenv); 552 } 553 554 return ((jint)changed); 555 } 556 557 /* 558 * pool_get_pool(3pool) wrapper 559 */ 560 /*ARGSUSED*/ 561 JNIEXPORT jlong JNICALL 562 Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1pool(JNIEnv *jenv, 563 jclass jcls, jlong jconf, jstring jname) { 564 const char *name; 565 pool_t *result; 566 567 name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) : 568 NULL; 569 result = (pool_t *)pool_get_pool((pool_conf_t *)(uintptr_t)jconf, name); 570 571 if (name) 572 (*jenv)->ReleaseStringUTFChars(jenv, jname, name); 573 return ((jlong)(uintptr_t)result); 574 } 575 576 /* 577 * pool_query_pools(3pool) wrapper 578 */ 579 /*ARGSUSED*/ 580 JNIEXPORT jobject JNICALL 581 Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1pools(JNIEnv *jenv, 582 jclass jcls, jlong jconf, jobject jprops) { 583 pool_value_t **props; 584 pool_t **result; 585 jclass Lclazz; 586 jmethodID Lsize; 587 jint size; 588 uint_t nelem; 589 int i; 590 591 592 /* 593 * Initialize the target parameter for case when input is null 594 */ 595 props = NULL; 596 if (jprops != NULL) { 597 Lclazz = (*jenv)->GetObjectClass(jenv, jprops); 598 Lsize = (*jenv)->GetMethodID(jenv, Lclazz, "size", "()I"); 599 size = (*jenv)->CallIntMethod(jenv, jprops, Lsize); 600 601 if (size != 0) { 602 jmethodID Lget; 603 604 Lget = (*jenv)->GetMethodID(jenv, Lclazz, "get", 605 "(I)Ljava/lang/Object;"); 606 /* 607 * Allocate space for the props array 608 */ 609 610 if ((props = calloc(size + 1, sizeof (pool_value_t *))) 611 == NULL) { 612 throwException(jenv, "java/lang/Exception", 613 "Could not allocate props array"); 614 return (NULL); 615 } 616 /* 617 * Copy in the array 618 */ 619 for (i = 0; i < size; i++) { 620 jobject aVal; 621 jclass Vclazz; 622 jfieldID Vthis; 623 jlong this; 624 625 aVal = (*jenv)->CallObjectMethod(jenv, jprops, 626 Lget, (jint) i); 627 Vclazz = (*jenv)->GetObjectClass(jenv, aVal); 628 Vthis = (*jenv)->GetFieldID(jenv, Vclazz, 629 "_this", "J"); 630 this = (*jenv)->GetLongField(jenv, aVal, Vthis); 631 props[i] = (pool_value_t *)(uintptr_t)this; 632 } 633 } 634 } 635 result = pool_query_pools((pool_conf_t *)(uintptr_t)jconf, &nelem, 636 props); 637 free(props); 638 return (copyArray(jenv, (void **)result)); 639 } 640 641 /* 642 * pool_get_resource(3pool) wrapper 643 */ 644 /*ARGSUSED*/ 645 JNIEXPORT jlong JNICALL 646 Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1resource( 647 JNIEnv *jenv, jclass jcls, jlong jconf, jstring jtype, jstring jname) { 648 const char *type; 649 const char *name; 650 pool_resource_t *result; 651 652 type = (jtype) ? (*jenv)->GetStringUTFChars(jenv, jtype, 0) : 653 NULL; 654 name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) : 655 NULL; 656 result = pool_get_resource((pool_conf_t *)(uintptr_t)jconf, type, name); 657 658 if (type) 659 (*jenv)->ReleaseStringUTFChars(jenv, jtype, type); 660 if (name) 661 (*jenv)->ReleaseStringUTFChars(jenv, jname, name); 662 return ((jlong)(uintptr_t)result); 663 } 664 665 /* 666 * pool_query_resources(3pool) wrapper 667 */ 668 /*ARGSUSED*/ 669 JNIEXPORT jobject JNICALL 670 Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1resources( 671 JNIEnv *jenv, jclass jcls, jlong jconf, jobject jprops) { 672 pool_value_t **props; 673 pool_resource_t **result; 674 jclass Lclazz; 675 jmethodID Lsize; 676 jint size; 677 uint_t nelem; 678 int i; 679 680 /* 681 * Initialize the target parameter for case when input is null 682 */ 683 props = NULL; 684 if (jprops != NULL) { 685 Lclazz = (*jenv)->GetObjectClass(jenv, jprops); 686 Lsize = (*jenv)->GetMethodID(jenv, Lclazz, "size", "()I"); 687 size = (*jenv)->CallIntMethod(jenv, jprops, Lsize); 688 689 if (size != 0) { 690 jmethodID Lget; 691 692 Lget = (*jenv)->GetMethodID(jenv, Lclazz, "get", 693 "(I)Ljava/lang/Object;"); 694 /* 695 * Allocate space for the props array 696 */ 697 if ((props = calloc(size + 1, sizeof (pool_value_t *))) 698 == NULL) { 699 throwException(jenv, "java/lang/Exception", 700 "Could not allocate props array"); 701 return (NULL); 702 } 703 /* 704 * Copy in the array 705 */ 706 for (i = 0; i < size; i++) { 707 jobject aVal; 708 jclass Vclazz; 709 jfieldID Vthis; 710 jlong this; 711 712 713 aVal = (*jenv)->CallObjectMethod(jenv, jprops, 714 Lget, (jint) i); 715 Vclazz = (*jenv)->GetObjectClass(jenv, aVal); 716 Vthis = (*jenv)->GetFieldID(jenv, Vclazz, 717 "_this", "J"); 718 this = (*jenv)->GetLongField(jenv, aVal, Vthis); 719 props[i] = (pool_value_t *)(uintptr_t)this; 720 } 721 } 722 } 723 result = pool_query_resources((pool_conf_t *)(uintptr_t)jconf, &nelem, 724 props); 725 free(props); 726 return (copyArray(jenv, (void *)result)); 727 } 728 729 /* 730 * pool_query_components(3pool) wrapper 731 */ 732 /*ARGSUSED*/ 733 JNIEXPORT jobject JNICALL 734 Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1components( 735 JNIEnv *jenv, jclass jcls, jlong jconf, jobject jprops) { 736 pool_value_t **props; 737 pool_component_t **result; 738 jclass Lclazz; 739 jmethodID Lsize; 740 jint size; 741 uint_t nelem; 742 int i; 743 744 /* 745 * Initialize the target parameter for case when input is null 746 */ 747 props = NULL; 748 if (jprops != NULL) { 749 Lclazz = (*jenv)->GetObjectClass(jenv, jprops); 750 Lsize = (*jenv)->GetMethodID(jenv, Lclazz, "size", "()I"); 751 size = (*jenv)->CallIntMethod(jenv, jprops, Lsize); 752 753 if (size != 0) { 754 jmethodID Lget; 755 756 Lget = (*jenv)->GetMethodID(jenv, Lclazz, "get", 757 "(I)Ljava/lang/Object;"); 758 /* 759 * Allocate space for the props array 760 */ 761 762 if ((props = calloc(size + 1, sizeof (pool_value_t *))) 763 == NULL) { 764 throwException(jenv, "java/lang/Exception", 765 "Could not allocate props array"); 766 return (NULL); 767 } 768 /* 769 * Copy in the array 770 */ 771 for (i = 0; i < size; i++) { 772 jobject aVal; 773 jclass Vclazz; 774 jfieldID Vthis; 775 jlong this; 776 777 aVal = (*jenv)->CallObjectMethod(jenv, jprops, 778 Lget, (jint) i); 779 Vclazz = (*jenv)->GetObjectClass(jenv, aVal); 780 Vthis = (*jenv)->GetFieldID(jenv, Vclazz, 781 "_this", "J"); 782 this = (*jenv)->GetLongField(jenv, aVal, Vthis); 783 props[i] = (pool_value_t *)(uintptr_t)this; 784 } 785 } 786 } 787 result = pool_query_components((pool_conf_t *)(uintptr_t)jconf, &nelem, 788 props); 789 free(props); 790 return (copyArray(jenv, (void **)result)); 791 } 792 793 /* 794 * pool_conf_location(3pool) wrapper 795 */ 796 /*ARGSUSED*/ 797 JNIEXPORT jstring JNICALL 798 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1location( 799 JNIEnv *jenv, jclass jcls, jlong jconf) { 800 jstring jresult = NULL; 801 const char *result; 802 803 result = pool_conf_location((pool_conf_t *)(uintptr_t)jconf); 804 805 if (result) 806 jresult = (*jenv)->NewStringUTF(jenv, result); 807 return (jresult); 808 } 809 810 /* 811 * pool_conf_info(3pool) wrapper 812 */ 813 /*ARGSUSED*/ 814 JNIEXPORT jstring JNICALL 815 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1info(JNIEnv *jenv, 816 jclass jcls, jlong jconf, jint jflags) { 817 jstring jresult = NULL; 818 const char *result; 819 820 result = pool_conf_info((pool_conf_t *)(uintptr_t)jconf, (int)jflags); 821 822 if (result) 823 jresult = (*jenv)->NewStringUTF(jenv, result); 824 free((void *)result); 825 return (jresult); 826 } 827 828 /* 829 * pool_resource_create(3pool) wrapper 830 */ 831 /*ARGSUSED*/ 832 JNIEXPORT jlong JNICALL 833 Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1create( 834 JNIEnv *jenv, jclass jcls, jlong jconf, jstring jtype, jstring jname) { 835 const char *type; 836 const char *name; 837 pool_resource_t *result; 838 839 type = (jtype) ? (*jenv)->GetStringUTFChars(jenv, jtype, 0) : 840 NULL; 841 name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) : 842 NULL; 843 result = 844 pool_resource_create((pool_conf_t *)(uintptr_t)jconf, type, name); 845 846 if (type) 847 (*jenv)->ReleaseStringUTFChars(jenv, jtype, type); 848 if (name) 849 (*jenv)->ReleaseStringUTFChars(jenv, jname, name); 850 return ((jlong)(uintptr_t)result); 851 } 852 853 /* 854 * pool_resource_destroy(3pool) wrapper 855 */ 856 /*ARGSUSED*/ 857 JNIEXPORT jint JNICALL 858 Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1destroy( 859 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jresource) { 860 return ((jint)pool_resource_destroy((pool_conf_t *)(uintptr_t)jconf, 861 (pool_resource_t *)(uintptr_t)jresource)); 862 } 863 864 /* 865 * pool_resource_transfer(3pool) wrapper 866 */ 867 /*ARGSUSED*/ 868 JNIEXPORT jint JNICALL 869 Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1transfer( 870 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jsource, jlong jtarget, 871 jlong jsize) { 872 return (pool_resource_transfer((pool_conf_t *)(uintptr_t)jconf, 873 (pool_resource_t *)(uintptr_t)jsource, 874 (pool_resource_t *)(uintptr_t)jtarget, 875 (uint64_t)jsize)); 876 } 877 878 /* 879 * pool_resource_xtransfer(3pool) wrapper 880 */ 881 /*ARGSUSED*/ 882 JNIEXPORT jint JNICALL 883 Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1xtransfer( 884 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jsource, jlong jtarget, 885 jobject jcomponents) { 886 pool_component_t **components; 887 int result; 888 jclass Lclazz; 889 jmethodID Lsize; 890 jint size; 891 892 /* 893 * Initialize the target parameter for case when input is null 894 */ 895 components = NULL; 896 if (jcomponents != NULL) { 897 Lclazz = (*jenv)->GetObjectClass(jenv, jcomponents); 898 Lsize = (*jenv)->GetMethodID(jenv, Lclazz, "size", "()I"); 899 size = (*jenv)->CallIntMethod(jenv, jcomponents, Lsize); 900 901 if (size != 0) { 902 jmethodID Lget; 903 int i; 904 905 Lget = (*jenv)->GetMethodID(jenv, 906 Lclazz, "get", "(I)Ljava/lang/Object;"); 907 /* Allocate space for the components array */ 908 909 if ((components = calloc(size + 1, 910 sizeof (pool_component_t *))) == NULL) { 911 throwException(jenv, "java/lang/Exception", 912 "Could not allocate component array"); 913 return (NULL); 914 } 915 /* 916 * Copy in the array 917 */ 918 for (i = 0; i < size; i++) { 919 jobject aVal; 920 jclass Vclazz; 921 jlong this; 922 jmethodID Vthis; 923 924 aVal = (*jenv)->CallObjectMethod(jenv, 925 jcomponents, Lget, (jint) i); 926 Vclazz = (*jenv)->GetObjectClass(jenv, 927 aVal); 928 Vthis = (*jenv)->GetMethodID(jenv, 929 Vclazz, "getComponent", "()J"); 930 this = (*jenv)->CallLongMethod(jenv, 931 aVal, Vthis); 932 components[i] = 933 (pool_component_t *)(uintptr_t)this; 934 } 935 } 936 } 937 result = (int)pool_resource_xtransfer((pool_conf_t *)(uintptr_t)jconf, 938 (pool_resource_t *)(uintptr_t)jsource, 939 (pool_resource_t *)(uintptr_t)jtarget, 940 components); 941 free(components); 942 943 return ((jint)result); 944 } 945 946 /* 947 * pool_query_resource_components(3pool) wrapper 948 */ 949 /*ARGSUSED*/ 950 JNIEXPORT jobject JNICALL 951 Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1resource_\ 952 1components(JNIEnv *jenv, jclass jcls, jlong jconf, jlong jresource, 953 jobject jprops) { 954 pool_value_t **props; 955 pool_component_t **result; 956 jclass Lclazz; 957 jmethodID Lsize; 958 uint_t nelem; 959 jint size; 960 961 /* 962 * Initialize the target parameter for case when input is null 963 */ 964 props = NULL; 965 if (jprops != NULL) { 966 Lclazz = (*jenv)->GetObjectClass(jenv, jprops); 967 Lsize = (*jenv)->GetMethodID(jenv, Lclazz, "size", "()I"); 968 size = (*jenv)->CallIntMethod(jenv, jprops, Lsize); 969 970 if (size != 0) { 971 jmethodID Lget; 972 int i; 973 974 Lget = (*jenv)->GetMethodID(jenv, Lclazz, "get", 975 "(I)Ljava/lang/Object;"); 976 /* 977 * Allocate space for the props array 978 */ 979 if ((props = calloc(size + 1, sizeof (pool_value_t *))) 980 == NULL) { 981 throwException(jenv, "java/lang/Exception", 982 "Could not allocate props array"); 983 return (NULL); 984 } 985 /* 986 * Copy in the array 987 */ 988 for (i = 0; i < size; i++) { 989 jobject aVal; 990 jclass Vclazz; 991 jfieldID Vthis; 992 jlong this; 993 994 aVal = (*jenv)->CallObjectMethod(jenv, jprops, 995 Lget, (jint) i); 996 Vclazz = (*jenv)->GetObjectClass(jenv, aVal); 997 Vthis = (*jenv)->GetFieldID(jenv, Vclazz, 998 "_this", "J"); 999 this = (*jenv)->GetLongField(jenv, aVal, Vthis); 1000 props[i] = (pool_value_t *)(uintptr_t)this; 1001 } 1002 } 1003 } 1004 result = pool_query_resource_components( 1005 (pool_conf_t *)(uintptr_t)jconf, 1006 (pool_resource_t *)(uintptr_t)jresource, &nelem, props); 1007 free(props); 1008 return (copyArray(jenv, (void **)result)); 1009 } 1010 1011 /* 1012 * pool_resource_info(3pool) wrapper 1013 */ 1014 /*ARGSUSED*/ 1015 JNIEXPORT jstring JNICALL 1016 Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1info( 1017 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jresource, jint jflags) { 1018 jstring jresult = NULL; 1019 const char *result; 1020 1021 result = pool_resource_info((pool_conf_t *)(uintptr_t)jconf, 1022 (pool_resource_t *)(uintptr_t)jresource, (int)jflags); 1023 1024 if (result) 1025 jresult = (*jenv)->NewStringUTF(jenv, result); 1026 free((void *)result); 1027 return (jresult); 1028 } 1029 1030 /* 1031 * pool_create(3pool) wrapper 1032 */ 1033 /*ARGSUSED*/ 1034 JNIEXPORT jlong JNICALL 1035 Java_com_sun_solaris_service_pools_PoolInternal_pool_1create(JNIEnv *jenv, 1036 jclass jcls, jlong jconf, jstring jname) { 1037 const char *name; 1038 pool_t *result; 1039 1040 name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) : 1041 NULL; 1042 result = pool_create((pool_conf_t *)(uintptr_t)jconf, name); 1043 1044 if (name) 1045 (*jenv)->ReleaseStringUTFChars(jenv, jname, name); 1046 return ((jlong)(uintptr_t)result); 1047 } 1048 1049 /* 1050 * pool_destroy(3pool) wrapper 1051 */ 1052 /*ARGSUSED*/ 1053 JNIEXPORT jint JNICALL 1054 Java_com_sun_solaris_service_pools_PoolInternal_pool_1destroy(JNIEnv *jenv, 1055 jclass jcls, jlong jconf, jlong jpool) { 1056 return ((jint)pool_destroy((pool_conf_t *)(uintptr_t)jconf, 1057 (pool_t *)(uintptr_t)jpool)); 1058 } 1059 1060 /* 1061 * pool_associate(3pool) wrapper 1062 */ 1063 /*ARGSUSED*/ 1064 JNIEXPORT jint JNICALL 1065 Java_com_sun_solaris_service_pools_PoolInternal_pool_1associate(JNIEnv *jenv, 1066 jclass jcls, jlong jconf, jlong jpool, jlong jresource) { 1067 return ((jint)pool_associate((pool_conf_t *)(uintptr_t)jconf, 1068 (pool_t *)(uintptr_t)jpool, 1069 (pool_resource_t *)(uintptr_t)jresource)); 1070 } 1071 1072 /* 1073 * pool_dissociate(3pool) wrapper 1074 */ 1075 /*ARGSUSED*/ 1076 JNIEXPORT jint JNICALL 1077 Java_com_sun_solaris_service_pools_PoolInternal_pool_1dissociate(JNIEnv *jenv, 1078 jclass jcls, jlong jconf, jlong jpool, jlong jresource) { 1079 return ((jint)pool_dissociate((pool_conf_t *)(uintptr_t)jconf, 1080 (pool_t *)(uintptr_t)jpool, 1081 (pool_resource_t *)(uintptr_t)jresource)); 1082 } 1083 1084 /* 1085 * pool_info(3pool) wrapper 1086 */ 1087 /*ARGSUSED*/ 1088 JNIEXPORT jstring JNICALL 1089 Java_com_sun_solaris_service_pools_PoolInternal_pool_1info(JNIEnv *jenv, 1090 jclass jcls, jlong jconf, jlong jpool, jint jflags) { 1091 jstring jresult = NULL; 1092 const char *result; 1093 1094 result = pool_info((pool_conf_t *)(uintptr_t)jconf, 1095 (pool_t *)(uintptr_t)jpool, (int)jflags); 1096 1097 if (result) 1098 jresult = (*jenv)->NewStringUTF(jenv, result); 1099 free((void *)result); 1100 return (jresult); 1101 } 1102 1103 /* 1104 * pool_query_pool_resources(3pool) wrapper 1105 */ 1106 /*ARGSUSED*/ 1107 JNIEXPORT jobject JNICALL 1108 Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1pool_1resources( 1109 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jpool, jobject jprops) { 1110 pool_value_t **props; 1111 pool_resource_t **result; 1112 jclass Lclazz; 1113 jmethodID Lsize; 1114 uint_t nelem; 1115 jint size; 1116 1117 /* 1118 * Initialize the target parameter for case when input is null 1119 */ 1120 props = NULL; 1121 if (jprops != NULL) { 1122 Lclazz = (*jenv)->GetObjectClass(jenv, jprops); 1123 Lsize = (*jenv)->GetMethodID(jenv, Lclazz, "size", "()I"); 1124 size = (*jenv)->CallIntMethod(jenv, jprops, Lsize); 1125 1126 if (size != 0) { 1127 jmethodID Lget; 1128 int i; 1129 1130 Lget = (*jenv)->GetMethodID(jenv, 1131 Lclazz, "get", "(I)Ljava/lang/Object;"); 1132 /* 1133 * Allocate space for the props array 1134 */ 1135 1136 if ((props = calloc(size + 1, sizeof (pool_value_t *))) 1137 == NULL) { 1138 throwException(jenv, "java/lang/Exception", 1139 "Could not allocate props array"); 1140 return (NULL); 1141 } 1142 /* 1143 * Copy in the array 1144 */ 1145 for (i = 0; i < size; i++) { 1146 jobject aVal; 1147 jclass Vclazz; 1148 jfieldID Vthis; 1149 jlong this; 1150 1151 aVal = (*jenv)->CallObjectMethod(jenv, jprops, 1152 Lget, (jint) i); 1153 Vclazz = (*jenv)->GetObjectClass(jenv, aVal); 1154 Vthis = (*jenv)->GetFieldID(jenv, Vclazz, 1155 "_this", "J"); 1156 this = (*jenv)->GetLongField(jenv, aVal, Vthis); 1157 props[i] = (pool_value_t *)(uintptr_t)this; 1158 } 1159 } 1160 } 1161 result = pool_query_pool_resources((pool_conf_t *)(uintptr_t)jconf, 1162 (pool_t *)(uintptr_t)jpool, &nelem, props); 1163 free(props); 1164 return (copyArray(jenv, (void **)result)); 1165 } 1166 1167 /* 1168 * pool_get_owning_resource(3pool) wrapper 1169 */ 1170 /*ARGSUSED*/ 1171 JNIEXPORT jlong JNICALL 1172 Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1owning_1resource( 1173 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jcomponent) { 1174 return ((jlong)(uintptr_t)pool_get_owning_resource( 1175 (pool_conf_t *)(uintptr_t)jconf, 1176 (pool_component_t *)(uintptr_t)jcomponent)); 1177 } 1178 1179 /* 1180 * pool_component_info(3pool) wrapper 1181 */ 1182 /*ARGSUSED*/ 1183 JNIEXPORT jstring JNICALL 1184 Java_com_sun_solaris_service_pools_PoolInternal_pool_1component_1info( 1185 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jcomponent, jint jflags) { 1186 jstring jresult = NULL; 1187 const char *result; 1188 1189 result = pool_component_info((pool_conf_t *)(uintptr_t)jconf, 1190 (pool_component_t *)(uintptr_t)jcomponent, (int)jflags); 1191 1192 if (result) 1193 jresult = (*jenv)->NewStringUTF(jenv, result); 1194 free((void *)result); 1195 return (jresult); 1196 } 1197 1198 /* 1199 * pool_get_property(3pool) wrapper 1200 */ 1201 /*ARGSUSED*/ 1202 JNIEXPORT jint JNICALL 1203 Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1property( 1204 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jelem, jstring jname, 1205 jlong jproperty) { 1206 const char *name; 1207 int result; 1208 1209 name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) : 1210 NULL; 1211 result = pool_get_property((pool_conf_t *)(uintptr_t)jconf, 1212 (pool_elem_t *)(uintptr_t)jelem, name, 1213 (pool_value_t *)(uintptr_t)jproperty); 1214 1215 if (name) 1216 (*jenv)->ReleaseStringUTFChars(jenv, jname, name); 1217 return ((jint)result); 1218 } 1219 1220 /* 1221 * pool_put_property(3pool) wrapper 1222 */ 1223 /*ARGSUSED*/ 1224 JNIEXPORT jint JNICALL 1225 Java_com_sun_solaris_service_pools_PoolInternal_pool_1put_1property( 1226 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jelem, jstring jname, 1227 jlong jvalue) { 1228 const char *name; 1229 int result; 1230 1231 name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) : NULL; 1232 result = (int)pool_put_property((pool_conf_t *)(uintptr_t)jconf, 1233 (pool_elem_t *)(uintptr_t)jelem, name, 1234 (pool_value_t *)(uintptr_t)jvalue); 1235 1236 if (name) 1237 (*jenv)->ReleaseStringUTFChars(jenv, jname, name); 1238 return ((jint)result); 1239 } 1240 1241 /* 1242 * pool_rm_property(3pool) wrapper 1243 */ 1244 /*ARGSUSED*/ 1245 JNIEXPORT jint JNICALL 1246 Java_com_sun_solaris_service_pools_PoolInternal_pool_1rm_1property(JNIEnv *jenv, 1247 jclass jcls, jlong jconf, jlong jelem, jstring jname) { 1248 const char *name; 1249 int result; 1250 1251 name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) : NULL; 1252 result = pool_rm_property((pool_conf_t *)(uintptr_t)jconf, 1253 (pool_elem_t *)(uintptr_t)jelem, name); 1254 1255 if (name) 1256 (*jenv)->ReleaseStringUTFChars(jenv, jname, name); 1257 return ((jint)result); 1258 } 1259 1260 /* 1261 * pool_walk_properties(3pool) wrapper 1262 */ 1263 /*ARGSUSED*/ 1264 JNIEXPORT jint JNICALL 1265 Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1properties( 1266 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jelem, jlong jarg, 1267 jlong jcallback) { 1268 int result; 1269 1270 result = (int)pool_walk_properties((pool_conf_t *)(uintptr_t)jconf, 1271 (pool_elem_t *)(uintptr_t)jelem, (void *)(uintptr_t)jarg, 1272 (int (*)(pool_conf_t *, pool_elem_t *, char const *, 1273 pool_value_t *, void *))(uintptr_t)jcallback); 1274 1275 return ((jint)result); 1276 } 1277 1278 /* 1279 * pool_conf_to_elem(3pool) wrapper 1280 */ 1281 /*ARGSUSED*/ 1282 JNIEXPORT jlong JNICALL 1283 Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1to_1elem( 1284 JNIEnv *jenv, jclass jcls, jlong jconf) { 1285 return ((jlong)(uintptr_t)pool_conf_to_elem( 1286 (pool_conf_t *)(uintptr_t)jconf)); 1287 } 1288 1289 /* 1290 * pool_to_elem(3pool) wrapper 1291 */ 1292 /*ARGSUSED*/ 1293 JNIEXPORT jlong JNICALL 1294 Java_com_sun_solaris_service_pools_PoolInternal_pool_1to_1elem(JNIEnv *jenv, 1295 jclass jcls, jlong jconf, jlong jpool) { 1296 return ((jlong)(uintptr_t)pool_to_elem((pool_conf_t *)(uintptr_t)jconf, 1297 (pool_t *)(uintptr_t)jpool)); 1298 } 1299 1300 /* 1301 * pool_resource_to_elem(3pool) wrapper 1302 */ 1303 /*ARGSUSED*/ 1304 JNIEXPORT jlong JNICALL 1305 Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1to_1elem( 1306 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jresource) { 1307 return ((jlong)(uintptr_t)pool_resource_to_elem( 1308 (pool_conf_t *)(uintptr_t)jconf, 1309 (pool_resource_t *)(uintptr_t)jresource)); 1310 } 1311 1312 /* 1313 * pool_component_to_elem(3pool) wrapper 1314 */ 1315 /*ARGSUSED*/ 1316 JNIEXPORT jlong JNICALL 1317 Java_com_sun_solaris_service_pools_PoolInternal_pool_1component_1to_1elem( 1318 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jcomponent) { 1319 return ((jlong)(uintptr_t)pool_component_to_elem( 1320 (pool_conf_t *)(uintptr_t)jconf, 1321 (pool_component_t *)(uintptr_t)jcomponent)); 1322 } 1323 1324 /* 1325 * pool_value_get_type(3pool) wrapper 1326 */ 1327 /*ARGSUSED*/ 1328 JNIEXPORT jint JNICALL 1329 Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1get_1type( 1330 JNIEnv *jenv, jclass jcls, jlong jvalue) { 1331 return ((jint)pool_value_get_type((pool_value_t *)(uintptr_t)jvalue)); 1332 } 1333 1334 /* 1335 * pool_value_set_uint64(3pool) wrapper 1336 */ 1337 /*ARGSUSED*/ 1338 JNIEXPORT void JNICALL 1339 Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1uint64( 1340 JNIEnv *jenv, jclass jcls, jlong jvalue, jlong jui64) { 1341 pool_value_set_uint64( 1342 (pool_value_t *)(uintptr_t)jvalue, (uint64_t)jui64); 1343 } 1344 1345 /* 1346 * pool_value_set_int64(3pool) wrapper 1347 */ 1348 /*ARGSUSED*/ 1349 JNIEXPORT void JNICALL 1350 Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1int64( 1351 JNIEnv *jenv, jclass jcls, jlong jvalue, jlong ji64) { 1352 pool_value_set_int64((pool_value_t *)(uintptr_t)jvalue, (int64_t)ji64); 1353 } 1354 1355 /* 1356 * pool_value_set_double(3pool) wrapper 1357 */ 1358 /*ARGSUSED*/ 1359 JNIEXPORT void JNICALL 1360 Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1double( 1361 JNIEnv *jenv, jclass jcls, jlong jvalue, jdouble jd) { 1362 pool_value_set_double((pool_value_t *)(uintptr_t)jvalue, (double)jd); 1363 } 1364 1365 /* 1366 * pool_value_set_bool(3pool) wrapper 1367 */ 1368 /*ARGSUSED*/ 1369 JNIEXPORT void JNICALL 1370 Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1bool( 1371 JNIEnv *jenv, jclass jcls, jlong jvalue, jshort jb) { 1372 pool_value_set_bool((pool_value_t *)(uintptr_t)jvalue, (uchar_t)jb); 1373 } 1374 1375 /* 1376 * pool_value_set_string(3pool) wrapper 1377 */ 1378 /*ARGSUSED*/ 1379 JNIEXPORT jint JNICALL 1380 Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1string( 1381 JNIEnv * jenv, jclass jcls, jlong jvalue, jstring jstr) { 1382 const char *str; 1383 int result; 1384 1385 str = (jstr) ? (*jenv)->GetStringUTFChars(jenv, jstr, 0) : NULL; 1386 result = pool_value_set_string((pool_value_t *)(uintptr_t)jvalue, str); 1387 1388 if (str) 1389 (*jenv)->ReleaseStringUTFChars(jenv, jstr, str); 1390 return ((jint)result); 1391 } 1392 1393 /* 1394 * pool_value_get_name(3pool) wrapper 1395 */ 1396 /*ARGSUSED*/ 1397 JNIEXPORT jstring JNICALL 1398 Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1get_1name( 1399 JNIEnv *jenv, jclass jcls, jlong jvalue) { 1400 jstring jresult = NULL; 1401 const char *result; 1402 1403 result = pool_value_get_name((pool_value_t *)(uintptr_t)jvalue); 1404 1405 if (result) 1406 jresult = (*jenv)->NewStringUTF(jenv, result); 1407 return (jresult); 1408 } 1409 1410 /* 1411 * pool_value_set_name(3pool) wrapper 1412 */ 1413 /*ARGSUSED*/ 1414 JNIEXPORT jint JNICALL 1415 Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1name( 1416 JNIEnv *jenv, jclass jcls, jlong jvalue, jstring jname) { 1417 const char *name; 1418 int result; 1419 1420 name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) : NULL; 1421 result = pool_value_set_name((pool_value_t *)(uintptr_t)jvalue, name); 1422 1423 if (name) 1424 (*jenv)->ReleaseStringUTFChars(jenv, jname, name); 1425 return ((jint)result); 1426 } 1427 1428 /* 1429 * pool_value_alloc(3pool) wrapper 1430 */ 1431 /*ARGSUSED*/ 1432 JNIEXPORT jlong JNICALL 1433 Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1alloc(JNIEnv *jenv, 1434 jclass jcls) { 1435 return ((jlong)(uintptr_t)pool_value_alloc()); 1436 } 1437 1438 /* 1439 * pool_value_free(3pool) wrapper 1440 */ 1441 /*ARGSUSED*/ 1442 JNIEXPORT void JNICALL 1443 Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1free(JNIEnv *jenv, 1444 jclass jcls, jlong jvalue) { 1445 pool_value_free((pool_value_t *)(uintptr_t)jvalue); 1446 } 1447 1448 /* 1449 * pool_static_location(3pool) wrapper 1450 */ 1451 /*ARGSUSED*/ 1452 JNIEXPORT jstring JNICALL 1453 Java_com_sun_solaris_service_pools_PoolInternal_pool_1static_1location( 1454 JNIEnv *jenv, jclass jcls) { 1455 jstring jresult = NULL; 1456 const char *result; 1457 1458 result = pool_static_location(); 1459 1460 if (result) 1461 jresult = (*jenv)->NewStringUTF(jenv, result); 1462 return (jresult); 1463 } 1464 1465 /* 1466 * pool_dynamic_location(3pool) wrapper 1467 */ 1468 /*ARGSUSED*/ 1469 JNIEXPORT jstring JNICALL 1470 Java_com_sun_solaris_service_pools_PoolInternal_pool_1dynamic_1location(JNIEnv * 1471 jenv, jclass jcls) { 1472 jstring jresult = NULL; 1473 const char *result; 1474 1475 result = pool_dynamic_location(); 1476 1477 if (result) 1478 jresult = (*jenv)->NewStringUTF(jenv, result); 1479 return (jresult); 1480 } 1481 1482 /* 1483 * pool_set_binding(3pool) wrapper 1484 */ 1485 /*ARGSUSED*/ 1486 JNIEXPORT jint JNICALL 1487 Java_com_sun_solaris_service_pools_PoolInternal_pool_1set_1binding(JNIEnv *jenv, 1488 jclass jcls, jstring jpool, jint jidtype, jint jpid) { 1489 const char *pool; 1490 int result; 1491 1492 pool = (jpool) ? (*jenv)->GetStringUTFChars(jenv, jpool, 0) : NULL; 1493 result = (int)pool_set_binding(pool, (idtype_t)jidtype, (id_t)jpid); 1494 1495 if (pool) 1496 (*jenv)->ReleaseStringUTFChars(jenv, jpool, pool); 1497 return ((jint)result); 1498 } 1499 1500 /* 1501 * pool_get_binding(3pool) wrapper 1502 */ 1503 /*ARGSUSED*/ 1504 JNIEXPORT jstring JNICALL 1505 Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1binding(JNIEnv *jenv, 1506 jclass jcls, jint jpid) { 1507 jstring jresult = NULL; 1508 const char *result; 1509 1510 result = pool_get_binding((pid_t)jpid); 1511 1512 if (result) 1513 jresult = (*jenv)->NewStringUTF(jenv, result); 1514 free((void *)result); 1515 return (jresult); 1516 } 1517 1518 /* 1519 * pool_get_resource_binding(3pool) wrapper 1520 */ 1521 /*ARGSUSED*/ 1522 JNIEXPORT jstring JNICALL 1523 Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1resource_1binding( 1524 JNIEnv *jenv, jclass jcls, jstring jtype, jint jpid) { 1525 jstring jresult = NULL; 1526 const char *type; 1527 const char *result; 1528 1529 type = (jtype) ? (*jenv)->GetStringUTFChars(jenv, jtype, 0) : NULL; 1530 result = pool_get_resource_binding(type, (pid_t)jpid); 1531 1532 if (result) 1533 jresult = (*jenv)->NewStringUTF(jenv, result); 1534 free((void *)result); 1535 if (type) 1536 (*jenv)->ReleaseStringUTFChars(jenv, jtype, type); 1537 return (jresult); 1538 } 1539 1540 /* 1541 * pool_walk_pools(3pool) wrapper 1542 */ 1543 /*ARGSUSED*/ 1544 JNIEXPORT jint JNICALL 1545 Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1pools(JNIEnv *jenv, 1546 jclass jcls, jlong jconf, jlong jarg, jlong jcallback) { 1547 int result; 1548 1549 result = pool_walk_pools((pool_conf_t *)(uintptr_t)jconf, 1550 (void *)(uintptr_t)jarg, 1551 (int (*)(pool_conf_t *, pool_t *, void *))(uintptr_t)jcallback); 1552 return ((jint)result); 1553 } 1554 1555 /* 1556 * pool_walk_resources(3pool) wrapper 1557 */ 1558 /*ARGSUSED*/ 1559 JNIEXPORT jint JNICALL 1560 Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1resources( 1561 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jpool, jlong jarg, 1562 jlong jcallback) { 1563 int result; 1564 1565 result = pool_walk_resources((pool_conf_t *)(uintptr_t)jconf, 1566 (pool_t *)(uintptr_t)jpool, (void *)(uintptr_t)jarg, 1567 (int (*)(pool_conf_t *, pool_resource_t *, void *)) 1568 (uintptr_t)jcallback); 1569 return ((jint)result); 1570 } 1571 1572 /* 1573 * pool_walk_components(3pool) wrapper 1574 */ 1575 /*ARGSUSED*/ 1576 JNIEXPORT jint JNICALL 1577 Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1components( 1578 JNIEnv *jenv, jclass jcls, jlong jconf, jlong jresource, jlong jarg, 1579 jlong jcallback) { 1580 int result; 1581 1582 result = pool_walk_components((pool_conf_t *)(uintptr_t)jconf, 1583 (pool_resource_t *)(uintptr_t)jresource, (void *)(uintptr_t)jarg, 1584 (int (*)(pool_conf_t *, pool_component_t *, void *)) 1585 (uintptr_t)jcallback); 1586 return ((jint)result); 1587 } 1588 1589 /*ARGSUSED*/ 1590 JNIEXPORT jint JNICALL 1591 Java_com_sun_solaris_service_pools_Element_walkProps(JNIEnv *env, 1592 jobject obj, jlong conf, jlong elem, jobject handler, jobject userobj) 1593 { 1594 struct pool_callback pc; 1595 1596 pc.pc_user = userobj; 1597 pc.pc_handler = handler; 1598 pc.pc_elem = obj; 1599 pc.pc_env = env; 1600 return (pool_walk_properties((pool_conf_t *)*(void**)&conf, 1601 (pool_elem_t *)*(void**)&elem, (void *)&pc, pool_property_walker)); 1602 } 1603 1604 /*ARGSUSED*/ 1605 static int 1606 pool_property_walker(pool_conf_t *conf, pool_elem_t *pe, const char *name, 1607 pool_value_t *pv, void *user) 1608 { 1609 jclass clazz, vclazz; 1610 jmethodID mgetwalk, mvcon; 1611 struct pool_callback *pc = (struct pool_callback *)user; 1612 jobject valueObj; 1613 pool_value_t *pv_new; 1614 uint64_t uval; 1615 int64_t ival; 1616 double dval; 1617 uchar_t bval; 1618 const char *sval; 1619 1620 /* 1621 * Since we intend to embed our value into a Java Value object 1622 * and then reclaim the value when the object is garbage 1623 * collected we must create a new pool value and then pass this 1624 * to the constructor. We must not use the pool value which is 1625 * passed to us. 1626 */ 1627 1628 if ((pv_new = pool_value_alloc()) == NULL) 1629 return (PO_FAIL); 1630 switch (pool_value_get_type(pv)) { 1631 case POC_UINT: 1632 (void) pool_value_get_uint64(pv, &uval); 1633 (void) pool_value_set_uint64(pv_new, uval); 1634 break; 1635 case POC_INT: 1636 (void) pool_value_get_int64(pv, &ival); 1637 (void) pool_value_set_int64(pv_new, ival); 1638 break; 1639 case POC_DOUBLE: 1640 (void) pool_value_get_double(pv, &dval); 1641 (void) pool_value_set_double(pv_new, dval); 1642 break; 1643 case POC_BOOL: 1644 (void) pool_value_get_bool(pv, &bval); 1645 (void) pool_value_set_bool(pv_new, bval); 1646 break; 1647 case POC_STRING: 1648 (void) pool_value_get_string(pv, &sval); 1649 (void) pool_value_set_string(pv_new, sval); 1650 break; 1651 default: 1652 pool_value_free(pv_new); 1653 return (PO_FAIL); 1654 } 1655 if (pool_value_set_name(pv_new, name) != PO_SUCCESS || 1656 (vclazz = (*pc->pc_env)->FindClass(pc->pc_env, 1657 "com/sun/solaris/service/pools/Value")) == NULL || 1658 (mvcon = (*pc->pc_env)->GetMethodID(pc->pc_env, vclazz, 1659 "<init>", "(J)V")) == NULL || 1660 (valueObj = (*pc->pc_env)->NewObject(pc->pc_env, vclazz, mvcon, 1661 pv_new)) == NULL || 1662 (clazz = (*pc->pc_env)->GetObjectClass(pc->pc_env, pc->pc_handler)) 1663 == NULL || 1664 (mgetwalk = (*pc->pc_env)->GetMethodID(pc->pc_env, 1665 clazz, "walk", 1666 "(Lcom/sun/solaris/service/pools/Element;Lcom/sun/solaris/" 1667 "service/pools/Value;Ljava/lang/Object;)I")) == NULL) 1668 return (PO_FAIL); 1669 return ((*pc->pc_env)->CallIntMethod(pc->pc_env, 1670 pc->pc_handler, mgetwalk, pc->pc_elem, valueObj, pc->pc_user)); 1671 } 1672 1673 /*ARGSUSED*/ 1674 JNIEXPORT jlong JNICALL 1675 Java_com_sun_solaris_service_pools_Value_getLongValue(JNIEnv *jenv, 1676 jclass class, jlong pointer) 1677 { 1678 int64_t arg2; 1679 int result; 1680 1681 result = 1682 pool_value_get_int64((pool_value_t *)(uintptr_t)pointer, &arg2); 1683 1684 if (result != PO_SUCCESS) { /* it could be a uint64 */ 1685 result = 1686 pool_value_get_uint64((pool_value_t *)(uintptr_t)pointer, 1687 (uint64_t *)&arg2); 1688 if (result != PO_SUCCESS) { 1689 throw_pe(jenv); 1690 } 1691 /* 1692 * Unfortunately, Java has no unsigned types, so we lose some 1693 * precision by forcing the top bit clear 1694 */ 1695 arg2 &= 0x7fffffffffffffffULL; 1696 } 1697 return ((jlong)arg2); 1698 } 1699 1700 /*ARGSUSED*/ 1701 JNIEXPORT jstring JNICALL 1702 Java_com_sun_solaris_service_pools_Value_getStringValue(JNIEnv *jenv, 1703 jclass class, jlong pointer) 1704 { 1705 const char *arg2; 1706 int result; 1707 1708 result = 1709 pool_value_get_string((pool_value_t *)(uintptr_t)pointer, &arg2); 1710 if (result != PO_SUCCESS) 1711 throw_pe(jenv); 1712 return ((*jenv)->NewStringUTF(jenv, arg2)); 1713 } 1714 1715 /*ARGSUSED*/ 1716 JNIEXPORT jboolean JNICALL 1717 Java_com_sun_solaris_service_pools_Value_getBoolValue(JNIEnv *jenv, 1718 jclass class, jlong pointer) 1719 { 1720 uchar_t arg2; 1721 int result; 1722 1723 result = pool_value_get_bool((pool_value_t *)(uintptr_t)pointer, &arg2); 1724 1725 if (result != PO_SUCCESS) { 1726 throw_pe(jenv); 1727 } 1728 if (arg2 == PO_TRUE) 1729 return (JNI_TRUE); 1730 else 1731 return (JNI_FALSE); 1732 } 1733 1734 /*ARGSUSED*/ 1735 JNIEXPORT jdouble JNICALL 1736 Java_com_sun_solaris_service_pools_Value_getDoubleValue(JNIEnv *jenv, 1737 jclass class, jlong pointer) 1738 { 1739 double arg2; 1740 int result; 1741 1742 result = 1743 pool_value_get_double((pool_value_t *)(uintptr_t)pointer, &arg2); 1744 1745 if (result != PO_SUCCESS) { 1746 throw_pe(jenv); 1747 } 1748 return ((jdouble)arg2); 1749 } 1750 1751 /*ARGSUSED*/ 1752 JNIEXPORT jobject JNICALL 1753 Java_com_sun_solaris_service_pools_Value_getUnsignedInt64Value(JNIEnv *jenv, 1754 jclass class, jlong pointer) 1755 { 1756 uint64_t arg2; 1757 int result; 1758 1759 result = 1760 pool_value_get_uint64((pool_value_t *)(uintptr_t)pointer, &arg2); 1761 1762 if (result != PO_SUCCESS) { 1763 throw_pe(jenv); 1764 } 1765 return (makeUnsignedInt64(jenv, arg2)); 1766 } 1767 1768 /*ARGSUSED*/ 1769 JNIEXPORT jobject JNICALL 1770 Java_com_sun_solaris_service_pools_HRTime_timestamp(JNIEnv *env, jobject obj) 1771 { 1772 return (makeUnsignedInt64(env, gethrtime())); 1773 } 1774 1775 /* 1776 * Cache class, method, and field IDs. 1777 */ 1778 /*ARGSUSED*/ 1779 JNIEXPORT void JNICALL 1780 Java_com_sun_solaris_service_pools_PoolInternal_init(JNIEnv *env, jclass clazz) 1781 { 1782 jclass ui64class_lref; 1783 1784 if (!(ui64class_lref = (*env)->FindClass(env, 1785 "com/sun/solaris/service/pools/UnsignedInt64"))) 1786 return; /* exception thrown */ 1787 if (!(ui64class = (*env)->NewGlobalRef(env, ui64class_lref))) 1788 return; /* exception thrown */ 1789 ui64cons_mid = (*env)->GetMethodID(env, ui64class, "<init>", "([B)V"); 1790 } 1791