// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright IBM Corp. 2019
 */
#include <linux/pgtable.h>
#include <asm/physmem_info.h>
#include <asm/cpacf.h>
#include <asm/timex.h>
#include <asm/sclp.h>
#include <asm/kasan.h>
#include "decompressor.h"
#include "boot.h"

#define PRNG_MODE_TDES  1
#define PRNG_MODE_SHA512 2
#define PRNG_MODE_TRNG  3

struct prno_parm {
 u32 res;
 u32 reseed_counter;
 u64 stream_bytes;
 u8  V[112];
 u8  C[112];
};

struct prng_parm {
 u8  parm_block[32];
 u32 reseed_counter;
 u64 byte_counter;
};

static int check_prng(void)
{
 if (!cpacf_query_func(CPACF_KMC, CPACF_KMC_PRNG)) {
  boot_warn("KASLR disabled: CPU has no PRNG\n");
  return 0;
 }
 if (cpacf_query_func(CPACF_PRNO, CPACF_PRNO_TRNG))
  return PRNG_MODE_TRNG;
 if (cpacf_query_func(CPACF_PRNO, CPACF_PRNO_SHA512_DRNG_GEN))
  return PRNG_MODE_SHA512;
 else
  return PRNG_MODE_TDES;
}

int get_random(unsigned long limit, unsigned long *value)
{
 struct prng_parm prng = {
  /* initial parameter block for tdes mode, copied from libica */
  .parm_block = {
   0x0F, 0x2B, 0x8E, 0x63, 0x8C, 0x8E, 0xD2, 0x52,
   0x64, 0xB7, 0xA0, 0x7B, 0x75, 0x28, 0xB8, 0xF4,
   0x75, 0x5F, 0xD2, 0xA6, 0x8D, 0x97, 0x11, 0xFF,
   0x49, 0xD8, 0x23, 0xF3, 0x7E, 0x21, 0xEC, 0xA0
  },
 };
 unsigned long seed, random;
 struct prno_parm prno;
 __u64 entropy[4];
 int mode, i;

 mode = check_prng();
 seed = get_tod_clock_fast();
 switch (mode) {
 case PRNG_MODE_TRNG:
  cpacf_trng(NULL, 0, (u8 *) &random, sizeof(random));
  break;
 case PRNG_MODE_SHA512:
  cpacf_prno(CPACF_PRNO_SHA512_DRNG_SEED, &prno, NULL, 0,
      (u8 *) &seed, sizeof(seed));
  cpacf_prno(CPACF_PRNO_SHA512_DRNG_GEN, &prno, (u8 *) &random,
      sizeof(random), NULL, 0);
  break;
 case PRNG_MODE_TDES:
  /* add entropy */
  *(unsigned long *) prng.parm_block ^= seed;
  for (i = 0; i < 16; i++) {
   cpacf_kmc(CPACF_KMC_PRNG, prng.parm_block,
      (u8 *) entropy, (u8 *) entropy,
      sizeof(entropy));
   memcpy(prng.parm_block, entropy, sizeof(entropy));
  }
  random = seed;
  cpacf_kmc(CPACF_KMC_PRNG, prng.parm_block, (u8 *) &random,
     (u8 *) &random, sizeof(random));
  break;
 default:
  return -1;
 }
 *value = random % limit;
 return 0;
}

static void sort_reserved_ranges(struct reserved_range *res, unsigned long size)
{
 struct reserved_range tmp;
 int i, j;

 for (i = 1; i < size; i++) {
  tmp = res[i];
  for (j = i - 1; j >= 0 && res[j].start > tmp.start; j--)
   res[j + 1] = res[j];
  res[j + 1] = tmp;
 }
}

static unsigned long iterate_valid_positions(unsigned long size, unsigned long align,
          unsigned long _min, unsigned long _max,
          struct reserved_range *res, size_t res_count,
          bool pos_count, unsigned long find_pos)
{
 unsigned long start, end, tmp_end, range_pos, pos = 0;
 struct reserved_range *res_end = res + res_count;
 struct reserved_range *skip_res;
 int i;

 align = max(align, 8UL);
 _min = round_up(_min, align);
 for_each_physmem_usable_range(i, &start, &end) {
  if (_min >= end)
   continue;
  start = round_up(start, align);
  if (start >= _max)
   break;
  start = max(_min, start);
  end = min(_max, end);

  while (start + size <= end) {
   /* skip reserved ranges below the start */
   while (res && res->end <= start) {
    res++;
    if (res >= res_end)
     res = NULL;
   }
   skip_res = NULL;
   tmp_end = end;
   /* has intersecting reserved range */
   if (res && res->start < end) {
    skip_res = res;
    tmp_end = res->start;
   }
   if (start + size <= tmp_end) {
    range_pos = (tmp_end - start - size) / align + 1;
    if (pos_count) {
     pos += range_pos;
    } else {
     if (range_pos >= find_pos)
      return start + (find_pos - 1) * align;
     find_pos -= range_pos;
    }
   }
   if (!skip_res)
    break;
   start = round_up(skip_res->end, align);
  }
 }

 return pos_count ? pos : 0;
}

/*
 * Two types of decompressor memory allocations/reserves are considered
 * differently.
 *
 * "Static" or "single" allocations are done via physmem_alloc_range() and
 * physmem_reserve(), and they are listed in physmem_info.reserved[]. Each
 * type of "static" allocation can only have one allocation per type and
 * cannot have chains.
 *
 * On the other hand, "dynamic" or "repetitive" allocations are done via
 * physmem_alloc_or_die(). These allocations are tightly packed together
 * top down from the end of online memory. physmem_alloc_pos represents
 * current position where those allocations start.
 *
 * Functions randomize_within_range() and iterate_valid_positions()
 * only consider "dynamic" allocations by never looking above
 * physmem_alloc_pos. "Static" allocations, however, are explicitly
 * considered by checking the "res" (reserves) array. The first
 * reserved_range of a "dynamic" allocation may also be checked along the
 * way, but it will always be above the maximum value anyway.
 */
unsigned long randomize_within_range(unsigned long size, unsigned long align,
         unsigned long min, unsigned long max)
{
 struct reserved_range res[RR_MAX];
 unsigned long max_pos, pos;

 memcpy(res, physmem_info.reserved, sizeof(res));
 sort_reserved_ranges(res, ARRAY_SIZE(res));
 max = min(max, get_physmem_alloc_pos());

 max_pos = iterate_valid_positions(size, align, min, max, res, ARRAY_SIZE(res), true, 0);
 if (!max_pos)
  return 0;
 if (get_random(max_pos, &pos))
  return 0;
 return iterate_valid_positions(size, align, min, max, res, ARRAY_SIZE(res), false, pos + 1);
}