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 2004 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
30 #include <stdlib.h>
31 #include <sys/lgrp_user.h>
32
33 #include "jlgrp.h"
34
35 static lgrp_cookie_t getCookie(JNIEnv *, jclass, jobject);
36 static void throwException(JNIEnv *, const char *, const char *);
37
38 /*
39 * Return the output of the getCookie() method executed on the
40 * supplied instance.
41 */
42 lgrp_cookie_t
getCookie(JNIEnv * env,jclass clazz,jobject obj)43 getCookie(JNIEnv *env, jclass clazz, jobject obj)
44 {
45 jfieldID fid;
46
47 fid = (*env)->GetFieldID(env, clazz, "cookie", "J");
48 return ((lgrp_cookie_t)(*env)->GetLongField(env, obj, fid));
49 }
50
51 /*
52 * Throw an exception of the specified class with the specified message.
53 */
54 void
throwException(JNIEnv * env,const char * class,const char * msg)55 throwException(JNIEnv *env, const char *class, const char *msg)
56 {
57 jclass clazz;
58
59 clazz = (*env)->FindClass(env, class);
60
61 (*env)->ThrowNew(env, clazz, msg);
62 }
63
64 /*
65 * Obtain an lgrp cookie for an lgrp snapshot which contains details
66 * about available resources that the operating system knows about.
67 *
68 * If the call fails, then throw an exception which indicates that the
69 * snapshot could not be obtained.
70 */
71 /*ARGSUSED1*/
72 JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_locality_LocalityDomain_jl_1init(JNIEnv * env,jobject obj,jint view)73 Java_com_sun_solaris_service_locality_LocalityDomain_jl_1init(JNIEnv *env,
74 jobject obj, jint view)
75 {
76 lgrp_cookie_t cookie;
77
78 if ((cookie = lgrp_init(view)) == LGRP_COOKIE_NONE) {
79 throwException(env, "java/lang/Exception",
80 "Could not obtain latency group cookie");
81 }
82
83 return ((jlong)cookie);
84 }
85
86 /*
87 * Release the snapshot in use by this instance. It is assumed that
88 * the cookie is held in the "cookie" field of the invoking instance
89 */
90 JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_locality_LocalityDomain_jl_1fini(JNIEnv * env,jobject obj)91 Java_com_sun_solaris_service_locality_LocalityDomain_jl_1fini(JNIEnv *env,
92 jobject obj)
93 {
94 jclass clazz;
95
96 clazz = (*env)->GetObjectClass(env, obj);
97 return ((jint)lgrp_fini(getCookie(env, clazz, obj)));
98 }
99
100 /*
101 * Create a new LocalityGroup object which acts as a proxy for the
102 * root LocalityGroup.
103 */
104 JNIEXPORT jobject JNICALL
Java_com_sun_solaris_service_locality_LocalityDomain_jl_1root(JNIEnv * env,jobject obj)105 Java_com_sun_solaris_service_locality_LocalityDomain_jl_1root(JNIEnv *env,
106 jobject obj)
107 {
108 jclass clazz;
109 jmethodID mid;
110 jlong root;
111 jobject lgrp;
112
113 clazz = (*env)->GetObjectClass(env, obj);
114
115 root = (jlong) lgrp_root(getCookie(env, clazz, obj));
116
117 clazz = (*env)->FindClass(env, "com/sun/solaris/service/locality/"
118 "LocalityGroup");
119 mid = (*env)->GetMethodID(env, clazz, "<init>", "(Lcom/sun/solaris/"
120 "service/locality/LocalityDomain;JLcom/sun/solaris/service/"
121 "locality/LocalityGroup;)V");
122 lgrp = (*env)->NewObject(env, clazz, mid, obj, root, NULL);
123 return (lgrp);
124 }
125
126 /*
127 * Return a new array containing all of the child LocalityGroup ids
128 * for the supplied instance.
129 */
130 JNIEXPORT jlongArray JNICALL
Java_com_sun_solaris_service_locality_LocalityGroup_jl_1children(JNIEnv * env,jobject obj)131 Java_com_sun_solaris_service_locality_LocalityGroup_jl_1children(JNIEnv *env,
132 jobject obj)
133 {
134 jclass clazz;
135 jfieldID fid;
136 lgrp_cookie_t cookie;
137 jlong id;
138 jsize nchild0, nchild;
139 jlongArray children;
140 int i;
141 lgrp_id_t *native_child;
142 jlong *java_child;
143 jobject domain;
144
145 clazz = (*env)->GetObjectClass(env, obj);
146 fid = (*env)->GetFieldID(env, clazz, "domain",
147 "Lcom/sun/solaris/service/locality/LocalityDomain;");
148 domain = (*env)->GetObjectField(env, obj, fid);
149
150 cookie = getCookie(env, (*env)->GetObjectClass(env, domain), domain);
151 fid = (*env)->GetFieldID(env, clazz, "id", "J");
152 id = (*env)->GetLongField(env, obj, fid);
153 retry:
154 nchild0 = (jsize)lgrp_children(cookie, (lgrp_id_t)id, NULL, 0);
155 children = (*env)->NewLongArray(env, nchild0);
156 if ((native_child = calloc(nchild0, sizeof (lgrp_id_t))) == NULL) {
157 throwException(env, "java/lang/Exception",
158 "Could not allocate memory for native_child array");
159 return (NULL);
160 }
161 nchild = lgrp_children(cookie, (lgrp_id_t)id, native_child, nchild0);
162 if (nchild != nchild0) {
163 free(native_child);
164 goto retry;
165 }
166
167 if ((java_child = calloc(nchild, sizeof (jlong))) == NULL) {
168 throwException(env, "java/lang/Exception",
169 "Could not allocate memory for java_child array");
170 free(native_child);
171 return (NULL);
172 }
173
174 for (i = 0; i < nchild; i++)
175 java_child[i] = (jlong) native_child[i];
176 (*env)->SetLongArrayRegion(env, children, 0, nchild, java_child);
177 free(native_child);
178 free(java_child);
179 return (children);
180 }
181
182 /*
183 * Return a new array containing all of the cpus contained directly
184 * within the LocalityGroup identified by the supplied instance.
185 */
186 JNIEXPORT jintArray JNICALL
Java_com_sun_solaris_service_locality_LocalityGroup_jl_1cpus(JNIEnv * env,jobject obj)187 Java_com_sun_solaris_service_locality_LocalityGroup_jl_1cpus(JNIEnv *env,
188 jobject obj)
189 {
190 jclass clazz;
191 jfieldID fid;
192 lgrp_cookie_t cookie;
193 jlong id;
194 jsize ncpus0, ncpus;
195 jintArray cpus;
196 int i;
197 processorid_t *native_cpus;
198 jint *java_cpus;
199 jobject domain;
200
201 clazz = (*env)->GetObjectClass(env, obj);
202 fid = (*env)->GetFieldID(env, clazz, "domain",
203 "Lcom/sun/solaris/service/locality/LocalityDomain;");
204 domain = (*env)->GetObjectField(env, obj, fid);
205
206 cookie = getCookie(env, (*env)->GetObjectClass(env, domain), domain);
207
208 fid = (*env)->GetFieldID(env, clazz, "id", "J");
209 id = (*env)->GetLongField(env, obj, fid);
210 retry:
211 ncpus0 = (jsize)lgrp_cpus((lgrp_cookie_t)cookie, (lgrp_id_t)id,
212 NULL, 0, LGRP_CONTENT_DIRECT);
213 cpus = (*env)->NewIntArray(env, ncpus0);
214 if ((native_cpus = calloc(ncpus0, sizeof (processorid_t))) == NULL) {
215 throwException(env, "java/lang/Exception",
216 "Could not allocate memory for native_cpus array");
217 return (NULL);
218 }
219 ncpus = (jsize)lgrp_cpus((lgrp_cookie_t)cookie, (lgrp_id_t)id,
220 native_cpus, ncpus0, LGRP_CONTENT_DIRECT);
221 if (ncpus != ncpus0) {
222 free(native_cpus);
223 goto retry;
224 }
225
226 if ((java_cpus = calloc(ncpus, sizeof (jint))) == NULL) {
227 free(native_cpus);
228 throwException(env, "java/lang/Exception",
229 "Could not allocate memory for java_cpus array");
230 return (NULL);
231 }
232
233 for (i = 0; i < ncpus; i++)
234 java_cpus[i] = (jint)native_cpus[i];
235 (*env)->SetIntArrayRegion(env, cpus, 0, ncpus, java_cpus);
236 free(native_cpus);
237 free(java_cpus);
238 return (cpus);
239 }
240
241 /*
242 * Return the latency between two supplied latency group IDs.
243 */
244 /*ARGSUSED*/
245 JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_locality_LocalityGroup_jl_1latency(JNIEnv * env,jobject obj,jlong from,jlong to)246 Java_com_sun_solaris_service_locality_LocalityGroup_jl_1latency(JNIEnv *env,
247 jobject obj, jlong from, jlong to)
248 {
249 return ((jint) lgrp_latency((lgrp_id_t)from, (lgrp_id_t)to));
250 }
251