sysctl_driver_example/sysctl_test.c at master · StMartin81/sysctl_driver_example · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
#include <linux/completion.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/rwsem.h>
#include <linux/slab.h>
#include <linux/sysctl.h>

#define DATA_MAX_SIZE 1024
#define START_MEASUREMENT "start_measurement"
#define MEASUREMENT_FINISHED "measurement_finished"
#define START_MEASUREMENT_IDX 0
#define MEASUREMENT_FINISHED_IDX 1
static const char g_device_name[] = "sysctl_dev";

struct sysctl_data
{
  struct ctl_table ctl_table[3];
  struct ctl_path ctl_path[3];
  struct completion measurement_data_ready;
  struct ctl_table_header* ctl_table_header;
  struct rw_semaphore lock;
  char data[DATA_MAX_SIZE];
};

static struct sysctl_data* sysctl_data;

int
start_measurement(struct ctl_table* ctl,
                  int write,
                  void __user* buffer,
                  size_t* lenp,
                  loff_t* ppos)
{
  long ret;
  struct sysctl_data* data = (struct sysctl_data*)ctl->data;
  struct ctl_table tmp_table = {
    .data = data->data,
    .maxlen = DATA_MAX_SIZE,
  };

  if (!*lenp || (*ppos && !write)) {
    *lenp = 0;
    return 0;
  }

  ret = wait_for_completion_interruptible_timeout(&data->measurement_data_ready,
                                                  msecs_to_jiffies(60000));
  if (ret < 0)
    return ret;
  else if (ret == 0)
    return -ETIME;

  down_read(&data->lock);
  ret = proc_dostring(&tmp_table, write, buffer, lenp, ppos);
  up_read(&data->lock);

  return ret;
}

int
measurement_finished(struct ctl_table* ctl,
                     int write,
                     void __user* buffer,
                     size_t* lenp,
                     loff_t* ppos)
{
  int ret = 0;
  struct sysctl_data* data = (struct sysctl_data*)ctl->data;
  struct ctl_table tmp_table = {
    .data = data->data,
    .maxlen = DATA_MAX_SIZE,
  };

  if (!*lenp || (*ppos && !write)) {
    *lenp = 0;
    return 0;
  }

  down_write(&data->lock);
  ret = proc_dostring(&tmp_table, write, buffer, lenp, ppos);
  up_write(&data->lock);
  complete(&(data->measurement_data_ready));

  return ret;
}

void
free_sysctl(struct sysctl_data* sysctl_data)
{
  if (sysctl_data) {
    unregister_sysctl_table(sysctl_data->ctl_table_header);
  }
  kfree(sysctl_data);
  sysctl_data = NULL;
}

int
init_sysctl(struct sysctl_data** sysctl_data, const char device_name[])
{
  struct ctl_path* ctl_path;
  struct ctl_table* ctl_table;
  int retval;

  retval = 0;

  if (!(*sysctl_data = kzalloc(sizeof(struct sysctl_data), GFP_KERNEL))) {
    pr_err("Can not allocate memory for sysctl_data structure\n");
    return -ENOMEM;
  }

  ctl_path = (*sysctl_data)->ctl_path;
  ctl_path[0].procname = "dev";
  ctl_path[1].procname = device_name;

  ctl_table = (*sysctl_data)->ctl_table;
  ctl_table[START_MEASUREMENT_IDX].procname = START_MEASUREMENT;
  ctl_table[START_MEASUREMENT_IDX].mode = 0444;
  ctl_table[START_MEASUREMENT_IDX].data = (*sysctl_data);
  ctl_table[START_MEASUREMENT_IDX].maxlen = DATA_MAX_SIZE;
  ctl_table[START_MEASUREMENT_IDX].proc_handler = start_measurement;

  ctl_table[MEASUREMENT_FINISHED_IDX].procname = MEASUREMENT_FINISHED;
  ctl_table[MEASUREMENT_FINISHED_IDX].mode = 0222;
  ctl_table[MEASUREMENT_FINISHED_IDX].data = (*sysctl_data);
  ctl_table[MEASUREMENT_FINISHED_IDX].maxlen = DATA_MAX_SIZE;
  ctl_table[MEASUREMENT_FINISHED_IDX].proc_handler = measurement_finished;

  init_completion(&((*sysctl_data)->measurement_data_ready));

  init_rwsem(&(*sysctl_data)->lock);

  (*sysctl_data)->ctl_table_header = register_sysctl_paths(ctl_path, ctl_table);
  return 0;
}

static int __init
sysctl_test_init(void)
{
  return init_sysctl(&sysctl_data, g_device_name);
}

void __exit
sysctl_test_exit(void)
{
  free_sysctl(sysctl_data);
}

module_init(sysctl_test_init);
module_exit(sysctl_test_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Martin Stolpe <martin.stolpe@iaf.fraunhofer.de>");
MODULE_DESCRIPTION("A simple sysfs example driver");
MODULE_VERSION("0.1");