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

Revision 11929, 9.7 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_sun4.c,v 1.23 1998-09-12 00:17:34 ghudson Exp $
6 *    $Locker:  $
7 */
8
9#define volatile
10#include <stdio.h>
11#include <string.h>
12#include <kvm.h>
13#include <nlist.h>
14#include <fcntl.h>
15#include <unistd.h>
16#include <sys/types.h>
17#include <sys/file.h>
18#include <sys/cpu.h>
19#include <ctype.h>
20#include <dirent.h>
21#include <sys/vtoc.h>
22/* OpenPROM stuff */
23#include <sys/promif.h>
24#include <sys/ddi.h>
25#include <sys/sunddi.h>
26#include <sys/ddi_impldefs.h>
27/* Frame buffer stuff */
28#include <sys/fbio.h>
29#include <errno.h>
30
31int verbose =0;
32
33struct nlist nl[] = {
34#define X_cpu 0
35      { "cputype" },
36#define X_maxmem 1
37      { "maxmem" },
38#define X_physmem 2
39      { "physmem" },
40#define X_topnode 3
41      { "top_devinfo" },
42      { "" }
43};
44
45main(argc, argv)
46int   argc;
47char  **argv;
48{
49kvm_t *kv;
50    int i;
51    int cpuflg = 0, dpyflg = 0, raflg = 0, memflg = 0;
52    int doathenaV = 0;
53    int dosyspV = 0;
54    int dolocalV = 0;
55    int dobosN = 0;
56    int dobosV = 0;
57    int dosysnam = 0;
58    int dosyscompatnam = 0;
59    FILE *f;
60
61    for (i = 1; i < argc; i++) {
62      if (argv[i][0] != '-')
63        usage(argv[0]);
64
65      switch (argv[i][1]) {
66      case 'c':
67          cpuflg++;
68          break;
69      case 'd':
70          dpyflg++;
71          break;
72      case 'r':
73          raflg++;
74          break;
75      case 'M':
76          memflg++;
77        break;
78        case 'A':
79          doathenaV = 1;
80          break;
81        case 'L':
82          dolocalV = 1;
83          break;
84        case 'P':
85          dosyspV = 1;
86          break;
87      case 'N':
88          dobosN = 1;
89          break;
90      case 'E':
91          dobosV = 1;
92          break;
93      case 'S':
94          dosysnam = 1;
95          break;
96      case 'C':
97          dosyscompatnam = 1;
98          break;
99      case 'v':
100          verbose++;
101          break;
102      default:
103          usage(argv[0]);
104      }
105    }
106
107    if ((argc == 1) || ((argc == 2) && verbose)) {
108      puts("sun4");
109      exit(0);
110    }
111
112     /* Print out version of Athena machtype compiled against */
113    if (doathenaV) {
114      if (verbose)
115      printf("Machtype version: %s.%s\n",ATHMAJV,ATHMINV);
116      else
117      printf("%s.%s\n",ATHMAJV,ATHMINV);
118    }
119
120   /* Print out version of attached packs */
121    if (dosyspV) {
122      char buf[256],rvd_version[256], *p;
123      if ((f = fopen("/srvd/.rvdinfo","r")) == NULL) {
124      printf("Syspack information unavailable\n");
125      } else {
126      fgets(buf,256,f);
127      fclose(f);
128     /* If it is verbose, give the whole line, else just the vers # */
129      if (verbose) {
130        printf(buf);
131      } else {
132        p = strchr(buf,' '); /* skip "Athena" */
133        p = strchr(p+1,' '); /* skip "RVD" */
134        p = strchr(p+1,' '); /* Skip "RSAIX" */
135        p = strchr(p+1,' '); /* skip "version" */
136        strncpy(rvd_version,p+1,256);
137        p = strchr(rvd_version,' ');
138        *p = '\0';
139        printf("%s\n",rvd_version);
140      }
141      }
142    }
143
144    /* Print out local version from /etc/athena/version */
145    if (dolocalV) {
146      char buf[256],loc_version[256], *p;
147      if ((f = fopen("/etc/athena/version","r")) == NULL) {
148      printf("Local version information unavailable\n");
149      } else {
150      fseek(f,-100,2);
151      while (fgets(buf,256,f) != NULL)
152        ;
153      fclose(f);
154
155      if (verbose) {
156        printf(buf);
157      } else {
158        p = strchr(buf,' '); /* skip "Athena" */
159        p = strchr(p+1,' '); /* skip "Workstation/Server" */
160        p = strchr(p+1,' '); /* Skip "RSAIX" */
161        p = strchr(p+1,' '); /* skip "version" */
162        strncpy(loc_version,p+1,256);
163        p = strchr(loc_version,' ');
164        *p = '\0';
165        printf("%s\n",loc_version);
166      }
167      }
168    }
169
170    /* Print out vendor OS name */
171    if (dobosN) {
172      if (verbose) {
173     printf(OSNAME " " OSVERS "\n");
174      } else {
175        printf(OSNAME "\n");
176      }
177    }
178
179    /* Print out vendor OS version */
180    if (dobosV) {
181        printf(OSVERS "\n");
182    }
183
184    /* Print out Athena System name */
185    if (dosysnam) {
186      printf("%s\n", ATHSYS);
187    }
188
189    /* Print out compatible Athena System names */
190    if (dosyscompatnam) {
191      printf("%s\n", ATHSYSCOMPAT);
192    }
193
194    if (cpuflg || dpyflg || raflg || memflg)
195      {
196        int memfd;
197      kv = kvm_open(NULL,NULL,NULL,O_RDONLY,NULL);
198      if (!kv) {
199        fprintf(stderr,"%s: unable to examine the kernel\n", argv[0]);
200        exit(2);
201      }
202      if (kvm_nlist(kv, &nl) < 0) {
203        fprintf(stderr,"%s: can't get namelist\n", argv[0]);
204        exit(2);
205      }
206     if (cpuflg)
207        do_cpu(kv, memfd);
208      if (dpyflg)
209        do_dpy(memfd);
210      if (raflg)
211        do_disk(memfd);
212      if (memflg)
213        do_memory(kv, memfd);
214      }
215      if (cpuflg || dpyflg || raflg || memflg)
216        kvm_close(kv);
217    exit(0);
218}
219
220usage(name)
221char *name;
222{
223    fprintf(stderr, "usage: %s [-v] [-c] [-d] [-r] [-E] [-N] [-M]\n",name);
224    fprintf(stderr, "             [-A] [-L] [-P] [-S]\n");
225    exit(1);
226}
227
228void do_cpu_prom(kvm_t *kernel)
229{
230  unsigned long   ptop;
231  struct dev_info top;
232  char            buf[BUFSIZ];
233
234  char*           cpustr;
235
236  /* read device name of the top node of the OpenPROM */
237
238  if (   (! nl[X_topnode].n_value)
239      || (kvm_read(kernel, (unsigned long) nl[X_topnode].n_value,
240                            (char*) &ptop, sizeof(ptop)) != sizeof(ptop))
241      || (! ptop)
242      || (kvm_read(kernel, (unsigned long) ptop,
243                            (char*) &top, sizeof(top)) != sizeof(top))
244      || (! top.devi_name)
245      || (kvm_read(kernel, (unsigned long) top.devi_name,
246                            (char*) &buf, sizeof(buf)) != sizeof(buf))
247      || (! buf[0]) ) {
248    fprintf(stderr, "Can't get CPU information from the kernel\n");
249    exit(2);
250  }
251  buf[BUFSIZ-1] = '\0';
252
253  /* now, return a string identifying the CPU */
254
255  if (verbose) {
256    /* "verbose" returns the kernel information directly */
257    puts(buf);
258
259  } else {
260
261    /* skip the initial "SUNW," */
262    if (cpustr = strchr(buf, ','))
263      cpustr++;
264    else
265      cpustr = buf;
266
267    /* reformat the result to look like "SPARC/Classic" or "SPARC/5" */
268    if (! strncmp(cpustr, "SPARC", sizeof("SPARC")-1)) {
269      cpustr += sizeof("SPARC")-1;
270
271      if (! strncmp(cpustr, "station-", sizeof("station-")-1))
272        cpustr += sizeof("station-")-1;
273      else
274        if (! strcmp(cpustr, "classic")) /* backwards compat - cap classic */
275          (*cpustr) = toupper(*cpustr);
276
277      printf("SPARC/%s\n", cpustr);
278
279    } else {
280      /* if it didn't start with "SPARC", just leave it be... */
281      puts(cpustr);
282    }
283  }
284
285  return;
286}
287
288do_cpu(kernel, mf)
289kvm_t *kernel;
290int mf;
291{
292     short cpu;
293short cpu_type;
294
295    cpu_type = kvm_read(kernel,nl[X_cpu].n_value,&cpu, sizeof(cpu));
296{
297        switch(cpu) {
298          case CPU_SUN4C_60:
299            puts(verbose ? "SPARCstation 1": "SPARC/1");
300            break;
301          case CPU_SUN4C_40:
302            puts(verbose ? "SPARCstation IPC" : "SPARC/IPC");
303            break;
304          case CPU_SUN4C_65:
305            puts(verbose ? "SPARCstation 1+" : "SPARC/1+");
306            break;
307          case CPU_SUN4C_20:
308            puts(verbose ? "SPARCstation SLC" : "SPARC/SLC");
309            break;
310          case CPU_SUN4C_75:
311            puts(verbose ? "SPARCstation 2" : "SPARC/2");
312            break;
313          case CPU_SUN4C_25:
314            puts(verbose ? "SPARCstation ELC" : "SPARC/ELC");
315            break;
316          case CPU_SUN4C_50:
317            puts(verbose ? "SPARCstation IPX" : "SPARC/IPX");
318            break;
319          case CPU_SUN4M_50:    /* 114... Sparc20 */
320          case OBP_ARCH:        /* 128 */
321            do_cpu_prom(kernel);
322                break;
323
324         default:
325           if(verbose)
326                printf("Unknown SUN type %d\n", cpu);
327           else
328              puts("SUN???");
329         }
330       }
331    return;
332}
333
334do_dpy(mf)
335int mf;
336{
337  int count;
338  char buf[1024], *p;
339
340  count = readlink("/dev/fb", buf, sizeof(buf) - 1);
341  if (count == -1) {
342    puts(verbose ? "unknown frame buffer" : "unknown");
343    return;
344  }
345  buf[count] = 0;
346  p = buf + count;
347  while (p > buf && isdigit(*(p - 1)))
348    *--p = 0;
349  p = strrchr(buf, ':');
350  if (!p) {
351    puts(verbose ? "unknown frame buffer" : "unknown");
352    return;
353  }
354  printf("%s%s\n", p + 1, verbose ? " frame buffer" : "");
355}
356
357do_disk(mf)
358int mf;
359{
360  DIR *dp;
361  struct dirent *de;
362  char path[MAXPATHLEN];
363  const char *devdir = "/dev/rdsk";
364  char *cp;
365  int fd;
366  int devlen;                   /* Length of device name, w/o partition */
367  struct vtoc vtoc;
368 
369  dp = opendir(devdir);
370  if (dp == NULL)
371    {
372      fprintf(stderr, "Cannot open %s: %s\n", devdir, strerror(errno));
373      exit(1);
374    }
375
376  while ((de = readdir(dp)) != NULL)
377    {
378      if ((!strcmp(de->d_name, ".")) || (!strcmp(de->d_name, "..")))
379        continue;
380
381      /* By convention partition (slice) 2 is the whole disk. */
382      cp = strrchr(de->d_name, 's');
383      if ((cp == NULL) || (strcmp(cp, "s2") != 0))
384        continue;
385      devlen = cp - de->d_name;         /* Get name length w/o partition */
386      sprintf(path, "%s/%s", devdir, de->d_name);
387      fd = open(path, O_RDONLY);
388      if (fd == -1)
389        continue;
390
391      if ((read_vtoc(fd, &vtoc) < 0) || (vtoc.v_sanity != VTOC_SANE))
392        {
393          close(fd);
394          continue;
395        }
396      close(fd);
397
398      if (!verbose)
399        {
400          /* Strip geometry info from the label text. */
401          cp = strchr(vtoc.v_asciilabel, ' ');
402          if (cp)
403            *cp = '\0';
404        }
405
406      printf("%.*s: %.*s\n",
407             devlen, de->d_name,
408             LEN_DKL_ASCII, vtoc.v_asciilabel);
409    }
410
411  closedir(dp);
412  return;
413}
414
415#define MEG (1024*1024)
416
417do_memory (kernel, mf)
418kvm_t *kernel;
419int mf;
420{
421   int pos, mem, nbpp;
422
423   nbpp = getpagesize() / 1024;
424   kvm_read(kernel, nl[X_maxmem].n_value, &mem, sizeof(mem));
425   if(verbose)
426      printf("%d user, ", mem * nbpp);
427   kvm_read(kernel, nl[X_physmem].n_value, &mem, sizeof(mem));
428   if(verbose)
429      printf("%d (%d M) total\n", mem * nbpp, (mem * nbpp + 916) / 1024);
430   else
431      printf("%d\n", mem * nbpp + 916);
432   return;
433}
434
Note: See TracBrowser for help on using the repository browser.