cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

s390-ccw.h (4370B)

      1/*
      2 * S390 CCW boot loader
      3 *
      4 * Copyright (c) 2013 Alexander Graf <agraf@suse.de>
      5 *
      6 * This work is licensed under the terms of the GNU GPL, version 2 or (at
      7 * your option) any later version. See the COPYING file in the top-level
      8 * directory.
      9 */
     10
     11#ifndef S390_CCW_H
     12#define S390_CCW_H
     13
     14/* #define DEBUG */
     15
     16typedef unsigned char      u8;
     17typedef unsigned short     u16;
     18typedef unsigned int       u32;
     19typedef unsigned long long u64;
     20typedef unsigned long      ulong;
     21typedef unsigned char      __u8;
     22typedef unsigned short     __u16;
     23typedef unsigned int       __u32;
     24typedef unsigned long long __u64;
     25
     26#define true 1
     27#define false 0
     28#define PAGE_SIZE 4096
     29
     30#define EIO     1
     31#define EBUSY   2
     32#define ENODEV  3
     33
     34#ifndef NULL
     35#define NULL    0
     36#endif
     37#ifndef MIN
     38#define MIN(a, b) (((a) < (b)) ? (a) : (b))
     39#endif
     40#ifndef MIN_NON_ZERO
     41#define MIN_NON_ZERO(a, b) ((a) == 0 ? (b) : \
     42                            ((b) == 0 ? (a) : (MIN(a, b))))
     43#endif
     44
     45#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
     46
     47#include "cio.h"
     48#include "iplb.h"
     49
     50/* start.s */
     51void disabled_wait(void) __attribute__ ((__noreturn__));
     52void consume_sclp_int(void);
     53void consume_io_int(void);
     54
     55/* main.c */
     56void write_subsystem_identification(void);
     57void write_iplb_location(void);
     58extern char stack[PAGE_SIZE * 8] __attribute__((__aligned__(PAGE_SIZE)));
     59unsigned int get_loadparm_index(void);
     60
     61/* sclp.c */
     62void sclp_print(const char *string);
     63void sclp_set_write_mask(uint32_t receive_mask, uint32_t send_mask);
     64void sclp_setup(void);
     65void sclp_get_loadparm_ascii(char *loadparm);
     66int sclp_read(char *str, size_t count);
     67
     68/* virtio.c */
     69unsigned long virtio_load_direct(ulong rec_list1, ulong rec_list2,
     70                                 ulong subchan_id, void *load_addr);
     71bool virtio_is_supported(SubChannelId schid);
     72int virtio_blk_setup_device(SubChannelId schid);
     73int virtio_read(ulong sector, void *load_addr);
     74
     75/* bootmap.c */
     76void zipl_load(void);
     77
     78/* jump2ipl.c */
     79void write_reset_psw(uint64_t psw);
     80void jump_to_IPL_code(uint64_t address);
     81void jump_to_low_kernel(void);
     82
     83/* menu.c */
     84void menu_set_parms(uint8_t boot_menu_flag, uint32_t boot_menu_timeout);
     85int menu_get_zipl_boot_index(const char *menu_data);
     86bool menu_is_enabled_zipl(void);
     87int menu_get_enum_boot_index(bool *valid_entries);
     88bool menu_is_enabled_enum(void);
     89
     90#define MAX_BOOT_ENTRIES  31
     91
     92__attribute__ ((__noreturn__))
     93static inline void panic(const char *string)
     94{
     95    sclp_print(string);
     96    disabled_wait();
     97}
     98
     99static inline void fill_hex(char *out, unsigned char val)
    100{
    101    const char hex[] = "0123456789abcdef";
    102
    103    out[0] = hex[(val >> 4) & 0xf];
    104    out[1] = hex[val & 0xf];
    105}
    106
    107static inline void fill_hex_val(char *out, void *ptr, unsigned size)
    108{
    109    unsigned char *value = ptr;
    110    unsigned int i;
    111
    112    for (i = 0; i < size; i++) {
    113        fill_hex(&out[i*2], value[i]);
    114    }
    115}
    116
    117static inline void print_int(const char *desc, u64 addr)
    118{
    119    char out[] = ": 0xffffffffffffffff\n";
    120
    121    fill_hex_val(&out[4], &addr, sizeof(addr));
    122
    123    sclp_print(desc);
    124    sclp_print(out);
    125}
    126
    127static inline void debug_print_int(const char *desc, u64 addr)
    128{
    129#ifdef DEBUG
    130    print_int(desc, addr);
    131#endif
    132}
    133
    134static inline void debug_print_addr(const char *desc, void *p)
    135{
    136#ifdef DEBUG
    137    debug_print_int(desc, (unsigned int)(unsigned long)p);
    138#endif
    139}
    140
    141/***********************************************
    142 *           Hypercall functions               *
    143 ***********************************************/
    144
    145#define KVM_S390_VIRTIO_NOTIFY          0
    146#define KVM_S390_VIRTIO_RESET           1
    147#define KVM_S390_VIRTIO_SET_STATUS      2
    148#define KVM_S390_VIRTIO_CCW_NOTIFY      3
    149
    150#define MAX_SECTOR_SIZE 4096
    151
    152static inline void IPL_assert(bool term, const char *message)
    153{
    154    if (!term) {
    155        sclp_print("\n! ");
    156        sclp_print(message);
    157        panic(" !\n"); /* no return */
    158    }
    159}
    160
    161static inline void IPL_check(bool term, const char *message)
    162{
    163    if (!term) {
    164        sclp_print("\n! WARNING: ");
    165        sclp_print(message);
    166        sclp_print(" !\n");
    167    }
    168}
    169
    170extern const unsigned char ebc2asc[256];
    171static inline void ebcdic_to_ascii(const char *src,
    172                                   char *dst,
    173                                   unsigned int size)
    174{
    175    unsigned int i;
    176
    177    for (i = 0; i < size; i++) {
    178        unsigned c = src[i];
    179        dst[i] = ebc2asc[c];
    180    }
    181}
    182
    183#endif /* S390_CCW_H */