root/lib/test_sysctl.c

DEFINITIONS

1. test_sysctl_init
2. test_sysctl_exit

   1 /*
   2  * proc sysctl test driver
   3  *
   4  * Copyright (C) 2017 Luis R. Rodriguez <mcgrof@kernel.org>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the Free
   8  * Software Foundation; either version 2 of the License, or at your option any
   9  * later version; or, when distributed separately from the Linux kernel or
  10  * when incorporated into other software packages, subject to the following
  11  * license:
  12  *
  13  * This program is free software; you can redistribute it and/or modify it
  14  * under the terms of copyleft-next (version 0.3.1 or later) as published
  15  * at http://copyleft-next.org/.
  16  */
  17 
  18 /*
  19  * This module provides an interface to the the proc sysctl interfaces.  This
  20  * driver requires CONFIG_PROC_SYSCTL. It will not normally be loaded by the
  21  * system unless explicitly requested by name. You can also build this driver
  22  * into your kernel.
  23  */
  24 
  25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  26 
  27 #include <linux/init.h>
  28 #include <linux/list.h>
  29 #include <linux/module.h>
  30 #include <linux/printk.h>
  31 #include <linux/fs.h>
  32 #include <linux/miscdevice.h>
  33 #include <linux/slab.h>
  34 #include <linux/uaccess.h>
  35 #include <linux/async.h>
  36 #include <linux/delay.h>
  37 #include <linux/vmalloc.h>
  38 
  39 static int i_zero;
  40 static int i_one_hundred = 100;
  41 
  42 struct test_sysctl_data {
  43         int int_0001;
  44         int int_0002;
  45         int int_0003[4];
  46 
  47         unsigned int uint_0001;
  48 
  49         char string_0001[65];
  50 
  51 #define SYSCTL_TEST_BITMAP_SIZE 65536
  52         unsigned long *bitmap_0001;
  53 };
  54 
  55 static struct test_sysctl_data test_data = {
  56         .int_0001 = 60,
  57         .int_0002 = 1,
  58 
  59         .int_0003[0] = 0,
  60         .int_0003[1] = 1,
  61         .int_0003[2] = 2,
  62         .int_0003[3] = 3,
  63 
  64         .uint_0001 = 314,
  65 
  66         .string_0001 = "(none)",
  67 };
  68 
  69 /* These are all under /proc/sys/debug/test_sysctl/ */
  70 static struct ctl_table test_table[] = {
  71         {
  72                 .procname       = "int_0001",
  73                 .data           = &test_data.int_0001,
  74                 .maxlen         = sizeof(int),
  75                 .mode           = 0644,
  76                 .proc_handler   = proc_dointvec_minmax,
  77                 .extra1         = &i_zero,
  78                 .extra2         = &i_one_hundred,
  79         },
  80         {
  81                 .procname       = "int_0002",
  82                 .data           = &test_data.int_0002,
  83                 .maxlen         = sizeof(int),
  84                 .mode           = 0644,
  85                 .proc_handler   = proc_dointvec,
  86         },
  87         {
  88                 .procname       = "int_0003",
  89                 .data           = &test_data.int_0003,
  90                 .maxlen         = sizeof(test_data.int_0003),
  91                 .mode           = 0644,
  92                 .proc_handler   = proc_dointvec,
  93         },
  94         {
  95                 .procname       = "uint_0001",
  96                 .data           = &test_data.uint_0001,
  97                 .maxlen         = sizeof(unsigned int),
  98                 .mode           = 0644,
  99                 .proc_handler   = proc_douintvec,
 100         },
 101         {
 102                 .procname       = "string_0001",
 103                 .data           = &test_data.string_0001,
 104                 .maxlen         = sizeof(test_data.string_0001),
 105                 .mode           = 0644,
 106                 .proc_handler   = proc_dostring,
 107         },
 108         {
 109                 .procname       = "bitmap_0001",
 110                 .data           = &test_data.bitmap_0001,
 111                 .maxlen         = SYSCTL_TEST_BITMAP_SIZE,
 112                 .mode           = 0644,
 113                 .proc_handler   = proc_do_large_bitmap,
 114         },
 115         { }
 116 };
 117 
 118 static struct ctl_table test_sysctl_table[] = {
 119         {
 120                 .procname       = "test_sysctl",
 121                 .maxlen         = 0,
 122                 .mode           = 0555,
 123                 .child          = test_table,
 124         },
 125         { }
 126 };
 127 
 128 static struct ctl_table test_sysctl_root_table[] = {
 129         {
 130                 .procname       = "debug",
 131                 .maxlen         = 0,
 132                 .mode           = 0555,
 133                 .child          = test_sysctl_table,
 134         },
 135         { }
 136 };
 137 
 138 static struct ctl_table_header *test_sysctl_header;
 139 
 140 static int __init test_sysctl_init(void)
 141 {
 142         test_data.bitmap_0001 = kzalloc(SYSCTL_TEST_BITMAP_SIZE/8, GFP_KERNEL);
 143         if (!test_data.bitmap_0001)
 144                 return -ENOMEM;
 145         test_sysctl_header = register_sysctl_table(test_sysctl_root_table);
 146         if (!test_sysctl_header) {
 147                 kfree(test_data.bitmap_0001);
 148                 return -ENOMEM;
 149         }
 150         return 0;
 151 }
 152 late_initcall(test_sysctl_init);
 153 
 154 static void __exit test_sysctl_exit(void)
 155 {
 156         kfree(test_data.bitmap_0001);
 157         if (test_sysctl_header)
 158                 unregister_sysctl_table(test_sysctl_header);
 159 }
 160 
 161 module_exit(test_sysctl_exit);
 162 
 163 MODULE_AUTHOR("Luis R. Rodriguez <mcgrof@kernel.org>");
 164 MODULE_LICENSE("GPL");