[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Minios-devel] [UNIKRAFT PATCH v3 2/8] lib/uklibparam: Introduce the library parameter



Hi Sharan, this patch looks good.

-- Felipe

Reviewed-by: Felipe Huici <felipe.huici@xxxxxxxxx>

On 21.08.19, 17:54, "Sharan Santhanam" <Sharan.Santhanam@xxxxxxxxx> wrote:

    This patch provides the header necessary to register a variable as an
    boot argument with Unikraft that may depend on user input. The patch
    provides an implementation for parsing scalar arguments.
    
    Signed-off-by: Sharan Santhanam <sharan.santhanam@xxxxxxxxx>
    ---
     MAINTAINERS.md                       |   5 +
     lib/Config.uk                        |   1 +
     lib/Makefile.uk                      |   1 +
     lib/uklibparam/Config.uk             |   5 +
     lib/uklibparam/Makefile.uk           |   7 +
     lib/uklibparam/exportsyms.uk         |   2 +
     lib/uklibparam/include/uk/libparam.h | 414 ++++++++++++++++++++
     lib/uklibparam/param.c               | 544 +++++++++++++++++++++++++++
     8 files changed, 979 insertions(+)
     create mode 100644 lib/uklibparam/Config.uk
     create mode 100644 lib/uklibparam/Makefile.uk
     create mode 100644 lib/uklibparam/exportsyms.uk
     create mode 100644 lib/uklibparam/include/uk/libparam.h
     create mode 100644 lib/uklibparam/param.c
    
    diff --git a/MAINTAINERS.md b/MAINTAINERS.md
    index e3eb898d..690ca7eb 100644
    --- a/MAINTAINERS.md
    +++ b/MAINTAINERS.md
    @@ -126,6 +126,11 @@ Try to look for the most precise areas first. In case 
nothing fits use
        L:      minios-devel@xxxxxxxxxxxxx
        F: lib/ukdebug/*
     
    +   LIBUKLIBPARAM
    +   M: Sharan Santhanam <sharan.santhanam@xxxxxxxxx>
    +   L:      minios-devel@xxxxxxxxxxxxx
    +   F: lib/uklibparam/*
    +
        UNIKRAFT GENERAL
        M:      Simon Kuenzer <simon.kuenzer@xxxxxxxxx>
        M:      Sharan Santhanam <sharan.santhanam@xxxxxxxxx>
    diff --git a/lib/Config.uk b/lib/Config.uk
    index e97a9af3..204f5216 100644
    --- a/lib/Config.uk
    +++ b/lib/Config.uk
    @@ -50,3 +50,4 @@ source "lib/ukbus/Config.uk"
     source "lib/uksglist/Config.uk"
     source "lib/uknetdev/Config.uk"
     source "lib/posix-libdl/Config.uk"
    +source "lib/uklibparam/Config.uk"
    diff --git a/lib/Makefile.uk b/lib/Makefile.uk
    index b41345de..ac1e38bc 100644
    --- a/lib/Makefile.uk
    +++ b/lib/Makefile.uk
    @@ -27,3 +27,4 @@ $(eval $(call _import_lib,$(CONFIG_UK_BASE)/lib/ukbus))
     $(eval $(call _import_lib,$(CONFIG_UK_BASE)/lib/uksglist))
     $(eval $(call _import_lib,$(CONFIG_UK_BASE)/lib/uknetdev))
     $(eval $(call _import_lib,$(CONFIG_UK_BASE)/lib/posix-libdl))
    +$(eval $(call _import_lib,$(CONFIG_UK_BASE)/lib/uklibparam))
    diff --git a/lib/uklibparam/Config.uk b/lib/uklibparam/Config.uk
    new file mode 100644
    index 00000000..18bb43d6
    --- /dev/null
    +++ b/lib/uklibparam/Config.uk
    @@ -0,0 +1,5 @@
    +config LIBUKLIBPARAM
    +       bool "uk library parameter: Pass arguments to a unikraft library"
    +       default n
    +       select LIBUKDEBUG
    +       select LIBNOLIBC if !HAVE_LIBC
    diff --git a/lib/uklibparam/Makefile.uk b/lib/uklibparam/Makefile.uk
    new file mode 100644
    index 00000000..3d450b86
    --- /dev/null
    +++ b/lib/uklibparam/Makefile.uk
    @@ -0,0 +1,7 @@
    +$(eval $(call addlib_s,libuklibparam,$(CONFIG_LIBUKLIBPARAM)))
    +
    +ASINCLUDES-y       += -I$(LIBUKLIBPARAM_BASE)/include
    +CINCLUDES-y        += -I$(LIBUKLIBPARAM_BASE)/include
    +CXXINCLUDES-y      += -I$(LIBUKLIBPARAM_BASE)/include
    +
    +LIBUKLIBPARAM_SRCS-y += $(LIBUKLIBPARAM_BASE)/param.c
    diff --git a/lib/uklibparam/exportsyms.uk b/lib/uklibparam/exportsyms.uk
    new file mode 100644
    index 00000000..94b6ca77
    --- /dev/null
    +++ b/lib/uklibparam/exportsyms.uk
    @@ -0,0 +1,2 @@
    +uk_libparam_parse
    +_uk_libparam_lib_add
    diff --git a/lib/uklibparam/include/uk/libparam.h 
b/lib/uklibparam/include/uk/libparam.h
    new file mode 100644
    index 00000000..454cc0d6
    --- /dev/null
    +++ b/lib/uklibparam/include/uk/libparam.h
    @@ -0,0 +1,414 @@
    +/* SPDX-License-Identifier: BSD-3-Clause */
    +/*
    + * Authors: Sharan Santhanam <sharan.santhanam@xxxxxxxxx>
    + *
    + * Copyright (c) 2019, NEC Europe Ltd., NEC Corporation. All rights 
reserved.
    + *
    + * Redistribution and use in source and binary forms, with or without
    + * modification, are permitted provided that the following conditions
    + * are met:
    + *
    + * 1. Redistributions of source code must retain the above copyright
    + *    notice, this list of conditions and the following disclaimer.
    + * 2. Redistributions in binary form must reproduce the above copyright
    + *    notice, this list of conditions and the following disclaimer in the
    + *    documentation and/or other materials provided with the distribution.
    + * 3. Neither the name of the copyright holder nor the names of its
    + *    contributors may be used to endorse or promote products derived from
    + *    this software without specific prior written permission.
    + *
    + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 
IS"
    + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
THE
    + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
PURPOSE
    + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS 
BE
    + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
THE
    + * POSSIBILITY OF SUCH DAMAGE.
    + *
    + * THIS HEADER MAY NOT BE EXTRACTED OR MODIFIED IN ANY WAY.
    + */
    +#ifndef __UK_LIBPARAM_H
    +#define __UK_LIBPARAM_H
    +
    +#include <uk/config.h>
    +#ifndef __ASSEMBLY__
    +#include <uk/ctors.h>
    +#include <uk/arch/types.h>
    +#include <uk/essentials.h>
    +#include <uk/list.h>
    +#include <uk/print.h>
    +
    +#ifdef __cplusplus
    +extern C {
    +#endif /* __cplusplus */
    +#endif /* !__ASSEMBLY__ */
    +
    +/**
    + * Variable name prefix/suffix
    + */
    +#define UK_LIBPARAM_SECTION        uk_lib_arg
    +/**
    + * Library: section suffix for the name and the
    + * parameter.
    + */
    +#define LIB_PARAM_SUFFIX   __lib_param
    +#define LIB_NAME_SUFFIX            __lib_str
    +/**
    + * Library variable names for the name and the
    + * parameter.
    + */
    +#define LIB_PARAMVAR_PREFIX        _lib_param_
    +#define LIB_NAMEVAR_PREFIX _lib_name_
    +/**
    + * Parameter within a library: section suffix for the name and the
    + * parameter.
    + */
    +#define PARAM_SECTION_SUFFIX       __param_arg
    +#define PARAM_NAME_SUFFIX  __param_str
    +/**
    + * Parameter within a library: variable name prefix for the name and the
    + * parameter.
    + */
    +#define PARAM_PARAMVAR_PREFIX      _param_param_
    +#define PARAM_NAMEVAR_PREFIX       _param_name_
    +
    +#define __STRINGCONCAT(x, y)       x ## y
    +
    +/**
    + * Create a section name.
    + * @param libname
    + * The library name
    + * @param section
    + * The section suffix for the library
    + */
    +#define _LIB_PARAM_SECTION_NAME(libname, section_name)             \
    +                           __STRINGCONCAT(libname, section_name)
    +
    +/**
    + * Macros to denote the start / stop of a section.
    + */
    +#define _SECTION_START(name)       __STRINGCONCAT(__start_, name)
    +#define _SECTION_STOP(name)        __STRINGCONCAT(__stop_, name)
    +
    +/**
    + * Make sure there is a dummy implementation for the UK_PARAM family of
    + * functions.
    + */
    +#ifndef CONFIG_LIBUKLIBPARAM
    +/**
    + * Declare a library param.
    + * @param name
    + * The name of the library param.
    + * @param type
    + * The type of the param.
    + */
    +#define UK_LIB_PARAM(name, type)
    +
    +#else /* !CONFIG_LIBUKLIBPARAM */
    +/**
    + * Each parameter is bit-mapped as follows:
    + * ---------------------------------------
    + * | sign | copy | size of the parameter |
    + * ---------------------------------------
    + * 7     6      5                       0
    + */
    +/**
    + * Sign bit: Shift & Mask
    + */
    +#define PARAM_SIGN_SHIFT   (7)
    +#define PARAM_SIGN_MASK            (0x1)
    +/**
    + * Shallow copy: Shift & Mask
    + */
    +#define PARAM_SCOPY_SHIFT  (6)
    +#define PARAM_SCOPY_MASK   (0x1)
    +/**
    + * Size of the param: Shift & Mask
    + */
    +#define PARAM_SIZE_SHIFT   (0x0)
    +#define PARAM_SIZE_MASK         (0x3F)
    +
    +#ifndef __ASSEMBLY__
    +/**
    + * Get the parameter type.
    + * @param sign
    + * The sign of the data type.
    + * @param scopy
    + * Flag to indicate shallow copy.
    + * 1 - shallow copy.
    + * 0 - data copy.
    + * @param size
    + * The size of the parameter.
    + */
    +#define PARAM_TYPE(sign, scopy, size)                              \
    +           (                                               \
    +                   ((((__u8) (sign & PARAM_SIGN_MASK)) <<  \
    +                             PARAM_SIGN_SHIFT) |           \
    +                   (((__u8) (scopy & PARAM_SCOPY_MASK)) << \
    +                             PARAM_SCOPY_SHIFT) |          \
    +                   (((__u8) (size & PARAM_SIZE_MASK)) <<   \
    +                             PARAM_SIZE_SHIFT))            \
    +           )
    +
    +/**
    + * Support data types as parameters
    + */
    +#define _LIB_PARAM___s8            PARAM_TYPE(1, 0, sizeof(__s8))
    +#define _LIB_PARAM_char            _LIB_PARAM___s8
    +#define _LIB_PARAM___u8            PARAM_TYPE(0, 0, sizeof(__u8))
    +#define _LIB_PARAM___s16   PARAM_TYPE(1, 0, sizeof(__s16))
    +#define _LIB_PARAM___u16   PARAM_TYPE(0, 0, sizeof(__u16))
    +#define _LIB_PARAM___s32   PARAM_TYPE(1, 0, sizeof(__s32))
    +#define _LIB_PARAM_int             _LIB_PARAM___s32
    +#define _LIB_PARAM___u32   PARAM_TYPE(0, 0, sizeof(__u32))
    +#define _LIB_PARAM___s64   PARAM_TYPE(1, 0, sizeof(__s64))
    +#define _LIB_PARAM___u64   PARAM_TYPE(0, 0, sizeof(__u64))
    +
    +struct uk_param {
    +   /* The name of the param */
    +   const char *name;
    +   /* Type information for the param */
    +   const __u8 param_type;
    +   /* Type information for the variable size param */
    +   const __u8 param_size;
    +   /* Define a reference to location of the parameter */
    +   __uptr addr;
    +};
    +
    +struct uk_lib_section {
    +   /* Library name */
    +   const char *lib_name;
    +   /* Section header of the uk_param args */
    +   struct uk_param *sec_addr_start;
    +   /* Length of the section */
    +   __u32   len;
    +   /* Next section entry */
    +   struct uk_list_head next;
    +};
    +
    +/**
    + * Parse through the kernel parameter
    + * @param progname
    + * The application name
    + * @param argc
    + * The number of arguments
    + * @param argv
    + * Reference to the command line arguments
    + * @return
    + * On success, return the number of argument parsed.
    + * On Failure, return the error code.
    + */
    +int uk_libparam_parse(const char *progname, int argc, char **argv);
    +
    +/**
    + * Register the library containing kernel parameter.
    + *
    + * @param lib_sec
    + * A reference to the uk_lib_section.
    + */
    +void _uk_libparam_lib_add(struct uk_lib_section *lib_sec);
    +
    +/**
    + * Add a variable to a specific section.
    + * @param section_name
    + * The name of the section.
    + * @param align_type
    + * The alignment requirements for the variable definitions.
    + */
    +#define _LIB_PARAM_SECTION_ADD(section_name, align_type)           \
    +                           __attribute__ ((used,                   \
    +                                           section(                \
    +                                   __STRINGIFY(section_name)),     \
    +                                   aligned(sizeof(align_type))     \
    +                                        ))
    +/**
    + * Create a constructor name.
    + * @param libname
    + * The library name.
    + * @param suffix
    + * The suffix appended to the library name.
    + */
    +#define _LIB_UK_CONSTRUCT_NAME(libname, suffix)                    \
    +          __STRINGCONCAT(libname, suffix)
    +
    +/**
    + * Create a variable name
    + * @param prefix
    + * The prefix to the variable name.
    + * @param name
    + * The name of the variable
    + */
    +#define _LIB_VARNAME_SET(prefix, name)                             \
    +                    __STRINGCONCAT(prefix, name)
    +
    +/**
    + * Import the section header.
    + * @param libname
    + * The library name.
    + * @param section_suffix
    + * The suffix string for the section name
    + */
    +#define UK_LIB_IMPORT_SECTION_PARAMS(libname, section_suffix)              
\
    +   extern char *_SECTION_START(                                    \
    +                   _LIB_PARAM_SECTION_NAME(libname,                \
    +                                           section_suffix));       \
    +   extern char *_SECTION_STOP(                                     \
    +                   _LIB_PARAM_SECTION_NAME(libname,                \
    +                                           section_suffix))        \
    +
    +/**
    + * Create a library name variable and uk_lib_section for each library.
    + * @param libname
    + * The library name.
    + */
    +#define UK_LIB_SECTION_CREATE(section, libname)                            
\
    +   static const char                                               \
    +           _LIB_VARNAME_SET(LIB_NAMEVAR_PREFIX, libname)[] =       \
    +                                           __STRINGIFY(libname);   \
    +   static _LIB_PARAM_SECTION_ADD(                                  \
    +                                 _LIB_PARAM_SECTION_NAME(section,  \
    +                                           LIB_PARAM_SUFFIX),      \
    +                                           void *)                 \
    +           struct uk_lib_section                                   \
    +                   _LIB_VARNAME_SET(LIB_PARAMVAR_PREFIX, libname) = \
    +                   { .lib_name = __NULL,                           \
    +                     .sec_addr_start = __NULL, .len = 0            \
    +                   }
    +
    +#define UK_LIB_CTOR_PRIO   1
    +
    +#define UK_LIB_CONSTRUCTOR_SETUP(prio, name)                               
\
    +   __UK_CTOR_FUNC(prio, name)
    +
    +/**
    + * Create a constructor to initialize the parameters in the library.
    + */
    +#define UK_LIB_CONSTRUCTOR_CREATE(libname)                         \
    +   static void _LIB_UK_CONSTRUCT_NAME(libname, process_arg)(void)  \
    +   {                                                               \
    +           int len = (__uptr) &_SECTION_STOP(                      \
    +                           _LIB_PARAM_SECTION_NAME(                \
    +                                   libname, PARAM_SECTION_SUFFIX)  \
    +                                   ) -                             \
    +                     (__uptr) &_SECTION_START(                     \
    +                           _LIB_PARAM_SECTION_NAME(                \
    +                                   libname, PARAM_SECTION_SUFFIX)  \
    +                                    );                             \
    +           if (len > 0) {                                          \
    +                   _LIB_VARNAME_SET(LIB_PARAMVAR_PREFIX, libname). \
    +                                   sec_addr_start =                \
    +                                           (struct uk_param *)     \
    +                                           ALIGN_UP((__uptr)       \
    +                                           &_SECTION_START(        \
    +                                           _LIB_PARAM_SECTION_NAME(\
    +                                           libname,                \
    +                                           PARAM_SECTION_SUFFIX)), \
    +                                           sizeof(void *));        \
    +                   _LIB_VARNAME_SET(LIB_PARAMVAR_PREFIX, libname). \
    +                                           len =   len;            \
    +                   _LIB_VARNAME_SET(LIB_PARAMVAR_PREFIX, libname). \
    +                                    lib_name =             \
    +                                           &_LIB_VARNAME_SET(      \
    +                                           LIB_NAMEVAR_PREFIX,     \
    +                                           libname)[0];            \
    +                   _uk_libparam_lib_add(&_LIB_VARNAME_SET(         \
    +                                           LIB_PARAMVAR_PREFIX,    \
    +                                           libname)                \
    +                                       );                          \
    +           }                                                       \
    +   }                                                               \
    +
    +#define UK_LIB_CONSTRUCTOR_INIT(libname)                           \
    +           UK_LIB_IMPORT_SECTION_PARAMS(libname,                   \
    +                                        PARAM_SECTION_SUFFIX);     \
    +           UK_LIB_SECTION_CREATE(UK_LIBPARAM_SECTION, libname);    \
    +           UK_LIB_CONSTRUCTOR_CREATE(libname)                      \
    +           UK_LIB_CONSTRUCTOR_SETUP(UK_LIB_CTOR_PRIO,              \
    +                   _LIB_UK_CONSTRUCT_NAME(libname, process_arg))
    +
    +
    +/**
    + * Create a constructor to fill in the parameter.
    + */
    +#ifdef UK_LIBPARAM_PREFIX
    +   UK_LIB_CONSTRUCTOR_INIT(UK_LIBPARAM_PREFIX);
    +#endif /* UK_LIBPARAM_PREFIX */
    +
    +/**
    + * Create the fully qualified name of a parameter.
    + *
    + * @param libname
    + * The name of the library
    + * @param name
    + * The name of the parameter
    + */
    +#define _LIB_PARAM_STRING(libname, name)                   \
    +                   libname.name
    +
    +/**
    + * Initialize the parameter string in a variable. The name of the
    + * parameter is stored in a separate linker section.
    + *
    + * @param name
    + * The name of the variable
    + * @param value
    + * The string representation of the parameter.
    + */
    +#define _LIB_PARAM_NAME_SET(name, value)                           \
    +   static const                                                    \
    +   char _LIB_VARNAME_SET(PARAM_NAMEVAR_PREFIX, name)[] =           \
    +                                           __STRINGIFY(value)
    +
    +
    +/**
    + * Initialize the parameter structure.
    + *
    + * @param param_name
    + * The name of the parameter
    + * @param type
    + * The type of the parameter
    + * @param cnt
    + * The number of the elements of that type.
    + */
    +#define _LIB_UK_PARAM_SET(param_name, type, cnt)                   \
    +   static const                                                    \
    +   _LIB_PARAM_SECTION_ADD(                                         \
    +                           _LIB_PARAM_SECTION_NAME(                \
    +                                           UK_LIBPARAM_PREFIX,     \
    +                                           PARAM_SECTION_SUFFIX),  \
    +                                           void *                  \
    +                           )                                       \
    +   struct uk_param _LIB_VARNAME_SET(PARAM_SECTION_SUFFIX,          \
    +                                    param_name) = {                \
    +           .name = _LIB_VARNAME_SET(PARAM_NAMEVAR_PREFIX,          \
    +                                     param_name),                  \
    +           .param_type = _LIB_PARAM_##type,                        \
    +           .param_size = cnt,                                      \
    +           .addr       = (__uptr) &param_name,                     \
    +   }
    +
    +/**
    + * Declare a library param.
    + * @param name
    + * The name of the library param.
    + * @param type
    + * The type of the param.
    + */
    +#define UK_LIB_PARAM(name, type)                                   \
    +   _LIB_PARAM_NAME_SET(name, _LIB_PARAM_STRING(UK_LIBPARAM_PREFIX, \
    +                                               name));             \
    +   _LIB_UK_PARAM_SET(name, type, 1)
    +#endif /* !__ASSEMBLY__ */
    +#endif /* CONFIG_LIBUKLIBPARAM */
    +
    +#ifndef __ASSEMBLY__
    +#ifdef __cplusplus
    +}
    +#endif /* __cplusplus */
    +#endif /* !__ASSEMBLY */
    +
    +#endif /* __UK_LIBPARAM_H */
    diff --git a/lib/uklibparam/param.c b/lib/uklibparam/param.c
    new file mode 100644
    index 00000000..666820dd
    --- /dev/null
    +++ b/lib/uklibparam/param.c
    @@ -0,0 +1,544 @@
    +/* SPDX-License-Identifier: BSD-3-Clause */
    +/*
    + * Authors: Sharan Santhanam <sharan.santhanam@xxxxxxxxx>
    + *
    + * Copyright (c) 2019, NEC Europe Ltd., NEC Corporation. All rights 
reserved.
    + *
    + * Redistribution and use in source and binary forms, with or without
    + * modification, are permitted provided that the following conditions
    + * are met:
    + *
    + * 1. Redistributions of source code must retain the above copyright
    + *    notice, this list of conditions and the following disclaimer.
    + * 2. Redistributions in binary form must reproduce the above copyright
    + *    notice, this list of conditions and the following disclaimer in the
    + *    documentation and/or other materials provided with the distribution.
    + * 3. Neither the name of the copyright holder nor the names of its
    + *    contributors may be used to endorse or promote products derived from
    + *    this software without specific prior written permission.
    + *
    + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 
IS"
    + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
THE
    + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
PURPOSE
    + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS 
BE
    + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
THE
    + * POSSIBILITY OF SUCH DAMAGE.
    + *
    + * THIS HEADER MAY NOT BE EXTRACTED OR MODIFIED IN ANY WAY.
    + */
    +#include <string.h>
    +#include <stdlib.h>
    +#include <stdio.h>
    +#include <errno.h>
    +#include <uk/list.h>
    +#include <uk/arch/limits.h>
    +#include <uk/print.h>
    +#include <uk/assert.h>
    +#include <uk/libparam.h>
    +#include <uk/version.h>
    +
    +#define LIB_ARG_SEP         "--"
    +#define NUMBER_SET(fn, type, value, addr, max, min, errcode, result_type, 
fmt)\
    +   do {                                                            \
    +           errno = 0;                                              \
    +           result_type result = (result_type)fn(value, NULL, 10);  \
    +           unsigned long long maxvalue =                           \
    +                           (sizeof(type) == sizeof(maxvalue)) ?    \
    +                           (result_type)-1 :                       \
    +                           (1ULL << ((sizeof(type) << 3))) - 1;    \
    +           uk_pr_debug("max value: 0x%llx\n", maxvalue);           \
    +           if (errno != 0)                                         \
    +                   errcode = -errno;                               \
    +           else if (result >= maxvalue) {                          \
    +                   errcode = 1;                                    \
    +                   *((type *)addr) = (type)(result & maxvalue);    \
    +           } else {                                                \
    +                   errcode = 0;                                    \
    +                   *((type *)addr) = (type)(result & maxvalue);    \
    +           }                                                       \
    +           uk_pr_debug("Converting value %s to %"fmt" %"fmt"\n",   \
    +                       value, *(type *)addr, result);              \
    +   } while (0)
    +
    +#define PARGS_PARAM_SET(pargs, parameter, len)                             
\
    +   do {                                                            \
    +           if ((pargs)->param_len)                                 \
    +                   uk_pr_warn("Found no value. Parameter %s skipped\n",\
    +                              (pargs)->param);                     \
    +           (pargs)->param = (parameter);                           \
    +           (pargs)->param_len = (len);                             \
    +   } while (0)
    +
    +struct param_args {
    +   /* Reference to the start of the library */
    +   char *lib;
    +   /* Reference to the start of the parameter */
    +   char *param;
    +   /* Reference to the start of the value */
    +   char *value;
    +   /* length of the library name */
    +   __u32 lib_len;
    +   /* length of the parameter */
    +   __u32 param_len;
    +   /* length of the value */
    +   __u32 value_len;
    +};
    +
    +static UK_LIST_HEAD(uk_libsections);
    +
    +/**
    + * Local functions
    + */
    +static int kernel_arg_range_fetch(int argc, char **argv);
    +static void uk_usage(const char *progname);
    +static int kernel_arg_fetch(char **args, int nr_args,
    +                       struct param_args *pargs, int *rewind);
    +static int kernel_lib_fetch(struct param_args *pargs,
    +                       struct uk_lib_section **section);
    +static int kernel_parse_arg(struct param_args *pargs,
    +                       struct uk_lib_section *section,
    +                       struct uk_param **param);
    +static int kernel_arg_set(void *addr, char *value, int size, int sign);
    +static int kernel_args_set(struct param_args *pargs,
    +                      struct uk_param *param);
    +static int kernel_value_sanitize(struct param_args *pargs);
    +
    +void _uk_libparam_lib_add(struct uk_lib_section *lib_sec)
    +{
    +   uk_pr_info("libname: %s, %d\n", lib_sec->lib_name, lib_sec->len);
    +   uk_list_add_tail(&lib_sec->next, &uk_libsections);
    +}
    +
    +static void uk_usage(const char *progname)
    +{
    +   printf("Usage: %s\n", progname);
    +   printf(" [[UNIKRAFT KERNEL ARGUMENT]].. -- [[APPLICATION 
ARGUMENT]]..\n\n");
    +   printf("Unikraft library arguments:\n");
    +   printf("The library arguments are represented as 
[LIBPARAM_PREFIX].[PARAMNAME]\n\n");
    +   printf("  -h, --help                 display this help and exit\n");
    +   printf("  -V, --version              display Unikraft version and 
exit\n");
    +}
    +
    +static int kernel_arg_range_fetch(int argc, char **argv)
    +{
    +   int i = 0;
    +
    +   while (i < argc) {
    +           /* Separate the kernel param from the application parameters */
    +           if (strcmp(LIB_ARG_SEP, argv[i]) == 0)
    +                   return i;
    +           i++;
    +   }
    +
    +   return -1;
    +}
    +
    +static int kernel_arg_fetch(char **args, int nr_args,
    +                       struct param_args *pargs, int *rewind)
    +{
    +   int i = 0;
    +   int rc = 0;
    +   char *equals_ptr = NULL, *dupl_ptr = NULL;
    +   int len, cnt = 0, equals = -1;
    +
    +   UK_ASSERT(rewind && pargs);
    +
    +   pargs->param = NULL;
    +   pargs->value = NULL;
    +   pargs->param_len = 0;
    +   pargs->value_len = 0;
    +
    +   for (i = 0; (!pargs->value_len ||
    +                !pargs->param_len) && i < nr_args; i++) {
    +           uk_pr_debug("at index:%d user args %s\n", i, args[i]);
    +           len = strlen(args[i]);
    +           /* if the equals character is present */
    +           if (!equals_ptr)
    +                   equals_ptr = strchr(args[i], '=');
    +           cnt++;
    +           /* Check for multiple '=' */
    +           dupl_ptr = strrchr(args[i], '=');
    +           if (equals_ptr && dupl_ptr && equals_ptr !=  dupl_ptr) {
    +                   uk_pr_err("Multiple '=' character found. Skipping 
argument %s\n",
    +                              args[i]);
    +                   rc = -EINVAL;
    +                   goto exit;
    +           } else if (equals < 0) {
    +                   /* Searching for the parameters */
    +                   if (equals_ptr && (len > 1) &&
    +                      (equals_ptr - args[i]) == (len - 1)) {
    +                           /* [libname_prefix].[parameter]= value */
    +                           uk_pr_debug("Expecting parameter with equals 
%s\n",
    +                                        args[i]);
    +                           PARGS_PARAM_SET(pargs, args[i], len - 1);
    +                           equals = i;
    +                   } else if (equals_ptr && (len > 1) &&
    +                              equals_ptr == args[i]) {
    +                           /* [libname_prefix].[parameter] =value */
    +                           uk_pr_debug("Expecting equals followed by value 
%s\n",
    +                                       args[i]);
    +                           pargs->value =  equals_ptr + 1;
    +                           pargs->value_len = len - 1;
    +                           equals = i;
    +                   } else if (equals_ptr && len == 1) {
    +                           /* Contains only equals */
    +                           equals = i;
    +                           continue;
    +                   } else if (equals_ptr) {
    +                           /* [libname_prefix].[parameter]=value */
    +                           uk_pr_debug("Expecting entire argument %s\n",
    +                                       args[i]);
    +                           PARGS_PARAM_SET(pargs, args[i],
    +                                           equals_ptr - args[i]);
    +                           equals = i;
    +                           pargs->value = equals_ptr + 1;
    +                           pargs->value_len = len - (pargs->param_len + 1);
    +                   } else if (!equals_ptr) {
    +                           /* [libname_prefix].[parameter] = value */
    +                           uk_pr_debug("Expecting parameter alone%s\n",
    +                                       args[i]);
    +                           PARGS_PARAM_SET(pargs, args[i], len);
    +                           pargs->param = args[i];
    +                           pargs->param_len = len;
    +                   } else {
    +                           uk_pr_err("Failed to parse the argument %s\n",
    +                                     args[i]);
    +                           rc = -EINVAL;
    +                           goto exit;
    +                   }
    +           } else if (equals >= 0) {
    +                   uk_pr_debug("Expecting value only %s\n",
    +                               args[i]);
    +                   pargs->value = args[i];
    +                   pargs->value_len = len;
    +           } else {
    +                   /* Error case */
    +                   uk_pr_err("Failed to parse the argument:%s\n", args[i]);
    +                   rc = -EINVAL;
    +                   goto exit;
    +
    +           }
    +   }
    +
    +   uk_pr_debug("pargs->param: %p, pargs->value: %p\n", pargs->param,
    +               pargs->value);
    +   if (pargs->param_len != 0 && pargs->value_len == 0) {
    +           uk_pr_err("Failed to completely parse the user argument\n");
    +           rc = -EINVAL;
    +           goto exit;
    +   }
    +
    +exit:
    +   *rewind = cnt;
    +   return rc;
    +}
    +
    +/**
    + * Kernel Parameter are passed in this format
    + * [libname_prefix].[parameter]
    + */
    +static int kernel_lib_fetch(struct param_args *pargs,
    +                       struct uk_lib_section **section)
    +{
    +   char *libparam;
    +   struct uk_lib_section *iter;
    +
    +   UK_ASSERT(section && pargs);
    +   pargs->lib_len = 0;
    +   libparam = memchr(pargs->param, '.', pargs->param_len);
    +   if (!libparam) {
    +           uk_pr_err("Failed to identify the library\n");
    +           goto error_exit;
    +   }
    +
    +   uk_list_for_each_entry(iter, &uk_libsections, next) {
    +           uk_pr_debug("Lib: %s, libname: %s %ld\n", iter->lib_name,
    +                       pargs->param, libparam - pargs->param);
    +           /**
    +            * Compare the length of the library names to avoid having
    +            * library with a similar prefix wrongly matching.
    +            */
    +           if ((strlen(iter->lib_name) ==
    +               (size_t) (libparam - pargs->param)) &&
    +               memcmp(pargs->param, iter->lib_name,
    +                      (libparam - pargs->param)) == 0) {
    +                   *section = iter;
    +                   pargs->lib_len = libparam - pargs->param;
    +                   return 0;
    +           }
    +   }
    +   uk_pr_err("Failed to fetch the library\n");
    +
    +error_exit:
    +   *section = NULL;
    +   pargs->lib_len = 0;
    +   return -EINVAL;
    +}
    +
    +static int kernel_parse_arg(struct param_args *pargs,
    +                       struct uk_lib_section *section,
    +                       struct uk_param **param)
    +{
    +   int i = 0;
    +   struct uk_param *iter;
    +   int len = 0;
    +
    +   UK_ASSERT(section && param && pargs);
    +
    +   len = section->len / sizeof(struct uk_param);
    +   iter = section->sec_addr_start;
    +   uk_pr_debug("Section length %d section@%p, uk_param: %lu\n", len, iter,
    +               sizeof(*iter));
    +
    +   for (i = 0; i < len; i++, iter++) {
    +           UK_ASSERT(iter->name);
    +           uk_pr_debug("Param name: %s at address: %p\n", iter->name,
    +                       iter);
    +           /**
    +            * Compare the length of the library names to avoid having
    +            * library with a similar prefix wrongly matching.
    +            */
    +           if ((strlen(iter->name) == pargs->param_len) &&
    +                memcmp(iter->name, pargs->param, pargs->param_len) == 0) {
    +                   *param = iter;
    +                   return 0;
    +           }
    +   }
    +
    +   uk_pr_err("Failed to identify the parameter\n");
    +   *param = NULL;
    +   return -EINVAL;
    +}
    +
    +static int kernel_arg_set(void *addr, char *value, int size, int sign)
    +{
    +   int error = 0;
    +
    +   /**
    +    * Check for the output address instead of UK_ASSERT because this is
    +    * a user provided input.
    +    */
    +   if (!addr) {
    +           uk_pr_err("Invalid output buffer\n");
    +           goto error_exit;
    +   }
    +
    +   switch (size) {
    +   case 1:
    +           if (sign) {
    +                   *((__s8 *)addr) = *value;
    +                   if (strnlen(value, 2) > 1)
    +                           error = 1;
    +           } else
    +                   NUMBER_SET(strtoul, __u8, value, addr, __U8_MAX,
    +                              __U8_MIN, error, __u32, __PRIu8);
    +           break;
    +   case 2:
    +           if (sign)
    +                   NUMBER_SET(strtol, __s16, value, addr, __S16_MAX,
    +                              __S16_MIN, error, __u32, __PRIs16);
    +           else
    +                   NUMBER_SET(strtoul, __u16, value, addr, __U16_MAX,
    +                              __U16_MIN, error, __u32, __PRIu16);
    +           break;
    +   case 4:
    +           if (sign)
    +                   NUMBER_SET(strtol, __s32, value, addr, __S32_MAX,
    +                              __S32_MIN, error, __u32, __PRIs32);
    +           else
    +                   NUMBER_SET(strtoul, __u32, value, addr, __U32_MAX,
    +                              __U32_MIN, error, __u32, __PRIu32);
    +           break;
    +   case 8:
    +           if (sign)
    +                   NUMBER_SET(strtoll, __s64, value, addr, __S64_MAX,
    +                              __S64_MIN, error, __u64, __PRIs64);
    +           else
    +                   NUMBER_SET(strtoull, __u64, value, addr, __U64_MAX,
    +                              __U64_MIN, error, __u64, __PRIu64);
    +           break;
    +   default:
    +           uk_pr_err("Cannot understand type of size %d\n", size);
    +           goto error_exit;
    +   }
    +   if (error < 0)
    +           goto error_exit;
    +   else if (error == 1)
    +           uk_pr_warn("Overflow/Underflow detected in value %s\n", value);
    +   return 0;
    +
    +error_exit:
    +   uk_pr_err("Failed to convert value %s\n", value);
    +   return -EINVAL;
    +}
    +
    +static int kernel_args_set(struct param_args *pargs,
    +                      struct uk_param *param)
    +{
    +   int rc = 0;
    +   int sign = (param->param_type >> PARAM_SIGN_SHIFT) & PARAM_SIGN_MASK;
    +   int scopy = (param->param_type >> PARAM_SCOPY_SHIFT) & PARAM_SCOPY_MASK;
    +   int param_type = (param->param_type >> PARAM_SIZE_SHIFT)
    +                           & PARAM_SIZE_MASK;
    +   uk_pr_debug("Parameter value %s, type: %d, sign: %d scopy: %d\n",
    +               pargs->value, param_type, sign, scopy);
    +
    +   if (scopy == 1)
    +           /* Reference the pointer instead of copying the value */
    +           *((__uptr *)param->addr) = (__uptr) pargs->value;
    +   else {
    +           if (param->param_size == 1) {
    +                   rc = kernel_arg_set((void *)param->addr,
    +                                       pargs->value, param_type, sign);
    +           } else {
    +                   uk_pr_err("Error: Cannot find the parameter\n");
    +                   rc = -EINVAL;
    +           }
    +   }
    +
    +   return rc;
    +}
    +
    +/**
    + * The function removes parse for quotes around the value.
    + * TODO: We do not support nested '"'.
    + */
    +static int kernel_value_sanitize(struct param_args *pargs)
    +{
    +   int rc = 0;
    +   char *ptr;
    +   char *start_idx = NULL;
    +   char *end_idx = NULL;
    +   int qcnt = 0;
    +
    +   UK_ASSERT(pargs && pargs->value);
    +   ptr = pargs->value;
    +   uk_pr_debug("Sanitizing value %s (length %d)\n", pargs->value,
    +               pargs->value_len);
    +
    +   do {
    +           switch (*ptr) {
    +           case ' ':
    +           case '\r':
    +           case '\n':
    +           case '\t':
    +           case '\v':
    +                   ptr++;
    +                   break;
    +           case'\'':
    +           case '"':
    +                   if (start_idx)
    +                           end_idx = ptr;
    +                   else if (!start_idx)
    +                           start_idx = ptr + 1;
    +                   ptr++;
    +                   qcnt++;
    +                   break;
    +           default:
    +                   if (!start_idx)
    +                           start_idx = ptr;
    +                   ptr++;
    +                   break;
    +           }
    +   } while (*ptr != '\0' && !(end_idx && start_idx));
    +   if (!end_idx)
    +           end_idx =  ptr;
    +
    +   uk_pr_debug("Adjusting start to %p & end to %p #quotes: %d\n",
    +               start_idx, end_idx, qcnt);
    +
    +   if (qcnt == 1) {
    +           uk_pr_err("Value %s not quoted properly\n", pargs->value);
    +           rc = -EINVAL;
    +   } else if (start_idx && end_idx) {
    +           memset(pargs->value, '\0', start_idx - pargs->value);
    +           memset(end_idx, '\0',
    +                  (pargs->value + pargs->value_len) - end_idx);
    +           pargs->value = start_idx;
    +           pargs->value_len = end_idx - start_idx;
    +   }
    +   uk_pr_debug("Sanitized value %s (length %d)\n", pargs->value,
    +               pargs->value_len);
    +
    +   return rc;
    +}
    +
    +int uk_libparam_parse(const char *progname, int argc, char **argv)
    +{
    +   int keindex = 0;
    +   int rc = 0, cnt = 0, args_read, i;
    +   struct param_args pargs = {0};
    +   struct uk_lib_section *section = NULL;
    +   struct uk_param *param = NULL;
    +
    +   keindex = kernel_arg_range_fetch(argc, argv);
    +   if (keindex < 0) {
    +           uk_pr_info("No library arguments found\n");
    +           return 0;
    +   }
    +
    +   uk_pr_debug("Library argument ends at %d\n", keindex);
    +
    +   while (cnt < keindex) {
    +           /* help and version */
    +           if (strcmp(argv[cnt], "-h") == 0 ||
    +               strcmp(argv[cnt], "--help") == 0) {
    +                   uk_usage(progname);
    +                   ukplat_halt();
    +           } else if (strcmp(argv[cnt], "-V") == 0 ||
    +                      strcmp(argv[cnt], "--version") == 0) {
    +                   uk_version();
    +                   ukplat_halt();
    +           }
    +
    +           args_read = 0;
    +           /* Fetch the argument from the input */
    +           rc = kernel_arg_fetch(&argv[cnt], (keindex - cnt),
    +                                 &pargs, &args_read);
    +           if (rc < 0) {
    +                   uk_pr_err("Failed to fetch arg between index %d and 
%d\n",
    +                             cnt, (cnt + args_read));
    +                   uk_pr_err("Skipping Args:");
    +                   for ( i = cnt; i < cnt + args_read; i++)
    +                           uk_pr_err(" %s", argv[i]);
    +                   uk_pr_err("\n");
    +                   cnt += args_read;
    +                   continue;
    +           }
    +           uk_pr_debug("Processing argument %s\n", pargs.param);
    +           cnt += args_read;
    +
    +           /* Fetch library for the argument */
    +           rc = kernel_lib_fetch(&pargs, &section);
    +           if (rc < 0 || !section) {
    +                   uk_pr_err("Failed to identify the library\n");
    +                   continue;
    +           }
    +
    +           /* Fetch the parameter for the argument */
    +           rc = kernel_parse_arg(&pargs, section, &param);
    +           if (rc < 0 || !param) {
    +                   uk_pr_err("Failed to parse arg\n");
    +                   continue;
    +           }
    +
    +           rc = kernel_value_sanitize(&pargs);
    +           if (rc  < 0) {
    +                   uk_pr_err("Failed to sanitize %s param\n", pargs.param);
    +                   continue;
    +           }
    +
    +           rc = kernel_args_set(&pargs, param);
    +           uk_pr_info("Parsed %d args\n", cnt);
    +   }
    +
    +   /* Replacing the -- with progname */
    +   argv[keindex] = DECONST(char *, progname);
    +
    +   return keindex + 1;
    +}
    -- 
    2.20.1
    
    

_______________________________________________
Minios-devel mailing list
Minios-devel@xxxxxxxxxxxxxxxxxxxx
https://lists.xenproject.org/mailman/listinfo/minios-devel

 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.