Fix kthread_create() in kern_sensors.c.
[dragonfly.git] / sys / kern / kern_sensors.c
1 /* $OpenBSD: kern_sensors.c,v 1.19 2007/06/04 18:42:05 deraadt Exp $ */
2
3 /*
4  * Copyright (c) 2005 David Gwynne <dlg@openbsd.org>
5  * Copyright (c) 2006 Constantine A. Murenin <cnst+openbsd@bugmail.mojo.ru>
6  *
7  * Permission to use, copy, modify, and distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18  */
19
20 #include <sys/param.h>
21 #include <sys/systm.h>
22 #include <sys/kernel.h>
23 #include <sys/malloc.h>
24 #include <sys/kthread.h>
25 #include <sys/queue.h>
26 #include <sys/types.h>
27 #include <sys/time.h>
28 #include <sys/lock.h>
29
30 #include <sys/sysctl.h>
31 #include <sys/sensors.h>
32
33 int                     sensordev_count = 0;
34 SLIST_HEAD(, ksensordev) sensordev_list = SLIST_HEAD_INITIALIZER(sensordev_list);
35
36 struct ksensordev       *sensordev_get(int);
37 struct ksensor          *sensor_find(struct ksensordev *, enum sensor_type, int);
38
39 struct sensor_task {
40         void                            *arg;
41         void                            (*func)(void *);
42
43         int                             period;
44         time_t                          nextrun;
45         volatile int                    running;
46         TAILQ_ENTRY(sensor_task)        entry;
47 };
48
49 void    sensor_task_thread(void *);
50 void    sensor_task_schedule(struct sensor_task *);
51
52 TAILQ_HEAD(, sensor_task) tasklist = TAILQ_HEAD_INITIALIZER(tasklist);
53
54 #ifndef NOSYSCTL8HACK
55 void    sensor_sysctl8magic_install(struct ksensordev *);
56 void    sensor_sysctl8magic_deinstall(struct ksensordev *);
57 #endif
58
59 void
60 sensordev_install(struct ksensordev *sensdev)
61 {
62         struct ksensordev *v, *nv;
63
64         /* mtx_lock(&Giant); */
65         if (sensordev_count == 0) {
66                 sensdev->num = 0;
67                 SLIST_INSERT_HEAD(&sensordev_list, sensdev, list);
68         } else {
69                 for (v = SLIST_FIRST(&sensordev_list);
70                     (nv = SLIST_NEXT(v, list)) != NULL; v = nv)
71                         if (nv->num - v->num > 1)
72                                 break;
73                 sensdev->num = v->num + 1;
74                 SLIST_INSERT_AFTER(v, sensdev, list);
75         }
76         sensordev_count++;
77         /* mtx_unlock(&Giant); */
78
79 #ifndef NOSYSCTL8HACK
80         sensor_sysctl8magic_install(sensdev);
81 #endif
82 }
83
84 void
85 sensor_attach(struct ksensordev *sensdev, struct ksensor *sens)
86 {
87         struct ksensor *v, *nv;
88         struct ksensors_head *sh;
89         int i;
90
91         /* mtx_lock(&Giant); */
92         sh = &sensdev->sensors_list;
93         if (sensdev->sensors_count == 0) {
94                 for (i = 0; i < SENSOR_MAX_TYPES; i++)
95                         sensdev->maxnumt[i] = 0;
96                 sens->numt = 0;
97                 SLIST_INSERT_HEAD(sh, sens, list);
98         } else {
99                 for (v = SLIST_FIRST(sh);
100                     (nv = SLIST_NEXT(v, list)) != NULL; v = nv)
101                         if (v->type == sens->type && (v->type != nv->type || 
102                             (v->type == nv->type && nv->numt - v->numt > 1)))
103                                 break;
104                 /* sensors of the same type go after each other */
105                 if (v->type == sens->type)
106                         sens->numt = v->numt + 1;
107                 else
108                         sens->numt = 0;
109                 SLIST_INSERT_AFTER(v, sens, list);
110         }
111         /* we only increment maxnumt[] if the sensor was added
112          * to the last position of sensors of this type
113          */
114         if (sensdev->maxnumt[sens->type] == sens->numt)
115                 sensdev->maxnumt[sens->type]++;
116         sensdev->sensors_count++;
117         /* mtx_unlock(&Giant); */
118 }
119
120 void
121 sensordev_deinstall(struct ksensordev *sensdev)
122 {
123         /* mtx_lock(&Giant); */
124         sensordev_count--;
125         SLIST_REMOVE(&sensordev_list, sensdev, ksensordev, list);
126         /* mtx_unlock(&Giant); */
127
128 #ifndef NOSYSCTL8HACK
129         sensor_sysctl8magic_deinstall(sensdev);
130 #endif
131 }
132
133 void
134 sensor_detach(struct ksensordev *sensdev, struct ksensor *sens)
135 {
136         struct ksensors_head *sh;
137
138         /* mtx_lock(&Giant); */
139         sh = &sensdev->sensors_list;
140         sensdev->sensors_count--;
141         SLIST_REMOVE(sh, sens, ksensor, list);
142         /* we only decrement maxnumt[] if this is the tail 
143          * sensor of this type
144          */
145         if (sens->numt == sensdev->maxnumt[sens->type] - 1)
146                 sensdev->maxnumt[sens->type]--;
147         /* mtx_unlock(&Giant); */
148 }
149
150 struct ksensordev *
151 sensordev_get(int num)
152 {
153         struct ksensordev *sd;
154
155         SLIST_FOREACH(sd, &sensordev_list, list)
156                 if (sd->num == num)
157                         return (sd);
158
159         return (NULL);
160 }
161
162 struct ksensor *
163 sensor_find(struct ksensordev *sensdev, enum sensor_type type, int numt)
164 {
165         struct ksensor *s;
166         struct ksensors_head *sh;
167
168         sh = &sensdev->sensors_list;
169         SLIST_FOREACH(s, sh, list)
170                 if (s->type == type && s->numt == numt)
171                         return (s);
172
173         return (NULL);
174 }
175
176 int
177 sensor_task_register(void *arg, void (*func)(void *), int period)
178 {
179         struct sensor_task      *st;
180         int                      create_thread = 0;
181
182         st = kmalloc(sizeof(struct sensor_task), M_DEVBUF, M_NOWAIT);
183         if (st == NULL)
184                 return (1);
185
186         st->arg = arg;
187         st->func = func;
188         st->period = period;
189
190         st->running = 1;
191
192         if (TAILQ_EMPTY(&tasklist))
193                 create_thread = 1;
194
195         st->nextrun = 0;
196         TAILQ_INSERT_HEAD(&tasklist, st, entry);
197
198         if (create_thread)
199                 if (kthread_create(sensor_task_thread, NULL, NULL,
200                     "sensors") != 0)
201                         panic("sensors kthread");
202         
203         wakeup(&tasklist);
204
205         return (0);
206 }
207
208 void
209 sensor_task_unregister(void *arg)
210 {
211         struct sensor_task      *st;
212
213         TAILQ_FOREACH(st, &tasklist, entry)
214                 if (st->arg == arg)
215                         st->running = 0;
216 }
217
218 void
219 sensor_task_thread(void *arg)
220 {
221         struct sensor_task      *st, *nst;
222         time_t                  now;
223
224         while (!TAILQ_EMPTY(&tasklist)) {
225                 while ((nst = TAILQ_FIRST(&tasklist))->nextrun >
226                     (now = time_second))
227                         tsleep(&tasklist, 0, "timeout",
228                                (nst->nextrun - now) * hz);
229
230                 while ((st = nst) != NULL) {
231                         nst = TAILQ_NEXT(st, entry);
232
233                         if (st->nextrun > now)
234                                 break;
235
236                         /* take it out while we work on it */
237                         TAILQ_REMOVE(&tasklist, st, entry);
238
239                         if (!st->running) {
240                                 kfree(st, M_DEVBUF);
241                                 continue;
242                         }
243
244                         /* run the task */
245                         st->func(st->arg);
246                         /* stick it back in the tasklist */
247                         sensor_task_schedule(st);
248                 }
249         }
250
251         kthread_exit();
252 }
253
254 void
255 sensor_task_schedule(struct sensor_task *st)
256 {
257         struct sensor_task      *cst;
258
259         st->nextrun = time_second + st->period;
260
261         TAILQ_FOREACH(cst, &tasklist, entry) {
262                 if (cst->nextrun > st->nextrun) {
263                         TAILQ_INSERT_BEFORE(cst, st, entry);
264                         return;
265                 }
266         }
267
268         /* must be an empty list, or at the end of the list */
269         TAILQ_INSERT_TAIL(&tasklist, st, entry);
270 }
271
272 /*
273  * sysctl glue code
274  */
275 int sysctl_handle_sensordev(SYSCTL_HANDLER_ARGS);
276 int sysctl_handle_sensor(SYSCTL_HANDLER_ARGS);
277 int sysctl_sensors_handler(SYSCTL_HANDLER_ARGS);
278
279 #ifndef NOSYSCTL8HACK
280
281 SYSCTL_NODE(_hw, OID_AUTO, sensors, CTLFLAG_RD, NULL,
282     "Hardware Sensors sysctl internal magic");
283 SYSCTL_NODE(_hw, HW_SENSORS, _sensors, CTLFLAG_RD, sysctl_sensors_handler,
284     "Hardware Sensors XP MIB interface");
285
286 #else /* NOSYSCTL8HACK */
287
288 SYSCTL_NODE(_hw, HW_SENSORS, sensors, CTLFLAG_RD, sysctl_sensors_handler,
289     "Hardware Sensors");
290 int sensors_debug = 1;
291 SYSCTL_INT(_hw_sensors, OID_AUTO, debug, CTLFLAG_RD, &sensors_debug, 0, "sensors debug");
292
293 #endif /* !NOSYSCTL8HACK */
294
295
296 #ifndef NOSYSCTL8HACK
297
298 /*
299  * XXX:
300  * FreeBSD's sysctl(9) .oid_handler functionality is not accustomed
301  * for the CTLTYPE_NODE handler to handle the undocumented sysctl
302  * magic calls.  As soon as such functionality is developed, 
303  * sysctl_sensors_handler() should be converted to handle all such
304  * calls, and these sysctl_add_oid(9) calls should be removed 
305  * "with a big axe".  This whole sysctl_add_oid(9) business is solely
306  * to please sysctl(8).
307  */
308
309 void
310 sensor_sysctl8magic_install(struct ksensordev *sensdev)
311 {
312         struct sysctl_oid_list *ol;     
313         struct sysctl_ctx_list *cl = &sensdev->clist;
314         struct ksensor *s;
315         struct ksensors_head *sh = &sensdev->sensors_list;
316
317         sysctl_ctx_init(cl);
318         ol = SYSCTL_CHILDREN(SYSCTL_ADD_NODE(cl, (&SYSCTL_NODE_CHILDREN(_hw,
319             sensors)), sensdev->num, sensdev->xname, CTLFLAG_RD, NULL, ""));
320         SLIST_FOREACH(s, sh, list) {
321                 char n[32];
322
323                 ksnprintf(n, sizeof(n), "%s%d", sensor_type_s[s->type], s->numt);
324                 SYSCTL_ADD_PROC(cl, ol, OID_AUTO, n, CTLTYPE_STRUCT |
325                     CTLFLAG_RD, s, 0, sysctl_handle_sensor, "S,sensor", "");
326         }
327 }
328
329 void
330 sensor_sysctl8magic_deinstall(struct ksensordev *sensdev)
331 {
332         struct sysctl_ctx_list *cl = &sensdev->clist;
333
334         sysctl_ctx_free(cl);
335 }
336
337 #endif /* !NOSYSCTL8HACK */
338
339
340 int
341 sysctl_handle_sensordev(SYSCTL_HANDLER_ARGS)
342 {
343         struct ksensordev *ksd = arg1;
344         struct sensordev *usd;
345         int error;
346
347         if (req->newptr)
348                 return (EPERM);
349
350         /* Grab a copy, to clear the kernel pointers */
351         usd = kmalloc(sizeof(*usd), M_TEMP, M_WAITOK | M_ZERO);
352         usd->num = ksd->num;
353         strlcpy(usd->xname, ksd->xname, sizeof(usd->xname));
354         memcpy(usd->maxnumt, ksd->maxnumt, sizeof(usd->maxnumt));
355         usd->sensors_count = ksd->sensors_count;
356
357         error = SYSCTL_OUT(req, usd, sizeof(struct sensordev));
358
359         kfree(usd, M_TEMP);
360         return (error);
361
362 }
363
364 int
365 sysctl_handle_sensor(SYSCTL_HANDLER_ARGS)
366 {
367         struct ksensor *ks = arg1;
368         struct sensor *us;
369         int error;
370
371         if (req->newptr)
372                 return (EPERM);
373
374         /* Grab a copy, to clear the kernel pointers */
375         us = kmalloc(sizeof(*us), M_TEMP, M_WAITOK | M_ZERO);
376         memcpy(us->desc, ks->desc, sizeof(ks->desc));
377         us->tv = ks->tv;
378         us->value = ks->value;
379         us->type = ks->type;
380         us->status = ks->status;
381         us->numt = ks->numt;
382         us->flags = ks->flags;
383
384         error = SYSCTL_OUT(req, us, sizeof(struct sensor));
385
386         kfree(us, M_TEMP);
387         return (error);
388 }
389
390 int
391 sysctl_sensors_handler(SYSCTL_HANDLER_ARGS)
392 {
393         int *name = arg1;
394         u_int namelen = arg2;
395         struct ksensordev *ksd;
396         struct ksensor *ks;
397         int dev, numt;
398         enum sensor_type type;
399
400         if (namelen != 1 && namelen != 3)
401                 return (ENOTDIR);
402
403         dev = name[0];
404         if ((ksd = sensordev_get(dev)) == NULL)
405                 return (ENOENT);
406
407         if (namelen == 1)
408                 return (sysctl_handle_sensordev(NULL, ksd, 0, req));
409
410         type = name[1];
411         numt = name[2];
412
413         if ((ks = sensor_find(ksd, type, numt)) == NULL)
414                 return (ENOENT);
415         return (sysctl_handle_sensor(NULL, ks, 0, req));
416 }