Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-next-2.6
[linux-2.6] / arch / s390 / appldata / appldata_base.c
1 /*
2  * arch/s390/appldata/appldata_base.c
3  *
4  * Base infrastructure for Linux-z/VM Monitor Stream, Stage 1.
5  * Exports appldata_register_ops() and appldata_unregister_ops() for the
6  * data gathering modules.
7  *
8  * Copyright IBM Corp. 2003, 2009
9  *
10  * Author: Gerald Schaefer <gerald.schaefer@de.ibm.com>
11  */
12
13 #define KMSG_COMPONENT  "appldata"
14 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
15
16 #include <linux/module.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/timer.h>
33 #include <asm/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           /* default (CPU) time for
41                                                    sampling interval in
42                                                    milliseconds */
43
44 #define TOD_MICRO       0x01000                 /* nr. of TOD clock units
45                                                    for 1 microsecond */
46
47 static struct platform_device *appldata_pdev;
48
49 /*
50  * /proc entries (sysctl)
51  */
52 static const char appldata_proc_name[APPLDATA_PROC_NAME_LENGTH] = "appldata";
53 static int appldata_timer_handler(ctl_table *ctl, int write, struct file *filp,
54                                   void __user *buffer, size_t *lenp, loff_t *ppos);
55 static int appldata_interval_handler(ctl_table *ctl, int write,
56                                          struct file *filp,
57                                          void __user *buffer,
58                                          size_t *lenp, loff_t *ppos);
59
60 static struct ctl_table_header *appldata_sysctl_header;
61 static struct ctl_table appldata_table[] = {
62         {
63                 .procname       = "timer",
64                 .mode           = S_IRUGO | S_IWUSR,
65                 .proc_handler   = &appldata_timer_handler,
66         },
67         {
68                 .procname       = "interval",
69                 .mode           = S_IRUGO | S_IWUSR,
70                 .proc_handler   = &appldata_interval_handler,
71         },
72         { },
73 };
74
75 static struct ctl_table appldata_dir_table[] = {
76         {
77                 .procname       = appldata_proc_name,
78                 .maxlen         = 0,
79                 .mode           = S_IRUGO | S_IXUGO,
80                 .child          = appldata_table,
81         },
82         { },
83 };
84
85 /*
86  * Timer
87  */
88 static DEFINE_PER_CPU(struct vtimer_list, appldata_timer);
89 static atomic_t appldata_expire_count = ATOMIC_INIT(0);
90
91 static DEFINE_SPINLOCK(appldata_timer_lock);
92 static int appldata_interval = APPLDATA_CPU_INTERVAL;
93 static int appldata_timer_active;
94 static int appldata_timer_suspended = 0;
95
96 /*
97  * Work queue
98  */
99 static struct workqueue_struct *appldata_wq;
100 static void appldata_work_fn(struct work_struct *work);
101 static DECLARE_WORK(appldata_work, appldata_work_fn);
102
103
104 /*
105  * Ops list
106  */
107 static DEFINE_MUTEX(appldata_ops_mutex);
108 static LIST_HEAD(appldata_ops_list);
109
110
111 /*************************** timer, work, DIAG *******************************/
112 /*
113  * appldata_timer_function()
114  *
115  * schedule work and reschedule timer
116  */
117 static void appldata_timer_function(unsigned long data)
118 {
119         if (atomic_dec_and_test(&appldata_expire_count)) {
120                 atomic_set(&appldata_expire_count, num_online_cpus());
121                 queue_work(appldata_wq, (struct work_struct *) data);
122         }
123 }
124
125 /*
126  * appldata_work_fn()
127  *
128  * call data gathering function for each (active) module
129  */
130 static void appldata_work_fn(struct work_struct *work)
131 {
132         struct list_head *lh;
133         struct appldata_ops *ops;
134         int i;
135
136         i = 0;
137         get_online_cpus();
138         mutex_lock(&appldata_ops_mutex);
139         list_for_each(lh, &appldata_ops_list) {
140                 ops = list_entry(lh, struct appldata_ops, list);
141                 if (ops->active == 1) {
142                         ops->callback(ops->data);
143                 }
144         }
145         mutex_unlock(&appldata_ops_mutex);
146         put_online_cpus();
147 }
148
149 /*
150  * appldata_diag()
151  *
152  * prepare parameter list, issue DIAG 0xDC
153  */
154 int appldata_diag(char record_nr, u16 function, unsigned long buffer,
155                         u16 length, char *mod_lvl)
156 {
157         struct appldata_product_id id = {
158                 .prod_nr    = {0xD3, 0xC9, 0xD5, 0xE4,
159                                0xE7, 0xD2, 0xD9},       /* "LINUXKR" */
160                 .prod_fn    = 0xD5D3,                   /* "NL" */
161                 .version_nr = 0xF2F6,                   /* "26" */
162                 .release_nr = 0xF0F1,                   /* "01" */
163         };
164
165         id.record_nr = record_nr;
166         id.mod_lvl = (mod_lvl[0]) << 8 | mod_lvl[1];
167         return appldata_asm(&id, function, (void *) buffer, length);
168 }
169 /************************ timer, work, DIAG <END> ****************************/
170
171
172 /****************************** /proc stuff **********************************/
173
174 /*
175  * appldata_mod_vtimer_wrap()
176  *
177  * wrapper function for mod_virt_timer(), because smp_call_function_single()
178  * accepts only one parameter.
179  */
180 static void __appldata_mod_vtimer_wrap(void *p) {
181         struct {
182                 struct vtimer_list *timer;
183                 u64    expires;
184         } *args = p;
185         mod_virt_timer_periodic(args->timer, args->expires);
186 }
187
188 #define APPLDATA_ADD_TIMER      0
189 #define APPLDATA_DEL_TIMER      1
190 #define APPLDATA_MOD_TIMER      2
191
192 /*
193  * __appldata_vtimer_setup()
194  *
195  * Add, delete or modify virtual timers on all online cpus.
196  * The caller needs to get the appldata_timer_lock spinlock.
197  */
198 static void
199 __appldata_vtimer_setup(int cmd)
200 {
201         u64 per_cpu_interval;
202         int i;
203
204         switch (cmd) {
205         case APPLDATA_ADD_TIMER:
206                 if (appldata_timer_active)
207                         break;
208                 per_cpu_interval = (u64) (appldata_interval*1000 /
209                                           num_online_cpus()) * TOD_MICRO;
210                 for_each_online_cpu(i) {
211                         per_cpu(appldata_timer, i).expires = per_cpu_interval;
212                         smp_call_function_single(i, add_virt_timer_periodic,
213                                                  &per_cpu(appldata_timer, i),
214                                                  1);
215                 }
216                 appldata_timer_active = 1;
217                 break;
218         case APPLDATA_DEL_TIMER:
219                 for_each_online_cpu(i)
220                         del_virt_timer(&per_cpu(appldata_timer, i));
221                 if (!appldata_timer_active)
222                         break;
223                 appldata_timer_active = 0;
224                 atomic_set(&appldata_expire_count, num_online_cpus());
225                 break;
226         case APPLDATA_MOD_TIMER:
227                 per_cpu_interval = (u64) (appldata_interval*1000 /
228                                           num_online_cpus()) * TOD_MICRO;
229                 if (!appldata_timer_active)
230                         break;
231                 for_each_online_cpu(i) {
232                         struct {
233                                 struct vtimer_list *timer;
234                                 u64    expires;
235                         } args;
236                         args.timer = &per_cpu(appldata_timer, i);
237                         args.expires = per_cpu_interval;
238                         smp_call_function_single(i, __appldata_mod_vtimer_wrap,
239                                                  &args, 1);
240                 }
241         }
242 }
243
244 /*
245  * appldata_timer_handler()
246  *
247  * Start/Stop timer, show status of timer (0 = not active, 1 = active)
248  */
249 static int
250 appldata_timer_handler(ctl_table *ctl, int write, struct file *filp,
251                            void __user *buffer, size_t *lenp, loff_t *ppos)
252 {
253         int len;
254         char buf[2];
255
256         if (!*lenp || *ppos) {
257                 *lenp = 0;
258                 return 0;
259         }
260         if (!write) {
261                 len = sprintf(buf, appldata_timer_active ? "1\n" : "0\n");
262                 if (len > *lenp)
263                         len = *lenp;
264                 if (copy_to_user(buffer, buf, len))
265                         return -EFAULT;
266                 goto out;
267         }
268         len = *lenp;
269         if (copy_from_user(buf, buffer, len > sizeof(buf) ? sizeof(buf) : len))
270                 return -EFAULT;
271         get_online_cpus();
272         spin_lock(&appldata_timer_lock);
273         if (buf[0] == '1')
274                 __appldata_vtimer_setup(APPLDATA_ADD_TIMER);
275         else if (buf[0] == '0')
276                 __appldata_vtimer_setup(APPLDATA_DEL_TIMER);
277         spin_unlock(&appldata_timer_lock);
278         put_online_cpus();
279 out:
280         *lenp = len;
281         *ppos += len;
282         return 0;
283 }
284
285 /*
286  * appldata_interval_handler()
287  *
288  * Set (CPU) timer interval for collection of data (in milliseconds), show
289  * current timer interval.
290  */
291 static int
292 appldata_interval_handler(ctl_table *ctl, int write, struct file *filp,
293                            void __user *buffer, size_t *lenp, loff_t *ppos)
294 {
295         int len, interval;
296         char buf[16];
297
298         if (!*lenp || *ppos) {
299                 *lenp = 0;
300                 return 0;
301         }
302         if (!write) {
303                 len = sprintf(buf, "%i\n", appldata_interval);
304                 if (len > *lenp)
305                         len = *lenp;
306                 if (copy_to_user(buffer, buf, len))
307                         return -EFAULT;
308                 goto out;
309         }
310         len = *lenp;
311         if (copy_from_user(buf, buffer, len > sizeof(buf) ? sizeof(buf) : len)) {
312                 return -EFAULT;
313         }
314         interval = 0;
315         sscanf(buf, "%i", &interval);
316         if (interval <= 0)
317                 return -EINVAL;
318
319         get_online_cpus();
320         spin_lock(&appldata_timer_lock);
321         appldata_interval = interval;
322         __appldata_vtimer_setup(APPLDATA_MOD_TIMER);
323         spin_unlock(&appldata_timer_lock);
324         put_online_cpus();
325 out:
326         *lenp = len;
327         *ppos += len;
328         return 0;
329 }
330
331 /*
332  * appldata_generic_handler()
333  *
334  * Generic start/stop monitoring and DIAG, show status of
335  * monitoring (0 = not in process, 1 = in process)
336  */
337 static int
338 appldata_generic_handler(ctl_table *ctl, int write, struct file *filp,
339                            void __user *buffer, size_t *lenp, loff_t *ppos)
340 {
341         struct appldata_ops *ops = NULL, *tmp_ops;
342         int rc, len, found;
343         char buf[2];
344         struct list_head *lh;
345
346         found = 0;
347         mutex_lock(&appldata_ops_mutex);
348         list_for_each(lh, &appldata_ops_list) {
349                 tmp_ops = list_entry(lh, struct appldata_ops, list);
350                 if (&tmp_ops->ctl_table[2] == ctl) {
351                         found = 1;
352                 }
353         }
354         if (!found) {
355                 mutex_unlock(&appldata_ops_mutex);
356                 return -ENODEV;
357         }
358         ops = ctl->data;
359         if (!try_module_get(ops->owner)) {      // protect this function
360                 mutex_unlock(&appldata_ops_mutex);
361                 return -ENODEV;
362         }
363         mutex_unlock(&appldata_ops_mutex);
364
365         if (!*lenp || *ppos) {
366                 *lenp = 0;
367                 module_put(ops->owner);
368                 return 0;
369         }
370         if (!write) {
371                 len = sprintf(buf, ops->active ? "1\n" : "0\n");
372                 if (len > *lenp)
373                         len = *lenp;
374                 if (copy_to_user(buffer, buf, len)) {
375                         module_put(ops->owner);
376                         return -EFAULT;
377                 }
378                 goto out;
379         }
380         len = *lenp;
381         if (copy_from_user(buf, buffer,
382                            len > sizeof(buf) ? sizeof(buf) : len)) {
383                 module_put(ops->owner);
384                 return -EFAULT;
385         }
386
387         mutex_lock(&appldata_ops_mutex);
388         if ((buf[0] == '1') && (ops->active == 0)) {
389                 // protect work queue callback
390                 if (!try_module_get(ops->owner)) {
391                         mutex_unlock(&appldata_ops_mutex);
392                         module_put(ops->owner);
393                         return -ENODEV;
394                 }
395                 ops->callback(ops->data);       // init record
396                 rc = appldata_diag(ops->record_nr,
397                                         APPLDATA_START_INTERVAL_REC,
398                                         (unsigned long) ops->data, ops->size,
399                                         ops->mod_lvl);
400                 if (rc != 0) {
401                         pr_err("Starting the data collection for %s "
402                                "failed with rc=%d\n", ops->name, rc);
403                         module_put(ops->owner);
404                 } else
405                         ops->active = 1;
406         } else if ((buf[0] == '0') && (ops->active == 1)) {
407                 ops->active = 0;
408                 rc = appldata_diag(ops->record_nr, APPLDATA_STOP_REC,
409                                 (unsigned long) ops->data, ops->size,
410                                 ops->mod_lvl);
411                 if (rc != 0)
412                         pr_err("Stopping the data collection for %s "
413                                "failed with rc=%d\n", ops->name, rc);
414                 module_put(ops->owner);
415         }
416         mutex_unlock(&appldata_ops_mutex);
417 out:
418         *lenp = len;
419         *ppos += len;
420         module_put(ops->owner);
421         return 0;
422 }
423
424 /*************************** /proc stuff <END> *******************************/
425
426
427 /************************* module-ops management *****************************/
428 /*
429  * appldata_register_ops()
430  *
431  * update ops list, register /proc/sys entries
432  */
433 int appldata_register_ops(struct appldata_ops *ops)
434 {
435         if (ops->size > APPLDATA_MAX_REC_SIZE)
436                 return -EINVAL;
437
438         ops->ctl_table = kzalloc(4 * sizeof(struct ctl_table), GFP_KERNEL);
439         if (!ops->ctl_table)
440                 return -ENOMEM;
441
442         mutex_lock(&appldata_ops_mutex);
443         list_add(&ops->list, &appldata_ops_list);
444         mutex_unlock(&appldata_ops_mutex);
445
446         ops->ctl_table[0].procname = appldata_proc_name;
447         ops->ctl_table[0].maxlen   = 0;
448         ops->ctl_table[0].mode     = S_IRUGO | S_IXUGO;
449         ops->ctl_table[0].child    = &ops->ctl_table[2];
450
451         ops->ctl_table[2].procname = ops->name;
452         ops->ctl_table[2].mode     = S_IRUGO | S_IWUSR;
453         ops->ctl_table[2].proc_handler = appldata_generic_handler;
454         ops->ctl_table[2].data = ops;
455
456         ops->sysctl_header = register_sysctl_table(ops->ctl_table);
457         if (!ops->sysctl_header)
458                 goto out;
459         return 0;
460 out:
461         mutex_lock(&appldata_ops_mutex);
462         list_del(&ops->list);
463         mutex_unlock(&appldata_ops_mutex);
464         kfree(ops->ctl_table);
465         return -ENOMEM;
466 }
467
468 /*
469  * appldata_unregister_ops()
470  *
471  * update ops list, unregister /proc entries, stop DIAG if necessary
472  */
473 void appldata_unregister_ops(struct appldata_ops *ops)
474 {
475         mutex_lock(&appldata_ops_mutex);
476         list_del(&ops->list);
477         mutex_unlock(&appldata_ops_mutex);
478         unregister_sysctl_table(ops->sysctl_header);
479         kfree(ops->ctl_table);
480 }
481 /********************** module-ops management <END> **************************/
482
483
484 /**************************** suspend / resume *******************************/
485 static int appldata_freeze(struct device *dev)
486 {
487         struct appldata_ops *ops;
488         int rc;
489         struct list_head *lh;
490
491         get_online_cpus();
492         spin_lock(&appldata_timer_lock);
493         if (appldata_timer_active) {
494                 __appldata_vtimer_setup(APPLDATA_DEL_TIMER);
495                 appldata_timer_suspended = 1;
496         }
497         spin_unlock(&appldata_timer_lock);
498         put_online_cpus();
499
500         mutex_lock(&appldata_ops_mutex);
501         list_for_each(lh, &appldata_ops_list) {
502                 ops = list_entry(lh, struct appldata_ops, list);
503                 if (ops->active == 1) {
504                         rc = appldata_diag(ops->record_nr, APPLDATA_STOP_REC,
505                                         (unsigned long) ops->data, ops->size,
506                                         ops->mod_lvl);
507                         if (rc != 0)
508                                 pr_err("Stopping the data collection for %s "
509                                        "failed with rc=%d\n", ops->name, rc);
510                 }
511         }
512         mutex_unlock(&appldata_ops_mutex);
513         return 0;
514 }
515
516 static int appldata_restore(struct device *dev)
517 {
518         struct appldata_ops *ops;
519         int rc;
520         struct list_head *lh;
521
522         get_online_cpus();
523         spin_lock(&appldata_timer_lock);
524         if (appldata_timer_suspended) {
525                 __appldata_vtimer_setup(APPLDATA_ADD_TIMER);
526                 appldata_timer_suspended = 0;
527         }
528         spin_unlock(&appldata_timer_lock);
529         put_online_cpus();
530
531         mutex_lock(&appldata_ops_mutex);
532         list_for_each(lh, &appldata_ops_list) {
533                 ops = list_entry(lh, struct appldata_ops, list);
534                 if (ops->active == 1) {
535                         ops->callback(ops->data);       // init record
536                         rc = appldata_diag(ops->record_nr,
537                                         APPLDATA_START_INTERVAL_REC,
538                                         (unsigned long) ops->data, ops->size,
539                                         ops->mod_lvl);
540                         if (rc != 0) {
541                                 pr_err("Starting the data collection for %s "
542                                        "failed with rc=%d\n", ops->name, rc);
543                         }
544                 }
545         }
546         mutex_unlock(&appldata_ops_mutex);
547         return 0;
548 }
549
550 static int appldata_thaw(struct device *dev)
551 {
552         return appldata_restore(dev);
553 }
554
555 static struct dev_pm_ops appldata_pm_ops = {
556         .freeze         = appldata_freeze,
557         .thaw           = appldata_thaw,
558         .restore        = appldata_restore,
559 };
560
561 static struct platform_driver appldata_pdrv = {
562         .driver = {
563                 .name   = "appldata",
564                 .owner  = THIS_MODULE,
565                 .pm     = &appldata_pm_ops,
566         },
567 };
568 /************************* suspend / resume <END> ****************************/
569
570
571 /******************************* init / exit *********************************/
572
573 static void __cpuinit appldata_online_cpu(int cpu)
574 {
575         init_virt_timer(&per_cpu(appldata_timer, cpu));
576         per_cpu(appldata_timer, cpu).function = appldata_timer_function;
577         per_cpu(appldata_timer, cpu).data = (unsigned long)
578                 &appldata_work;
579         atomic_inc(&appldata_expire_count);
580         spin_lock(&appldata_timer_lock);
581         __appldata_vtimer_setup(APPLDATA_MOD_TIMER);
582         spin_unlock(&appldata_timer_lock);
583 }
584
585 static void __cpuinit appldata_offline_cpu(int cpu)
586 {
587         del_virt_timer(&per_cpu(appldata_timer, cpu));
588         if (atomic_dec_and_test(&appldata_expire_count)) {
589                 atomic_set(&appldata_expire_count, num_online_cpus());
590                 queue_work(appldata_wq, &appldata_work);
591         }
592         spin_lock(&appldata_timer_lock);
593         __appldata_vtimer_setup(APPLDATA_MOD_TIMER);
594         spin_unlock(&appldata_timer_lock);
595 }
596
597 static int __cpuinit appldata_cpu_notify(struct notifier_block *self,
598                                          unsigned long action,
599                                          void *hcpu)
600 {
601         switch (action) {
602         case CPU_ONLINE:
603         case CPU_ONLINE_FROZEN:
604                 appldata_online_cpu((long) hcpu);
605                 break;
606         case CPU_DEAD:
607         case CPU_DEAD_FROZEN:
608                 appldata_offline_cpu((long) hcpu);
609                 break;
610         default:
611                 break;
612         }
613         return NOTIFY_OK;
614 }
615
616 static struct notifier_block __cpuinitdata appldata_nb = {
617         .notifier_call = appldata_cpu_notify,
618 };
619
620 /*
621  * appldata_init()
622  *
623  * init timer, register /proc entries
624  */
625 static int __init appldata_init(void)
626 {
627         int i, rc;
628
629         rc = platform_driver_register(&appldata_pdrv);
630         if (rc)
631                 return rc;
632
633         appldata_pdev = platform_device_register_simple("appldata", -1, NULL,
634                                                         0);
635         if (IS_ERR(appldata_pdev)) {
636                 rc = PTR_ERR(appldata_pdev);
637                 goto out_driver;
638         }
639         appldata_wq = create_singlethread_workqueue("appldata");
640         if (!appldata_wq) {
641                 rc = -ENOMEM;
642                 goto out_device;
643         }
644
645         get_online_cpus();
646         for_each_online_cpu(i)
647                 appldata_online_cpu(i);
648         put_online_cpus();
649
650         /* Register cpu hotplug notifier */
651         register_hotcpu_notifier(&appldata_nb);
652
653         appldata_sysctl_header = register_sysctl_table(appldata_dir_table);
654         return 0;
655
656 out_device:
657         platform_device_unregister(appldata_pdev);
658 out_driver:
659         platform_driver_unregister(&appldata_pdrv);
660         return rc;
661 }
662
663 __initcall(appldata_init);
664
665 /**************************** init / exit <END> ******************************/
666
667 EXPORT_SYMBOL_GPL(appldata_register_ops);
668 EXPORT_SYMBOL_GPL(appldata_unregister_ops);
669 EXPORT_SYMBOL_GPL(appldata_diag);
670
671 #ifdef CONFIG_SWAP
672 EXPORT_SYMBOL_GPL(si_swapinfo);
673 #endif
674 EXPORT_SYMBOL_GPL(nr_threads);
675 EXPORT_SYMBOL_GPL(nr_running);
676 EXPORT_SYMBOL_GPL(nr_iowait);