1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright IBM Corp. 2019
  4 */
  5#include <linux/pgtable.h>
  6#include <asm/physmem_info.h>
  7#include <asm/cpacf.h>
  8#include <asm/timex.h>
  9#include <asm/sclp.h>
 10#include <asm/kasan.h>
 11#include "decompressor.h"
 12#include "boot.h"
 13
 14#define PRNG_MODE_TDES	 1
 15#define PRNG_MODE_SHA512 2
 16#define PRNG_MODE_TRNG	 3
 17
 18struct prno_parm {
 19	u32 res;
 20	u32 reseed_counter;
 21	u64 stream_bytes;
 22	u8  V[112];
 23	u8  C[112];
 24};
 25
 26struct prng_parm {
 27	u8  parm_block[32];
 28	u32 reseed_counter;
 29	u64 byte_counter;
 30};
 31
 32static int check_prng(void)
 33{
 34	if (!cpacf_query_func(CPACF_KMC, CPACF_KMC_PRNG)) {
 35		boot_printk("KASLR disabled: CPU has no PRNG\n");
 36		return 0;
 37	}
 38	if (cpacf_query_func(CPACF_PRNO, CPACF_PRNO_TRNG))
 39		return PRNG_MODE_TRNG;
 40	if (cpacf_query_func(CPACF_PRNO, CPACF_PRNO_SHA512_DRNG_GEN))
 41		return PRNG_MODE_SHA512;
 42	else
 43		return PRNG_MODE_TDES;
 44}
 45
 46int get_random(unsigned long limit, unsigned long *value)
 47{
 48	struct prng_parm prng = {
 49		/* initial parameter block for tdes mode, copied from libica */
 50		.parm_block = {
 51			0x0F, 0x2B, 0x8E, 0x63, 0x8C, 0x8E, 0xD2, 0x52,
 52			0x64, 0xB7, 0xA0, 0x7B, 0x75, 0x28, 0xB8, 0xF4,
 53			0x75, 0x5F, 0xD2, 0xA6, 0x8D, 0x97, 0x11, 0xFF,
 54			0x49, 0xD8, 0x23, 0xF3, 0x7E, 0x21, 0xEC, 0xA0
 55		},
 56	};
 57	unsigned long seed, random;
 58	struct prno_parm prno;
 59	__u64 entropy[4];
 60	int mode, i;
 61
 62	mode = check_prng();
 63	seed = get_tod_clock_fast();
 64	switch (mode) {
 65	case PRNG_MODE_TRNG:
 66		cpacf_trng(NULL, 0, (u8 *) &random, sizeof(random));
 67		break;
 68	case PRNG_MODE_SHA512:
 69		cpacf_prno(CPACF_PRNO_SHA512_DRNG_SEED, &prno, NULL, 0,
 70			   (u8 *) &seed, sizeof(seed));
 71		cpacf_prno(CPACF_PRNO_SHA512_DRNG_GEN, &prno, (u8 *) &random,
 72			   sizeof(random), NULL, 0);
 73		break;
 74	case PRNG_MODE_TDES:
 75		/* add entropy */
 76		*(unsigned long *) prng.parm_block ^= seed;
 77		for (i = 0; i < 16; i++) {
 78			cpacf_kmc(CPACF_KMC_PRNG, prng.parm_block,
 79				  (u8 *) entropy, (u8 *) entropy,
 80				  sizeof(entropy));
 81			memcpy(prng.parm_block, entropy, sizeof(entropy));
 82		}
 83		random = seed;
 84		cpacf_kmc(CPACF_KMC_PRNG, prng.parm_block, (u8 *) &random,
 85			  (u8 *) &random, sizeof(random));
 86		break;
 87	default:
 88		return -1;
 89	}
 90	*value = random % limit;
 91	return 0;
 92}
 93
 94static void sort_reserved_ranges(struct reserved_range *res, unsigned long size)
 95{
 96	struct reserved_range tmp;
 97	int i, j;
 98
 99	for (i = 1; i < size; i++) {
100		tmp = res[i];
101		for (j = i - 1; j >= 0 && res[j].start > tmp.start; j--)
102			res[j + 1] = res[j];
103		res[j + 1] = tmp;
104	}
105}
106
107static unsigned long iterate_valid_positions(unsigned long size, unsigned long align,
108					     unsigned long _min, unsigned long _max,
109					     struct reserved_range *res, size_t res_count,
110					     bool pos_count, unsigned long find_pos)
111{
112	unsigned long start, end, tmp_end, range_pos, pos = 0;
113	struct reserved_range *res_end = res + res_count;
114	struct reserved_range *skip_res;
115	int i;
116
117	align = max(align, 8UL);
118	_min = round_up(_min, align);
119	for_each_physmem_usable_range(i, &start, &end) {
120		if (_min >= end)
121			continue;
122		start = round_up(start, align);
123		if (start >= _max)
124			break;
125		start = max(_min, start);
126		end = min(_max, end);
127
128		while (start + size <= end) {
129			/* skip reserved ranges below the start */
130			while (res && res->end <= start) {
131				res++;
132				if (res >= res_end)
133					res = NULL;
134			}
135			skip_res = NULL;
136			tmp_end = end;
137			/* has intersecting reserved range */
138			if (res && res->start < end) {
139				skip_res = res;
140				tmp_end = res->start;
141			}
142			if (start + size <= tmp_end) {
143				range_pos = (tmp_end - start - size) / align + 1;
144				if (pos_count) {
145					pos += range_pos;
146				} else {
147					if (range_pos >= find_pos)
148						return start + (find_pos - 1) * align;
149					find_pos -= range_pos;
150				}
151			}
152			if (!skip_res)
153				break;
154			start = round_up(skip_res->end, align);
155		}
156	}
157
158	return pos_count ? pos : 0;
159}
160
161/*
162 * Two types of decompressor memory allocations/reserves are considered
163 * differently.
164 *
165 * "Static" or "single" allocations are done via physmem_alloc_range() and
166 * physmem_reserve(), and they are listed in physmem_info.reserved[]. Each
167 * type of "static" allocation can only have one allocation per type and
168 * cannot have chains.
169 *
170 * On the other hand, "dynamic" or "repetitive" allocations are done via
171 * physmem_alloc_top_down(). These allocations are tightly packed together
172 * top down from the end of online memory. physmem_alloc_pos represents
173 * current position where those allocations start.
174 *
175 * Functions randomize_within_range() and iterate_valid_positions()
176 * only consider "dynamic" allocations by never looking above
177 * physmem_alloc_pos. "Static" allocations, however, are explicitly
178 * considered by checking the "res" (reserves) array. The first
179 * reserved_range of a "dynamic" allocation may also be checked along the
180 * way, but it will always be above the maximum value anyway.
181 */
182unsigned long randomize_within_range(unsigned long size, unsigned long align,
183				     unsigned long min, unsigned long max)
184{
185	struct reserved_range res[RR_MAX];
186	unsigned long max_pos, pos;
187
188	memcpy(res, physmem_info.reserved, sizeof(res));
189	sort_reserved_ranges(res, ARRAY_SIZE(res));
190	max = min(max, get_physmem_alloc_pos());
191
192	max_pos = iterate_valid_positions(size, align, min, max, res, ARRAY_SIZE(res), true, 0);
193	if (!max_pos)
194		return 0;
195	if (get_random(max_pos, &pos))
196		return 0;
197	return iterate_valid_positions(size, align, min, max, res, ARRAY_SIZE(res), false, pos + 1);
198}