Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/arch/s390/appldata/appldata_base.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us