params.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751
  1. /* Helpers for initial module or kernel cmdline parsing
  2. Copyright (C) 2001 Rusty Russell.
  3. This program is free software; you can redistribute it and/or modify
  4. it under the terms of the GNU General Public License as published by
  5. the Free Software Foundation; either version 2 of the License, or
  6. (at your option) any later version.
  7. This program is distributed in the hope that it will be useful,
  8. but WITHOUT ANY WARRANTY; without even the implied warranty of
  9. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  10. GNU General Public License for more details.
  11. You should have received a copy of the GNU General Public License
  12. along with this program; if not, write to the Free Software
  13. Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  14. */
  15. #include <linux/moduleparam.h>
  16. #include <linux/kernel.h>
  17. #include <linux/string.h>
  18. #include <linux/errno.h>
  19. #include <linux/module.h>
  20. #include <linux/device.h>
  21. #include <linux/err.h>
  22. #include <linux/slab.h>
  23. #if 0
  24. #define DEBUGP printk
  25. #else
  26. #define DEBUGP(fmt, a...)
  27. #endif
  28. static inline char dash2underscore(char c)
  29. {
  30. if (c == '-')
  31. return '_';
  32. return c;
  33. }
  34. static inline int parameq(const char *input, const char *paramname)
  35. {
  36. unsigned int i;
  37. for (i = 0; dash2underscore(input[i]) == paramname[i]; i++)
  38. if (input[i] == '\0')
  39. return 1;
  40. return 0;
  41. }
  42. static int parse_one(char *param,
  43. char *val,
  44. struct kernel_param *params,
  45. unsigned num_params,
  46. int (*handle_unknown)(char *param, char *val))
  47. {
  48. unsigned int i;
  49. /* Find parameter */
  50. for (i = 0; i < num_params; i++) {
  51. if (parameq(param, params[i].name)) {
  52. DEBUGP("They are equal! Calling %p\n",
  53. params[i].set);
  54. return params[i].set(val, &params[i]);
  55. }
  56. }
  57. if (handle_unknown) {
  58. DEBUGP("Unknown argument: calling %p\n", handle_unknown);
  59. return handle_unknown(param, val);
  60. }
  61. DEBUGP("Unknown argument `%s'\n", param);
  62. return -ENOENT;
  63. }
  64. /* You can use " around spaces, but can't escape ". */
  65. /* Hyphens and underscores equivalent in parameter names. */
  66. static char *next_arg(char *args, char **param, char **val)
  67. {
  68. unsigned int i, equals = 0;
  69. int in_quote = 0, quoted = 0;
  70. char *next;
  71. if (*args == '"') {
  72. args++;
  73. in_quote = 1;
  74. quoted = 1;
  75. }
  76. for (i = 0; args[i]; i++) {
  77. if (args[i] == ' ' && !in_quote)
  78. break;
  79. if (equals == 0) {
  80. if (args[i] == '=')
  81. equals = i;
  82. }
  83. if (args[i] == '"')
  84. in_quote = !in_quote;
  85. }
  86. *param = args;
  87. if (!equals)
  88. *val = NULL;
  89. else {
  90. args[equals] = '\0';
  91. *val = args + equals + 1;
  92. /* Don't include quotes in value. */
  93. if (**val == '"') {
  94. (*val)++;
  95. if (args[i-1] == '"')
  96. args[i-1] = '\0';
  97. }
  98. if (quoted && args[i-1] == '"')
  99. args[i-1] = '\0';
  100. }
  101. if (args[i]) {
  102. args[i] = '\0';
  103. next = args + i + 1;
  104. } else
  105. next = args + i;
  106. /* Chew up trailing spaces. */
  107. while (*next == ' ')
  108. next++;
  109. return next;
  110. }
  111. /* Args looks like "foo=bar,bar2 baz=fuz wiz". */
  112. int parse_args(const char *name,
  113. char *args,
  114. struct kernel_param *params,
  115. unsigned num,
  116. int (*unknown)(char *param, char *val))
  117. {
  118. char *param, *val;
  119. DEBUGP("Parsing ARGS: %s\n", args);
  120. /* Chew leading spaces */
  121. while (*args == ' ')
  122. args++;
  123. while (*args) {
  124. int ret;
  125. int irq_was_disabled;
  126. args = next_arg(args, &param, &val);
  127. irq_was_disabled = irqs_disabled();
  128. ret = parse_one(param, val, params, num, unknown);
  129. if (irq_was_disabled && !irqs_disabled()) {
  130. printk(KERN_WARNING "parse_args(): option '%s' enabled "
  131. "irq's!\n", param);
  132. }
  133. switch (ret) {
  134. case -ENOENT:
  135. printk(KERN_ERR "%s: Unknown parameter `%s'\n",
  136. name, param);
  137. return ret;
  138. case -ENOSPC:
  139. printk(KERN_ERR
  140. "%s: `%s' too large for parameter `%s'\n",
  141. name, val ?: "", param);
  142. return ret;
  143. case 0:
  144. break;
  145. default:
  146. printk(KERN_ERR
  147. "%s: `%s' invalid for parameter `%s'\n",
  148. name, val ?: "", param);
  149. return ret;
  150. }
  151. }
  152. /* All parsed OK. */
  153. return 0;
  154. }
  155. /* Lazy bastard, eh? */
  156. #define STANDARD_PARAM_DEF(name, type, format, tmptype, strtolfn) \
  157. int param_set_##name(const char *val, struct kernel_param *kp) \
  158. { \
  159. char *endp; \
  160. tmptype l; \
  161. \
  162. if (!val) return -EINVAL; \
  163. l = strtolfn(val, &endp, 0); \
  164. if (endp == val || ((type)l != l)) \
  165. return -EINVAL; \
  166. *((type *)kp->arg) = l; \
  167. return 0; \
  168. } \
  169. int param_get_##name(char *buffer, struct kernel_param *kp) \
  170. { \
  171. return sprintf(buffer, format, *((type *)kp->arg)); \
  172. }
  173. STANDARD_PARAM_DEF(byte, unsigned char, "%c", unsigned long, simple_strtoul);
  174. STANDARD_PARAM_DEF(short, short, "%hi", long, simple_strtol);
  175. STANDARD_PARAM_DEF(ushort, unsigned short, "%hu", unsigned long, simple_strtoul);
  176. STANDARD_PARAM_DEF(int, int, "%i", long, simple_strtol);
  177. STANDARD_PARAM_DEF(uint, unsigned int, "%u", unsigned long, simple_strtoul);
  178. STANDARD_PARAM_DEF(long, long, "%li", long, simple_strtol);
  179. STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", unsigned long, simple_strtoul);
  180. int param_set_charp(const char *val, struct kernel_param *kp)
  181. {
  182. if (!val) {
  183. printk(KERN_ERR "%s: string parameter expected\n",
  184. kp->name);
  185. return -EINVAL;
  186. }
  187. if (strlen(val) > 1024) {
  188. printk(KERN_ERR "%s: string parameter too long\n",
  189. kp->name);
  190. return -ENOSPC;
  191. }
  192. *(char **)kp->arg = (char *)val;
  193. return 0;
  194. }
  195. int param_get_charp(char *buffer, struct kernel_param *kp)
  196. {
  197. return sprintf(buffer, "%s", *((char **)kp->arg));
  198. }
  199. int param_set_bool(const char *val, struct kernel_param *kp)
  200. {
  201. /* No equals means "set"... */
  202. if (!val) val = "1";
  203. /* One of =[yYnN01] */
  204. switch (val[0]) {
  205. case 'y': case 'Y': case '1':
  206. *(int *)kp->arg = 1;
  207. return 0;
  208. case 'n': case 'N': case '0':
  209. *(int *)kp->arg = 0;
  210. return 0;
  211. }
  212. return -EINVAL;
  213. }
  214. int param_get_bool(char *buffer, struct kernel_param *kp)
  215. {
  216. /* Y and N chosen as being relatively non-coder friendly */
  217. return sprintf(buffer, "%c", (*(int *)kp->arg) ? 'Y' : 'N');
  218. }
  219. int param_set_invbool(const char *val, struct kernel_param *kp)
  220. {
  221. int boolval, ret;
  222. struct kernel_param dummy = { .arg = &boolval };
  223. ret = param_set_bool(val, &dummy);
  224. if (ret == 0)
  225. *(int *)kp->arg = !boolval;
  226. return ret;
  227. }
  228. int param_get_invbool(char *buffer, struct kernel_param *kp)
  229. {
  230. int val;
  231. struct kernel_param dummy = { .arg = &val };
  232. val = !*(int *)kp->arg;
  233. return param_get_bool(buffer, &dummy);
  234. }
  235. /* We cheat here and temporarily mangle the string. */
  236. static int param_array(const char *name,
  237. const char *val,
  238. unsigned int min, unsigned int max,
  239. void *elem, int elemsize,
  240. int (*set)(const char *, struct kernel_param *kp),
  241. int *num)
  242. {
  243. int ret;
  244. struct kernel_param kp;
  245. char save;
  246. /* Get the name right for errors. */
  247. kp.name = name;
  248. kp.arg = elem;
  249. /* No equals sign? */
  250. if (!val) {
  251. printk(KERN_ERR "%s: expects arguments\n", name);
  252. return -EINVAL;
  253. }
  254. *num = 0;
  255. /* We expect a comma-separated list of values. */
  256. do {
  257. int len;
  258. if (*num == max) {
  259. printk(KERN_ERR "%s: can only take %i arguments\n",
  260. name, max);
  261. return -EINVAL;
  262. }
  263. len = strcspn(val, ",");
  264. /* nul-terminate and parse */
  265. save = val[len];
  266. ((char *)val)[len] = '\0';
  267. ret = set(val, &kp);
  268. if (ret != 0)
  269. return ret;
  270. kp.arg += elemsize;
  271. val += len+1;
  272. (*num)++;
  273. } while (save == ',');
  274. if (*num < min) {
  275. printk(KERN_ERR "%s: needs at least %i arguments\n",
  276. name, min);
  277. return -EINVAL;
  278. }
  279. return 0;
  280. }
  281. int param_array_set(const char *val, struct kernel_param *kp)
  282. {
  283. struct kparam_array *arr = kp->arg;
  284. unsigned int temp_num;
  285. return param_array(kp->name, val, 1, arr->max, arr->elem,
  286. arr->elemsize, arr->set, arr->num ?: &temp_num);
  287. }
  288. int param_array_get(char *buffer, struct kernel_param *kp)
  289. {
  290. int i, off, ret;
  291. struct kparam_array *arr = kp->arg;
  292. struct kernel_param p;
  293. p = *kp;
  294. for (i = off = 0; i < (arr->num ? *arr->num : arr->max); i++) {
  295. if (i)
  296. buffer[off++] = ',';
  297. p.arg = arr->elem + arr->elemsize * i;
  298. ret = arr->get(buffer + off, &p);
  299. if (ret < 0)
  300. return ret;
  301. off += ret;
  302. }
  303. buffer[off] = '\0';
  304. return off;
  305. }
  306. int param_set_copystring(const char *val, struct kernel_param *kp)
  307. {
  308. struct kparam_string *kps = kp->arg;
  309. if (!val) {
  310. printk(KERN_ERR "%s: missing param set value\n", kp->name);
  311. return -EINVAL;
  312. }
  313. if (strlen(val)+1 > kps->maxlen) {
  314. printk(KERN_ERR "%s: string doesn't fit in %u chars.\n",
  315. kp->name, kps->maxlen-1);
  316. return -ENOSPC;
  317. }
  318. strcpy(kps->string, val);
  319. return 0;
  320. }
  321. int param_get_string(char *buffer, struct kernel_param *kp)
  322. {
  323. struct kparam_string *kps = kp->arg;
  324. return strlcpy(buffer, kps->string, kps->maxlen);
  325. }
  326. /* sysfs output in /sys/modules/XYZ/parameters/ */
  327. extern struct kernel_param __start___param[], __stop___param[];
  328. #define MAX_KBUILD_MODNAME KOBJ_NAME_LEN
  329. struct param_attribute
  330. {
  331. struct module_attribute mattr;
  332. struct kernel_param *param;
  333. };
  334. struct module_param_attrs
  335. {
  336. struct attribute_group grp;
  337. struct param_attribute attrs[0];
  338. };
  339. #ifdef CONFIG_SYSFS
  340. #define to_param_attr(n) container_of(n, struct param_attribute, mattr);
  341. static ssize_t param_attr_show(struct module_attribute *mattr,
  342. struct module *mod, char *buf)
  343. {
  344. int count;
  345. struct param_attribute *attribute = to_param_attr(mattr);
  346. if (!attribute->param->get)
  347. return -EPERM;
  348. count = attribute->param->get(buf, attribute->param);
  349. if (count > 0) {
  350. strcat(buf, "\n");
  351. ++count;
  352. }
  353. return count;
  354. }
  355. /* sysfs always hands a nul-terminated string in buf. We rely on that. */
  356. static ssize_t param_attr_store(struct module_attribute *mattr,
  357. struct module *owner,
  358. const char *buf, size_t len)
  359. {
  360. int err;
  361. struct param_attribute *attribute = to_param_attr(mattr);
  362. if (!attribute->param->set)
  363. return -EPERM;
  364. err = attribute->param->set(buf, attribute->param);
  365. if (!err)
  366. return len;
  367. return err;
  368. }
  369. #endif
  370. #ifdef CONFIG_MODULES
  371. #define __modinit
  372. #else
  373. #define __modinit __init
  374. #endif
  375. #ifdef CONFIG_SYSFS
  376. /*
  377. * param_sysfs_setup - setup sysfs support for one module or KBUILD_MODNAME
  378. * @mk: struct module_kobject (contains parent kobject)
  379. * @kparam: array of struct kernel_param, the actual parameter definitions
  380. * @num_params: number of entries in array
  381. * @name_skip: offset where the parameter name start in kparam[].name. Needed for built-in "modules"
  382. *
  383. * Create a kobject for a (per-module) group of parameters, and create files
  384. * in sysfs. A pointer to the param_kobject is returned on success,
  385. * NULL if there's no parameter to export, or other ERR_PTR(err).
  386. */
  387. static __modinit struct module_param_attrs *
  388. param_sysfs_setup(struct module_kobject *mk,
  389. struct kernel_param *kparam,
  390. unsigned int num_params,
  391. unsigned int name_skip)
  392. {
  393. struct module_param_attrs *mp;
  394. unsigned int valid_attrs = 0;
  395. unsigned int i, size[2];
  396. struct param_attribute *pattr;
  397. struct attribute **gattr;
  398. int err;
  399. for (i=0; i<num_params; i++) {
  400. if (kparam[i].perm)
  401. valid_attrs++;
  402. }
  403. if (!valid_attrs)
  404. return NULL;
  405. size[0] = ALIGN(sizeof(*mp) +
  406. valid_attrs * sizeof(mp->attrs[0]),
  407. sizeof(mp->grp.attrs[0]));
  408. size[1] = (valid_attrs + 1) * sizeof(mp->grp.attrs[0]);
  409. mp = kmalloc(size[0] + size[1], GFP_KERNEL);
  410. if (!mp)
  411. return ERR_PTR(-ENOMEM);
  412. mp->grp.name = "parameters";
  413. mp->grp.attrs = (void *)mp + size[0];
  414. pattr = &mp->attrs[0];
  415. gattr = &mp->grp.attrs[0];
  416. for (i = 0; i < num_params; i++) {
  417. struct kernel_param *kp = &kparam[i];
  418. if (kp->perm) {
  419. pattr->param = kp;
  420. pattr->mattr.show = param_attr_show;
  421. pattr->mattr.store = param_attr_store;
  422. pattr->mattr.attr.name = (char *)&kp->name[name_skip];
  423. pattr->mattr.attr.owner = mk->mod;
  424. pattr->mattr.attr.mode = kp->perm;
  425. *(gattr++) = &(pattr++)->mattr.attr;
  426. }
  427. }
  428. *gattr = NULL;
  429. if ((err = sysfs_create_group(&mk->kobj, &mp->grp))) {
  430. kfree(mp);
  431. return ERR_PTR(err);
  432. }
  433. return mp;
  434. }
  435. #ifdef CONFIG_MODULES
  436. /*
  437. * module_param_sysfs_setup - setup sysfs support for one module
  438. * @mod: module
  439. * @kparam: module parameters (array)
  440. * @num_params: number of module parameters
  441. *
  442. * Adds sysfs entries for module parameters, and creates a link from
  443. * /sys/module/[mod->name]/parameters to /sys/parameters/[mod->name]/
  444. */
  445. int module_param_sysfs_setup(struct module *mod,
  446. struct kernel_param *kparam,
  447. unsigned int num_params)
  448. {
  449. struct module_param_attrs *mp;
  450. mp = param_sysfs_setup(&mod->mkobj, kparam, num_params, 0);
  451. if (IS_ERR(mp))
  452. return PTR_ERR(mp);
  453. mod->param_attrs = mp;
  454. return 0;
  455. }
  456. /*
  457. * module_param_sysfs_remove - remove sysfs support for one module
  458. * @mod: module
  459. *
  460. * Remove sysfs entries for module parameters and the corresponding
  461. * kobject.
  462. */
  463. void module_param_sysfs_remove(struct module *mod)
  464. {
  465. if (mod->param_attrs) {
  466. sysfs_remove_group(&mod->mkobj.kobj,
  467. &mod->param_attrs->grp);
  468. /* We are positive that no one is using any param
  469. * attrs at this point. Deallocate immediately. */
  470. kfree(mod->param_attrs);
  471. mod->param_attrs = NULL;
  472. }
  473. }
  474. #endif
  475. /*
  476. * kernel_param_sysfs_setup - wrapper for built-in params support
  477. */
  478. static void __init kernel_param_sysfs_setup(const char *name,
  479. struct kernel_param *kparam,
  480. unsigned int num_params,
  481. unsigned int name_skip)
  482. {
  483. struct module_kobject *mk;
  484. int ret;
  485. mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL);
  486. BUG_ON(!mk);
  487. mk->mod = THIS_MODULE;
  488. kobj_set_kset_s(mk, module_subsys);
  489. kobject_set_name(&mk->kobj, name);
  490. kobject_init(&mk->kobj);
  491. ret = kobject_add(&mk->kobj);
  492. BUG_ON(ret < 0);
  493. param_sysfs_setup(mk, kparam, num_params, name_skip);
  494. kobject_uevent(&mk->kobj, KOBJ_ADD);
  495. }
  496. /*
  497. * param_sysfs_builtin - add contents in /sys/parameters for built-in modules
  498. *
  499. * Add module_parameters to sysfs for "modules" built into the kernel.
  500. *
  501. * The "module" name (KBUILD_MODNAME) is stored before a dot, the
  502. * "parameter" name is stored behind a dot in kernel_param->name. So,
  503. * extract the "module" name for all built-in kernel_param-eters,
  504. * and for all who have the same, call kernel_param_sysfs_setup.
  505. */
  506. static void __init param_sysfs_builtin(void)
  507. {
  508. struct kernel_param *kp, *kp_begin = NULL;
  509. unsigned int i, name_len, count = 0;
  510. char modname[MAX_KBUILD_MODNAME + 1] = "";
  511. for (i=0; i < __stop___param - __start___param; i++) {
  512. char *dot;
  513. kp = &__start___param[i];
  514. /* We do not handle args without periods. */
  515. dot = memchr(kp->name, '.', MAX_KBUILD_MODNAME);
  516. if (!dot) {
  517. DEBUGP("couldn't find period in %s\n", kp->name);
  518. continue;
  519. }
  520. name_len = dot - kp->name;
  521. /* new kbuild_modname? */
  522. if (strlen(modname) != name_len
  523. || strncmp(modname, kp->name, name_len) != 0) {
  524. /* add a new kobject for previous kernel_params. */
  525. if (count)
  526. kernel_param_sysfs_setup(modname,
  527. kp_begin,
  528. count,
  529. strlen(modname)+1);
  530. strncpy(modname, kp->name, name_len);
  531. modname[name_len] = '\0';
  532. count = 0;
  533. kp_begin = kp;
  534. }
  535. count++;
  536. }
  537. /* last kernel_params need to be registered as well */
  538. if (count)
  539. kernel_param_sysfs_setup(modname, kp_begin, count,
  540. strlen(modname)+1);
  541. }
  542. /* module-related sysfs stuff */
  543. #define to_module_attr(n) container_of(n, struct module_attribute, attr);
  544. #define to_module_kobject(n) container_of(n, struct module_kobject, kobj);
  545. static ssize_t module_attr_show(struct kobject *kobj,
  546. struct attribute *attr,
  547. char *buf)
  548. {
  549. struct module_attribute *attribute;
  550. struct module_kobject *mk;
  551. int ret;
  552. attribute = to_module_attr(attr);
  553. mk = to_module_kobject(kobj);
  554. if (!attribute->show)
  555. return -EIO;
  556. ret = attribute->show(attribute, mk->mod, buf);
  557. return ret;
  558. }
  559. static ssize_t module_attr_store(struct kobject *kobj,
  560. struct attribute *attr,
  561. const char *buf, size_t len)
  562. {
  563. struct module_attribute *attribute;
  564. struct module_kobject *mk;
  565. int ret;
  566. attribute = to_module_attr(attr);
  567. mk = to_module_kobject(kobj);
  568. if (!attribute->store)
  569. return -EIO;
  570. ret = attribute->store(attribute, mk->mod, buf, len);
  571. return ret;
  572. }
  573. static struct sysfs_ops module_sysfs_ops = {
  574. .show = module_attr_show,
  575. .store = module_attr_store,
  576. };
  577. static struct kobj_type module_ktype;
  578. static int uevent_filter(struct kset *kset, struct kobject *kobj)
  579. {
  580. struct kobj_type *ktype = get_ktype(kobj);
  581. if (ktype == &module_ktype)
  582. return 1;
  583. return 0;
  584. }
  585. static struct kset_uevent_ops module_uevent_ops = {
  586. .filter = uevent_filter,
  587. };
  588. decl_subsys(module, &module_ktype, &module_uevent_ops);
  589. static struct kobj_type module_ktype = {
  590. .sysfs_ops = &module_sysfs_ops,
  591. };
  592. /*
  593. * param_sysfs_init - wrapper for built-in params support
  594. */
  595. static int __init param_sysfs_init(void)
  596. {
  597. int ret;
  598. ret = subsystem_register(&module_subsys);
  599. if (ret < 0) {
  600. printk(KERN_WARNING "%s (%d): subsystem_register error: %d\n",
  601. __FILE__, __LINE__, ret);
  602. return ret;
  603. }
  604. param_sysfs_builtin();
  605. return 0;
  606. }
  607. subsys_initcall(param_sysfs_init);
  608. #else
  609. #if 0
  610. static struct sysfs_ops module_sysfs_ops = {
  611. .show = NULL,
  612. .store = NULL,
  613. };
  614. #endif
  615. #endif
  616. EXPORT_SYMBOL(param_set_byte);
  617. EXPORT_SYMBOL(param_get_byte);
  618. EXPORT_SYMBOL(param_set_short);
  619. EXPORT_SYMBOL(param_get_short);
  620. EXPORT_SYMBOL(param_set_ushort);
  621. EXPORT_SYMBOL(param_get_ushort);
  622. EXPORT_SYMBOL(param_set_int);
  623. EXPORT_SYMBOL(param_get_int);
  624. EXPORT_SYMBOL(param_set_uint);
  625. EXPORT_SYMBOL(param_get_uint);
  626. EXPORT_SYMBOL(param_set_long);
  627. EXPORT_SYMBOL(param_get_long);
  628. EXPORT_SYMBOL(param_set_ulong);
  629. EXPORT_SYMBOL(param_get_ulong);
  630. EXPORT_SYMBOL(param_set_charp);
  631. EXPORT_SYMBOL(param_get_charp);
  632. EXPORT_SYMBOL(param_set_bool);
  633. EXPORT_SYMBOL(param_get_bool);
  634. EXPORT_SYMBOL(param_set_invbool);
  635. EXPORT_SYMBOL(param_get_invbool);
  636. EXPORT_SYMBOL(param_array_set);
  637. EXPORT_SYMBOL(param_array_get);
  638. EXPORT_SYMBOL(param_set_copystring);
  639. EXPORT_SYMBOL(param_get_string);