1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 /*
26  * Telco-alarm library, which communicates through libpcp to set/get
27  * alarms.
28  */
29 
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <sys/types.h>
33 #include <unistd.h>
34 #include <libpcp.h>
35 
36 #include "tsalarm.h"
37 
38 /* Message Types */
39 #define	TSALARM_CONTROL		15
40 #define	TSALARM_CONTROL_R	16
41 
42 #define	TSALARM_CHANNEL_TIMEOUT	20
43 #define	TSALARM_MAX_RETRIES	3
44 #define	TSALARM_SERVICE_NAME	"SUNW,sun4v-telco-alarm"
45 
46 int
47 tsalarm_get(uint32_t alarm_type, uint32_t *alarm_state)
48 {
49 	int		chnl_fd;
50 	tsalarm_req_t	*req_ptr = NULL;
51 	tsalarm_resp_t	*resp_ptr = NULL;
52 	pcp_msg_t	send_msg;
53 	pcp_msg_t	recv_msg;
54 	int		rc = TSALARM_SUCCESS;
55 	int		retries;
56 
57 	/* initialize virtual channel */
58 	for (retries = 1; retries <= TSALARM_MAX_RETRIES; retries++) {
59 		if ((chnl_fd = pcp_init(TSALARM_SERVICE_NAME)) < 0) {
60 			if (retries == TSALARM_MAX_RETRIES) {
61 				rc = TSALARM_CHANNEL_INIT_FAILURE;
62 				goto cleanup;
63 			}
64 			(void) sleep(TSALARM_CHANNEL_TIMEOUT);
65 		} else
66 			break;
67 	}
68 
69 	/* create request message data */
70 	req_ptr = malloc(sizeof (tsalarm_req_t));
71 	if (req_ptr == NULL) {
72 		rc = TSALARM_NULL_REQ_DATA;
73 		goto cleanup;
74 	}
75 	req_ptr->alarm_action = TSALARM_STATUS;
76 	req_ptr->alarm_id = alarm_type;
77 
78 	send_msg.msg_type = TSALARM_CONTROL;
79 	send_msg.sub_type = 0;
80 	send_msg.msg_len = sizeof (tsalarm_req_t);
81 	send_msg.msg_data = (uint8_t *)req_ptr;
82 
83 	/*
84 	 * Send the request and receive the response.
85 	 */
86 	if (pcp_send_recv(chnl_fd, &send_msg, &recv_msg,
87 	    TSALARM_CHANNEL_TIMEOUT) < 0) {
88 		/* we either timed out or erred; either way try again */
89 		(void) sleep(TSALARM_CHANNEL_TIMEOUT);
90 
91 		if (pcp_send_recv(chnl_fd, &send_msg, &recv_msg,
92 		    TSALARM_CHANNEL_TIMEOUT) < 0) {
93 			rc = TSALARM_COMM_FAILURE;
94 			goto cleanup;
95 		}
96 	}
97 
98 	/*
99 	 * verify that the Alarm action has taken place
100 	 */
101 	if ((resp_ptr = (tsalarm_resp_t *)recv_msg.msg_data) == NULL)
102 		goto cleanup;
103 
104 	/*
105 	 * validate that this data was meant for us
106 	 */
107 	if (recv_msg.msg_type != TSALARM_CONTROL_R) {
108 		rc = TSALARM_UNBOUND_PACKET_RECVD;
109 		goto cleanup;
110 	}
111 
112 	if (resp_ptr->status == TSALARM_ERROR) {
113 		rc = TSALARM_GET_ERROR;
114 		goto cleanup;
115 	}
116 
117 	if (resp_ptr->alarm_state == TSALARM_STATE_UNKNOWN) {
118 		rc = TSALARM_GET_ERROR;
119 		goto cleanup;
120 	}
121 
122 	*alarm_state = resp_ptr->alarm_state;
123 
124 cleanup:
125 	if (req_ptr != NULL)
126 		free(req_ptr);
127 
128 	/* free recv_msg.msg_data through pointer to make sure it is valid */
129 	if (resp_ptr != NULL)
130 		free(resp_ptr);
131 
132 	/* close virtual channel fd */
133 	(void) pcp_close(chnl_fd);
134 
135 	return (rc);
136 }
137 
138 int
139 tsalarm_set(uint32_t alarm_type, uint32_t alarm_state)
140 {
141 	int		chnl_fd;
142 	tsalarm_req_t   *req_ptr = NULL;
143 	tsalarm_resp_t  *resp_ptr = NULL;
144 	pcp_msg_t	send_msg;
145 	pcp_msg_t	recv_msg;
146 	int		rc = TSALARM_SUCCESS;
147 	int		retries;
148 
149 	/* initialize virtual channel */
150 	for (retries = 1; retries <= TSALARM_MAX_RETRIES; retries++) {
151 		if ((chnl_fd = pcp_init(TSALARM_SERVICE_NAME)) < 0) {
152 			if (retries == TSALARM_MAX_RETRIES) {
153 				rc = TSALARM_CHANNEL_INIT_FAILURE;
154 				goto cleanup;
155 			}
156 			(void) sleep(TSALARM_CHANNEL_TIMEOUT);
157 		} else
158 			break;
159 	}
160 
161 	/* create request message data */
162 	req_ptr = malloc(sizeof (tsalarm_req_t));
163 	if (req_ptr == NULL) {
164 		rc = TSALARM_NULL_REQ_DATA;
165 		goto cleanup;
166 	}
167 	req_ptr->alarm_id = alarm_type;
168 	if (alarm_state == TSALARM_STATE_ON)
169 		req_ptr->alarm_action = TSALARM_ENABLE;
170 	else if (alarm_state == TSALARM_STATE_OFF)
171 		req_ptr->alarm_action = TSALARM_DISABLE;
172 
173 	send_msg.msg_type = TSALARM_CONTROL;
174 	send_msg.sub_type = 0;
175 	send_msg.msg_len = sizeof (tsalarm_req_t);
176 	send_msg.msg_data = (uint8_t *)req_ptr;
177 
178 	/*
179 	 * Send the request and receive the response.
180 	 */
181 	if (pcp_send_recv(chnl_fd, &send_msg, &recv_msg,
182 	    TSALARM_CHANNEL_TIMEOUT) < 0) {
183 		/* we either timed out or erred; either way try again */
184 		(void) sleep(TSALARM_CHANNEL_TIMEOUT);
185 
186 		if (pcp_send_recv(chnl_fd, &send_msg, &recv_msg,
187 		    TSALARM_CHANNEL_TIMEOUT) < 0) {
188 			rc = TSALARM_COMM_FAILURE;
189 			goto cleanup;
190 		}
191 	}
192 
193 	/*
194 	 * verify that the Alarm action has taken place
195 	 */
196 	if ((resp_ptr = (tsalarm_resp_t *)recv_msg.msg_data) == NULL)
197 		goto cleanup;
198 
199 	/*
200 	 * validate that this data was meant for us
201 	 */
202 	if (recv_msg.msg_type != TSALARM_CONTROL_R) {
203 		rc = TSALARM_UNBOUND_PACKET_RECVD;
204 		goto cleanup;
205 	}
206 
207 	if (resp_ptr->status == TSALARM_ERROR) {
208 		rc = TSALARM_SET_ERROR;
209 		goto cleanup;
210 	}
211 
212 	/*
213 	 * ensure the Alarm action taken is the one requested
214 	 */
215 	if ((req_ptr->alarm_action == TSALARM_DISABLE) &&
216 	    (resp_ptr->alarm_state != TSALARM_STATE_OFF)) {
217 		rc = TSALARM_SET_ERROR;
218 		goto cleanup;
219 	} else if ((req_ptr->alarm_action == TSALARM_ENABLE) &&
220 	    (resp_ptr->alarm_state != TSALARM_STATE_ON)) {
221 		rc = TSALARM_SET_ERROR;
222 		goto cleanup;
223 	} else if (resp_ptr->alarm_state == TSALARM_STATE_UNKNOWN) {
224 		rc = TSALARM_SET_ERROR;
225 		goto cleanup;
226 	}
227 
228 cleanup:
229 	if (req_ptr != NULL)
230 		free(req_ptr);
231 
232 	/* free recv_msg.msg_data through pointer to make sure it is valid */
233 	if (resp_ptr != NULL)
234 		free(resp_ptr);
235 
236 	/* close virtual channel fd */
237 	(void) pcp_close(chnl_fd);
238 
239 	return (rc);
240 }
241