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