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" : "0\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] == '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" : "0\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] == '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 	appldata_timer.function = appldata_timer_function;
533 	appldata_timer.data = (unsigned long) &appldata_work;
534 
535 	rc = platform_driver_register(&appldata_pdrv);
536 	if (rc)
537 		return rc;
538 
539 	appldata_pdev = platform_device_register_simple("appldata", -1, NULL,
540 							0);
541 	if (IS_ERR(appldata_pdev)) {
542 		rc = PTR_ERR(appldata_pdev);
543 		goto out_driver;
544 	}
545 	appldata_wq = create_singlethread_workqueue("appldata");
546 	if (!appldata_wq) {
547 		rc = -ENOMEM;
548 		goto out_device;
549 	}
550 
551 	appldata_sysctl_header = register_sysctl_table(appldata_dir_table);
552 	return 0;
553 
554 out_device:
555 	platform_device_unregister(appldata_pdev);
556 out_driver:
557 	platform_driver_unregister(&appldata_pdrv);
558 	return rc;
559 }
560 
561 __initcall(appldata_init);
562 
563 /**************************** init / exit <END> ******************************/
564 
565 EXPORT_SYMBOL_GPL(appldata_register_ops);
566 EXPORT_SYMBOL_GPL(appldata_unregister_ops);
567 EXPORT_SYMBOL_GPL(appldata_diag);
568 
569 #ifdef CONFIG_SWAP
570 EXPORT_SYMBOL_GPL(si_swapinfo);
571 #endif
572 EXPORT_SYMBOL_GPL(nr_threads);
573 EXPORT_SYMBOL_GPL(nr_running);
574 EXPORT_SYMBOL_GPL(nr_iowait);
575