1 #ifndef _LINUX_MODULE_PARAMS_H 2 #define _LINUX_MODULE_PARAMS_H 3 /* (C) Copyright 2001, 2002 Rusty Russell IBM Corporation */ 4 #include <linux/init.h> 5 #include <linux/stringify.h> 6 #include <linux/kernel.h> 7 8 /* You can override this manually, but generally this should match the 9 module name. */ 10 #ifdef MODULE 11 #define MODULE_PARAM_PREFIX /* empty */ 12 #else 13 #define MODULE_PARAM_PREFIX KBUILD_MODNAME "." 14 #endif 15 16 /* Chosen so that structs with an unsigned long line up. */ 17 #define MAX_PARAM_PREFIX_LEN (64 - sizeof(unsigned long)) 18 19 #ifdef MODULE 20 #define ___module_cat(a,b) __mod_ ## a ## b 21 #define __module_cat(a,b) ___module_cat(a,b) 22 #define __MODULE_INFO(tag, name, info) \ 23 static const char __module_cat(name,__LINE__)[] \ 24 __used \ 25 __attribute__((section(".modinfo"),unused)) = __stringify(tag) "=" info 26 #else /* !MODULE */ 27 #define __MODULE_INFO(tag, name, info) 28 #endif 29 #define __MODULE_PARM_TYPE(name, _type) \ 30 __MODULE_INFO(parmtype, name##type, #name ":" _type) 31 32 struct kernel_param; 33 34 /* Returns 0, or -errno. arg is in kp->arg. */ 35 typedef int (*param_set_fn)(const char *val, struct kernel_param *kp); 36 /* Returns length written or -errno. Buffer is 4k (ie. be short!) */ 37 typedef int (*param_get_fn)(char *buffer, struct kernel_param *kp); 38 39 /* Flag bits for kernel_param.flags */ 40 #define KPARAM_KMALLOCED 1 41 #define KPARAM_ISBOOL 2 42 43 struct kernel_param { 44 const char *name; 45 u16 perm; 46 u16 flags; 47 param_set_fn set; 48 param_get_fn get; 49 union { 50 void *arg; 51 const struct kparam_string *str; 52 const struct kparam_array *arr; 53 }; 54 }; 55 56 /* Special one for strings we want to copy into */ 57 struct kparam_string { 58 unsigned int maxlen; 59 char *string; 60 }; 61 62 /* Special one for arrays */ 63 struct kparam_array 64 { 65 unsigned int max; 66 unsigned int *num; 67 param_set_fn set; 68 param_get_fn get; 69 unsigned int elemsize; 70 void *elem; 71 }; 72 73 /* On alpha, ia64 and ppc64 relocations to global data cannot go into 74 read-only sections (which is part of respective UNIX ABI on these 75 platforms). So 'const' makes no sense and even causes compile failures 76 with some compilers. */ 77 #if defined(CONFIG_ALPHA) || defined(CONFIG_IA64) || defined(CONFIG_PPC64) 78 #define __moduleparam_const 79 #else 80 #define __moduleparam_const const 81 #endif 82 83 /* This is the fundamental function for registering boot/module 84 parameters. perm sets the visibility in sysfs: 000 means it's 85 not there, read bits mean it's readable, write bits mean it's 86 writable. */ 87 #define __module_param_call(prefix, name, set, get, arg, isbool, perm) \ 88 /* Default value instead of permissions? */ \ 89 static int __param_perm_check_##name __attribute__((unused)) = \ 90 BUILD_BUG_ON_ZERO((perm) < 0 || (perm) > 0777 || ((perm) & 2)) \ 91 + BUILD_BUG_ON_ZERO(sizeof(""prefix) > MAX_PARAM_PREFIX_LEN); \ 92 static const char __param_str_##name[] = prefix #name; \ 93 static struct kernel_param __moduleparam_const __param_##name \ 94 __used \ 95 __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \ 96 = { __param_str_##name, perm, isbool ? KPARAM_ISBOOL : 0, \ 97 set, get, { arg } } 98 99 #define module_param_call(name, set, get, arg, perm) \ 100 __module_param_call(MODULE_PARAM_PREFIX, \ 101 name, set, get, arg, \ 102 __same_type(*(arg), bool), perm) 103 104 /* Helper functions: type is byte, short, ushort, int, uint, long, 105 ulong, charp, bool or invbool, or XXX if you define param_get_XXX, 106 param_set_XXX and param_check_XXX. */ 107 #define module_param_named(name, value, type, perm) \ 108 param_check_##type(name, &(value)); \ 109 module_param_call(name, param_set_##type, param_get_##type, &value, perm); \ 110 __MODULE_PARM_TYPE(name, #type) 111 112 #define module_param(name, type, perm) \ 113 module_param_named(name, name, type, perm) 114 115 #ifndef MODULE 116 /** 117 * core_param - define a historical core kernel parameter. 118 * @name: the name of the cmdline and sysfs parameter (often the same as var) 119 * @var: the variable 120 * @type: the type (for param_set_##type and param_get_##type) 121 * @perm: visibility in sysfs 122 * 123 * core_param is just like module_param(), but cannot be modular and 124 * doesn't add a prefix (such as "printk."). This is for compatibility 125 * with __setup(), and it makes sense as truly core parameters aren't 126 * tied to the particular file they're in. 127 */ 128 #define core_param(name, var, type, perm) \ 129 param_check_##type(name, &(var)); \ 130 __module_param_call("", name, param_set_##type, param_get_##type, \ 131 &var, __same_type(var, bool), perm) 132 #endif /* !MODULE */ 133 134 /* Actually copy string: maxlen param is usually sizeof(string). */ 135 #define module_param_string(name, string, len, perm) \ 136 static const struct kparam_string __param_string_##name \ 137 = { len, string }; \ 138 __module_param_call(MODULE_PARAM_PREFIX, name, \ 139 param_set_copystring, param_get_string, \ 140 .str = &__param_string_##name, 0, perm); \ 141 __MODULE_PARM_TYPE(name, "string") 142 143 /* Called on module insert or kernel boot */ 144 extern int parse_args(const char *name, 145 char *args, 146 struct kernel_param *params, 147 unsigned num, 148 int (*unknown)(char *param, char *val)); 149 150 /* Called by module remove. */ 151 #ifdef CONFIG_SYSFS 152 extern void destroy_params(const struct kernel_param *params, unsigned num); 153 #else 154 static inline void destroy_params(const struct kernel_param *params, 155 unsigned num) 156 { 157 } 158 #endif /* !CONFIG_SYSFS */ 159 160 /* All the helper functions */ 161 /* The macros to do compile-time type checking stolen from Jakub 162 Jelinek, who IIRC came up with this idea for the 2.4 module init code. */ 163 #define __param_check(name, p, type) \ 164 static inline type *__check_##name(void) { return(p); } 165 166 extern int param_set_byte(const char *val, struct kernel_param *kp); 167 extern int param_get_byte(char *buffer, struct kernel_param *kp); 168 #define param_check_byte(name, p) __param_check(name, p, unsigned char) 169 170 extern int param_set_short(const char *val, struct kernel_param *kp); 171 extern int param_get_short(char *buffer, struct kernel_param *kp); 172 #define param_check_short(name, p) __param_check(name, p, short) 173 174 extern int param_set_ushort(const char *val, struct kernel_param *kp); 175 extern int param_get_ushort(char *buffer, struct kernel_param *kp); 176 #define param_check_ushort(name, p) __param_check(name, p, unsigned short) 177 178 extern int param_set_int(const char *val, struct kernel_param *kp); 179 extern int param_get_int(char *buffer, struct kernel_param *kp); 180 #define param_check_int(name, p) __param_check(name, p, int) 181 182 extern int param_set_uint(const char *val, struct kernel_param *kp); 183 extern int param_get_uint(char *buffer, struct kernel_param *kp); 184 #define param_check_uint(name, p) __param_check(name, p, unsigned int) 185 186 extern int param_set_long(const char *val, struct kernel_param *kp); 187 extern int param_get_long(char *buffer, struct kernel_param *kp); 188 #define param_check_long(name, p) __param_check(name, p, long) 189 190 extern int param_set_ulong(const char *val, struct kernel_param *kp); 191 extern int param_get_ulong(char *buffer, struct kernel_param *kp); 192 #define param_check_ulong(name, p) __param_check(name, p, unsigned long) 193 194 extern int param_set_charp(const char *val, struct kernel_param *kp); 195 extern int param_get_charp(char *buffer, struct kernel_param *kp); 196 #define param_check_charp(name, p) __param_check(name, p, char *) 197 198 /* For historical reasons "bool" parameters can be (unsigned) "int". */ 199 extern int param_set_bool(const char *val, struct kernel_param *kp); 200 extern int param_get_bool(char *buffer, struct kernel_param *kp); 201 #define param_check_bool(name, p) \ 202 static inline void __check_##name(void) \ 203 { \ 204 BUILD_BUG_ON(!__same_type(*(p), bool) && \ 205 !__same_type(*(p), unsigned int) && \ 206 !__same_type(*(p), int)); \ 207 } 208 209 extern int param_set_invbool(const char *val, struct kernel_param *kp); 210 extern int param_get_invbool(char *buffer, struct kernel_param *kp); 211 #define param_check_invbool(name, p) __param_check(name, p, bool) 212 213 /* Comma-separated array: *nump is set to number they actually specified. */ 214 #define module_param_array_named(name, array, type, nump, perm) \ 215 static const struct kparam_array __param_arr_##name \ 216 = { ARRAY_SIZE(array), nump, param_set_##type, param_get_##type,\ 217 sizeof(array[0]), array }; \ 218 __module_param_call(MODULE_PARAM_PREFIX, name, \ 219 param_array_set, param_array_get, \ 220 .arr = &__param_arr_##name, \ 221 __same_type(array[0], bool), perm); \ 222 __MODULE_PARM_TYPE(name, "array of " #type) 223 224 #define module_param_array(name, type, nump, perm) \ 225 module_param_array_named(name, name, type, nump, perm) 226 227 extern int param_array_set(const char *val, struct kernel_param *kp); 228 extern int param_array_get(char *buffer, struct kernel_param *kp); 229 230 extern int param_set_copystring(const char *val, struct kernel_param *kp); 231 extern int param_get_string(char *buffer, struct kernel_param *kp); 232 233 /* for exporting parameters in /sys/parameters */ 234 235 struct module; 236 237 #if defined(CONFIG_SYSFS) && defined(CONFIG_MODULES) 238 extern int module_param_sysfs_setup(struct module *mod, 239 struct kernel_param *kparam, 240 unsigned int num_params); 241 242 extern void module_param_sysfs_remove(struct module *mod); 243 #else 244 static inline int module_param_sysfs_setup(struct module *mod, 245 struct kernel_param *kparam, 246 unsigned int num_params) 247 { 248 return 0; 249 } 250 251 static inline void module_param_sysfs_remove(struct module *mod) 252 { } 253 #endif 254 255 #endif /* _LINUX_MODULE_PARAMS_H */ 256