source: trunk/athena/bin/machtype/machtype_sgi.c @ 11929

Revision 11929, 12.2 KB checked in by ghudson, 26 years ago (diff)
Nuke -k and -m flags.
Line 
1/*
2 *  Machtype: determine machine type & display type
3 *
4 * RCS Info
5 *      $Id: machtype_sgi.c,v 1.11 1998-09-12 00:17:33 ghudson Exp $
6 *      $Locker:  $
7 */
8
9#include <stdio.h>
10#include <string.h>
11#include <strings.h>
12#if defined(_AIX) && defined(_BSD)
13#undef _BSD
14#endif
15#include <nlist.h>
16#include <sys/param.h>
17#include <sys/types.h>
18#include <sys/file.h>
19
20#include <sys/sysinfo.h>
21#include <sys/ioctl.h>
22
23#include <ctype.h>
24#ifdef sgi
25#include <sys/cpu.h>
26#include <invent.h>
27void do_INV_SCSI(inventory_t *);
28void do_INV_SCSICONTROL(inventory_t *);
29void do_INV_DISK(inventory_t *);
30void do_INV_PROCESSOR(inventory_t *,int);
31void do_INV_GRAPHICS(inventory_t *);
32void do_INV_CAM(inventory_t *);
33#endif
34
35
36
37#define NL_NF(nl) ((nl).n_type == 0)
38
39#define KERNEL "/unix"
40#define MEMORY "/dev/kmem"
41
42int verbose = 0;
43
44struct nlist nl[] = {
45#define X_cpu 0
46        { "cputype" },
47#define X_maxmem 1
48        { "maxmem" },
49#define X_physmem 2
50        { "physmem" },
51#define X_nscsi 3
52        { "_nscsi_devices" },
53        { "" },
54};
55
56main(argc, argv)
57int     argc;
58char    **argv;
59{
60    int i;
61    int cpuflg = 0, dpyflg = 0, raflg = 0, memflg = 0;
62    int doathenaV = 0;
63    int dosyspV = 0;
64    int dolocalV = 0;
65    int dobosN = 0;
66    int dobosV = 0;
67    int dosysnam = 0;
68    int dosyscompatnam = 0;
69    FILE *f;
70    int memfd=0;
71
72    for (i = 1; i < argc; i++) {
73        if (argv[i][0] != '-')
74          usage(argv[0]);
75
76        switch (argv[i][1]) {
77        case 'c':
78            cpuflg++;
79            break;
80        case 'd':
81            dpyflg++;
82            break;
83        case 'r':
84            raflg++;
85            break;
86        case 'M':
87            memflg++;
88            break;
89        case 'A':
90            doathenaV = 1;
91            break;
92        case 'L':
93            dolocalV = 1;
94            break;
95        case 'P':
96            dosyspV = 1;
97            break;
98        case 'N':
99            dobosN = 1;
100            break;
101        case 'E':
102            dobosV = 1;
103            break;
104        case 'S':
105            dosysnam = 1;
106            break;
107        case 'C':
108            dosyscompatnam = 1;
109            break;
110        case 'v':
111            verbose++;
112            break;
113        default:
114            usage(argv[0]);
115        }
116    }
117
118
119    if ((argc == 1) || ((argc == 2) && verbose)) {
120#if defined(vax)
121      puts("vax");
122#else
123#if defined(ibm032)
124      puts("rt");
125#else
126#if defined(ultrix) && defined(mips)
127      puts("decmips");
128#else
129#if defined(i386) && defined(_AIX)
130      puts("ps2");
131#else /* ! ps2 */
132#if defined(sgi)
133        puts("sgi");
134#else
135#if defined(sun) && defined(sparc)
136      puts("sun4");
137#else /* ! sun sparc */
138#if defined(sun)
139      puts("sun3");
140#else
141      puts("???");
142#endif
143#endif
144#endif
145#endif
146#endif
147#endif
148#endif
149      exit(0);
150    }
151
152        /* Print out version of Athena machtype compiled against */
153    if (doathenaV) {
154      if (verbose)
155        printf("Machtype version: %s.%s\n",ATHMAJV,ATHMINV);
156      else
157        printf("%s.%s\n",ATHMAJV,ATHMINV);
158    }
159
160    /* Print out version of attached packs */
161    if (dosyspV) {
162      char buf[256],rvd_version[256], *p;
163      if ((f = fopen("/srvd/.rvdinfo","r")) == NULL) {
164        printf("Syspack information unavailable\n");
165      } else {
166        fgets(buf,256,f);
167        fclose(f);
168       
169        /* If it is verbose, give the whole line, else just the vers # */
170        if (verbose) {
171          printf(buf);
172        } else {
173          p = index(buf,' '); /* skip "Athena" */
174          p = index(p+1,' '); /* skip "RVD" */
175          p = index(p+1,' '); /* Skip "RSAIX" */
176          p = index(p+1,' '); /* skip "version" */
177          strncpy(rvd_version,p+1,256);
178          p = index(rvd_version,' ');
179          *p = '\0';
180          printf("%s\n",rvd_version);
181        }
182      }
183    }
184       
185    /* Print out local version from /etc/athena/version */
186    if (dolocalV) {
187      char buf[256],loc_version[256], *p;
188      if ((f = fopen("/etc/athena/version","r")) == NULL) {
189        printf("Local version information unavailable\n");
190      } else {
191        fseek(f,-100,2);
192        while (fgets(buf,256,f) != NULL)
193          ;
194        fclose(f);
195       
196        if (verbose) {
197          printf(buf);
198        } else {
199          p = index(buf,' '); /* skip "Athena" */
200          p = index(p+1,' '); /* skip "Workstation/Server" */
201          p = index(p+1,' '); /* Skip "RSAIX" */
202          p = index(p+1,' '); /* skip "version" */
203          strncpy(loc_version,p+1,256);
204          p = index(loc_version,' ');
205          *p = '\0';
206          printf("%s\n",loc_version);
207        }
208      }
209    }
210
211    /* Print out vendor OS name */
212    if (dobosN) {
213      if (verbose) {
214        printf(OSNAME " " OSVERS "\n");
215      } else {
216        printf(OSNAME "\n");
217      }
218    }
219
220    /* Print out vendor OS version */
221    if (dobosV) {
222        printf(OSVERS "\n");
223    }
224    if (dosysnam)
225        printf("%s\n", ATHSYS);
226    if (dosyscompatnam)
227        printf("%s\n", ATHSYSCOMPAT);
228    if (cpuflg)
229        do_cpu();
230    if (dpyflg)
231        do_dpy();
232    if (raflg)
233        do_disk();
234
235    if (memflg)
236      {
237
238        if (nlist(KERNEL, nl) < 0) {
239          fprintf(stderr,"%s: can't get namelist\n", argv[0]);
240          exit(2);
241        }
242        if ((memfd = open (MEMORY, O_RDONLY)) == -1) {
243          perror ("machtype: can't open memory");
244          exit(2);
245        }
246        if (memflg)
247          do_memory(memfd);
248      }
249    exit(0);
250}
251
252
253
254usage(name)
255char *name;
256{
257    fprintf(stderr, "usage: %s [-v] [-c] [-d] [-r] [-E] [-N] [-M]\n",name);
258    fprintf(stderr, "             [-A] [-L] [-P] [-S]\n");
259    exit(1);
260}
261
262
263do_cpu()
264{
265inventory_t *inv;
266int done=0;
267        (void)setinvent();
268        inv = getinvent();
269        while ((inv != NULL) && !done) {
270                if ( inv->inv_class == 1) {
271                        do_INV_PROCESSOR(inv,verbose);
272                }
273                inv = getinvent();
274        }
275}
276
277void do_INV_PROCESSOR(inventory_t *i,int verbose)
278{
279if (i->inv_type == INV_CPUBOARD )  {
280        switch (i->inv_state) {
281        case INV_R2300BOARD:
282                puts(verbose ? "SGI R2300": "R2300");
283                break;
284        case INV_IP4BOARD:
285                puts(verbose ? "SGI IP4": "IP4");
286                break;
287        case INV_IP5BOARD:
288                puts(verbose ? "SGI IP5": "IP5");
289                break;
290        case INV_IP6BOARD:
291                puts(verbose ? "SGI IP6": "IP6");
292                break;
293        case INV_IP7BOARD:
294                puts(verbose ? "SGI IP7": "IP7");
295                break;
296        case INV_IP9BOARD:
297                puts(verbose ? "SGI IP9": "IP9");
298                break;
299        case INV_IP12BOARD:
300                puts(verbose ? "SGI IP12": "IP12");
301                break;
302        case INV_IP15BOARD:
303                puts(verbose ? "SGI IP15": "IP15");
304                break;
305        case INV_IP17BOARD:
306                puts(verbose ? "SGI IP17": "IP17");
307                break;
308        case INV_IP19BOARD:
309                puts(verbose ? "SGI IP19": "IP19");
310                break;
311        case INV_IP20BOARD:
312                puts(verbose ? "SGI IP20": "IP20");
313                break;
314        case INV_IP21BOARD:
315                puts(verbose ? "SGI IP21": "IP21");
316                break;
317        case INV_IP22BOARD:
318                puts(verbose ? "SGI IP22": "IP22");
319                break;
320        case INV_IP26BOARD:
321                puts(verbose ? "SGI IP26": "IP26");
322                break;
323#ifdef INV_IP32BOARD
324        case INV_IP32BOARD:
325                puts(verbose ? "SGI IP32": "IP32");
326                break;
327#endif
328         default:
329           if(verbose)
330                printf("Unknown SGI type %d\n", i->inv_state);
331           else
332                puts("SGI???");
333        }
334        } else if (verbose) {
335                if (i->inv_type == INV_CPUCHIP) {
336                        fprintf(stdout,"CPU: MIPS R4600\n");
337        } else {
338                        fprintf(stdout,"FPU:MIPS R4610\n");
339        }
340}
341}
342
343
344#ifdef vax
345int ka420model()
346{
347    unsigned long cacr;
348    int kUmf;
349    if (nl[X_nexus].n_type == 0)
350        return -1;
351    kUmf = open("/dev/kUmem", O_RDONLY);
352    if (kUmf == -1)
353        return -1;
354    lseek(kUmf, nl[X_nexus].n_value + (int)&((struct nb_regs *)0)->nb_cacr, L_SET);
355    if(read(kUmf, &cacr, sizeof(cacr)) != sizeof(cacr))
356        return -1;
357    close (kUmf);
358    return (cacr >> 6) & 3;
359}
360#endif /* vax */
361
362do_dpy()
363{
364int status;
365inventory_t *inv;
366int done=0;
367#ifdef sgi
368    if (verbose) {
369        switch(fork()) {
370                case -1:
371                        fprintf (stderr,
372                        "Don't know how to determine display type for this machine.\n");
373                        return;
374                case 0:
375                        if ((execlp("/usr/gfx/gfxinfo","gfxinfo",NULL) ) == -1 ) {
376                                fprintf (stderr,
377                                "Don't know how to determine display type for this machine.\n");
378                                return;
379                        }       
380                default:
381                        wait(&status);
382                break;
383        } /* switch */
384        (void) setinvent();
385        inv = getinvent();
386        while ((inv != NULL) && !done) {
387                if ( inv->inv_class == INV_VIDEO) {
388                        do_INV_CAM(inv);
389                }
390                inv = getinvent();
391        }
392    } else { /* not verbose */
393        (void) setinvent();
394        inv = getinvent();
395        while ((inv != NULL) && !done) {
396                if ( inv->inv_class == INV_GRAPHICS) {
397                        do_INV_GRAPHICS(inv);
398                }
399                inv = getinvent();
400        }
401     } /* verbose */
402
403#else
404    fprintf (stderr,
405             "Don't know how to determine display type for this machine.\n");
406    return;
407#endif
408}
409
410void do_INV_GRAPHICS(inventory_t *i)
411{
412  switch(i->inv_type)
413    {
414    case INV_NEWPORT:
415      switch(i->inv_state)
416        {
417        case INV_NEWPORT_24:
418          fprintf(stdout,"XL-24\n");
419          break;
420        case INV_NEWPORT_XL:
421          fprintf(stdout,"XL\n");
422          break;
423        default:
424          fprintf(stdout,"NG1\n");
425          break;
426        }
427      break;
428    case INV_GR2:
429      /* an EXPRESS is an EXPRESS of course of course
430         except when you are a GR3-XZ */
431      if ((i->inv_state & ~INV_GR2_INDY) == INV_GR2_ELAN )
432        fprintf(stdout,"GR3-XZ\n");
433      else
434        fprintf(stdout,"UNKNOWN video\n");
435      break;
436#ifdef INV_CRIME
437    case INV_CRIME:
438      fprintf(stdout, "CRM\n");
439      break;
440#endif
441    default:
442      fprintf(stdout,"UNKNOWN video\n");
443    }
444}
445
446void do_INV_CAM(inventory_t *i)
447{
448        if (i->inv_type == INV_VIDEO_VINO ) {
449                if (i->inv_state == INV_VINO_INDY_CAM ) {
450                        fprintf(stdout,"\tIndy cam connected\n");
451                }
452        }
453}
454
455
456
457do_disk()
458{
459inventory_t *inv;
460int t;
461int done=0;
462        (void) setinvent();
463        inv = getinvent();
464        t = 0;
465        while ((inv != NULL) && !done) {
466                if (inv->inv_class == INV_DISK)
467                  do_INV_DISK(inv);
468                else if (inv->inv_class == INV_SCSI)
469                  do_INV_SCSI(inv);
470                inv = getinvent();
471        }
472}
473void do_INV_SCSI(inventory_t *i)
474{
475if (i->inv_type == INV_CDROM) {
476        fprintf(stdout,"CDROM: unit %i, on SCSI controller %i\n",i->inv_unit,i->inv_controller);
477} else {
478        fprintf(stdout,"Unknown type %i:unit %i, on SCSI controller %i\n",i->inv_type,i->inv_unit,i->inv_controller);
479}
480}
481
482void do_INV_DISK(inventory_t *i)
483{
484  switch (i->inv_type)
485    {
486    case INV_SCSIDRIVE:
487      printf("Disk drive: unit %u, on SCSI controller %u\n",
488             i->inv_unit, i->inv_controller);
489      break;
490
491    case INV_SCSIFLOPPY:
492      printf("Floppy drive: unit %u, on SCSI controller %u\n",
493             i->inv_unit, i->inv_controller);
494      break;
495
496    case INV_SCSICONTROL:
497    case INV_GIO_SCSICONTROL:
498#ifdef INV_PCI_SCSICONTROL
499    case INV_PCI_SCSICONTROL:
500#endif
501      do_INV_SCSICONTROL(i);
502      break;
503
504    default:
505      printf("Unknown type %u: unit %u, on SCSI controller %u\n",
506             i->inv_type, i->inv_unit, i->inv_controller);
507      break;
508    }
509}
510
511void do_INV_SCSICONTROL(inventory_t *i)
512{
513  /* Only display SCSI controller info when verbose */
514  if (!verbose)
515    return;
516
517  switch (i->inv_type)
518    {
519    case INV_SCSICONTROL:
520      printf("Integral");
521      break;
522    case INV_GIO_SCSICONTROL:
523      printf("GIO");
524      break;
525#ifdef INV_PCI_SCSICONTROL
526    case INV_PCI_SCSICONTROL:
527      printf("PCI");
528      break;
529#endif
530    default:
531      printf("Unknown");
532      break;
533    }
534
535  printf(" SCSI controller %u: Version ", i->inv_controller);
536
537  switch (i->inv_state)
538    {
539    case INV_WD93:
540      printf("WD 33C93");
541      break;
542
543    case INV_WD93A:
544      printf("WD 33C93A");
545      break;
546
547    case INV_WD93B:
548      printf("WD 33C93B");
549      break;
550
551    case INV_WD95A:
552      printf("WD 33C95A");
553      break;
554
555    case INV_SCIP95:
556      printf("SCIP w/WD 33C95A");
557      break;
558
559#ifdef INV_ADP7880
560    case INV_ADP7880:
561      printf("ADAPTEC 7880");
562      break;
563#endif
564
565    default:
566      printf("Unknown");
567      break;
568    }
569
570  if (i->inv_unit)
571    printf(", rev. %X", i->inv_unit);
572
573  putchar('\n');
574}
575
576
577#define MEG (1024*1024)
578
579do_memory (mf)
580int mf;
581{
582  int pos, mem, nbpp;
583  nbpp = getpagesize() / 1024;
584  pos = nl[X_maxmem].n_value;
585  if(pos == 0) {
586      fprintf(stderr, "can't find maxmem\n");
587      exit(3);
588  }
589  lseek(mf,pos,L_SET);  /* Error checking ? */
590  if(read(mf,&mem,4) == -1) {
591      perror("read (kmem)");
592      exit(4);
593  } else {
594    if(verbose)
595      printf("%d user, ",mem * nbpp);
596  }
597  pos = nl[X_physmem].n_value;
598  if(pos == 0) {
599      fprintf(stderr, "can't find physmem\n");
600      exit(3);
601  }
602  lseek(mf,pos,L_SET);
603  if(read(mf,&mem,4) == -1) {
604      perror("read (kmem)");
605      exit(4);
606  } else {
607    if(verbose)
608      printf("%d (%d M) total\n",mem * nbpp,(mem * getpagesize() + MEG/2)/MEG);
609    else
610      printf("%d\n", mem * nbpp);
611  }
612  return;
613}
614
Note: See TracBrowser for help on using the repository browser.