aboutsummaryrefslogtreecommitdiff
path: root/sysdeps/s390/cpu-features.c
blob: 39f8c23a60ef38c9db72c66933b9591210ee8fc3 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
/* Initialize cpu feature data.  s390x version.
   Copyright (C) 2023 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

#include <cpu-features.h>

#include <elf/dl-tunables.h>
#include <ifunc-memcmp.h>
#include <string.h>
extern __typeof (memcmp) MEMCMP_DEFAULT;

#define S390_COPY_CPU_FEATURES(SRC_PTR, DEST_PTR)	\
  (DEST_PTR)->hwcap = (SRC_PTR)->hwcap;			\
  (DEST_PTR)->stfle_bits[0] = (SRC_PTR)->stfle_bits[0];

static void
TUNABLE_CALLBACK (set_hwcaps) (tunable_val_t *valp)
{
  /* The current IFUNC selection is always using the most recent
     features which are available via AT_HWCAP or STFLE-bits.  But in
     some scenarios it is useful to adjust this selection.

     The environment variable:

     GLIBC_TUNABLES=glibc.cpu.hwcaps=-xxx,yyy,zzz,....

     can be used to enable HWCAP/STFLE feature yyy, disable HWCAP/STFLE feature
     xxx, where the feature name is case-sensitive and has to match the ones
     used below.  Furthermore, the ARCH-level zzz can be used to set various
     HWCAP/STFLE features at once.  */

  /* Copy the features from dl_s390_cpu_features, which contains the features
     provided by AT_HWCAP and stfle-instruction.  */
  struct cpu_features *cpu_features = &GLRO(dl_s390_cpu_features);
  struct cpu_features cpu_features_orig;
  S390_COPY_CPU_FEATURES (cpu_features, &cpu_features_orig);
  struct cpu_features cpu_features_curr;
  S390_COPY_CPU_FEATURES (cpu_features, &cpu_features_curr);

  const char *token = valp->strval;
  do
    {
      const char *token_end, *feature;
      bool disable;
      size_t token_len;
      size_t feature_len;

      /* Find token separator or end of string.  */
      for (token_end = token; *token_end != ','; token_end++)
	if (*token_end == '\0')
	  break;

      /* Determine feature.  */
      token_len = token_end - token;
      if (*token == '-')
	{
	  disable = true;
	  feature = token + 1;
	  feature_len = token_len - 1;
	}
      else
	{
	  disable = false;
	  feature = token;
	  feature_len = token_len;
	}

      /* Handle only the features here which are really used in the
	 IFUNC-resolvers.  All others are ignored as the values are only used
	 inside glibc.  */
      bool reset_features = false;
      unsigned long int hwcap_mask = 0UL;
      unsigned long long stfle_bits0_mask = 0ULL;

      if ((*feature == 'z' || *feature == 'a'))
	{
	  if ((feature_len == 5 && *feature == 'z'
	       && MEMCMP_DEFAULT (feature, "zEC12", 5) == 0)
	      || (feature_len == 6 && *feature == 'a'
		  && MEMCMP_DEFAULT (feature, "arch10", 6) == 0))
	    {
	      reset_features = true;
	      disable = true;
	      hwcap_mask = HWCAP_S390_VXRS | HWCAP_S390_VXRS_EXT
		| HWCAP_S390_VXRS_EXT2;
	      stfle_bits0_mask = S390_STFLE_MASK_ARCH13_MIE3;
	    }
	  else if ((feature_len == 3 && *feature == 'z'
		    && MEMCMP_DEFAULT (feature, "z13", 3) == 0)
		   || (feature_len == 6 && *feature == 'a'
		       && MEMCMP_DEFAULT (feature, "arch11", 6) == 0))
	    {
	      reset_features = true;
	      disable = true;
	      hwcap_mask = HWCAP_S390_VXRS_EXT | HWCAP_S390_VXRS_EXT2;
	      stfle_bits0_mask = S390_STFLE_MASK_ARCH13_MIE3;
	    }
	  else if ((feature_len == 3 && *feature == 'z'
		    && MEMCMP_DEFAULT (feature, "z14", 3) == 0)
		   || (feature_len == 6 && *feature == 'a'
		       && MEMCMP_DEFAULT (feature, "arch12", 6) == 0))
	    {
	      reset_features = true;
	      disable = true;
	      hwcap_mask = HWCAP_S390_VXRS_EXT2;
	      stfle_bits0_mask = S390_STFLE_MASK_ARCH13_MIE3;
	    }
	  else if ((feature_len == 3 && *feature == 'z'
		    && (MEMCMP_DEFAULT (feature, "z15", 3) == 0
			|| MEMCMP_DEFAULT (feature, "z16", 3) == 0))
		   || (feature_len == 6
		       && (MEMCMP_DEFAULT (feature, "arch13", 6) == 0
			   || MEMCMP_DEFAULT (feature, "arch14", 6) == 0)))
	    {
	      /* For z15 or newer we don't have to disable something,
		 but we have to reset to the original values.  */
	      reset_features = true;
	    }
	}
      else if (*feature == 'H')
	{
	  if (feature_len == 15
	      && MEMCMP_DEFAULT (feature, "HWCAP_S390_VXRS", 15) == 0)
	    {
	      hwcap_mask = HWCAP_S390_VXRS;
	      if (disable)
		hwcap_mask |= HWCAP_S390_VXRS_EXT | HWCAP_S390_VXRS_EXT2;
	    }
	  else if (feature_len == 19
		   && MEMCMP_DEFAULT (feature, "HWCAP_S390_VXRS_EXT", 19) == 0)
	    {
	      hwcap_mask = HWCAP_S390_VXRS_EXT;
	      if (disable)
		hwcap_mask |= HWCAP_S390_VXRS_EXT2;
	      else
		hwcap_mask |= HWCAP_S390_VXRS;
	    }
	  else if (feature_len == 20
		   && MEMCMP_DEFAULT (feature, "HWCAP_S390_VXRS_EXT2", 20) == 0)
	    {
	      hwcap_mask = HWCAP_S390_VXRS_EXT2;
	      if (!disable)
		hwcap_mask |= HWCAP_S390_VXRS | HWCAP_S390_VXRS_EXT;
	    }
	}
      else if (*feature == 'S')
	{
	  if (feature_len == 10
	      && MEMCMP_DEFAULT (feature, "STFLE_MIE3", 10) == 0)
	    {
	      stfle_bits0_mask = S390_STFLE_MASK_ARCH13_MIE3;
	    }
	}

      /* Perform the actions determined above.  */
      if (reset_features)
	{
	  S390_COPY_CPU_FEATURES (&cpu_features_orig, &cpu_features_curr);
	}

      if (hwcap_mask != 0UL)
	{
	  if (disable)
	    cpu_features_curr.hwcap &= ~hwcap_mask;
	  else
	    cpu_features_curr.hwcap |= hwcap_mask;
	}

      if (stfle_bits0_mask != 0ULL)
	{
	  if (disable)
	    cpu_features_curr.stfle_bits[0] &= ~stfle_bits0_mask;
	  else
	    cpu_features_curr.stfle_bits[0] |= stfle_bits0_mask;
	}

      /* Jump over current token ... */
      token += token_len;

      /* ... and skip token separator for next round.  */
      if (*token == ',') token++;
    }
  while (*token != '\0');

  /* Copy back the features after checking that no unsupported features were
     enabled by user.  */
  cpu_features->hwcap = cpu_features_curr.hwcap & cpu_features_orig.hwcap;
  cpu_features->stfle_bits[0] = cpu_features_curr.stfle_bits[0]
    & cpu_features_orig.stfle_bits[0];
}

static inline void
init_cpu_features (struct cpu_features *cpu_features)
{
  /* Fill cpu_features as passed by kernel and machine.  */
  cpu_features->hwcap = GLRO(dl_hwcap);

  /* We want just 1 double word to be returned.  */
  if (__glibc_likely ((cpu_features->hwcap & HWCAP_S390_STFLE)
		      && (cpu_features->hwcap & HWCAP_S390_ZARCH)
		      && (cpu_features->hwcap & HWCAP_S390_HIGH_GPRS)))
    {
      register unsigned long reg0 __asm__("0") = 0;
      __asm__ __volatile__(".machine push"        "\n\t"
			   ".machine \"z9-109\""  "\n\t"
			   ".machinemode \"zarch_nohighgprs\"\n\t"
			   "stfle %0"             "\n\t"
			   ".machine pop"         "\n"
			   : "=QS" (cpu_features->stfle_bits[0]),
			     "+d" (reg0)
			   : : "cc");
    }
  else
    {
      cpu_features->stfle_bits[0] = 0ULL;
    }

  TUNABLE_GET (glibc, cpu, hwcaps, tunable_val_t *, TUNABLE_CALLBACK (set_hwcaps));
}