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 /*
28 * Implementation to get PORT nodes state and condition information
29 */
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <ctype.h>
33 #include <strings.h>
34 #include <fcntl.h>
35 #include <unistd.h>
36 #include <stropts.h>
37 #include <locale.h>
38 #include <syslog.h>
39 #include <sys/types.h>
40 #include <sys/termios.h>
41 #include <sys/stat.h>
42 #include <fcntl.h>
43 #include <kstat.h>
44 #include <signal.h>
45 #include <assert.h>
46 #include <config_admin.h>
47
48 #include <picl.h>
49 #include "piclfrutree.h"
50
51 #define LINK_UP "link_up"
52 #define DUPLEX "duplex"
53 #define IF_SPEED "ifspeed"
54 #define IERRORS "ierrors"
55 #define IPACKETS "ipackets"
56 #define OERRORS "oerrors"
57 #define OPACKETS "opackets"
58 #define NOCANPUT "nocanput"
59 #define RUNT_ERRORS "runt_errors"
60 #define COLLISIONS "collisions"
61
62 typedef int (*funcp)(kstat_ctl_t *, char *, int);
63
64 static kstat_named_t *kstat_name_lookup(kstat_ctl_t *, char *, int, char *);
65 static int kstat_network_port_state(kstat_ctl_t *kc, char *, int);
66 static int kstat_network_port_cond(kstat_ctl_t *kc, char *, int);
67 static int serial_port_state(kstat_ctl_t *, char *, int);
68 static int serial_port_cond(kstat_ctl_t *kc, char *, int);
69 static int parallel_port_state(kstat_ctl_t *, char *, int);
70 static int parallel_port_cond(kstat_ctl_t *kc, char *, int);
71 static void sig_alarm_handler(int);
72
73 static funcp port_state[] = {
74 kstat_network_port_state,
75 serial_port_state,
76 parallel_port_state
77 };
78
79 static funcp port_cond[] = {
80 kstat_network_port_cond,
81 serial_port_cond,
82 parallel_port_cond
83 };
84
85 /*
86 * kstat_port_state: returns ethernet, or serial, or parallel port status
87 * 1 = up, 0 = down, anything else = unknown
88 */
89 int
90 kstat_port_state(frutree_port_type_t port_type, char *driver_name,
91 int driver_instance)
92 {
93 int rc = -1;
94 kstat_ctl_t *kc = NULL;
95
96 switch (port_type) {
97 case NETWORK_PORT:
98 case SERIAL_PORT:
99 case PARALLEL_PORT:
100 if ((kc = kstat_open()) == NULL) {
101 return (-1);
102 }
103 rc = port_state[port_type](kc, driver_name, driver_instance);
104 kstat_close(kc);
105 return (rc);
106 default:
107 return (-1);
108 }
109 }
110
111 /*
112 * kstat_port_cond: returns ethernet, or serial, or parallel port condition
113 */
114 int
115 kstat_port_cond(frutree_port_type_t port_type, char *driver_name,
116 int driver_instance)
117 {
118 int rc = -1;
119 kstat_ctl_t *kc = NULL;
120 switch (port_type) {
121 case NETWORK_PORT:
122 case SERIAL_PORT:
123 case PARALLEL_PORT:
124 if ((kc = kstat_open()) == NULL) {
125 return (-1);
126 }
127 rc = port_cond[port_type](kc, driver_name, driver_instance);
128 kstat_close(kc);
129 return (rc);
130 default:
131 return (-1);
132 }
133 }
134
135 static kstat_named_t *
136 kstat_name_lookup(kstat_ctl_t *kc, char *ks_module, int ks_instance, char *name)
137 {
138 kstat_t *ksp;
139
140 assert(kc);
141 assert(ks_module);
142 assert(name);
143
144 for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
145 if (strcmp(ksp->ks_module, ks_module) == 0 &&
146 ksp->ks_instance == ks_instance &&
147 ksp->ks_type == KSTAT_TYPE_NAMED &&
148 kstat_read(kc, ksp, NULL) != -1 &&
149 kstat_data_lookup(ksp, name)) {
150
151 ksp = kstat_lookup(kc, ks_module, ks_instance,
152 ksp->ks_name);
153 if (!ksp)
154 return (NULL);
155 if (kstat_read(kc, ksp, NULL) == -1)
156 return (NULL);
157 return ((kstat_named_t *)kstat_data_lookup(ksp, name));
158 }
159 }
160 return (NULL);
161 }
162
163 /*
164 * kstat_network_port_state: returns kstat info of a network port
165 * 1 = up, 0 = down, anything else = unknown
166 */
167 static int
168 kstat_network_port_state(kstat_ctl_t *kc, char *ks_module, int ks_instance)
169 {
170 kstat_named_t *port_datap = NULL;
171
172 if ((port_datap = kstat_name_lookup(kc, ks_module, ks_instance,
173 LINK_UP)) == NULL) {
174 return (-1);
175 }
176 if (port_datap == NULL) {
177 return (-1);
178 }
179 if (port_datap->data_type == KSTAT_DATA_UINT32) {
180 if (port_datap->value.ui32 == 1) {
181 return (1);
182 } else if (port_datap->value.ui32 == 0) {
183 return (0);
184 } else {
185 return (-1);
186 }
187 } else {
188 if (port_datap->value.ui64 == 1) {
189 return (1);
190 } else if (port_datap->value.ui64 == 0) {
191 return (0);
192 } else {
193 return (-1);
194 }
195 }
196 }
197
198 /*
199 * kstat_network_port_cond: returns kstat info of a network port
200 * 0 = OK, 1 = FAILING, 2 = FAILED, 3 = TESTING, -1 = unknown
201 */
202 static int
203 kstat_network_port_cond(kstat_ctl_t *kc, char *ks_module, int ks_instance)
204 {
205 kstat_named_t *port_datap = NULL;
206 uint64_t collisions, runt, link_up, link_duplex;
207 uint64_t ifspeed, ierrors, ipackets, oerrors, opackets;
208
209 if ((port_datap = kstat_name_lookup(kc, ks_module, ks_instance,
210 LINK_UP)) == NULL) {
211 return (-1);
212 }
213
214 if (port_datap->data_type == KSTAT_DATA_UINT32) {
215 link_up = port_datap->value.ui32;
216 } else {
217 link_up = port_datap->value.ui64;
218 }
219 if (link_up == 0) {
220 return (2);
221 }
222
223 if ((port_datap = kstat_name_lookup(kc, ks_module, ks_instance,
224 DUPLEX)) == NULL) {
225 return (-1);
226 }
227
228 if (port_datap->data_type == KSTAT_DATA_UINT32) {
229 link_duplex = port_datap->value.ui32;
230 } else {
231 link_duplex = port_datap->value.ui64;
232 }
233 if (link_duplex == 0) {
234 return (2);
235 }
236
237 if ((port_datap = kstat_name_lookup(kc, ks_module, ks_instance,
238 IF_SPEED)) == NULL) {
239 return (-1);
240 }
241 if (port_datap->data_type == KSTAT_DATA_UINT32) {
242 ifspeed = port_datap->value.ui32;
243 } else {
244 ifspeed = port_datap->value.ui64;
245 }
246 if (ifspeed == 0) {
247 return (2);
248 }
249
250 /* check for FAILING conditions */
251 if ((port_datap = kstat_name_lookup(kc, ks_module, ks_instance,
252 IERRORS)) == NULL) {
253 return (-1);
254 }
255 if (port_datap->data_type == KSTAT_DATA_UINT32) {
256 ierrors = port_datap->value.ui32;
257 } else {
258 ierrors = port_datap->value.ui64;
259 }
260
261 if ((port_datap = kstat_name_lookup(kc, ks_module, ks_instance,
262 IPACKETS)) == NULL) {
263 return (-1);
264 }
265
266 if (port_datap->data_type == KSTAT_DATA_UINT32) {
267 ipackets = port_datap->value.ui32;
268 } else {
269 ipackets = port_datap->value.ui64;
270 }
271 if (ierrors > ipackets/10) {
272 return (1);
273 }
274
275 if ((port_datap = kstat_name_lookup(kc, ks_module, ks_instance,
276 OERRORS)) == NULL) {
277 return (-1);
278 }
279 if (port_datap->data_type == KSTAT_DATA_UINT32) {
280 oerrors = port_datap->value.ui32;
281 } else {
282 oerrors = port_datap->value.ui64;
283 }
284
285 if ((port_datap = kstat_name_lookup(kc, ks_module, ks_instance,
286 OPACKETS)) == NULL) {
287 return (-1);
288 }
289 if (port_datap->data_type == KSTAT_DATA_UINT32) {
290 opackets = port_datap->value.ui32;
291 } else {
292 opackets = port_datap->value.ui64;
293 }
294 if (oerrors > opackets/10) {
295 return (1);
296 }
297
298 if ((port_datap = kstat_name_lookup(kc, ks_module, ks_instance,
299 RUNT_ERRORS)) == NULL) {
300 return (-1);
301 }
302 if (port_datap->data_type == KSTAT_DATA_UINT32) {
303 runt = port_datap->value.ui32;
304 } else {
305 runt = port_datap->value.ui64;
306 }
307 if (runt > ipackets/10) {
308 return (1);
309 }
310
311 if ((port_datap = kstat_name_lookup(kc, ks_module, ks_instance,
312 COLLISIONS)) == NULL) {
313 return (-1);
314 }
315 if (port_datap->data_type == KSTAT_DATA_UINT32) {
316 collisions = port_datap->value.ui32;
317 } else {
318 collisions = port_datap->value.ui64;
319 }
320 if (collisions > (opackets+ipackets)/30) {
321 return (1);
322 }
323 return (0);
324 }
325
326 /*
327 * serial_port_state: returns status a serial port
328 * 1 = up, 0 = down, anything else = unknown
329 */
330
331 /* ARGSUSED */
332 static int
333 serial_port_state(kstat_ctl_t *kc, char *driver, int instance)
334 {
335 int fd;
336 char device[20];
337 struct termios flags;
338 struct sigaction old_sa, new_sa;
339
340 (void) memset(&old_sa, 0, sizeof (old_sa));
341 (void) memset(&new_sa, 0, sizeof (new_sa));
342 new_sa.sa_handler = sig_alarm_handler;
343 (void) sigaction(SIGALRM, &new_sa, &old_sa);
344 (void) alarm(1);
345
346 (void) snprintf(device, sizeof (device), "/dev/tty%c", instance+'a');
347 fd = open(device, O_RDONLY|O_NDELAY|O_NONBLOCK|O_NOCTTY);
348
349 /* Restore sig action flags */
350 (void) sigaction(SIGALRM, &old_sa, (struct sigaction *)0);
351 /* Disable alarm */
352 (void) alarm(0);
353
354 if (fd == -1) {
355 return (-1);
356 }
357
358 if (isatty(fd) == 0) {
359 (void) close(fd);
360 return (-1);
361 }
362 (void) memset(&flags, 0, sizeof (flags));
363 if (ioctl(fd, TCGETS, &flags) != 0) {
364 (void) close(fd);
365 return (-1);
366 }
367 (void) close(fd);
368 return ((flags.c_cflag & TIOCM_LE) ? 1 : 0);
369 }
370
371 /* ARGSUSED */
372 static void
373 sig_alarm_handler(int signo)
374 {
375 }
376
377 /*
378 * serial_port_cond: returns status of a serial port
379 * 0 = OK, 1 = FAILING, 2 = FAILED, 3 = TESTING, anything else = UNKNOWN
380 */
381 static int
382 serial_port_cond(kstat_ctl_t *kc, char *driver, int instance)
383 {
384 switch (serial_port_state(kc, driver, instance)) {
385 case 1:
386 return (0);
387 default:
388 return (-1);
389 }
390 }
391
392 /*
393 * parallel_port_state: returns kstat info of a serial port
394 * 1 = up, 0 = down, anything else = unknown
395 */
396 static int
397 parallel_port_state(kstat_ctl_t *kc, char *ks_module, int ks_instance)
398 {
399 kstat_t *ksp = NULL;
400 kstat_named_t *port_datap = NULL;
401 char *data_lookup;
402 char ks_name[20];
403
404 (void) snprintf(ks_name, sizeof (ks_name), "%s%d", ks_module,
405 ks_instance);
406 if ((ksp = kstat_lookup(kc, ks_module, ks_instance, ks_name)) == NULL) {
407 return (-1);
408 }
409 if (kstat_read(kc, ksp, NULL) == -1) {
410 return (-1);
411 }
412 data_lookup = "";
413 port_datap = (kstat_named_t *)kstat_data_lookup(ksp, data_lookup);
414 if (port_datap == NULL) {
415 return (-1);
416 }
417 return (-1);
418 }
419
420 /*
421 * parallel_port_cond: returns kstat info of a serial port
422 * 1 = up, 0 = down, anything else = unknown
423 */
424 static int
425 parallel_port_cond(kstat_ctl_t *kc, char *ks_module, int ks_instance)
426 {
427 return (parallel_port_state(kc, ks_module, ks_instance));
428 }