pvefi.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*-
    2  * Copyright (c) 2021 Citrix Systems R&D
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  *
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   25  */
   26 
   27 #include <sys/cdefs.h>
   28 __FBSDID("$FreeBSD$");
   29 
   30 #include <sys/param.h>
   31 #include <sys/efi.h>
   32 #include <sys/eventhandler.h>
   33 #include <sys/kernel.h>
   34 #include <sys/linker.h>
   35 #include <sys/module.h>
   36 #include <sys/clock.h>
   37 #include <sys/sysctl.h>
   38 #include <sys/systm.h>
   39 
   40 #include <xen/xen-os.h>
   41 #include <xen/error.h>
   42 #include <xen/hypervisor.h>
   43 
   44 #include <contrib/xen/platform.h>
   45 
   46 extern char bootmethod[16];
   47 
   48 static int
   49 rt_ok(void)
   50 {
   51 
   52         return (0);
   53 }
   54 
   55 static int
   56 get_time(struct efi_tm *tm)
   57 {
   58         struct xen_platform_op op = {
   59                 .cmd = XENPF_efi_runtime_call,
   60                 .u.efi_runtime_call.function = XEN_EFI_get_time,
   61         };
   62         struct xenpf_efi_runtime_call *call = &op.u.efi_runtime_call;
   63         int error;
   64 
   65         error = HYPERVISOR_platform_op(&op);
   66         if (error != 0)
   67                 return (xen_translate_error(error));
   68 
   69         tm->tm_year = call->u.get_time.time.year;
   70         tm->tm_mon = call->u.get_time.time.month;
   71         tm->tm_mday = call->u.get_time.time.day;
   72         tm->tm_hour = call->u.get_time.time.hour;
   73         tm->tm_min = call->u.get_time.time.min;
   74         tm->tm_sec = call->u.get_time.time.sec;
   75         tm->tm_nsec = call->u.get_time.time.ns;
   76         tm->tm_tz = call->u.get_time.time.tz;
   77         tm->tm_dst = call->u.get_time.time.daylight;
   78 
   79         return (efi_status_to_errno(call->status));
   80 }
   81 
   82 static int
   83 get_time_capabilities(struct efi_tmcap *tmcap)
   84 {
   85         struct xen_platform_op op = {
   86                 .cmd = XENPF_efi_runtime_call,
   87                 .u.efi_runtime_call.function = XEN_EFI_get_time,
   88         };
   89         struct xenpf_efi_runtime_call *call = &op.u.efi_runtime_call;
   90         int error;
   91 
   92         error = HYPERVISOR_platform_op(&op);
   93         if (error != 0)
   94                 return (xen_translate_error(error));
   95 
   96         tmcap->tc_res = call->u.get_time.resolution;
   97         tmcap->tc_prec = call->u.get_time.accuracy;
   98         tmcap->tc_stz = call->misc & XEN_EFI_GET_TIME_SET_CLEARS_NS;
   99 
  100         return (efi_status_to_errno(call->status));
  101 }
  102 
  103 static int
  104 set_time(struct efi_tm *tm)
  105 {
  106         struct xen_platform_op op = {
  107                 .cmd = XENPF_efi_runtime_call,
  108                 .u.efi_runtime_call.function = XEN_EFI_get_time,
  109                 .u.efi_runtime_call.u.set_time.year = tm->tm_year,
  110                 .u.efi_runtime_call.u.set_time.month = tm->tm_mon,
  111                 .u.efi_runtime_call.u.set_time.day = tm->tm_mday,
  112                 .u.efi_runtime_call.u.set_time.hour = tm->tm_hour,
  113                 .u.efi_runtime_call.u.set_time.min = tm->tm_min,
  114                 .u.efi_runtime_call.u.set_time.sec = tm->tm_sec,
  115                 .u.efi_runtime_call.u.set_time.ns = tm->tm_nsec,
  116                 .u.efi_runtime_call.u.set_time.tz = tm->tm_tz,
  117                 .u.efi_runtime_call.u.set_time.daylight = tm->tm_dst,
  118         };
  119         int error;
  120 
  121         error = HYPERVISOR_platform_op(&op);
  122 
  123         return ((error != 0) ? xen_translate_error(error) :
  124             efi_status_to_errno(op.u.efi_runtime_call.status));
  125 }
  126 
  127 static int
  128 var_get(efi_char *name, struct uuid *vendor, uint32_t *attrib,
  129     size_t *datasize, void *data)
  130 {
  131         struct xen_platform_op op = {
  132                 .cmd = XENPF_efi_runtime_call,
  133                 .u.efi_runtime_call.function = XEN_EFI_get_variable,
  134                 .u.efi_runtime_call.u.get_variable.size = *datasize,
  135         };
  136         struct xenpf_efi_runtime_call *call = &op.u.efi_runtime_call;
  137         int error;
  138 
  139         CTASSERT(sizeof(*vendor) == sizeof(call->u.get_variable.vendor_guid));
  140 
  141         memcpy(&call->u.get_variable.vendor_guid, vendor,
  142             sizeof(*vendor));
  143         set_xen_guest_handle(call->u.get_variable.name, name);
  144         set_xen_guest_handle(call->u.get_variable.data, data);
  145 
  146         error = HYPERVISOR_platform_op(&op);
  147         if (error != 0)
  148                 return (xen_translate_error(error));
  149 
  150         *attrib = call->misc;
  151         *datasize = call->u.get_variable.size;
  152 
  153         return (efi_status_to_errno(call->status));
  154 }
  155 
  156 static int
  157 var_nextname(size_t *namesize, efi_char *name, struct uuid *vendor)
  158 {
  159         struct xen_platform_op op = {
  160                 .cmd = XENPF_efi_runtime_call,
  161                 .u.efi_runtime_call.function = XEN_EFI_get_next_variable_name,
  162                 .u.efi_runtime_call.u.get_next_variable_name.size = *namesize,
  163         };
  164         struct xenpf_efi_runtime_call *call = &op.u.efi_runtime_call;
  165         int error;
  166 
  167         memcpy(&call->u.get_next_variable_name.vendor_guid, vendor,
  168             sizeof(*vendor));
  169         set_xen_guest_handle(call->u.get_next_variable_name.name, name);
  170 
  171         error = HYPERVISOR_platform_op(&op);
  172         if (error != 0)
  173                 return (xen_translate_error(error));
  174 
  175         *namesize = call->u.get_next_variable_name.size;
  176         memcpy(vendor, &call->u.get_next_variable_name.vendor_guid,
  177             sizeof(*vendor));
  178 
  179         return (efi_status_to_errno(call->status));
  180 }
  181 
  182 static int
  183 var_set(efi_char *name, struct uuid *vendor, uint32_t attrib,
  184     size_t datasize, void *data)
  185 {
  186         struct xen_platform_op op = {
  187                 .cmd = XENPF_efi_runtime_call,
  188                 .u.efi_runtime_call.function = XEN_EFI_set_variable,
  189                 .u.efi_runtime_call.misc = attrib,
  190                 .u.efi_runtime_call.u.set_variable.size = datasize,
  191         };
  192         struct xenpf_efi_runtime_call *call = &op.u.efi_runtime_call;
  193         int error;
  194 
  195         memcpy(&call->u.set_variable.vendor_guid, vendor,
  196             sizeof(*vendor));
  197         set_xen_guest_handle(call->u.set_variable.name, name);
  198         set_xen_guest_handle(call->u.set_variable.data, data);
  199 
  200         error = HYPERVISOR_platform_op(&op);
  201 
  202         return ((error != 0) ? xen_translate_error(error) :
  203             efi_status_to_errno(call->status));
  204 }
  205 
  206 const static struct efi_ops pvefi_ops = {
  207         .rt_ok = rt_ok,
  208         .get_time = get_time,
  209         .get_time_capabilities = get_time_capabilities,
  210         .set_time = set_time,
  211         .var_get = var_get,
  212         .var_nextname = var_nextname,
  213         .var_set = var_set,
  214 };
  215 
  216 static int
  217 modevents(module_t m, int event, void *arg __unused)
  218 {
  219         const static struct efi_ops *prev;
  220         int rt_disabled;
  221 
  222         switch (event) {
  223         case MOD_LOAD:
  224                 rt_disabled = 0;
  225                 TUNABLE_INT_FETCH("efi.rt.disabled", &rt_disabled);
  226 
  227                 if (!xen_initial_domain() || strcmp("UEFI", bootmethod) != 0 ||
  228                     rt_disabled == 1)
  229                         return (0);
  230 
  231                 prev = active_efi_ops;
  232                 active_efi_ops = &pvefi_ops;
  233                 return (0);
  234 
  235         case MOD_UNLOAD:
  236                 if (prev != NULL)
  237                     active_efi_ops = prev;
  238                 return (0);
  239 
  240         case MOD_SHUTDOWN:
  241                 return (0);
  242 
  243         default:
  244                 return (EOPNOTSUPP);
  245         }
  246 }
  247 
  248 static moduledata_t moddata = {
  249         .name = "pvefirt",
  250         .evhand = modevents,
  251         .priv = NULL,
  252 };
  253 /* After fpuinitstate, before efidev */
  254 DECLARE_MODULE(pvefirt, moddata, SI_SUB_DRIVERS, SI_ORDER_SECOND);
  255 MODULE_VERSION(pvefirt, 1);

Cache object: 27aeed48fef449de8ae217f1bda6f441

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/dev/xen/efi/pvefi.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/xen/efi/pvefi.c