1
2
3
4
5
6
7
8
9
10
11
12#define KMSG_COMPONENT "appldata"
13#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
14
15#include <linux/module.h>
16#include <linux/sched/stat.h>
17#include <linux/init.h>
18#include <linux/slab.h>
19#include <linux/errno.h>
20#include <linux/interrupt.h>
21#include <linux/proc_fs.h>
22#include <linux/mm.h>
23#include <linux/swap.h>
24#include <linux/pagemap.h>
25#include <linux/sysctl.h>
26#include <linux/notifier.h>
27#include <linux/cpu.h>
28#include <linux/workqueue.h>
29#include <linux/suspend.h>
30#include <linux/platform_device.h>
31#include <asm/appldata.h>
32#include <asm/vtimer.h>
33#include <linux/uaccess.h>
34#include <asm/io.h>
35#include <asm/smp.h>
36
37#include "appldata.h"
38
39
40#define APPLDATA_CPU_INTERVAL 10000
41
42
43
44#define TOD_MICRO 0x01000
45
46
47static struct platform_device *appldata_pdev;
48
49
50
51
52static const char appldata_proc_name[APPLDATA_PROC_NAME_LENGTH] = "appldata";
53static int appldata_timer_handler(struct ctl_table *ctl, int write,
54 void __user *buffer, size_t *lenp, loff_t *ppos);
55static int appldata_interval_handler(struct ctl_table *ctl, int write,
56 void __user *buffer,
57 size_t *lenp, loff_t *ppos);
58
59static struct ctl_table_header *appldata_sysctl_header;
60static struct ctl_table appldata_table[] = {
61 {
62 .procname = "timer",
63 .mode = S_IRUGO | S_IWUSR,
64 .proc_handler = appldata_timer_handler,
65 },
66 {
67 .procname = "interval",
68 .mode = S_IRUGO | S_IWUSR,
69 .proc_handler = appldata_interval_handler,
70 },
71 { },
72};
73
74static struct ctl_table appldata_dir_table[] = {
75 {
76 .procname = appldata_proc_name,
77 .maxlen = 0,
78 .mode = S_IRUGO | S_IXUGO,
79 .child = appldata_table,
80 },
81 { },
82};
83
84
85
86
87static struct vtimer_list appldata_timer;
88
89static DEFINE_SPINLOCK(appldata_timer_lock);
90static int appldata_interval = APPLDATA_CPU_INTERVAL;
91static int appldata_timer_active;
92static int appldata_timer_suspended = 0;
93
94
95
96
97static struct workqueue_struct *appldata_wq;
98static void appldata_work_fn(struct work_struct *work);
99static DECLARE_WORK(appldata_work, appldata_work_fn);
100
101
102
103
104
105static DEFINE_MUTEX(appldata_ops_mutex);
106static LIST_HEAD(appldata_ops_list);
107
108
109
110
111
112
113
114
115static void appldata_timer_function(unsigned long data)
116{
117 queue_work(appldata_wq, (struct work_struct *) data);
118}
119
120
121
122
123
124
125static void appldata_work_fn(struct work_struct *work)
126{
127 struct list_head *lh;
128 struct appldata_ops *ops;
129
130 mutex_lock(&appldata_ops_mutex);
131 list_for_each(lh, &appldata_ops_list) {
132 ops = list_entry(lh, struct appldata_ops, list);
133 if (ops->active == 1) {
134 ops->callback(ops->data);
135 }
136 }
137 mutex_unlock(&appldata_ops_mutex);
138}
139
140static struct appldata_product_id appldata_id = {
141 .prod_nr = {0xD3, 0xC9, 0xD5, 0xE4,
142 0xE7, 0xD2, 0xD9},
143 .prod_fn = 0xD5D3,
144 .version_nr = 0xF2F6,
145 .release_nr = 0xF0F1,
146};
147
148
149
150
151
152
153int appldata_diag(char record_nr, u16 function, unsigned long buffer,
154 u16 length, char *mod_lvl)
155{
156 struct appldata_parameter_list *parm_list;
157 struct appldata_product_id *id;
158 int rc;
159
160 parm_list = kmalloc(sizeof(*parm_list), GFP_KERNEL);
161 id = kmemdup(&appldata_id, sizeof(appldata_id), GFP_KERNEL);
162 rc = -ENOMEM;
163 if (parm_list && id) {
164 id->record_nr = record_nr;
165 id->mod_lvl = (mod_lvl[0]) << 8 | mod_lvl[1];
166 rc = appldata_asm(parm_list, id, function,
167 (void *) buffer, length);
168 }
169 kfree(id);
170 kfree(parm_list);
171 return rc;
172}
173
174
175
176
177
178#define APPLDATA_ADD_TIMER 0
179#define APPLDATA_DEL_TIMER 1
180#define APPLDATA_MOD_TIMER 2
181
182
183
184
185
186
187
188static void __appldata_vtimer_setup(int cmd)
189{
190 u64 timer_interval = (u64) appldata_interval * 1000 * TOD_MICRO;
191
192 switch (cmd) {
193 case APPLDATA_ADD_TIMER:
194 if (appldata_timer_active)
195 break;
196 appldata_timer.expires = timer_interval;
197 add_virt_timer_periodic(&appldata_timer);
198 appldata_timer_active = 1;
199 break;
200 case APPLDATA_DEL_TIMER:
201 del_virt_timer(&appldata_timer);
202 if (!appldata_timer_active)
203 break;
204 appldata_timer_active = 0;
205 break;
206 case APPLDATA_MOD_TIMER:
207 if (!appldata_timer_active)
208 break;
209 mod_virt_timer_periodic(&appldata_timer, timer_interval);
210 }
211}
212
213
214
215
216
217
218static int
219appldata_timer_handler(struct ctl_table *ctl, int write,
220 void __user *buffer, size_t *lenp, loff_t *ppos)
221{
222 int timer_active = appldata_timer_active;
223 int zero = 0;
224 int one = 1;
225 int rc;
226 struct ctl_table ctl_entry = {
227 .procname = ctl->procname,
228 .data = &timer_active,
229 .maxlen = sizeof(int),
230 .extra1 = &zero,
231 .extra2 = &one,
232 };
233
234 rc = proc_douintvec_minmax(&ctl_entry, write, buffer, lenp, ppos);
235 if (rc < 0 || !write)
236 return rc;
237
238 spin_lock(&appldata_timer_lock);
239 if (timer_active)
240 __appldata_vtimer_setup(APPLDATA_ADD_TIMER);
241 else
242 __appldata_vtimer_setup(APPLDATA_DEL_TIMER);
243 spin_unlock(&appldata_timer_lock);
244 return 0;
245}
246
247
248
249
250
251
252
253static int
254appldata_interval_handler(struct ctl_table *ctl, int write,
255 void __user *buffer, size_t *lenp, loff_t *ppos)
256{
257 int interval = appldata_interval;
258 int one = 1;
259 int rc;
260 struct ctl_table ctl_entry = {
261 .procname = ctl->procname,
262 .data = &interval,
263 .maxlen = sizeof(int),
264 .extra1 = &one,
265 };
266
267 rc = proc_dointvec_minmax(&ctl_entry, write, buffer, lenp, ppos);
268 if (rc < 0 || !write)
269 return rc;
270
271 spin_lock(&appldata_timer_lock);
272 appldata_interval = interval;
273 __appldata_vtimer_setup(APPLDATA_MOD_TIMER);
274 spin_unlock(&appldata_timer_lock);
275 return 0;
276}
277
278
279
280
281
282
283
284static int
285appldata_generic_handler(struct ctl_table *ctl, int write,
286 void __user *buffer, size_t *lenp, loff_t *ppos)
287{
288 struct appldata_ops *ops = NULL, *tmp_ops;
289 struct list_head *lh;
290 int rc, found;
291 int active;
292 int zero = 0;
293 int one = 1;
294 struct ctl_table ctl_entry = {
295 .data = &active,
296 .maxlen = sizeof(int),
297 .extra1 = &zero,
298 .extra2 = &one,
299 };
300
301 found = 0;
302 mutex_lock(&appldata_ops_mutex);
303 list_for_each(lh, &appldata_ops_list) {
304 tmp_ops = list_entry(lh, struct appldata_ops, list);
305 if (&tmp_ops->ctl_table[2] == ctl) {
306 found = 1;
307 }
308 }
309 if (!found) {
310 mutex_unlock(&appldata_ops_mutex);
311 return -ENODEV;
312 }
313 ops = ctl->data;
314 if (!try_module_get(ops->owner)) {
315 mutex_unlock(&appldata_ops_mutex);
316 return -ENODEV;
317 }
318 mutex_unlock(&appldata_ops_mutex);
319
320 active = ops->active;
321 rc = proc_douintvec_minmax(&ctl_entry, write, buffer, lenp, ppos);
322 if (rc < 0 || !write) {
323 module_put(ops->owner);
324 return rc;
325 }
326
327 mutex_lock(&appldata_ops_mutex);
328 if (active && (ops->active == 0)) {
329
330 if (!try_module_get(ops->owner)) {
331 mutex_unlock(&appldata_ops_mutex);
332 module_put(ops->owner);
333 return -ENODEV;
334 }
335 ops->callback(ops->data);
336 rc = appldata_diag(ops->record_nr,
337 APPLDATA_START_INTERVAL_REC,
338 (unsigned long) ops->data, ops->size,
339 ops->mod_lvl);
340 if (rc != 0) {
341 pr_err("Starting the data collection for %s "
342 "failed with rc=%d\n", ops->name, rc);
343 module_put(ops->owner);
344 } else
345 ops->active = 1;
346 } else if (!active && (ops->active == 1)) {
347 ops->active = 0;
348 rc = appldata_diag(ops->record_nr, APPLDATA_STOP_REC,
349 (unsigned long) ops->data, ops->size,
350 ops->mod_lvl);
351 if (rc != 0)
352 pr_err("Stopping the data collection for %s "
353 "failed with rc=%d\n", ops->name, rc);
354 module_put(ops->owner);
355 }
356 mutex_unlock(&appldata_ops_mutex);
357 module_put(ops->owner);
358 return 0;
359}
360
361
362
363
364
365
366
367
368
369
370int appldata_register_ops(struct appldata_ops *ops)
371{
372 if (ops->size > APPLDATA_MAX_REC_SIZE)
373 return -EINVAL;
374
375 ops->ctl_table = kcalloc(4, sizeof(struct ctl_table), GFP_KERNEL);
376 if (!ops->ctl_table)
377 return -ENOMEM;
378
379 mutex_lock(&appldata_ops_mutex);
380 list_add(&ops->list, &appldata_ops_list);
381 mutex_unlock(&appldata_ops_mutex);
382
383 ops->ctl_table[0].procname = appldata_proc_name;
384 ops->ctl_table[0].maxlen = 0;
385 ops->ctl_table[0].mode = S_IRUGO | S_IXUGO;
386 ops->ctl_table[0].child = &ops->ctl_table[2];
387
388 ops->ctl_table[2].procname = ops->name;
389 ops->ctl_table[2].mode = S_IRUGO | S_IWUSR;
390 ops->ctl_table[2].proc_handler = appldata_generic_handler;
391 ops->ctl_table[2].data = ops;
392
393 ops->sysctl_header = register_sysctl_table(ops->ctl_table);
394 if (!ops->sysctl_header)
395 goto out;
396 return 0;
397out:
398 mutex_lock(&appldata_ops_mutex);
399 list_del(&ops->list);
400 mutex_unlock(&appldata_ops_mutex);
401 kfree(ops->ctl_table);
402 return -ENOMEM;
403}
404
405
406
407
408
409
410void appldata_unregister_ops(struct appldata_ops *ops)
411{
412 mutex_lock(&appldata_ops_mutex);
413 list_del(&ops->list);
414 mutex_unlock(&appldata_ops_mutex);
415 unregister_sysctl_table(ops->sysctl_header);
416 kfree(ops->ctl_table);
417}
418
419
420
421
422static int appldata_freeze(struct device *dev)
423{
424 struct appldata_ops *ops;
425 int rc;
426 struct list_head *lh;
427
428 spin_lock(&appldata_timer_lock);
429 if (appldata_timer_active) {
430 __appldata_vtimer_setup(APPLDATA_DEL_TIMER);
431 appldata_timer_suspended = 1;
432 }
433 spin_unlock(&appldata_timer_lock);
434
435 mutex_lock(&appldata_ops_mutex);
436 list_for_each(lh, &appldata_ops_list) {
437 ops = list_entry(lh, struct appldata_ops, list);
438 if (ops->active == 1) {
439 rc = appldata_diag(ops->record_nr, APPLDATA_STOP_REC,
440 (unsigned long) ops->data, ops->size,
441 ops->mod_lvl);
442 if (rc != 0)
443 pr_err("Stopping the data collection for %s "
444 "failed with rc=%d\n", ops->name, rc);
445 }
446 }
447 mutex_unlock(&appldata_ops_mutex);
448 return 0;
449}
450
451static int appldata_restore(struct device *dev)
452{
453 struct appldata_ops *ops;
454 int rc;
455 struct list_head *lh;
456
457 spin_lock(&appldata_timer_lock);
458 if (appldata_timer_suspended) {
459 __appldata_vtimer_setup(APPLDATA_ADD_TIMER);
460 appldata_timer_suspended = 0;
461 }
462 spin_unlock(&appldata_timer_lock);
463
464 mutex_lock(&appldata_ops_mutex);
465 list_for_each(lh, &appldata_ops_list) {
466 ops = list_entry(lh, struct appldata_ops, list);
467 if (ops->active == 1) {
468 ops->callback(ops->data);
469 rc = appldata_diag(ops->record_nr,
470 APPLDATA_START_INTERVAL_REC,
471 (unsigned long) ops->data, ops->size,
472 ops->mod_lvl);
473 if (rc != 0) {
474 pr_err("Starting the data collection for %s "
475 "failed with rc=%d\n", ops->name, rc);
476 }
477 }
478 }
479 mutex_unlock(&appldata_ops_mutex);
480 return 0;
481}
482
483static int appldata_thaw(struct device *dev)
484{
485 return appldata_restore(dev);
486}
487
488static const struct dev_pm_ops appldata_pm_ops = {
489 .freeze = appldata_freeze,
490 .thaw = appldata_thaw,
491 .restore = appldata_restore,
492};
493
494static struct platform_driver appldata_pdrv = {
495 .driver = {
496 .name = "appldata",
497 .pm = &appldata_pm_ops,
498 },
499};
500
501
502
503
504
505
506
507
508
509
510static int __init appldata_init(void)
511{
512 int rc;
513
514 init_virt_timer(&appldata_timer);
515 appldata_timer.function = appldata_timer_function;
516 appldata_timer.data = (unsigned long) &appldata_work;
517
518 rc = platform_driver_register(&appldata_pdrv);
519 if (rc)
520 return rc;
521
522 appldata_pdev = platform_device_register_simple("appldata", -1, NULL,
523 0);
524 if (IS_ERR(appldata_pdev)) {
525 rc = PTR_ERR(appldata_pdev);
526 goto out_driver;
527 }
528 appldata_wq = alloc_ordered_workqueue("appldata", 0);
529 if (!appldata_wq) {
530 rc = -ENOMEM;
531 goto out_device;
532 }
533
534 appldata_sysctl_header = register_sysctl_table(appldata_dir_table);
535 return 0;
536
537out_device:
538 platform_device_unregister(appldata_pdev);
539out_driver:
540 platform_driver_unregister(&appldata_pdrv);
541 return rc;
542}
543
544__initcall(appldata_init);
545
546
547
548EXPORT_SYMBOL_GPL(appldata_register_ops);
549EXPORT_SYMBOL_GPL(appldata_unregister_ops);
550EXPORT_SYMBOL_GPL(appldata_diag);
551
552#ifdef CONFIG_SWAP
553EXPORT_SYMBOL_GPL(si_swapinfo);
554#endif
555EXPORT_SYMBOL_GPL(nr_threads);
556EXPORT_SYMBOL_GPL(nr_running);
557EXPORT_SYMBOL_GPL(nr_iowait);
558