1/* -*- mode: C; c-basic-offset: 3; -*- */
2
3#include <setjmp.h>
4#include <signal.h>
5#include <stdio.h>
6#include <stdlib.h>
7#include <string.h>
8#include <assert.h>
9#include <ctype.h>     // isspace
10#include <fcntl.h>     // open
11#include <unistd.h>    // lseek
12#include <sys/stat.h>  // S_IRUSR
13
14// This file determines s390x features a processor supports.
15//
16// We return:
17// - 0 if the machine provides the asked-for feature and the cpu
18//     model, if specified, matches the machine
19// - 1 the machine does not provide the asked-for feature or the
20//     cpu model, if specified, does not match the machine
21// - 1 for an unknown cpu model in /proc/cpu_info
22// - 2 if the asked-for feature isn't recognised (this will be the case for
23//     any feature if run on a non-s390x machine).
24// - 3 if there was a usage error (it also prints an error message).
25//
26// USAGE:
27//
28//    s390x_features <feature> [<machine-model>]
29//
30// The machine_model is optional and it can be something like:
31//
32//   z9        -- Host needs to be a z9 (and nothing else)
33//   z9:       -- Host needs to be a z9 or any later model
34//   :z9       -- Host needs to be a model up to and including z9
35//   z900:z9   -- Host needs to be at least a z900 and at most a z9.
36//                Any model in between is OK, too.
37
38jmp_buf env;
39
40#if defined(VGA_s390x)
41
42void handle_sigill(int signum)
43{
44   longjmp(env, 1);
45}
46
47unsigned long long stfle(void)
48{
49
50   unsigned long long ret;
51
52   signal(SIGILL, handle_sigill);
53   if (setjmp(env)) {
54      /* stfle not available: assume no facilities */
55      return 0;
56   } else {
57      asm volatile("lghi 0, 0\n"
58                   ".insn s,0xb2b00000,%0\n" /* stfle */
59      : "=Q" (ret)::"0", "cc");
60      return ret;
61   }
62}
63
64
65/* Read /proc/cpuinfo. Look for lines like these
66
67      processor 0: version = FF,  identification = 0117C9,  machine = 2064
68
69   and return the machine model or NULL on error.
70   Adapted from function VG_(get_machine_model) in coregrind/m_machine.c */
71
72typedef struct {
73   const char *cpuinfo_name;
74   const char *real_name;
75} model_info;
76
77/* Array needs to be sorted chronologically. Oldest to newest */
78model_info models[] = {
79   { "2064", "z900"   },
80   { "2066", "z800"   },
81   { "2084", "z990"   },
82   { "2086", "z890"   },
83   { "2094", "z9-EC"  },
84   { "2096", "z9-BC"  },
85   { "2097", "z10-EC" },
86   { "2098", "z10-BC" },
87   { "2817", "z196"   },
88   { "2818", "z114"   },
89   { "2827", "zEC12"  },
90   { "2828", "zBC12"  },
91};
92
93
94/* Locate a machine model by name. Name can be either the cpuinfo
95   name or the external name. */
96static model_info *locate_model(const char *name)
97{
98   model_info *p;
99
100   /* Try cpuinfo name first */
101   for (p = models; p != models + sizeof models / sizeof models[0]; ++p) {
102      if (strcmp(p->cpuinfo_name, name) == 0) return p;  // found it
103   }
104
105   /* Now try external name */
106   for (p = models; p != models + sizeof models / sizeof models[0]; ++p) {
107      if (strcmp(p->real_name, name) == 0) return p;  // found it
108   }
109
110   return NULL;
111}
112
113
114static model_info *get_host(void)
115{
116   int    n, fh;
117   size_t num_bytes, file_buf_size;
118   char  *p, *m, *model_name, *file_buf;
119   model_info *model;
120
121   /* Slurp contents of /proc/cpuinfo into FILE_BUF */
122   fh = open("/proc/cpuinfo", O_RDONLY, S_IRUSR);
123   if (fh < 0) return NULL;
124
125   /* Determine the size of /proc/cpuinfo.
126      Work around broken-ness in /proc file system implementation.
127      fstat returns a zero size for /proc/cpuinfo although it is
128      claimed to be a regular file. */
129   num_bytes = 0;
130   file_buf_size = 1000;
131   file_buf = malloc(file_buf_size + 1);
132
133   while (42) {
134      n = read(fh, file_buf, file_buf_size);
135      if (n < 0) break;
136
137      num_bytes += n;
138      if (n < file_buf_size) break;  /* reached EOF */
139   }
140
141   if (n < 0) num_bytes = 0;   /* read error; ignore contents */
142
143   if (num_bytes > file_buf_size) {
144      free(file_buf);
145      lseek(fh, 0, SEEK_SET);
146      file_buf = malloc(num_bytes + 1);
147      n = read(fh, file_buf, num_bytes);
148      if (n < 0) num_bytes = 0;
149   }
150
151   file_buf[num_bytes] = '\0';
152   close(fh);
153
154   /* Parse file */
155   model = models + sizeof models / sizeof models[0];
156   for (p = file_buf; *p; ++p) {
157      /* Beginning of line */
158      if (strncmp(p, "processor", sizeof "processor" - 1 ) != 0) continue;
159
160      m = strstr(p, "machine");
161      if (m == NULL) continue;
162
163      p = m + sizeof "machine" - 1;
164      while (isspace(*p) || *p == '=') {
165         if (*p == '\n') goto next_line;
166         ++p;
167      }
168
169      model_name = p;
170      for (n = 0; n < sizeof models / sizeof models[0]; ++n) {
171         model_info *mm = models + n;
172         size_t len = strlen(mm->cpuinfo_name);
173         if (strncmp(mm->cpuinfo_name, model_name, len) == 0 &&
174             isspace(model_name[len])) {
175            /* In case there are different CPUs in this cluster return the
176               one with the dewest capabilities ("oldest" model). */
177            if (mm < model) model = mm;
178            p = model_name + len;
179            break;
180         }
181      }
182      /* Skip until end-of-line */
183      while (*p != '\n')
184         ++p;
185   next_line: ;
186   }
187
188   free(file_buf);
189
190   if (model == models + sizeof models / sizeof models[0]) return NULL;
191
192   return model;
193}
194
195
196/* Convenience macro that maps the facility bit number as given in the
197   Principles of Ops "facility indications" section to a bit mask */
198#define FAC_BIT(x)   (1ULL << (63 - (x)))
199
200static int go(char *feature, char *cpu)
201{
202   unsigned long long facilities;
203   unsigned long long match;
204   model_info *host, *from, *to, *p;
205   char *colon;
206
207   facilities = stfle();
208
209   if        (strcmp(feature, "s390x-zarch") == 0 ) {
210      match = (facilities & FAC_BIT(1)) && (facilities & FAC_BIT(2));
211   } else if (strcmp(feature, "s390x-n3") == 0 ) {
212      match = facilities & FAC_BIT(0);
213   } else if (strcmp(feature, "s390x-stfle") == 0 ) {
214      match = facilities & FAC_BIT(7);
215   } else if (strcmp(feature, "s390x-ldisp") == 0 ) {
216      match = (facilities & FAC_BIT(18)) && (facilities & FAC_BIT(19));
217   } else if (strcmp(feature, "s390x-eimm") == 0 ) {
218      match = facilities & FAC_BIT(21);
219   } else if (strcmp(feature, "s390x-stckf") == 0 ) {
220      match = facilities & FAC_BIT(25);
221   } else if (strcmp(feature, "s390x-genins") == 0 ) {
222      match = facilities & FAC_BIT(34);
223   } else if (strcmp(feature, "s390x-exrl") == 0 ) {
224      match = facilities & FAC_BIT(35);
225   } else if (strcmp(feature, "s390x-etf3") == 0 ) {
226      match = facilities & FAC_BIT(30);
227   } else if (strcmp(feature, "s390x-fpext") == 0 ) {
228      match = facilities & FAC_BIT(37);
229   } else if (strcmp(feature, "s390x-dfp") == 0 ) {
230      match = facilities & FAC_BIT(42);
231   } else if (strcmp(feature, "s390x-pfpo") == 0 ) {
232      match = facilities & FAC_BIT(44);
233   } else {
234      return 2;          // Unrecognised feature.
235   }
236
237   if (match == 0) return 1;   // facility not provided
238
239   /* Host provides facility. If no CPU was specified, we're done. */
240   if (cpu == NULL) return 0;
241
242   host = get_host();
243   if (host == NULL) return 1;  // unknown model
244
245   //   printf("host = %s (%s)\n", host->cpuinfo_name, host->real_name);
246
247   /* Determine interval of models in which to search for HOST. */
248   from = to = NULL;
249   colon = strchr(cpu, ':');
250
251   if (colon == NULL) {
252      // match exact
253      from = to = locate_model(cpu);
254   } else if (colon == cpu) {
255      // :NAME  match machines up to and including CPU
256      from = models;
257      to   = locate_model(cpu + 1);
258   } else if (colon[1] == '\0') {
259      // NAME:  match machines beginning with CPU or later
260      *colon = '\0';
261      from = locate_model(cpu);
262      to   = models + sizeof models / sizeof models[0] - 1;
263      *colon = ':';
264   } else {
265      // NAME:NAME  match machines in interval
266      *colon = '\0';
267      from = locate_model(cpu);
268      to   = locate_model(colon + 1);
269      *colon = ':';
270   }
271
272   if (from == NULL || to == NULL || from > to) {
273      fprintf(stderr, "invalid cpu specification '%s'\n", cpu);
274      return 3;
275   }
276
277#if 0
278   printf("from  %s (%s)  to  %s (%s)\n", from->cpuinfo_name, from->real_name,
279          to->cpuinfo_name, to->real_name);
280#endif
281
282   /* Search for HOST. */
283   for (p = from; p <= to; ++p) {
284      if (p == host) return 0;
285   }
286
287   return 1; // host does not match CPU specification
288}
289
290#else
291
292static int go(char *feature, char *cpu)
293{
294   return 2;      // Feature not recognised (non-s390x machine!)
295}
296
297#endif
298
299
300//---------------------------------------------------------------------------
301// main
302//---------------------------------------------------------------------------
303int main(int argc, char **argv)
304{
305   int rc, inverted = 0;
306
307   if (argc < 2 || argc > 3) {
308      fprintf( stderr, "usage: s390x_features <feature> [<machine-model>]\n" );
309      exit(3);                // Usage error.
310   }
311
312   if (argv[1][0] == '!') {
313      assert(argv[2] == NULL);   // not allowed
314      inverted = 1;
315      ++argv[1];
316   }
317
318   rc = go(argv[1], argv[2]);
319
320   if (inverted) {
321      switch (rc) {
322      case 0: rc = 1; break;
323      case 1: rc = 0; break;
324      case 2: rc = 2; break;
325      }
326   }
327
328   //   printf("rc = %d\n", rc);
329
330   return rc;
331}
332