[thirdparty/qemu.git] / target / s390x / cpu_features.c

/*
 * CPU features/facilities for s390x
 *
 * Copyright IBM Corp. 2016, 2018
 * Copyright Red Hat, Inc. 2019
 *
 * Author(s): David Hildenbrand <david@redhat.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or (at
 * your option) any later version. See the COPYING file in the top-level
 * directory.
 */

#include "qemu/osdep.h"
#include "qemu/module.h"
#include "cpu_features.h"
#ifndef CONFIG_USER_ONLY
#include "target/s390x/kvm/pv.h"
#endif

#define DEF_FEAT(_FEAT, _NAME, _TYPE, _BIT, _DESC) \
    [S390_FEAT_##_FEAT] = {                        \
        .name = _NAME,                             \
        .type = S390_FEAT_TYPE_##_TYPE,            \
        .bit = _BIT,                               \
        .desc = _DESC,                             \
    },
static const S390FeatDef s390_features[S390_FEAT_MAX] = {
    #include "cpu_features_def.h.inc"
};
#undef DEF_FEAT

const S390FeatDef *s390_feat_def(S390Feat feat)
{
    return &s390_features[feat];
}

S390Feat s390_feat_by_type_and_bit(S390FeatType type, int bit)
{
    S390Feat feat;

    for (feat = 0; feat < ARRAY_SIZE(s390_features); feat++) {
        if (s390_features[feat].type == type &&
            s390_features[feat].bit == bit) {
            return feat;
        }
    }
    return S390_FEAT_MAX;
}

void s390_init_feat_bitmap(const S390FeatInit init, S390FeatBitmap bitmap)
{
    int i, j;

    for (i = 0; i < (S390_FEAT_MAX / 64 + 1); i++) {
        if (init[i]) {
            for (j = 0; j < 64; j++) {
                if (init[i] & 1ULL << j) {
                    set_bit(i * 64 + j, bitmap);
                }
            }
        }
    }
}

void s390_fill_feat_block(const S390FeatBitmap features, S390FeatType type,
                          uint8_t *data)
{
    S390Feat feat;
    int bit_nr;

    switch (type) {
    case S390_FEAT_TYPE_STFL:
        if (test_bit(S390_FEAT_ZARCH, features)) {
            /* Features that are always active */
            set_be_bit(2, data);   /* z/Architecture */
            set_be_bit(138, data); /* Configuration-z-architectural-mode */
        }
        break;
    case S390_FEAT_TYPE_PTFF:
    case S390_FEAT_TYPE_KMAC:
    case S390_FEAT_TYPE_KMC:
    case S390_FEAT_TYPE_KM:
    case S390_FEAT_TYPE_KIMD:
    case S390_FEAT_TYPE_KLMD:
    case S390_FEAT_TYPE_PCKMO:
    case S390_FEAT_TYPE_KMCTR:
    case S390_FEAT_TYPE_KMF:
    case S390_FEAT_TYPE_KMO:
    case S390_FEAT_TYPE_PCC:
    case S390_FEAT_TYPE_PPNO:
    case S390_FEAT_TYPE_KMA:
    case S390_FEAT_TYPE_KDSA:
    case S390_FEAT_TYPE_SORTL:
    case S390_FEAT_TYPE_DFLTCC:
        set_be_bit(0, data); /* query is always available */
        break;
    default:
        break;
    };

    feat = find_first_bit(features, S390_FEAT_MAX);
    while (feat < S390_FEAT_MAX) {
        if (s390_features[feat].type == type) {
            bit_nr = s390_features[feat].bit;
            /* big endian on uint8_t array */
            set_be_bit(bit_nr, data);
        }
        feat = find_next_bit(features, S390_FEAT_MAX, feat + 1);
    }

#ifndef CONFIG_USER_ONLY
    if (!s390_is_pv()) {
        return;
    }

    /*
     * Some facilities are not available for CPUs in protected mode:
     * - All SIE facilities because SIE is not available
     * - DIAG318
     *
     * As VMs can move in and out of protected mode the CPU model
     * doesn't protect us from that problem because it is only
     * validated at the start of the VM.
     */
    switch (type) {
    case S390_FEAT_TYPE_SCLP_CPU:
        clear_be_bit(s390_feat_def(S390_FEAT_SIE_F2)->bit, data);
        clear_be_bit(s390_feat_def(S390_FEAT_SIE_SKEY)->bit, data);
        clear_be_bit(s390_feat_def(S390_FEAT_SIE_GPERE)->bit, data);
        clear_be_bit(s390_feat_def(S390_FEAT_SIE_SIIF)->bit, data);
        clear_be_bit(s390_feat_def(S390_FEAT_SIE_SIGPIF)->bit, data);
        clear_be_bit(s390_feat_def(S390_FEAT_SIE_IB)->bit, data);
        clear_be_bit(s390_feat_def(S390_FEAT_SIE_CEI)->bit, data);
        break;
    case S390_FEAT_TYPE_SCLP_CONF_CHAR:
        clear_be_bit(s390_feat_def(S390_FEAT_SIE_GSLS)->bit, data);
        clear_be_bit(s390_feat_def(S390_FEAT_HPMA2)->bit, data);
        clear_be_bit(s390_feat_def(S390_FEAT_SIE_KSS)->bit, data);
        break;
    case S390_FEAT_TYPE_SCLP_CONF_CHAR_EXT:
        clear_be_bit(s390_feat_def(S390_FEAT_SIE_64BSCAO)->bit, data);
        clear_be_bit(s390_feat_def(S390_FEAT_SIE_CMMA)->bit, data);
        clear_be_bit(s390_feat_def(S390_FEAT_SIE_PFMFI)->bit, data);
        clear_be_bit(s390_feat_def(S390_FEAT_SIE_IBS)->bit, data);
        break;
    case S390_FEAT_TYPE_SCLP_FAC134:
        clear_be_bit(s390_feat_def(S390_FEAT_DIAG_318)->bit, data);
        break;
    default:
        return;
    }
#endif
}

void s390_add_from_feat_block(S390FeatBitmap features, S390FeatType type,
                              uint8_t *data)
{
    int nr_bits, le_bit;

    switch (type) {
    case S390_FEAT_TYPE_STFL:
       nr_bits = 16384;
       break;
    case S390_FEAT_TYPE_PLO:
    case S390_FEAT_TYPE_SORTL:
    case S390_FEAT_TYPE_DFLTCC:
       nr_bits = 256;
       break;
    default:
       /* all cpu subfunctions have 128 bit */
       nr_bits = 128;
    };

    le_bit = find_first_bit((unsigned long *) data, nr_bits);
    while (le_bit < nr_bits) {
        /* convert the bit number to a big endian bit nr */
        S390Feat feat = s390_feat_by_type_and_bit(type, BE_BIT_NR(le_bit));
        /* ignore unknown bits */
        if (feat < S390_FEAT_MAX) {
            set_bit(feat, features);
        }
        le_bit = find_next_bit((unsigned long *) data, nr_bits, le_bit + 1);
    }
}

void s390_feat_bitmap_to_ascii(const S390FeatBitmap features, void *opaque,
                               void (*fn)(const char *name, void *opaque))
{
    S390FeatBitmap bitmap, tmp;
    S390FeatGroup group;
    S390Feat feat;

    bitmap_copy(bitmap, features, S390_FEAT_MAX);

    /* process whole groups first */
    for (group = 0; group < S390_FEAT_GROUP_MAX; group++) {
        const S390FeatGroupDef *def = s390_feat_group_def(group);

        bitmap_and(tmp, bitmap, def->feat, S390_FEAT_MAX);
        if (bitmap_equal(tmp, def->feat, S390_FEAT_MAX)) {
            bitmap_andnot(bitmap, bitmap, def->feat, S390_FEAT_MAX);
            fn(def->name, opaque);
        }
    }

    /* report leftovers as separate features */
    feat = find_first_bit(bitmap, S390_FEAT_MAX);
    while (feat < S390_FEAT_MAX) {
        fn(s390_feat_def(feat)->name, opaque);
        feat = find_next_bit(bitmap, S390_FEAT_MAX, feat + 1);
    };
}

void s390_get_deprecated_features(S390FeatBitmap features)
{
    static const int feats[] = {
         /* CSSKE is deprecated on newer generations */
         S390_FEAT_CONDITIONAL_SSKE,
         S390_FEAT_BPB,
         /* Deprecated on z16 */
         S390_FEAT_CONSTRAINT_TRANSACTIONAL_EXE,
         S390_FEAT_TRANSACTIONAL_EXE
    };
    int i;

    for (i = 0; i < ARRAY_SIZE(feats); i++) {
        set_bit(feats[i], features);
    }
}

#define FEAT_GROUP_INIT(_name, _group, _desc)        \
    {                                                \
        .name = _name,                               \
        .desc = _desc,                               \
        .init = { S390_FEAT_GROUP_LIST_ ## _group }, \
    }

/* indexed by feature group number for easy lookup */
static S390FeatGroupDef s390_feature_groups[] = {
    FEAT_GROUP_INIT("plo", PLO, "Perform-locked-operation facility"),
    FEAT_GROUP_INIT("tods", TOD_CLOCK_STEERING, "Tod-clock-steering facility"),
    FEAT_GROUP_INIT("gen13ptff", GEN13_PTFF, "PTFF enhancements introduced with z13"),
    FEAT_GROUP_INIT("msa", MSA, "Message-security-assist facility"),
    FEAT_GROUP_INIT("msa1", MSA_EXT_1, "Message-security-assist-extension 1 facility"),
    FEAT_GROUP_INIT("msa2", MSA_EXT_2, "Message-security-assist-extension 2 facility"),
    FEAT_GROUP_INIT("msa3", MSA_EXT_3, "Message-security-assist-extension 3 facility"),
    FEAT_GROUP_INIT("msa4", MSA_EXT_4, "Message-security-assist-extension 4 facility"),
    FEAT_GROUP_INIT("msa5", MSA_EXT_5, "Message-security-assist-extension 5 facility"),
    FEAT_GROUP_INIT("msa6", MSA_EXT_6, "Message-security-assist-extension 6 facility"),
    FEAT_GROUP_INIT("msa7", MSA_EXT_7, "Message-security-assist-extension 7 facility"),
    FEAT_GROUP_INIT("msa8", MSA_EXT_8, "Message-security-assist-extension 8 facility"),
    FEAT_GROUP_INIT("msa9", MSA_EXT_9, "Message-security-assist-extension 9 facility"),
    FEAT_GROUP_INIT("msa9_pckmo", MSA_EXT_9_PCKMO, "Message-security-assist-extension 9 PCKMO subfunctions"),
    FEAT_GROUP_INIT("mepochptff", MULTIPLE_EPOCH_PTFF, "PTFF enhancements introduced with Multiple-epoch facility"),
    FEAT_GROUP_INIT("esort", ENH_SORT, "Enhanced-sort facility"),
    FEAT_GROUP_INIT("deflate", DEFLATE_CONVERSION, "Deflate-conversion facility"),
};

const S390FeatGroupDef *s390_feat_group_def(S390FeatGroup group)
{
    return &s390_feature_groups[group];
}

static void init_groups(void)
{
    int i;

    /* init all bitmaps from generated data initially */
    for (i = 0; i < ARRAY_SIZE(s390_feature_groups); i++) {
        s390_init_feat_bitmap(s390_feature_groups[i].init,
                              s390_feature_groups[i].feat);
    }
}

type_init(init_groups)
Commit	Line	Data
78241744 MM	1	/*
	2	* CPU features/facilities for s390x
	3	*
27e84d4e	4	* Copyright IBM Corp. 2016, 2018
220ae900	5	* Copyright Red Hat, Inc. 2019
78241744	6	*
220ae900	7	* Author(s): David Hildenbrand <david@redhat.com>
78241744 MM	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2 or (at
	10	* your option) any later version. See the COPYING file in the top-level
	11	* directory.
	12	*/
	13
	14	#include "qemu/osdep.h"
8b3d6cb1	15	#include "qemu/module.h"
78241744	16	#include "cpu_features.h"
3ea7e312	17	#ifndef CONFIG_USER_ONLY
f5f9c6ea	18	#include "target/s390x/kvm/pv.h"
3ea7e312	19	#endif
78241744	20
220ae900 DH	21	#define DEF_FEAT(_FEAT, _NAME, _TYPE, _BIT, _DESC) \
	22	[S390_FEAT_##_FEAT] = { \
	23	.name = _NAME, \
	24	.type = S390_FEAT_TYPE_##_TYPE, \
	25	.bit = _BIT, \
	26	.desc = _DESC, \
	27	},
	28	static const S390FeatDef s390_features[S390_FEAT_MAX] = {
0979ed01	29	#include "cpu_features_def.h.inc"
78241744	30	};
220ae900	31	#undef DEF_FEAT
78241744 MM	32
	33	const S390FeatDef *s390_feat_def(S390Feat feat)
	34	{
	35	return &s390_features[feat];
	36	}
	37
	38	S390Feat s390_feat_by_type_and_bit(S390FeatType type, int bit)
	39	{
	40	S390Feat feat;
	41
	42	for (feat = 0; feat < ARRAY_SIZE(s390_features); feat++) {
	43	if (s390_features[feat].type == type &&
	44	s390_features[feat].bit == bit) {
	45	return feat;
	46	}
	47	}
	48	return S390_FEAT_MAX;
	49	}
	50
	51	void s390_init_feat_bitmap(const S390FeatInit init, S390FeatBitmap bitmap)
	52	{
	53	int i, j;
	54
	55	for (i = 0; i < (S390_FEAT_MAX / 64 + 1); i++) {
	56	if (init[i]) {
	57	for (j = 0; j < 64; j++) {
	58	if (init[i] & 1ULL << j) {
	59	set_bit(i * 64 + j, bitmap);
	60	}
	61	}
	62	}
	63	}
	64	}
	65
	66	void s390_fill_feat_block(const S390FeatBitmap features, S390FeatType type,
	67	uint8_t *data)
	68	{
	69	S390Feat feat;
	70	int bit_nr;
	71
cc18f907 DH	72	switch (type) {
	73	case S390_FEAT_TYPE_STFL:
	74	if (test_bit(S390_FEAT_ZARCH, features)) {
	75	/* Features that are always active */
3d1cfc3c DH	76	set_be_bit(2, data); /* z/Architecture */
3d1cfc3c DH	77	set_be_bit(138, data); /* Configuration-z-architectural-mode */
cc18f907 DH	78	}
	79	break;
	80	case S390_FEAT_TYPE_PTFF:
	81	case S390_FEAT_TYPE_KMAC:
	82	case S390_FEAT_TYPE_KMC:
	83	case S390_FEAT_TYPE_KM:
	84	case S390_FEAT_TYPE_KIMD:
	85	case S390_FEAT_TYPE_KLMD:
	86	case S390_FEAT_TYPE_PCKMO:
	87	case S390_FEAT_TYPE_KMCTR:
	88	case S390_FEAT_TYPE_KMF:
	89	case S390_FEAT_TYPE_KMO:
	90	case S390_FEAT_TYPE_PCC:
	91	case S390_FEAT_TYPE_PPNO:
	92	case S390_FEAT_TYPE_KMA:
5dacbe23	93	case S390_FEAT_TYPE_KDSA:
d220fabf	94	case S390_FEAT_TYPE_SORTL:
afc7b866	95	case S390_FEAT_TYPE_DFLTCC:
3d1cfc3c	96	set_be_bit(0, data); /* query is always available */
cc18f907 DH	97	break;
	98	default:
	99	break;
	100	};
78241744 MM	101
	102	feat = find_first_bit(features, S390_FEAT_MAX);
	103	while (feat < S390_FEAT_MAX) {
	104	if (s390_features[feat].type == type) {
	105	bit_nr = s390_features[feat].bit;
	106	/* big endian on uint8_t array */
3d1cfc3c	107	set_be_bit(bit_nr, data);
78241744 MM	108	}
	109	feat = find_next_bit(features, S390_FEAT_MAX, feat + 1);
	110	}
3ded270a	111
3ea7e312	112	#ifndef CONFIG_USER_ONLY
10248418 JF	113	if (!s390_is_pv()) {
	114	return;
	115	}
	116
	117	/*
	118	* Some facilities are not available for CPUs in protected mode:
	119	* - All SIE facilities because SIE is not available
	120	* - DIAG318
	121	*
	122	* As VMs can move in and out of protected mode the CPU model
	123	* doesn't protect us from that problem because it is only
	124	* validated at the start of the VM.
	125	*/
	126	switch (type) {
	127	case S390_FEAT_TYPE_SCLP_CPU:
	128	clear_be_bit(s390_feat_def(S390_FEAT_SIE_F2)->bit, data);
	129	clear_be_bit(s390_feat_def(S390_FEAT_SIE_SKEY)->bit, data);
	130	clear_be_bit(s390_feat_def(S390_FEAT_SIE_GPERE)->bit, data);
	131	clear_be_bit(s390_feat_def(S390_FEAT_SIE_SIIF)->bit, data);
	132	clear_be_bit(s390_feat_def(S390_FEAT_SIE_SIGPIF)->bit, data);
	133	clear_be_bit(s390_feat_def(S390_FEAT_SIE_IB)->bit, data);
	134	clear_be_bit(s390_feat_def(S390_FEAT_SIE_CEI)->bit, data);
	135	break;
	136	case S390_FEAT_TYPE_SCLP_CONF_CHAR:
	137	clear_be_bit(s390_feat_def(S390_FEAT_SIE_GSLS)->bit, data);
	138	clear_be_bit(s390_feat_def(S390_FEAT_HPMA2)->bit, data);
	139	clear_be_bit(s390_feat_def(S390_FEAT_SIE_KSS)->bit, data);
	140	break;
	141	case S390_FEAT_TYPE_SCLP_CONF_CHAR_EXT:
	142	clear_be_bit(s390_feat_def(S390_FEAT_SIE_64BSCAO)->bit, data);
	143	clear_be_bit(s390_feat_def(S390_FEAT_SIE_CMMA)->bit, data);
	144	clear_be_bit(s390_feat_def(S390_FEAT_SIE_PFMFI)->bit, data);
	145	clear_be_bit(s390_feat_def(S390_FEAT_SIE_IBS)->bit, data);
	146	break;
	147	case S390_FEAT_TYPE_SCLP_FAC134:
3ded270a	148	clear_be_bit(s390_feat_def(S390_FEAT_DIAG_318)->bit, data);
10248418 JF	149	break;
	150	default:
	151	return;
3ded270a	152	}
3ea7e312	153	#endif
78241744 MM	154	}
	155
	156	void s390_add_from_feat_block(S390FeatBitmap features, S390FeatType type,
	157	uint8_t *data)
	158	{
	159	int nr_bits, le_bit;
	160
	161	switch (type) {
	162	case S390_FEAT_TYPE_STFL:
c547a757	163	nr_bits = 16384;
78241744 MM	164	break;
78241744 MM	165	case S390_FEAT_TYPE_PLO:
d220fabf	166	case S390_FEAT_TYPE_SORTL:
afc7b866	167	case S390_FEAT_TYPE_DFLTCC:
78241744 MM	168	nr_bits = 256;
	169	break;
	170	default:
	171	/* all cpu subfunctions have 128 bit */
	172	nr_bits = 128;
	173	};
	174
	175	le_bit = find_first_bit((unsigned long *) data, nr_bits);
	176	while (le_bit < nr_bits) {
	177	/* convert the bit number to a big endian bit nr */
	178	S390Feat feat = s390_feat_by_type_and_bit(type, BE_BIT_NR(le_bit));
	179	/* ignore unknown bits */
	180	if (feat < S390_FEAT_MAX) {
	181	set_bit(feat, features);
	182	}
	183	le_bit = find_next_bit((unsigned long *) data, nr_bits, le_bit + 1);
	184	}
	185	}
	186
8b3d6cb1	187	void s390_feat_bitmap_to_ascii(const S390FeatBitmap features, void *opaque,
78241744 MM	188	void (fn)(const char name, void *opaque))
78241744 MM	189	{
8b3d6cb1 DH	190	S390FeatBitmap bitmap, tmp;
8b3d6cb1 DH	191	S390FeatGroup group;
78241744 MM	192	S390Feat feat;
78241744 MM	193
8b3d6cb1 DH	194	bitmap_copy(bitmap, features, S390_FEAT_MAX);
	195
	196	/* process whole groups first */
	197	for (group = 0; group < S390_FEAT_GROUP_MAX; group++) {
	198	const S390FeatGroupDef *def = s390_feat_group_def(group);
	199
	200	bitmap_and(tmp, bitmap, def->feat, S390_FEAT_MAX);
	201	if (bitmap_equal(tmp, def->feat, S390_FEAT_MAX)) {
	202	bitmap_andnot(bitmap, bitmap, def->feat, S390_FEAT_MAX);
	203	fn(def->name, opaque);
	204	}
	205	}
	206
	207	/* report leftovers as separate features */
78241744 MM	208	feat = find_first_bit(bitmap, S390_FEAT_MAX);
	209	while (feat < S390_FEAT_MAX) {
	210	fn(s390_feat_def(feat)->name, opaque);
	211	feat = find_next_bit(bitmap, S390_FEAT_MAX, feat + 1);
	212	};
	213	}
8b3d6cb1	214
8aa2211e CW	215	void s390_get_deprecated_features(S390FeatBitmap features)
	216	{
	217	static const int feats[] = {
	218	/* CSSKE is deprecated on newer generations */
	219	S390_FEAT_CONDITIONAL_SSKE,
	220	S390_FEAT_BPB,
6e55b32d CW	221	/* Deprecated on z16 */
	222	S390_FEAT_CONSTRAINT_TRANSACTIONAL_EXE,
	223	S390_FEAT_TRANSACTIONAL_EXE
8aa2211e CW	224	};
	225	int i;
	226
	227	for (i = 0; i < ARRAY_SIZE(feats); i++) {
	228	set_bit(feats[i], features);
	229	}
	230	}
	231
8b3d6cb1 DH	232	#define FEAT_GROUP_INIT(_name, _group, _desc) \
	233	{ \
	234	.name = _name, \
	235	.desc = _desc, \
	236	.init = { S390_FEAT_GROUP_LIST_ ## _group }, \
	237	}
	238
	239	/* indexed by feature group number for easy lookup */
	240	static S390FeatGroupDef s390_feature_groups[] = {
	241	FEAT_GROUP_INIT("plo", PLO, "Perform-locked-operation facility"),
	242	FEAT_GROUP_INIT("tods", TOD_CLOCK_STEERING, "Tod-clock-steering facility"),
	243	FEAT_GROUP_INIT("gen13ptff", GEN13_PTFF, "PTFF enhancements introduced with z13"),
	244	FEAT_GROUP_INIT("msa", MSA, "Message-security-assist facility"),
	245	FEAT_GROUP_INIT("msa1", MSA_EXT_1, "Message-security-assist-extension 1 facility"),
	246	FEAT_GROUP_INIT("msa2", MSA_EXT_2, "Message-security-assist-extension 2 facility"),
	247	FEAT_GROUP_INIT("msa3", MSA_EXT_3, "Message-security-assist-extension 3 facility"),
	248	FEAT_GROUP_INIT("msa4", MSA_EXT_4, "Message-security-assist-extension 4 facility"),
	249	FEAT_GROUP_INIT("msa5", MSA_EXT_5, "Message-security-assist-extension 5 facility"),
6da5c593 JH	250	FEAT_GROUP_INIT("msa6", MSA_EXT_6, "Message-security-assist-extension 6 facility"),
	251	FEAT_GROUP_INIT("msa7", MSA_EXT_7, "Message-security-assist-extension 7 facility"),
	252	FEAT_GROUP_INIT("msa8", MSA_EXT_8, "Message-security-assist-extension 8 facility"),
5dacbe23 CB	253	FEAT_GROUP_INIT("msa9", MSA_EXT_9, "Message-security-assist-extension 9 facility"),
5dacbe23 CB	254	FEAT_GROUP_INIT("msa9_pckmo", MSA_EXT_9_PCKMO, "Message-security-assist-extension 9 PCKMO subfunctions"),
ddf5d18a	255	FEAT_GROUP_INIT("mepochptff", MULTIPLE_EPOCH_PTFF, "PTFF enhancements introduced with Multiple-epoch facility"),
d220fabf	256	FEAT_GROUP_INIT("esort", ENH_SORT, "Enhanced-sort facility"),
afc7b866	257	FEAT_GROUP_INIT("deflate", DEFLATE_CONVERSION, "Deflate-conversion facility"),
8b3d6cb1 DH	258	};
	259
	260	const S390FeatGroupDef *s390_feat_group_def(S390FeatGroup group)
	261	{
	262	return &s390_feature_groups[group];
	263	}
	264
	265	static void init_groups(void)
	266	{
	267	int i;
	268
cced0d65	269	/* init all bitmaps from generated data initially */
8b3d6cb1 DH	270	for (i = 0; i < ARRAY_SIZE(s390_feature_groups); i++) {
	271	s390_init_feat_bitmap(s390_feature_groups[i].init,
	272	s390_feature_groups[i].feat);
	273	}
	274	}
	275
	276	type_init(init_groups)