kitten/include/lwk/params.h

   1 #ifndef _LWK_PARAMS_H
   2 #define _LWK_PARAMS_H
   3 /* (C) Copyright 2001, 2002 Rusty Russell IBM Corporation */
   4 #include <lwk/init.h>
   5 #include <lwk/stringify.h>
   6 #include <lwk/kernel.h>
   7
   8 struct kernel_param;
   9
  10 /* Returns 0, or -errno.  arg is in kp->arg. */
  11 typedef int (*param_set_fn)(const char *val, struct kernel_param *kp);
  12 /* Returns length written or -errno.  Buffer is 4k (ie. be short!) */
  13 typedef int (*param_get_fn)(char *buffer, struct kernel_param *kp);
  14
  15 struct kernel_param {
  16         const char *    name;
  17         param_set_fn    set;
  18         param_get_fn    get;
  19         void *          arg;
  20 };
  21
  22 /* Special one for strings we want to copy into */
  23 struct kparam_string {
  24         unsigned int    maxlen;
  25         char *          string;
  26 };
  27
  28 /* Special one for arrays */
  29 struct kparam_array {
  30         unsigned int    max;
  31         unsigned int *  num;
  32         param_set_fn    set;
  33         param_get_fn    get;
  34         unsigned int    elemsize;
  35         void *          elem;
  36 };
  37
  38 /* This is the fundamental function for registering kernel parameters. */
  39 #define __param_call(prefix, name, set, get, arg)                       \
  40         static char __param_str_##name[] = prefix #name;                \
  41         static struct kernel_param const __param_##name                 \
  42         __attribute_used__                                              \
  43     __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \
  44         = { __param_str_##name, set, get, arg }
  45
  46 /* Helper functions: type is byte, short, ushort, int, uint, long,
  47    ulong, charp, bool or invbool, or XXX if you define param_get_XXX,
  48    param_set_XXX and param_check_XXX. */
  49 #define __param_named(prefix, name, value, type)                        \
  50         param_check_##type(name, &(value));                             \
  51         __param_call(prefix, name, param_set_##type, param_get_##type, &value)
  52
  53 /* Actually copy string: maxlen param is usually sizeof(string). */
  54 #define __param_string(prefix, name, string, len)                       \
  55         static struct kparam_string __param_string_##name               \
  56                 = { len, string };                                      \
  57         __param_call(prefix, name, param_set_copystring,                \
  58                    param_get_string, &__param_string_##name)
  59
  60 /* Comma-separated array: *nump is set to number they actually specified. */
  61 #define __param_array_named(prefix, name, array, type, nump)            \
  62         static struct kparam_array __param_arr_##name                   \
  63         = { ARRAY_SIZE(array), nump, param_set_##type, param_get_##type,\
  64             sizeof(array[0]), array };                                  \
  65         __param_call(prefix, name, param_array_set, param_array_get,    \
  66                           &__param_arr_##name)
  67
  68 /* Call a function to parse the parameter */
  69 #define __param_func(prefix, name, func)                                \
  70         __param_call(prefix, name, func, NULL, NULL)
  71
  72 /*
  73  * Basic parameter interface.  These are just raw... they have no prefix.
  74  */
  75 #define param(name, type) \
  76         __param_named("", name, name, type)
  77
  78 #define param_named(name, value, type) \
  79         __param_named("", name, value, type)
  80
  81 #define param_string(name, string, len) \
  82         __param_string("", name, string, len)
  83
  84 #define param_array(name, type, nump) \
  85         __param_array_named("", name, name, type, nump)
  86
  87 #define param_array_named(name, array, type, nump) \
  88         __param_array_named("", name, array, type, nump)
  89
  90 #define param_func(name, func) \
  91         __param_func("", name, func)
  92
  93 /* Called at kernel boot */
  94 extern int parse_args(const char *name,
  95                       char *args,
  96                       struct kernel_param *params,
  97                       unsigned num,
  98                       int (*unknown)(char *param, char *val));
  99
 100 /* All the helper functions */
 101 /* The macros to do compile-time type checking stolen from Jakub
 102    Jelinek, who IIRC came up with this idea for the 2.4 module init code. */
 103 #define __param_check(name, p, type) \
 104         static inline type *__check_##name(void) { return(p); }
 105
 106 extern int param_set_byte(const char *val, struct kernel_param *kp);
 107 extern int param_get_byte(char *buffer, struct kernel_param *kp);
 108 #define param_check_byte(name, p) __param_check(name, p, unsigned char)
 109
 110 extern int param_set_short(const char *val, struct kernel_param *kp);
 111 extern int param_get_short(char *buffer, struct kernel_param *kp);
 112 #define param_check_short(name, p) __param_check(name, p, short)
 113
 114 extern int param_set_ushort(const char *val, struct kernel_param *kp);
 115 extern int param_get_ushort(char *buffer, struct kernel_param *kp);
 116 #define param_check_ushort(name, p) __param_check(name, p, unsigned short)
 117
 118 extern int param_set_int(const char *val, struct kernel_param *kp);
 119 extern int param_get_int(char *buffer, struct kernel_param *kp);
 120 #define param_check_int(name, p) __param_check(name, p, int)
 121
 122 extern int param_set_uint(const char *val, struct kernel_param *kp);
 123 extern int param_get_uint(char *buffer, struct kernel_param *kp);
 124 #define param_check_uint(name, p) __param_check(name, p, unsigned int)
 125
 126 extern int param_set_long(const char *val, struct kernel_param *kp);
 127 extern int param_get_long(char *buffer, struct kernel_param *kp);
 128 #define param_check_long(name, p) __param_check(name, p, long)
 129
 130 extern int param_set_ulong(const char *val, struct kernel_param *kp);
 131 extern int param_get_ulong(char *buffer, struct kernel_param *kp);
 132 #define param_check_ulong(name, p) __param_check(name, p, unsigned long)
 133
 134 extern int param_set_charp(const char *val, struct kernel_param *kp);
 135 extern int param_get_charp(char *buffer, struct kernel_param *kp);
 136 #define param_check_charp(name, p) __param_check(name, p, char *)
 137
 138 extern int param_set_bool(const char *val, struct kernel_param *kp);
 139 extern int param_get_bool(char *buffer, struct kernel_param *kp);
 140 #define param_check_bool(name, p) __param_check(name, p, int)
 141
 142 extern int param_set_invbool(const char *val, struct kernel_param *kp);
 143 extern int param_get_invbool(char *buffer, struct kernel_param *kp);
 144 #define param_check_invbool(name, p) __param_check(name, p, int)
 145
 146 extern int param_array_set(const char *val, struct kernel_param *kp);
 147 extern int param_array_get(char *buffer, struct kernel_param *kp);
 148
 149 extern int param_set_copystring(const char *val, struct kernel_param *kp);
 150 extern int param_get_string(char *buffer, struct kernel_param *kp);
 151
 152 extern int parse_params(const char *str);
 153 extern int param_set_by_name_int(char *param, int val);
 154
 155 /*
 156  * These two symbols are defined by the platform's linker script.
 157  * They surround a table of kernel parameter descriptors.  This table
 158  * is used by the command line parser to determine how each argument
 159  * should be handled... each encountered argument causes a search of
 160  * this table.
 161  */
 162 extern struct kernel_param __start___param[], __stop___param[];
 163
 164 #endif /* _LWK_PARAMS_H */