← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to kernel/params.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno, Martin Michlmayr
  • Date: 2011-04-06 13:53:30 UTC
  • mfrom: (43.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20110406135330-wjufxhd0tvn3zx4z
Tags: 2.6.38-3
http://bugs.debian.org/620124
http://bugs.debian.org/620284
http://bugs.debian.org/620204
[ Ben Hutchings ]
* [ppc64] Add to linux-tools package architectures (Closes: #620124)
* [amd64] Save cr4 to mmu_cr4_features at boot time (Closes: #620284)
* appletalk: Fix bugs introduced when removing use of BKL
* ALSA: Fix yet another race in disconnection
* cciss: Fix lost command issue
* ath9k: Fix kernel panic in AR2427
* ses: Avoid kernel panic when lun 0 is not mapped
* PCI/ACPI: Report ASPM support to BIOS if not disabled from command line

[ Aurelien Jarno ]
* rtlwifi: fix build when PCI is not enabled.

[ Martin Michlmayr ]
* rtlwifi: Eliminate udelay calls with too large values (Closes: #620204)

Show diffs side-by-side

added added

removed removed

Lines of Context:
kernel/params.c
31
31
#define DEBUGP(fmt, a...)
32
32
#endif
33
33
 
 
34
/* Protects all parameters, and incidentally kmalloced_param list. */
 
35
static DEFINE_MUTEX(param_lock);
 
36
 
 
37
/* This just allows us to keep track of which parameters are kmalloced. */
 
38
struct kmalloced_param {
 
39
        struct list_head list;
 
40
        char val[];
 
41
};
 
42
static LIST_HEAD(kmalloced_params);
 
43
 
 
44
static void *kmalloc_parameter(unsigned int size)
 
45
{
 
46
        struct kmalloced_param *p;
 
47
 
 
48
        p = kmalloc(sizeof(*p) + size, GFP_KERNEL);
 
49
        if (!p)
 
50
                return NULL;
 
51
 
 
52
        list_add(&p->list, &kmalloced_params);
 
53
        return p->val;
 
54
}
 
55
 
 
56
/* Does nothing if parameter wasn't kmalloced above. */
 
57
static void maybe_kfree_parameter(void *param)
 
58
{
 
59
        struct kmalloced_param *p;
 
60
 
 
61
        list_for_each_entry(p, &kmalloced_params, list) {
 
62
                if (p->val == param) {
 
63
                        list_del(&p->list);
 
64
                        kfree(p);
 
65
                        break;
 
66
                }
 
67
        }
 
68
}
 
69
 
34
70
static inline char dash2underscore(char c)
35
71
{
36
72
        if (c == '-')
49
85
 
50
86
static int parse_one(char *param,
51
87
                     char *val,
52
 
                     struct kernel_param *params, 
 
88
                     const struct kernel_param *params,
53
89
                     unsigned num_params,
54
90
                     int (*handle_unknown)(char *param, char *val))
55
91
{
56
92
        unsigned int i;
 
93
        int err;
57
94
 
58
95
        /* Find parameter */
59
96
        for (i = 0; i < num_params; i++) {
60
97
                if (parameq(param, params[i].name)) {
 
98
                        /* Noone handled NULL, so do it here. */
 
99
                        if (!val && params[i].ops->set != param_set_bool)
 
100
                                return -EINVAL;
61
101
                        DEBUGP("They are equal!  Calling %p\n",
62
 
                               params[i].set);
63
 
                        return params[i].set(val, &params[i]);
 
102
                               params[i].ops->set);
 
103
                        mutex_lock(&param_lock);
 
104
                        err = params[i].ops->set(val, &params[i]);
 
105
                        mutex_unlock(&param_lock);
 
106
                        return err;
64
107
                }
65
108
        }
66
109
 
122
165
                next = args + i;
123
166
 
124
167
        /* Chew up trailing spaces. */
125
 
        while (isspace(*next))
126
 
                next++;
127
 
        return next;
 
168
        return skip_spaces(next);
128
169
}
129
170
 
130
171
/* Args looks like "foo=bar,bar2 baz=fuz wiz". */
131
172
int parse_args(const char *name,
132
173
               char *args,
133
 
               struct kernel_param *params,
 
174
               const struct kernel_param *params,
134
175
               unsigned num,
135
176
               int (*unknown)(char *param, char *val))
136
177
{
139
180
        DEBUGP("Parsing ARGS: %s\n", args);
140
181
 
141
182
        /* Chew leading spaces */
142
 
        while (isspace(*args))
143
 
                args++;
 
183
        args = skip_spaces(args);
144
184
 
145
185
        while (*args) {
146
186
                int ret;
179
219
 
180
220
/* Lazy bastard, eh? */
181
221
#define STANDARD_PARAM_DEF(name, type, format, tmptype, strtolfn)       \
182
 
        int param_set_##name(const char *val, struct kernel_param *kp)  \
 
222
        int param_set_##name(const char *val, const struct kernel_param *kp) \
183
223
        {                                                               \
184
224
                tmptype l;                                              \
185
225
                int ret;                                                \
186
226
                                                                        \
187
 
                if (!val) return -EINVAL;                               \
188
227
                ret = strtolfn(val, 0, &l);                             \
189
228
                if (ret == -EINVAL || ((type)l != l))                   \
190
229
                        return -EINVAL;                                 \
191
230
                *((type *)kp->arg) = l;                                 \
192
231
                return 0;                                               \
193
232
        }                                                               \
194
 
        int param_get_##name(char *buffer, struct kernel_param *kp)     \
 
233
        int param_get_##name(char *buffer, const struct kernel_param *kp) \
195
234
        {                                                               \
196
235
                return sprintf(buffer, format, *((type *)kp->arg));     \
197
 
        }
 
236
        }                                                               \
 
237
        struct kernel_param_ops param_ops_##name = {                    \
 
238
                .set = param_set_##name,                                \
 
239
                .get = param_get_##name,                                \
 
240
        };                                                              \
 
241
        EXPORT_SYMBOL(param_set_##name);                                \
 
242
        EXPORT_SYMBOL(param_get_##name);                                \
 
243
        EXPORT_SYMBOL(param_ops_##name)
 
244
 
198
245
 
199
246
STANDARD_PARAM_DEF(byte, unsigned char, "%c", unsigned long, strict_strtoul);
200
247
STANDARD_PARAM_DEF(short, short, "%hi", long, strict_strtol);
204
251
STANDARD_PARAM_DEF(long, long, "%li", long, strict_strtol);
205
252
STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", unsigned long, strict_strtoul);
206
253
 
207
 
int param_set_charp(const char *val, struct kernel_param *kp)
 
254
int param_set_charp(const char *val, const struct kernel_param *kp)
208
255
{
209
 
        if (!val) {
210
 
                printk(KERN_ERR "%s: string parameter expected\n",
211
 
                       kp->name);
212
 
                return -EINVAL;
213
 
        }
214
 
 
215
256
        if (strlen(val) > 1024) {
216
257
                printk(KERN_ERR "%s: string parameter too long\n",
217
258
                       kp->name);
218
259
                return -ENOSPC;
219
260
        }
220
261
 
221
 
        /* This is a hack.  We can't need to strdup in early boot, and we
 
262
        maybe_kfree_parameter(*(char **)kp->arg);
 
263
 
 
264
        /* This is a hack.  We can't kmalloc in early boot, and we
222
265
         * don't need to; this mangled commandline is preserved. */
223
266
        if (slab_is_available()) {
224
 
                *(char **)kp->arg = kstrdup(val, GFP_KERNEL);
 
267
                *(char **)kp->arg = kmalloc_parameter(strlen(val)+1);
225
268
                if (!*(char **)kp->arg)
226
269
                        return -ENOMEM;
 
270
                strcpy(*(char **)kp->arg, val);
227
271
        } else
228
272
                *(const char **)kp->arg = val;
229
273
 
230
274
        return 0;
231
275
}
 
276
EXPORT_SYMBOL(param_set_charp);
232
277
 
233
 
int param_get_charp(char *buffer, struct kernel_param *kp)
 
278
int param_get_charp(char *buffer, const struct kernel_param *kp)
234
279
{
235
280
        return sprintf(buffer, "%s", *((char **)kp->arg));
236
281
}
 
282
EXPORT_SYMBOL(param_get_charp);
 
283
 
 
284
static void param_free_charp(void *arg)
 
285
{
 
286
        maybe_kfree_parameter(*((char **)arg));
 
287
}
 
288
 
 
289
struct kernel_param_ops param_ops_charp = {
 
290
        .set = param_set_charp,
 
291
        .get = param_get_charp,
 
292
        .free = param_free_charp,
 
293
};
 
294
EXPORT_SYMBOL(param_ops_charp);
237
295
 
238
296
/* Actually could be a bool or an int, for historical reasons. */
239
 
int param_set_bool(const char *val, struct kernel_param *kp)
 
297
int param_set_bool(const char *val, const struct kernel_param *kp)
240
298
{
241
299
        bool v;
242
300
 
261
319
                *(int *)kp->arg = v;
262
320
        return 0;
263
321
}
 
322
EXPORT_SYMBOL(param_set_bool);
264
323
 
265
 
int param_get_bool(char *buffer, struct kernel_param *kp)
 
324
int param_get_bool(char *buffer, const struct kernel_param *kp)
266
325
{
267
326
        bool val;
268
327
        if (kp->flags & KPARAM_ISBOOL)
273
332
        /* Y and N chosen as being relatively non-coder friendly */
274
333
        return sprintf(buffer, "%c", val ? 'Y' : 'N');
275
334
}
 
335
EXPORT_SYMBOL(param_get_bool);
 
336
 
 
337
struct kernel_param_ops param_ops_bool = {
 
338
        .set = param_set_bool,
 
339
        .get = param_get_bool,
 
340
};
 
341
EXPORT_SYMBOL(param_ops_bool);
276
342
 
277
343
/* This one must be bool. */
278
 
int param_set_invbool(const char *val, struct kernel_param *kp)
 
344
int param_set_invbool(const char *val, const struct kernel_param *kp)
279
345
{
280
346
        int ret;
281
347
        bool boolval;
288
354
                *(bool *)kp->arg = !boolval;
289
355
        return ret;
290
356
}
 
357
EXPORT_SYMBOL(param_set_invbool);
291
358
 
292
 
int param_get_invbool(char *buffer, struct kernel_param *kp)
 
359
int param_get_invbool(char *buffer, const struct kernel_param *kp)
293
360
{
294
361
        return sprintf(buffer, "%c", (*(bool *)kp->arg) ? 'N' : 'Y');
295
362
}
 
363
EXPORT_SYMBOL(param_get_invbool);
 
364
 
 
365
struct kernel_param_ops param_ops_invbool = {
 
366
        .set = param_set_invbool,
 
367
        .get = param_get_invbool,
 
368
};
 
369
EXPORT_SYMBOL(param_ops_invbool);
296
370
 
297
371
/* We break the rule and mangle the string. */
298
372
static int param_array(const char *name,
299
373
                       const char *val,
300
374
                       unsigned int min, unsigned int max,
301
375
                       void *elem, int elemsize,
302
 
                       int (*set)(const char *, struct kernel_param *kp),
 
376
                       int (*set)(const char *, const struct kernel_param *kp),
303
377
                       u16 flags,
304
378
                       unsigned int *num)
305
379
{
312
386
        kp.arg = elem;
313
387
        kp.flags = flags;
314
388
 
315
 
        /* No equals sign? */
316
 
        if (!val) {
317
 
                printk(KERN_ERR "%s: expects arguments\n", name);
318
 
                return -EINVAL;
319
 
        }
320
 
 
321
389
        *num = 0;
322
390
        /* We expect a comma-separated list of values. */
323
391
        do {
333
401
                /* nul-terminate and parse */
334
402
                save = val[len];
335
403
                ((char *)val)[len] = '\0';
 
404
                BUG_ON(!mutex_is_locked(&param_lock));
336
405
                ret = set(val, &kp);
337
406
 
338
407
                if (ret != 0)
350
419
        return 0;
351
420
}
352
421
 
353
 
int param_array_set(const char *val, struct kernel_param *kp)
 
422
static int param_array_set(const char *val, const struct kernel_param *kp)
354
423
{
355
424
        const struct kparam_array *arr = kp->arr;
356
425
        unsigned int temp_num;
357
426
 
358
427
        return param_array(kp->name, val, 1, arr->max, arr->elem,
359
 
                           arr->elemsize, arr->set, kp->flags,
 
428
                           arr->elemsize, arr->ops->set, kp->flags,
360
429
                           arr->num ?: &temp_num);
361
430
}
362
431
 
363
 
int param_array_get(char *buffer, struct kernel_param *kp)
 
432
static int param_array_get(char *buffer, const struct kernel_param *kp)
364
433
{
365
434
        int i, off, ret;
366
435
        const struct kparam_array *arr = kp->arr;
371
440
                if (i)
372
441
                        buffer[off++] = ',';
373
442
                p.arg = arr->elem + arr->elemsize * i;
374
 
                ret = arr->get(buffer + off, &p);
 
443
                BUG_ON(!mutex_is_locked(&param_lock));
 
444
                ret = arr->ops->get(buffer + off, &p);
375
445
                if (ret < 0)
376
446
                        return ret;
377
447
                off += ret;
380
450
        return off;
381
451
}
382
452
 
383
 
int param_set_copystring(const char *val, struct kernel_param *kp)
 
453
static void param_array_free(void *arg)
 
454
{
 
455
        unsigned int i;
 
456
        const struct kparam_array *arr = arg;
 
457
 
 
458
        if (arr->ops->free)
 
459
                for (i = 0; i < (arr->num ? *arr->num : arr->max); i++)
 
460
                        arr->ops->free(arr->elem + arr->elemsize * i);
 
461
}
 
462
 
 
463
struct kernel_param_ops param_array_ops = {
 
464
        .set = param_array_set,
 
465
        .get = param_array_get,
 
466
        .free = param_array_free,
 
467
};
 
468
EXPORT_SYMBOL(param_array_ops);
 
469
 
 
470
int param_set_copystring(const char *val, const struct kernel_param *kp)
384
471
{
385
472
        const struct kparam_string *kps = kp->str;
386
473
 
387
 
        if (!val) {
388
 
                printk(KERN_ERR "%s: missing param set value\n", kp->name);
389
 
                return -EINVAL;
390
 
        }
391
474
        if (strlen(val)+1 > kps->maxlen) {
392
475
                printk(KERN_ERR "%s: string doesn't fit in %u chars.\n",
393
476
                       kp->name, kps->maxlen-1);
396
479
        strcpy(kps->string, val);
397
480
        return 0;
398
481
}
 
482
EXPORT_SYMBOL(param_set_copystring);
399
483
 
400
 
int param_get_string(char *buffer, struct kernel_param *kp)
 
484
int param_get_string(char *buffer, const struct kernel_param *kp)
401
485
{
402
486
        const struct kparam_string *kps = kp->str;
403
487
        return strlcpy(buffer, kps->string, kps->maxlen);
404
488
}
 
489
EXPORT_SYMBOL(param_get_string);
 
490
 
 
491
struct kernel_param_ops param_ops_string = {
 
492
        .set = param_set_copystring,
 
493
        .get = param_get_string,
 
494
};
 
495
EXPORT_SYMBOL(param_ops_string);
405
496
 
406
497
/* sysfs output in /sys/modules/XYZ/parameters/ */
407
 
#define to_module_attr(n) container_of(n, struct module_attribute, attr);
408
 
#define to_module_kobject(n) container_of(n, struct module_kobject, kobj);
 
498
#define to_module_attr(n) container_of(n, struct module_attribute, attr)
 
499
#define to_module_kobject(n) container_of(n, struct module_kobject, kobj)
409
500
 
410
501
extern struct kernel_param __start___param[], __stop___param[];
411
502
 
412
503
struct param_attribute
413
504
{
414
505
        struct module_attribute mattr;
415
 
        struct kernel_param *param;
 
506
        const struct kernel_param *param;
416
507
};
417
508
 
418
509
struct module_param_attrs
423
514
};
424
515
 
425
516
#ifdef CONFIG_SYSFS
426
 
#define to_param_attr(n) container_of(n, struct param_attribute, mattr);
 
517
#define to_param_attr(n) container_of(n, struct param_attribute, mattr)
427
518
 
428
519
static ssize_t param_attr_show(struct module_attribute *mattr,
429
520
                               struct module *mod, char *buf)
431
522
        int count;
432
523
        struct param_attribute *attribute = to_param_attr(mattr);
433
524
 
434
 
        if (!attribute->param->get)
 
525
        if (!attribute->param->ops->get)
435
526
                return -EPERM;
436
527
 
437
 
        count = attribute->param->get(buf, attribute->param);
 
528
        mutex_lock(&param_lock);
 
529
        count = attribute->param->ops->get(buf, attribute->param);
 
530
        mutex_unlock(&param_lock);
438
531
        if (count > 0) {
439
532
                strcat(buf, "\n");
440
533
                ++count;
450
543
        int err;
451
544
        struct param_attribute *attribute = to_param_attr(mattr);
452
545
 
453
 
        if (!attribute->param->set)
 
546
        if (!attribute->param->ops->set)
454
547
                return -EPERM;
455
548
 
456
 
        err = attribute->param->set(buf, attribute->param);
 
549
        mutex_lock(&param_lock);
 
550
        err = attribute->param->ops->set(buf, attribute->param);
 
551
        mutex_unlock(&param_lock);
457
552
        if (!err)
458
553
                return len;
459
554
        return err;
467
562
#endif
468
563
 
469
564
#ifdef CONFIG_SYSFS
 
565
void __kernel_param_lock(void)
 
566
{
 
567
        mutex_lock(&param_lock);
 
568
}
 
569
EXPORT_SYMBOL(__kernel_param_lock);
 
570
 
 
571
void __kernel_param_unlock(void)
 
572
{
 
573
        mutex_unlock(&param_lock);
 
574
}
 
575
EXPORT_SYMBOL(__kernel_param_unlock);
 
576
 
470
577
/*
471
578
 * add_sysfs_param - add a parameter to sysfs
472
579
 * @mk: struct module_kobject
478
585
 * if there's an error.
479
586
 */
480
587
static __modinit int add_sysfs_param(struct module_kobject *mk,
481
 
                                     struct kernel_param *kp,
 
588
                                     const struct kernel_param *kp,
482
589
                                     const char *name)
483
590
{
484
591
        struct module_param_attrs *new;
519
626
        new->grp.attrs = attrs;
520
627
 
521
628
        /* Tack new one on the end. */
 
629
        sysfs_attr_init(&new->attrs[num].mattr.attr);
522
630
        new->attrs[num].param = kp;
523
631
        new->attrs[num].mattr.show = param_attr_show;
524
632
        new->attrs[num].mattr.store = param_attr_store;
559
667
 * /sys/module/[mod->name]/parameters/
560
668
 */
561
669
int module_param_sysfs_setup(struct module *mod,
562
 
                             struct kernel_param *kparam,
 
670
                             const struct kernel_param *kparam,
563
671
                             unsigned int num_params)
564
672
{
565
673
        int i, err;
604
712
 
605
713
void destroy_params(const struct kernel_param *params, unsigned num)
606
714
{
607
 
        /* FIXME: This should free kmalloced charp parameters.  It doesn't. */
 
715
        unsigned int i;
 
716
 
 
717
        for (i = 0; i < num; i++)
 
718
                if (params[i].ops->free)
 
719
                        params[i].ops->free(params[i].arg);
608
720
}
609
721
 
610
 
static void __init kernel_add_sysfs_param(const char *name,
611
 
                                          struct kernel_param *kparam,
612
 
                                          unsigned int name_skip)
 
722
static struct module_kobject * __init locate_module_kobject(const char *name)
613
723
{
614
724
        struct module_kobject *mk;
615
725
        struct kobject *kobj;
617
727
 
618
728
        kobj = kset_find_obj(module_kset, name);
619
729
        if (kobj) {
620
 
                /* We already have one.  Remove params so we can add more. */
621
730
                mk = to_module_kobject(kobj);
622
 
                /* We need to remove it before adding parameters. */
623
 
                sysfs_remove_group(&mk->kobj, &mk->mp->grp);
624
731
        } else {
625
732
                mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL);
626
733
                BUG_ON(!mk);
631
738
                                           "%s", name);
632
739
                if (err) {
633
740
                        kobject_put(&mk->kobj);
634
 
                        printk(KERN_ERR "Module '%s' failed add to sysfs, "
635
 
                               "error number %d\n", name, err);
636
 
                        printk(KERN_ERR "The system will be unstable now.\n");
637
 
                        return;
 
741
                        printk(KERN_ERR
 
742
                                "Module '%s' failed add to sysfs, error number %d\n",
 
743
                                name, err);
 
744
                        printk(KERN_ERR
 
745
                                "The system will be unstable now.\n");
 
746
                        return NULL;
638
747
                }
639
 
                /* So that exit path is even. */
 
748
 
 
749
                /* So that we hold reference in both cases. */
640
750
                kobject_get(&mk->kobj);
641
751
        }
642
752
 
 
753
        return mk;
 
754
}
 
755
 
 
756
static void __init kernel_add_sysfs_param(const char *name,
 
757
                                          struct kernel_param *kparam,
 
758
                                          unsigned int name_skip)
 
759
{
 
760
        struct module_kobject *mk;
 
761
        int err;
 
762
 
 
763
        mk = locate_module_kobject(name);
 
764
        if (!mk)
 
765
                return;
 
766
 
 
767
        /* We need to remove old parameters before adding more. */
 
768
        if (mk->mp)
 
769
                sysfs_remove_group(&mk->kobj, &mk->mp->grp);
 
770
 
643
771
        /* These should not fail at boot. */
644
772
        err = add_sysfs_param(mk, kparam, kparam->name + name_skip);
645
773
        BUG_ON(err);
684
812
        }
685
813
}
686
814
 
 
815
ssize_t __modver_version_show(struct module_attribute *mattr,
 
816
                              struct module *mod, char *buf)
 
817
{
 
818
        struct module_version_attribute *vattr =
 
819
                container_of(mattr, struct module_version_attribute, mattr);
 
820
 
 
821
        return sprintf(buf, "%s\n", vattr->version);
 
822
}
 
823
 
 
824
extern struct module_version_attribute __start___modver[], __stop___modver[];
 
825
 
 
826
static void __init version_sysfs_builtin(void)
 
827
{
 
828
        const struct module_version_attribute *vattr;
 
829
        struct module_kobject *mk;
 
830
        int err;
 
831
 
 
832
        for (vattr = __start___modver; vattr < __stop___modver; vattr++) {
 
833
                mk = locate_module_kobject(vattr->module_name);
 
834
                if (mk) {
 
835
                        err = sysfs_create_file(&mk->kobj, &vattr->mattr.attr);
 
836
                        kobject_uevent(&mk->kobj, KOBJ_ADD);
 
837
                        kobject_put(&mk->kobj);
 
838
                }
 
839
        }
 
840
}
687
841
 
688
842
/* module-related sysfs stuff */
689
843
 
725
879
        return ret;
726
880
}
727
881
 
728
 
static struct sysfs_ops module_sysfs_ops = {
 
882
static const struct sysfs_ops module_sysfs_ops = {
729
883
        .show = module_attr_show,
730
884
        .store = module_attr_store,
731
885
};
739
893
        return 0;
740
894
}
741
895
 
742
 
static struct kset_uevent_ops module_uevent_ops = {
 
896
static const struct kset_uevent_ops module_uevent_ops = {
743
897
        .filter = uevent_filter,
744
898
};
745
899
 
763
917
        }
764
918
        module_sysfs_initialized = 1;
765
919
 
 
920
        version_sysfs_builtin();
766
921
        param_sysfs_builtin();
767
922
 
768
923
        return 0;
770
925
subsys_initcall(param_sysfs_init);
771
926
 
772
927
#endif /* CONFIG_SYSFS */
773
 
 
774
 
EXPORT_SYMBOL(param_set_byte);
775
 
EXPORT_SYMBOL(param_get_byte);
776
 
EXPORT_SYMBOL(param_set_short);
777
 
EXPORT_SYMBOL(param_get_short);
778
 
EXPORT_SYMBOL(param_set_ushort);
779
 
EXPORT_SYMBOL(param_get_ushort);
780
 
EXPORT_SYMBOL(param_set_int);
781
 
EXPORT_SYMBOL(param_get_int);
782
 
EXPORT_SYMBOL(param_set_uint);
783
 
EXPORT_SYMBOL(param_get_uint);
784
 
EXPORT_SYMBOL(param_set_long);
785
 
EXPORT_SYMBOL(param_get_long);
786
 
EXPORT_SYMBOL(param_set_ulong);
787
 
EXPORT_SYMBOL(param_get_ulong);
788
 
EXPORT_SYMBOL(param_set_charp);
789
 
EXPORT_SYMBOL(param_get_charp);
790
 
EXPORT_SYMBOL(param_set_bool);
791
 
EXPORT_SYMBOL(param_get_bool);
792
 
EXPORT_SYMBOL(param_set_invbool);
793
 
EXPORT_SYMBOL(param_get_invbool);
794
 
EXPORT_SYMBOL(param_array_set);
795
 
EXPORT_SYMBOL(param_array_get);
796
 
EXPORT_SYMBOL(param_set_copystring);
797
 
EXPORT_SYMBOL(param_get_string);