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 #include <unistd.h>
30 #include <picl.h>
31 #include <picltree.h>
32 #include <picldefs.h>
33 #include <pthread.h>
34 #include <syslog.h>
35 #include <string.h>
36 #include <libnvpair.h>
37 #include <libintl.h>
38 #include "piclenvmond.h"
39
40 /* external funcs and varaibles */
41 extern void env_handle_event(const char *, const void *, size_t);
42 extern picl_errno_t env_init();
43 extern void env_platmod_fini();
44 extern int sensor_fd;
45 extern pthread_t env_temp_thr_tid;
46
47 /* local defines */
48 #define TIMEOUT (10)
49
50 #pragma init(piclenvmond_register)
51
52 /*
53 * Plugin registration entry points
54 */
55 static void piclenvmond_register(void);
56 static void piclenvmond_init(void);
57 static void piclenvmond_fini(void);
58 static void piclenvmond_evhandler(const char *, const void *, size_t, void *);
59
60 int env_debug = 0x0;
61
62 static picld_plugin_reg_t envmond_reg_info = {
63 PICLD_PLUGIN_VERSION_1,
64 PICLD_PLUGIN_CRITICAL,
65 "SUNW_piclenvmond",
66 piclenvmond_init,
67 piclenvmond_fini
68 };
69
70 typedef struct {
71 picl_nodehdl_t nodehdl;
72 char node_name[PICL_PROPNAMELEN_MAX];
73 } env_callback_args_t;
74
75 /*
76 * picld entry points
77 */
78 static void
79 piclenvmond_register(void)
80 {
81 (void) picld_plugin_register(&envmond_reg_info);
82 }
83
84 /*
85 * picld entry point
86 * - do all the initialization
87 * - register for interested picl events
88 */
89 static void
90 piclenvmond_init(void)
91 {
92 picl_errno_t rc = PICL_SUCCESS;
93
94 if ((rc = env_init()) != PICL_SUCCESS) {
95 syslog(LOG_ERR, gettext("SUNW_envmond:envmond init failed, "
96 "error = %d"), rc);
97 return;
98 }
99
100 /* register handler for state change events */
101 (void) ptree_register_handler(PICLEVENT_STATE_CHANGE,
102 piclenvmond_evhandler, NULL);
103 /* register handler for condition change events */
104 (void) ptree_register_handler(PICLEVENT_CONDITION_CHANGE,
105 piclenvmond_evhandler, NULL);
106
107 }
108
109 static void
110 piclenvmond_fini(void)
111 {
112 void *exitval;
113
114 /* unregister event handler */
115 (void) ptree_unregister_handler(PICLEVENT_STATE_CHANGE,
116 piclenvmond_evhandler, NULL);
117 (void) ptree_unregister_handler(PICLEVENT_CONDITION_CHANGE,
118 piclenvmond_evhandler, NULL);
119
120 /* cancel all the threads */
121 (void) pthread_cancel(env_temp_thr_tid);
122 (void) pthread_join(env_temp_thr_tid, &exitval);
123
124 /* do any platform specific cleanups required */
125 env_platmod_fini();
126 (void) close(sensor_fd);
127 }
128
129 /*ARGSUSED*/
130 static void
131 piclenvmond_evhandler(const char *ename, const void *earg, size_t size,
132 void *cookie)
133 {
134 env_handle_event(ename, earg, size);
135 }
136
137 /*
138 * Utility functions
139 */
140
141 /*
142 * create_property -- Create a PICL property
143 */
144 picl_errno_t
145 env_create_property(int ptype, int pmode, size_t psize, char *pname,
146 int (*readfn)(ptree_rarg_t *, void *),
147 int (*writefn)(ptree_warg_t *, const void *),
148 picl_nodehdl_t nodeh, picl_prophdl_t *propp, void *vbuf)
149 {
150 picl_errno_t rc; /* return code */
151 ptree_propinfo_t propinfo; /* propinfo structure */
152 picl_prophdl_t proph;
153
154 rc = ptree_get_prop_by_name(nodeh, pname, &proph);
155 if (rc == PICL_SUCCESS) { /* prop. already exists */
156 return (rc);
157 }
158
159 rc = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
160 ptype, pmode, psize, pname, readfn, writefn);
161 if (rc != PICL_SUCCESS) {
162 syslog(LOG_ERR, PTREE_INIT_PROPINFO_FAILED_MSG, rc);
163 return (rc);
164 }
165
166 rc = ptree_create_and_add_prop(nodeh, &propinfo, vbuf, propp);
167 if (rc != PICL_SUCCESS) {
168 syslog(LOG_ERR, PTREE_CREATE_AND_ADD_PROP_FAILED_MSG, rc);
169 return (rc);
170 }
171 return (PICL_SUCCESS);
172 }
173
174 /*
175 * The picl event completion handler.
176 */
177 /* ARGSUSED */
178 static void
179 event_completion_handler(char *ename, void *earg, size_t size)
180 {
181 free(earg);
182 free(ename);
183 }
184
185 /*
186 * utility routine to post PICL events
187 */
188 /*ARGSUSED*/
189 static int
190 post_picl_event(const char *ename, char *envl, size_t elen,
191 picl_nodehdl_t nodeh, int cond_wait)
192 {
193 nvlist_t *nvlp;
194 size_t nvl_size;
195 char *pack_buf = NULL;
196 char *evname;
197
198 if (nodeh == 0) {
199 return (PICL_FAILURE);
200 }
201 if ((evname = strdup(ename)) == NULL)
202 return (PICL_FAILURE);
203 if (envl) {
204 if (nvlist_unpack(envl, elen, &nvlp, 0) < 0) {
205 nvlist_free(nvlp);
206 free(evname);
207 return (PICL_FAILURE);
208 }
209 } else {
210 if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME_TYPE, NULL)) {
211 free(evname);
212 return (PICL_FAILURE);
213 }
214 }
215
216 if (nvlist_add_uint64(nvlp, PICLEVENTARG_NODEHANDLE, nodeh) == -1) {
217 nvlist_free(nvlp);
218 free(evname);
219 return (PICL_FAILURE);
220 }
221
222 if (nvlist_pack(nvlp, &pack_buf, &nvl_size, NV_ENCODE_NATIVE, NULL)) {
223 nvlist_free(nvlp);
224 free(evname);
225 return (PICL_FAILURE);
226 }
227 nvlist_free(nvlp);
228
229 if (env_debug & EVENTS) {
230 char enodename[PICL_PROPNAMELEN_MAX];
231 if (ptree_get_propval_by_name(nodeh, PICL_PROP_NAME,
232 enodename, sizeof (enodename)) == PICL_SUCCESS)
233 syslog(LOG_INFO, "envmond:Posting %s on %s\n",
234 ename, enodename);
235 }
236
237 if (ptree_post_event(evname, pack_buf, nvl_size,
238 event_completion_handler) != 0) {
239 syslog(LOG_ERR, gettext("SUNW_envmond: Error posting %s PICL"
240 " event."), ename);
241 free(pack_buf);
242 free(evname);
243 return (PICL_FAILURE);
244 }
245 return (PICL_SUCCESS);
246 }
247
248 /*
249 * post dr_req events
250 */
251 picl_errno_t
252 post_dr_req_event(picl_nodehdl_t fruh, char *dr_req_type, uint8_t wait)
253 {
254 nvlist_t *nvlp; /* nvlist of event specific args */
255 size_t nvl_size;
256 char *pack_buf = NULL;
257 char dr_ap_id[PICL_PROPNAMELEN_MAX];
258 int rc = PICL_SUCCESS;
259
260 if (env_debug & DEBUG)
261 syslog(LOG_DEBUG, "Post %s on %llx", dr_req_type, fruh);
262 if (fruh == 0) {
263 return (PICL_INVALIDARG);
264 }
265 if ((rc = ptree_get_propval_by_name(fruh, PICL_PROP_NAME,
266 dr_ap_id, sizeof (dr_ap_id))) != PICL_SUCCESS) {
267 return (rc);
268 }
269
270 if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME_TYPE, NULL)) {
271 return (PICL_FAILURE);
272 }
273
274 if (nvlist_add_string(nvlp, PICLEVENTARG_AP_ID, dr_ap_id) == -1) {
275 nvlist_free(nvlp);
276 return (PICL_FAILURE);
277 }
278 if (nvlist_add_string(nvlp, PICLEVENTARG_DR_REQ_TYPE, dr_req_type)
279 == -1) {
280 nvlist_free(nvlp);
281 return (PICL_FAILURE);
282 }
283 if (nvlist_pack(nvlp, &pack_buf, &nvl_size, NV_ENCODE_NATIVE, NULL)) {
284 nvlist_free(nvlp);
285 return (PICL_FAILURE);
286 }
287 nvlist_free(nvlp);
288
289 if (env_debug & DEBUG)
290 syslog(LOG_DEBUG, "Posting %s on %s", dr_req_type, dr_ap_id);
291 rc = post_picl_event(PICLEVENT_DR_REQ, pack_buf, nvl_size, fruh,
292 wait);
293
294 free(pack_buf);
295 return (rc);
296 }
297
298 /*
299 * routine to post dr_ap_state change events
300 */
301 picl_errno_t
302 post_dr_ap_state_change_event(picl_nodehdl_t nodehdl, char *dr_hint,
303 uint8_t wait)
304 {
305 nvlist_t *nvlp; /* nvlist of event specific args */
306 size_t nvl_size;
307 char *pack_buf = NULL;
308 char dr_ap_id[PICL_PROPNAMELEN_MAX];
309 int rc = PICL_SUCCESS;
310
311 if (nodehdl == 0) {
312 return (PICL_FAILURE);
313 }
314 if ((rc = ptree_get_propval_by_name(nodehdl, PICL_PROP_NAME,
315 dr_ap_id, sizeof (dr_ap_id))) != PICL_SUCCESS) {
316 return (rc);
317 }
318 if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME_TYPE, NULL)) {
319 return (PICL_FAILURE);
320 }
321
322 if (nvlist_add_string(nvlp, PICLEVENTARG_AP_ID, dr_ap_id) == -1) {
323 nvlist_free(nvlp);
324 return (PICL_FAILURE);
325 }
326 if (nvlist_add_string(nvlp, PICLEVENTARG_HINT, dr_hint) == -1) {
327 nvlist_free(nvlp);
328 return (PICL_FAILURE);
329 }
330 if (nvlist_pack(nvlp, &pack_buf, &nvl_size, NV_ENCODE_NATIVE, NULL)) {
331 nvlist_free(nvlp);
332 return (PICL_FAILURE);
333 }
334 nvlist_free(nvlp);
335 rc = post_picl_event(PICLEVENT_DR_AP_STATE_CHANGE, pack_buf,
336 nvl_size, nodehdl, wait);
337 free(pack_buf);
338 return (rc);
339 }
340
341 picl_errno_t
342 post_cpu_state_change_event(picl_nodehdl_t fruh, char *event_type, uint8_t wait)
343 {
344 nvlist_t *nvlp; /* nvlist of event specific args */
345 size_t nvl_size;
346 char *pack_buf = NULL;
347 int rc = PICL_SUCCESS;
348
349 if (fruh == 0) {
350 return (PICL_FAILURE);
351 }
352
353 if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME_TYPE, NULL))
354 return (PICL_FAILURE);
355
356 if (nvlist_add_int64(nvlp, PICLEVENTARG_NODEHANDLE, fruh)) {
357 nvlist_free(nvlp);
358 return (PICL_FAILURE);
359 }
360
361 if (nvlist_add_string(nvlp, PICLEVENTARG_CPU_EV_TYPE,
362 event_type) == -1) {
363 nvlist_free(nvlp);
364 return (PICL_FAILURE);
365 }
366
367 if (nvlist_pack(nvlp, &pack_buf, &nvl_size, NV_ENCODE_NATIVE, NULL)) {
368 nvlist_free(nvlp);
369 return (PICL_FAILURE);
370 }
371 nvlist_free(nvlp);
372 rc = post_picl_event(PICLEVENT_CPU_STATE_CHANGE, pack_buf,
373 nvl_size, fruh, wait);
374 free(pack_buf);
375 return (rc);
376 }
377
378 int
379 post_sensor_event(picl_nodehdl_t hdl, char *sensor_evalue, uint8_t wait)
380 {
381 nvlist_t *nvlp; /* nvlist of event specific args */
382 size_t nvl_size;
383 char *pack_buf = NULL;
384 char dr_ap_id[PICL_PROPNAMELEN_MAX];
385 int rc = PICL_SUCCESS;
386
387 if (env_debug & DEBUG)
388 syslog(LOG_DEBUG, "Post %s on %llx", sensor_evalue, hdl);
389 if (hdl == 0)
390 return (PICL_FAILURE);
391
392 if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME_TYPE, NULL))
393 return (PICL_FAILURE);
394
395 if (nvlist_add_string(nvlp, PICLEVENTARG_CONDITION,
396 sensor_evalue) == -1) {
397 nvlist_free(nvlp);
398 return (PICL_FAILURE);
399 }
400 if (nvlist_pack(nvlp, &pack_buf, &nvl_size, NV_ENCODE_NATIVE, NULL)) {
401 nvlist_free(nvlp);
402 return (PICL_FAILURE);
403 }
404 nvlist_free(nvlp);
405
406 if (env_debug & DEBUG) {
407 if (ptree_get_propval_by_name(hdl, PICL_PROP_NAME, dr_ap_id,
408 sizeof (dr_ap_id)) == PICL_SUCCESS)
409 syslog(LOG_DEBUG, "Posting %s on %s", sensor_evalue,
410 dr_ap_id);
411 }
412 rc = post_picl_event(PICLEVENT_CONDITION_CHANGE, pack_buf, nvl_size,
413 hdl, wait);
414 free(pack_buf);
415 return (rc);
416 }
417
418 /*
419 * return B_TRUE if admin lock is enabled
420 * return B_FALSE if admin lock is disabled
421 */
422 boolean_t
423 env_admin_lock_enabled(picl_nodehdl_t fruh)
424 {
425 char adminlock[PICL_PROPNAMELEN_MAX];
426
427 if (ptree_get_propval_by_name(fruh, PICL_PROP_ADMIN_LOCK,
428 adminlock, sizeof (adminlock))
429 != PICL_SUCCESS) {
430 return (B_FALSE);
431 }
432 if (strcmp(adminlock, PICL_ADMINLOCK_ENABLED) == 0) {
433 return (B_TRUE);
434 }
435 return (B_FALSE);
436 }