    /* SPDX-License-Identifier: MIT */
    /******************************************************************************
     * kexec.h - Public portion
     *
     * Xen port written by:
     * - Simon 'Horms' Horman <horms@verge.net.au>
     * - Magnus Damm <magnus@valinux.co.jp>
     */

    #ifndef _XEN_PUBLIC_KEXEC_H
    #define _XEN_PUBLIC_KEXEC_H

    /* This file describes the Kexec / Kdump hypercall interface for Xen.
     *
     * Kexec under vanilla Linux allows a user to reboot the physical machine
     * into a new user-specified kernel. The Xen port extends this idea
     * to allow rebooting of the machine from dom0. When kexec for dom0
     * is used to reboot,  both the hypervisor and the domains get replaced
     * with some other kernel. It is possible to kexec between vanilla
     * Linux and Xen and back again. Xen to Xen works well too.
     *
     * The hypercall interface for kexec can be divided into three main
     * types of hypercall operations:
     *
     * 1) Range information:
     *    This is used by the dom0 kernel to ask the hypervisor about various
     *    address information. This information is needed to allow kexec-tools
     *    to fill in the ELF headers for /proc/vmcore properly.
     *
     * 2) Load and unload of images:
     *    There are no big surprises here, the kexec binary from kexec-tools
     *    runs in userspace in dom0. The tool loads/unloads data into the
     *    dom0 kernel such as new kernel, initramfs and hypervisor. When
     *    loaded the dom0 kernel performs a load hypercall operation, and
     *    before releasing all page references the dom0 kernel calls unload.
     *
     * 3) Kexec operation:
     *    This is used to start a previously loaded kernel.
     */

    #include "xen.h"

    #if defined(__i386__) || defined(__x86_64__)
    #define KEXEC_XEN_NO_PAGES 17
    #endif

    /*
     * Prototype for this hypercall is:
     *  int kexec_op(unsigned long cmd, void *args)
     * @cmd  == KEXEC_CMD_...
     *          KEXEC operation to perform
     * @args == Operation-specific extra arguments (NULL if none).
     */

    /*
     * Kexec supports two types of operation:
     * - kexec into a regular kernel, very similar to a standard reboot
     *   - KEXEC_TYPE_DEFAULT is used to specify this type
     * - kexec into a special "crash kernel", aka kexec-on-panic
     *   - KEXEC_TYPE_CRASH is used to specify this type
     *   - parts of our system may be broken at kexec-on-panic time
     *     - the code should be kept as simple and self-contained as possible
     */

    #define KEXEC_TYPE_DEFAULT 0
    #define KEXEC_TYPE_CRASH   1

    /* The kexec implementation for Xen allows the user to load two
     * types of kernels, KEXEC_TYPE_DEFAULT and KEXEC_TYPE_CRASH.
     * All data needed for a kexec reboot is kept in one xen_kexec_image_t
     * per "instance". The data mainly consists of machine address lists to pages
     * together with destination addresses. The data in xen_kexec_image_t
     * is passed to the "code page" which is one page of code that performs
     * the final relocations before jumping to the new kernel.
     */

    typedef struct xen_kexec_image {
    #if defined(__i386__) || defined(__x86_64__)
        unsigned long page_list[KEXEC_XEN_NO_PAGES];
    #endif
        unsigned long indirection_page;
        unsigned long start_address;
    } xen_kexec_image_t;

    /*
     * Perform kexec having previously loaded a kexec or kdump kernel
     * as appropriate.
     * type == KEXEC_TYPE_DEFAULT or KEXEC_TYPE_CRASH [in]
     *
     * Control is transferred to the image entry point with the host in
     * the following state.
     *
     * - The image may be executed on any PCPU and all other PCPUs are
     *   stopped.
     *
     * - Local interrupts are disabled.
     *
     * - Register values are undefined.
     *
     * - The image segments have writeable 1:1 virtual to machine
     *   mappings.  The location of any page tables is undefined and these
     *   page table frames are not be mapped.
     */
    #define KEXEC_CMD_kexec                 0
    typedef struct xen_kexec_exec {
        int type;
    } xen_kexec_exec_t;

    /*
     * Load/Unload kernel image for kexec or kdump.
     * type  == KEXEC_TYPE_DEFAULT or KEXEC_TYPE_CRASH [in]
     * image == relocation information for kexec (ignored for unload) [in]
     */
    #define KEXEC_CMD_kexec_load_v1         1 /* obsolete since 0x00040400 */
    #define KEXEC_CMD_kexec_unload_v1       2 /* obsolete since 0x00040400 */
    typedef struct xen_kexec_load_v1 {
        int type;
        xen_kexec_image_t image;
    } xen_kexec_load_v1_t;

    #define KEXEC_RANGE_MA_CRASH      0 /* machine address and size of crash area */
    #define KEXEC_RANGE_MA_XEN        1 /* machine address and size of Xen itself */
    #define KEXEC_RANGE_MA_CPU        2 /* machine address and size of a CPU note */
    #define KEXEC_RANGE_MA_XENHEAP    3 /* machine address and size of xenheap
                                         * Note that although this is adjacent
                                         * to Xen it exists in a separate EFI
                                         * region on ia64, and thus needs to be
                                         * inserted into iomem_machine separately */
    #define KEXEC_RANGE_MA_BOOT_PARAM 4 /* Obsolete: machine address and size of
                                         * the ia64_boot_param */
    #define KEXEC_RANGE_MA_EFI_MEMMAP 5 /* machine address and size of
                                         * of the EFI Memory Map */
    #define KEXEC_RANGE_MA_VMCOREINFO 6 /* machine address and size of vmcoreinfo */

    /*
     * Find the address and size of certain memory areas
     * range == KEXEC_RANGE_... [in]
     * nr    == physical CPU number (starting from 0) if KEXEC_RANGE_MA_CPU [in]
     * size  == number of bytes reserved in window [out]
     * start == address of the first byte in the window [out]
     */
    #define KEXEC_CMD_kexec_get_range       3
    typedef struct xen_kexec_range {
        int range;
        int nr;
        unsigned long size;
        unsigned long start;
    } xen_kexec_range_t;

    #if __XEN_INTERFACE_VERSION__ >= 0x00040400
    /*
     * A contiguous chunk of a kexec image and it's destination machine
     * address.
     */
    typedef struct xen_kexec_segment {
        union {
            XEN_GUEST_HANDLE(const_void) h;
            uint64_t _pad;
        } buf;
        uint64_t buf_size;
        uint64_t dest_maddr;
        uint64_t dest_size;
    } xen_kexec_segment_t;
    DEFINE_XEN_GUEST_HANDLE(xen_kexec_segment_t);

    /*
     * Load a kexec image into memory.
     *
     * For KEXEC_TYPE_DEFAULT images, the segments may be anywhere in RAM.
     * The image is relocated prior to being executed.
     *
     * For KEXEC_TYPE_CRASH images, each segment of the image must reside
     * in the memory region reserved for kexec (KEXEC_RANGE_MA_CRASH) and
     * the entry point must be within the image. The caller is responsible
     * for ensuring that multiple images do not overlap.
     *
     * All image segments will be loaded to their destination machine
     * addresses prior to being executed.  The trailing portion of any
     * segments with a source buffer (from dest_maddr + buf_size to
     * dest_maddr + dest_size) will be zeroed.
     *
     * Segments with no source buffer will be accessible to the image when
     * it is executed.
     */

    #define KEXEC_CMD_kexec_load 4
    typedef struct xen_kexec_load {
        uint8_t  type;        /* One of KEXEC_TYPE_* */
        uint8_t  _pad;
        uint16_t arch;        /* ELF machine type (EM_*). */
        uint32_t nr_segments;
        union {
            XEN_GUEST_HANDLE(xen_kexec_segment_t) h;
            uint64_t _pad;
        } segments;
        uint64_t entry_maddr; /* image entry point machine address. */
    } xen_kexec_load_t;
    DEFINE_XEN_GUEST_HANDLE(xen_kexec_load_t);

    /*
     * Unload a kexec image.
     *
     * Type must be one of KEXEC_TYPE_DEFAULT or KEXEC_TYPE_CRASH.
     */
    #define KEXEC_CMD_kexec_unload 5
    typedef struct xen_kexec_unload {
        uint8_t type;
    } xen_kexec_unload_t;
    DEFINE_XEN_GUEST_HANDLE(xen_kexec_unload_t);

    /*
     * Figure out whether we have an image loaded. A return value of
     * zero indicates no image loaded. A return value of one
     * indicates an image is loaded. A negative return value
     * indicates an error.
     *
     * Type must be one of KEXEC_TYPE_DEFAULT or KEXEC_TYPE_CRASH.
     */
    #define KEXEC_CMD_kexec_status 6
    typedef struct xen_kexec_status {
        uint8_t type;
    } xen_kexec_status_t;
    DEFINE_XEN_GUEST_HANDLE(xen_kexec_status_t);

    #else /* __XEN_INTERFACE_VERSION__ < 0x00040400 */

    #define KEXEC_CMD_kexec_load KEXEC_CMD_kexec_load_v1
    #define KEXEC_CMD_kexec_unload KEXEC_CMD_kexec_unload_v1
    #define xen_kexec_load xen_kexec_load_v1
    #define xen_kexec_load_t xen_kexec_load_v1_t

    #endif

    #endif /* _XEN_PUBLIC_KEXEC_H */

    /*
     * Local variables:
     * mode: C
     * c-file-style: "BSD"
     * c-basic-offset: 4
     * tab-width: 4
     * indent-tabs-mode: nil
     * End:
     */