xref: /titanic_44/usr/src/cmd/pools/poold/libjpool/jpool.c (revision 56b2bdd1f04d465cfe4a95b88ae5cba5884154e4)
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