?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make a branch to make krunner Good Enough For Aaron™.
[kdebase/uwolfer.git] / apps / kinfocenter / info / info_solaris.cpp
blob8e1e98a92f6c613e5f18cedb09c20bd4f0846251
1 /*
2 * info_solaris.cpp
3 *
4 * Torsten Kasch <tk@Genetik.Uni-Bielefeld.DE>
5 */
6
7 #include "config-infocenter.h"
8
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <sys/mnttab.h>
12 #include <kstat.h>
13 #include <sys/types.h>
14 #include <sys/statvfs.h>
15 #include <time.h>
16
17 #ifdef HAVE_LIBDEVINFO_H
18 #include <ctype.h>
19 #include <string.h>
20 #include <unistd.h>
21 #include <sys/mkdev.h>
22 #include <sys/stat.h>
23 #include <devid.h>
24 #include <libdevinfo.h>
25 #endif /* HAVE_LIBDEVINFO_H */
26
27 #define INFO_CPU_AVAILABLE
28 #define INFO_IRQ_AVAILABLE
29 #define INFO_DMA_AVAILABLE
30 #define INFO_PCI_AVAILABLE
31 #define INFO_IOPORTS_AVAILABLE
32 #define INFO_SOUND_AVAILABLE
33 #define INFO_DEVICES_AVAILABLE
34 #define INFO_SCSI_AVAILABLE
35 #define INFO_PARTITIONS_AVAILABLE
36 #define INFO_XSERVER_AVAILABLE
37
38
39 bool GetInfo_CPU( Q3ListView *lBox ) {
40
41 kstat_ctl_t *kctl;
42 kstat_t *ksp;
43 kstat_named_t *kdata;
44 char cputype[16],
45 fputype[16];
46 char *timetxt;
47 char *ptr;
48 uint32_t i, ncpus;
49 unsigned long state_begin;
50 QString state;
51 QString mhz;
52 QString inst;
53
54 /*
55 * get a kstat handle first and update the user's kstat chain
56 */
57 if( (kctl = kstat_open()) == NULL ) {
58 return false;
59 }
60 while( kstat_chain_update( kctl ) != 0 )
61 ;
62
63 /*
64 * get the # of CPUs
65 */
66 if( (ksp = kstat_lookup( kctl, "unix", 0, "system_misc" )) == NULL ) {
67 return false;
68 }
69 if( kstat_read( kctl, ksp, NULL ) == -1 ) {
70 return false;
71 }
72 kdata = (kstat_named_t *) kstat_data_lookup( ksp, "ncpus" );
73 if( kdata != NULL ) {
74 ncpus = kdata->value.ui32;
75 } else {
76 ncpus = 0;
77 }
78
79 lBox->addColumn( i18n( "Instance" ));
80 lBox->addColumn( i18n( "CPU Type" ));
81 lBox->addColumn( i18n( "FPU Type" ));
82 lBox->addColumn( i18n( "MHz" ));
83 lBox->addColumn( i18n( "State" ));
84
85 /*
86 * get the per-processor info
87 */
88 for( i = 0; i < ncpus; i++ ) {
89
90 if( (ksp = kstat_lookup( kctl, "cpu_info", i, NULL )) == NULL ){
91 return false;
92 }
93
94 if( kstat_read( kctl, ksp, NULL ) == -1 ) {
95 return false;
96 }
97
98 inst.setNum( i );
99 kdata = (kstat_named_t *) kstat_data_lookup( ksp, "cpu_type" );
100 if( kdata != NULL ) {
101 strcpy( cputype, kdata->value.c );
102 } else {
103 sprintf( cputype, "???" );
104 }
105 kdata = (kstat_named_t *) kstat_data_lookup( ksp, "fpu_type" );
106 if( kdata != NULL ) {
107 strcpy( fputype, kdata->value.c );
108 } else {
109 sprintf( fputype, "???" );
110 }
111 kdata = (kstat_named_t *) kstat_data_lookup( ksp, "clock_MHz" );
112 if( kdata != NULL ) {
113 mhz.setNum( kdata->value.ul );
114 } else {
115 mhz.setNum( 0 );
116 }
117 kdata = (kstat_named_t *) kstat_data_lookup( ksp, "state" );
118 if( kdata != NULL ) {
119 state = QString( kdata->value.c );
120 } else {
121 state = "???";
122 }
123 kdata = (kstat_named_t *) kstat_data_lookup( ksp, "state_begin" );
124 if( kdata != NULL ) {
125 state_begin = kdata->value.i32;
126 if( (timetxt = ctime( (time_t *) &state_begin )) != NULL ) {
127 ptr = strrchr( timetxt, '\n' );
128 *ptr = '\0';
129 state += " since " + QString( timetxt );
130 }
131 }
132
133 new Q3ListViewItem( lBox, inst, cputype, fputype, mhz, state );
134 }
135
136 // sorting_allowed = true;
137 lBox->setSorting( 0 );
138
139 return true;
140 }
141
142 bool GetInfo_IRQ( Q3ListView * ) {
143 return false;
144 }
145
146 bool GetInfo_DMA( Q3ListView * ) {
147 return false;
148 }
149
150 bool GetInfo_PCI( Q3ListView * ) {
151 return false;
152 }
153
154 bool GetInfo_IO_Ports( Q3ListView * ) {
155 return false;
156 }
157
158 bool GetInfo_Sound( Q3ListView * ) {
159 return false;
160 }
161
162 bool GetInfo_SCSI( Q3ListView * ) {
163 return false;
164 }
165
166 bool GetInfo_Partitions( Q3ListView *lBox ) {
167
168 FILE *mnttab;
169 struct mnttab mnt;
170 struct statvfs statbuf;
171 fsblkcnt_t tmp;
172 QString total;
173 QString avail;
174 time_t mnttime;
175 char *timetxt;
176 char *ptr;
177
178 if( (mnttab = fopen( MNTTAB, "r" )) == NULL ) {
179 return false;
180 }
181
182 /*
183 * set up column headers
184 */
185 lBox->addColumn( i18n( "Device" ));
186 lBox->addColumn( i18n( "Mount Point" ));
187 lBox->addColumn( i18n( "FS Type" ));
188 lBox->addColumn( i18n( "Total Size" ));
189 // XXX: FIXME: how do I set column alignment correctly?
190 lBox->setColumnAlignment( 3, 2 );
191 lBox->addColumn( i18n( "Free Size" ));
192 // XXX: FIXME: how do I set column alignment correctly?
193 lBox->setColumnAlignment( 4, 2 );
194 lBox->addColumn( i18n( "Mount Time" ));
195 lBox->addColumn( i18n( "Mount Options" ));
196
197 /*
198 * get info about mounted file systems
199 */
200 rewind( mnttab );
201 while( getmntent( mnttab, &mnt ) == 0 ) {
202 /*
203 * skip fstype "nfs" and "autofs" for two reasons:
204 * o if the mountpoint is visible, the fs is not
205 * necessarily available (autofs option "-nobrowse")
206 * and we don't want to mount every remote fs just
207 * to get its size, do we?
208 * o the name "Partitions" for this statistics implies
209 * "local file systems only"
210 */
211 if( (strcmp( mnt.mnt_fstype, "nfs" ) == 0)
212 || (strcmp( mnt.mnt_fstype, "autofs" ) == 0) )
213 continue;
214 if( statvfs( mnt.mnt_mountp, &statbuf ) == 0 ) {
215 if( statbuf.f_blocks > 0 ) {
216 /*
217 * produce output in KB, MB, or GB for
218 * readability -- unfortunately, this
219 * breaks sorting for these columns...
220 */
221 tmp = statbuf.f_blocks
222 * (statbuf.f_frsize / 1024);
223 if( tmp > 9999 ) {
224 tmp /= 1024;
225 if( tmp > 9999 ) {
226 tmp /= 1024;
227 total.setNum( tmp );
228 total += " G";
229 } else {
230 total.setNum( tmp );
231 total += " M";
232 }
233 } else {
234 total.setNum( tmp );
235 total += " K";
236 }
237 // avail.setNum( statbuf.f_bavail );
238 // avail += " K";
239 tmp = statbuf.f_bavail
240 * (statbuf.f_frsize / 1024);
241 if( tmp > 9999 ) {
242 tmp /= 1024;
243 if( tmp > 9999 ) {
244 tmp /= 1024;
245 avail.setNum( tmp );
246 avail += " G";
247 } else {
248 avail.setNum( tmp );
249 avail += " M";
250 }
251 } else {
252 avail.setNum( tmp );
253 avail += " K";
254 }
255 } else {
256 total = "-";
257 avail = "-";
258 }
259 } else {
260 total = "???";
261 avail = "???";
262 }
263 /*
264 * ctime() adds a '\n' which we have to remove
265 * so that we get a one-line output for the Q3ListViewItem
266 */
267 mnttime = (time_t) atol( mnt.mnt_time );
268 if( (timetxt = ctime( &mnttime )) != NULL ) {
269 ptr = strrchr( timetxt, '\n' );
270 *ptr = '\0';
271 }
272
273 new Q3ListViewItem(
274 lBox,
275 mnt.mnt_special,
276 mnt.mnt_mountp,
277 mnt.mnt_fstype,
278 total,
279 avail,
280 QString( timetxt ),
281 mnt.mnt_mntopts
282 );
283 }
284 fclose( mnttab );
285
286 lBox->setSorting( 0 );
287 // sorting_allowed = true;
288
289 return true;
290 }
291
292 bool GetInfo_XServer_and_Video( Q3ListView *lBox ) {
293 return GetInfo_XServer_Generic( lBox );
294 }
295
296 #ifdef HAVE_LIBDEVINFO_H
297 /*
298 * get Solaris' device configuration data through libdevinfo(3)
299 * and display it in a prtconf(1M) style tree
300 *
301 * NOTE: though the devinfo library seems to be present on earlier
302 * Solaris releases, this interface is documented to be available
303 * since Solaris 7 (libdevinfo.h is missing on pre-Solaris 7 systems)
304 *
305 * documentation for libdevinfo(3) including code samples on which
306 * this implementation is based on is available at
307 * http://soldc.sun.com/developer/support/driver/wps/libdevinfo/
308 */
309
310 /*
311 * we start with various helper routines for GetInfo_Devices()
312 */
313
314 /*
315 * mktree() -- break up the device path and place its components
316 * into the tree widget
317 */
318 Q3ListViewItem *mktree( Q3ListViewItem *top, const char *path ) {
319
320 Q3ListViewItem *parent,
321 *previous,
322 *result;
323 char *str = strdup( path ),
324 *token;
325
326 /*
327 * start at "/"
328 */
329 parent = top;
330 result = (*top).firstChild();
331 previous = (*top).firstChild();
332
333 token = strtok( str, "/" );
334 while( token != NULL ) {
335 /*
336 * find insert pos:
337 * try to match the node at the current level
338 *
339 * NOTE: this implementation assumes that there are
340 * no two nodes with identical names at the
341 * same level of the device tree
342 */
343 while( result != NULL ) {
344 if( strcmp( token, (*result).text( 0 ).toLatin1()) == 0 )
345 break;
346 previous = result;
347 result = (*result).nextSibling();
348 }
349 if( result == NULL ) {
350 /*
351 * we haven't found the node, create a new one
352 */
353 result = new Q3ListViewItem( parent,
354 previous,
355 token );
356 } else {
357 /*
358 * we've found the node
359 */
360 parent = result;
361 previous = NULL;
362 if( (*result).firstChild() == NULL ) {
363 /*
364 * create new node during next iteration
365 */
366 result->setExpandable( true );
367 result->setOpen( false );
368 } else {
369 /*
370 * follow the child path
371 */
372 result = (*result).firstChild();
373 }
374 }
375 token = strtok( NULL, "/" );
376 }
377 free( str );
378
379 return( result );
380 }
381
382 /*
383 * prop_type_str() -- return the property type as a string
384 */
385 char *prop_type_str( di_prop_t prop ) {
386
387 switch( di_prop_type( prop )) {
388 case DI_PROP_TYPE_UNDEF_IT:
389 return( "undefined" );
390 case DI_PROP_TYPE_BOOLEAN:
391 return( "BOOL" );
392 case DI_PROP_TYPE_INT:
393 return( "INT" );
394 case DI_PROP_TYPE_STRING:
395 return( "STRING" );
396 case DI_PROP_TYPE_BYTE:
397 return( "BYTE" );
398 default:
399 return( "unknown" );
400 }
401 }
402
403 /*
404 * prop_type_guess() -- guess the property type
405 */
406 int prop_type_guess( uchar_t *data, int len ) {
407
408 int slen;
409 int guess;
410 int i, c;
411
412 if( len < 0 )
413 return( -1 );
414 else if( len == 0 )
415 return( DI_PROP_TYPE_BOOLEAN );
416
417 slen = 0;
418 guess = DI_PROP_TYPE_STRING;
419
420 for( i = 0; i < len; i++ ) {
421 c = (int) data[i];
422 switch( c ) {
423 case 0:
424 if( i == (len - 1 ))
425 break;
426 if( slen == 0 )
427 guess = DI_PROP_TYPE_BYTE;
428 else
429 guess = slen = 0;
430 break;
431 default:
432 if( ! isprint( c ))
433 guess = DI_PROP_TYPE_BYTE;
434 else
435 slen++;
436 }
437 if( guess != DI_PROP_TYPE_STRING )
438 break;
439 }
440
441 // if( (guess == DI_PROP_TYPE_BYTE) && (len % sizeof( int ) == 0 ))
442 // guess = DI_PROP_TYPE_INT;
443
444 return( guess );
445 }
446
447 /*
448 * dump_minor_node() -- examine a device minor node
449 * this routine gets passed to di_walk_node()
450 */
451 int dump_minor_node( di_node_t node, di_minor_t minor, void *arg ) {
452
453 Q3ListViewItem *item;
454 QString majmin;
455 char *type;
456 dev_t dev;
457
458 item = new Q3ListViewItem( (Q3ListViewItem *) arg,
459 di_minor_name( minor ));
460 item->setExpandable( true );
461 item->setOpen( false );
462 new Q3ListViewItem( item, i18n( "Spectype:" ),
463 (di_minor_spectype( minor ) == S_IFCHR)
464 ? i18n( "character special" )
465 : i18n( "block special" ));
466 type = di_minor_nodetype( minor );
467 new Q3ListViewItem( item, i18n( "Nodetype:" ),
468 (type == NULL) ? "NULL" : type );
469
470 if( (dev = di_minor_devt( minor )) != DDI_DEV_T_NONE ) {
471 majmin.sprintf( "%ld/%ld", major( dev ), minor( dev ));
472 new Q3ListViewItem( item, i18n( "Major/Minor:" ), majmin );
473 }
474
475 if( di_minor_next( node, minor ) == DI_MINOR_NIL )
476 return( DI_WALK_TERMINATE );
477 else
478 return( DI_WALK_CONTINUE );
479 }
480
481 /*
482 * propvalue() -- return the property value
483 */
484 QString propvalue( di_prop_t prop ) {
485
486 int type;
487 int i, n;
488 char *strp;
489 int *intp;
490 uchar_t *bytep;
491 QString result;
492
493 /*
494 * Since a lot of printable strings seem to be tagged as 'byte',
495 * we're going to guess, if the property is not STRING or INT
496 * The actual type is shown in the info tree, though.
497 */
498 type = di_prop_type( prop );
499 if( (type != DI_PROP_TYPE_STRING) && (type != DI_PROP_TYPE_INT) ) {
500 n = di_prop_bytes( prop, &bytep );
501 type = prop_type_guess( bytep, n );
502 }
503
504 result = "";
505 switch( type ) {
506 case DI_PROP_TYPE_STRING:
507 if( (n = di_prop_strings( prop, &strp )) < 0 ) {
508 result = "(error)";
509 } else {
510 for( i = 0; i < n; i++ ) {
511 result += "\"";
512 result += strp;
513 result += "\" ";
514 strp += strlen( strp ) + 1;
515 }
516 }
517 break;
518 case DI_PROP_TYPE_INT:
519 if( (n = di_prop_ints( prop, &intp )) < 0 ) {
520 result = "(error)";
521 } else {
522 for( i = 0; i < n; i++ ) {
523 QString tmp;
524 tmp.setNum( intp[i] );
525 result += tmp;
526 result += ' ';
527 }
528 }
529 break;
530 case DI_PROP_TYPE_BOOLEAN:
531 /*
532 * hmm, Sun's sample code handles the existence
533 * of a boolean property as "true", whereas
534 * prtconf(1M) obviously does not (Sol8, at least)
535 * -- we're doing the same and handle "bool" as "byte"
536 */
537 case DI_PROP_TYPE_BYTE:
538 if( (n = di_prop_bytes( prop, &bytep )) < 0 ) {
539 result = "(error)";
540 } else {
541 if( n == 0 ) {
542 result = i18n( "(no value)" );
543 break;
544 }
545 result = "0x";
546 for( i = 0; i < n; i++ ) {
547 QString tmp;
548 unsigned byte = (unsigned) bytep[i];
549 tmp.sprintf( "%2.2x", byte );
550 result += tmp;
551 }
552 }
553 break;
554 default:
555 result = "???";
556 }
557
558 return( result );
559 }
560
561 /*
562 * dump_node() -- examine a device node and its children
563 * this routine gets passed to di_walk_node()
564 */
565 int dump_node( di_node_t node, void *arg ) {
566
567 Q3ListViewItem *top = (Q3ListViewItem *) arg,
568 *parent,
569 *previous;
570 char *path;
571 char *drivername;
572 char *names;
573 QString compatnames;
574 int i, n;
575 di_prop_t prop;
576
577 path = di_devfs_path( node );
578
579 /*
580 * if this is the root node ("/"), initialize the tree
581 */
582 if( strlen( path ) == 1 ) {
583 top->setText( 0, QString( di_binding_name( node )));
584 top->setPixmap( 0, SmallIcon( "kcmdevices" ));
585 top->setOpen( true );
586 top->setSelectable( false );
587 top->setExpandable( false );
588 }
589
590 /*
591 * place the node in the tree
592 */
593 parent = mktree( top, path );
594
595 /*
596 * we have to handle the root node differently...
597 */
598 if( strlen( path ) > 1 ) {
599 parent->setExpandable( true );
600 parent->setOpen( false );
601 } else {
602 previous = parent;
603 parent = top;
604 }
605
606 /*
607 * node name and physical device path
608 */
609 drivername = di_driver_name( node );
610 previous = new Q3ListViewItem( parent,
611 i18n( "Driver Name:" ),
612 (drivername == NULL)
613 ? i18n( "(driver not attached)" )
614 : drivername );
615 previous = new Q3ListViewItem( parent, previous,
616 i18n( "Binding Name:" ), di_binding_name( node ));
617
618 n = di_compatible_names( node, &names );
619 if( n < 1 ) {
620 compatnames = i18n( "(none)" );
621 } else {
622 for( i = 0; i < n; i++ ) {
623 compatnames += names;
624 compatnames += ' ';
625 names += strlen( names ) + 1;
626 }
627 }
628
629 previous = new Q3ListViewItem( parent, previous,
630 i18n( "Compatible Names:" ), compatnames );
631
632 previous = new Q3ListViewItem( parent, previous,
633 i18n( "Physical Path:" ), QString( path ));
634
635 /*
636 * dump the node's property list (if any)
637 */
638 if( (prop = di_prop_next( node, DI_PROP_NIL )) != DI_PROP_NIL ) {
639 previous = new Q3ListViewItem( parent, previous, i18n( "Properties" ));
640 previous->setExpandable( true );
641 previous->setOpen( false );
642 do {
643 /*
644 * property type & value
645 */
646 Q3ListViewItem *tmp,
647 *prev;
648 tmp = new Q3ListViewItem( previous, di_prop_name( prop ));
649 tmp->setExpandable( true );
650 tmp->setOpen( false );
651 prev = new Q3ListViewItem( tmp, i18n( "Type:" ),
652 prop_type_str( prop ));
653 new Q3ListViewItem( tmp, prev, i18n( "Value:" ),
654 propvalue( prop ));
655 } while( (prop = di_prop_next( node, prop )) != DI_PROP_NIL );
656 }
657
658 /*
659 * if there are minor nodes, expand the tree appropriately
660 */
661 if( di_minor_next( node, DI_MINOR_NIL ) != DI_MINOR_NIL ) {
662 previous = new Q3ListViewItem( parent, previous, i18n( "Minor Nodes" ));
663 previous->setExpandable( true );
664 previous->setOpen( false );
665 di_walk_minor( node, NULL, 0, previous, dump_minor_node );
666 }
667
668 return( DI_WALK_CONTINUE );
669 }
670
671 bool GetInfo_Devices( Q3ListView *lBox ) {
672
673 Q3ListViewItem *top;
674 di_node_t root_node;
675
676 /*
677 * create a snapshot of the device tree
678 */
679 if( (root_node = di_init( "/", DINFOCPYALL )) == DI_NODE_NIL ) {
680 return( false );
681 }
682 // XXX: might try to di_prom_init() here as well (if we're setgid sys)
683
684 /*
685 * prepare the tree widget
686 */
687 lBox->addColumn( i18n( "Device Information" ));
688 lBox->addColumn( i18n( "Value" ));
689
690 top = new Q3ListViewItem( lBox );
691
692 /*
693 * traverse the device tree
694 */
695 di_walk_node( root_node, DI_WALK_CLDFIRST, top, dump_node );
696
697 di_fini( root_node );
698
699 sorting_allowed = false;
700 return true;
701 }
702
703 #else /* ! HAVE_LIBDEVINFO_H */
704 bool GetInfo_Devices( Q3ListView * ) {
705 return false;
706 }
707 #endif /* ! HAVE_LIBDEVINFO_H */
working branch for uwolfer