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 <asm/appldata.h>
30 #include <asm/vtimer.h>
31 #include <linux/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 /*
46  * /proc entries (sysctl)
47  */
48 static const char appldata_proc_name[APPLDATA_PROC_NAME_LENGTH] = "appldata";
49 static int appldata_timer_handler(struct ctl_table *ctl, int write,
50 				  void *buffer, size_t *lenp, loff_t *ppos);
51 static int appldata_interval_handler(struct ctl_table *ctl, int write,
52 				     void *buffer, size_t *lenp, loff_t *ppos);
53 
54 static struct ctl_table_header *appldata_sysctl_header;
55 static struct ctl_table appldata_table[] = {
56 	{
57 		.procname	= "timer",
58 		.mode		= S_IRUGO | S_IWUSR,
59 		.proc_handler	= appldata_timer_handler,
60 	},
61 	{
62 		.procname	= "interval",
63 		.mode		= S_IRUGO | S_IWUSR,
64 		.proc_handler	= appldata_interval_handler,
65 	},
66 	{ },
67 };
68 
69 static struct ctl_table appldata_dir_table[] = {
70 	{
71 		.procname	= appldata_proc_name,
72 		.maxlen		= 0,
73 		.mode		= S_IRUGO | S_IXUGO,
74 		.child		= appldata_table,
75 	},
76 	{ },
77 };
78 
79 /*
80  * Timer
81  */
82 static struct vtimer_list appldata_timer;
83 
84 static DEFINE_SPINLOCK(appldata_timer_lock);
85 static int appldata_interval = APPLDATA_CPU_INTERVAL;
86 static int appldata_timer_active;
87 
88 /*
89  * Work queue
90  */
91 static struct workqueue_struct *appldata_wq;
92 static void appldata_work_fn(struct work_struct *work);
93 static DECLARE_WORK(appldata_work, appldata_work_fn);
94 
95 
96 /*
97  * Ops list
98  */
99 static DEFINE_MUTEX(appldata_ops_mutex);
100 static LIST_HEAD(appldata_ops_list);
101 
102 
103 /*************************** timer, work, DIAG *******************************/
104 /*
105  * appldata_timer_function()
106  *
107  * schedule work and reschedule timer
108  */
109 static void appldata_timer_function(unsigned long data)
110 {
111 	queue_work(appldata_wq, (struct work_struct *) data);
112 }
113 
114 /*
115  * appldata_work_fn()
116  *
117  * call data gathering function for each (active) module
118  */
119 static void appldata_work_fn(struct work_struct *work)
120 {
121 	struct list_head *lh;
122 	struct appldata_ops *ops;
123 
124 	mutex_lock(&appldata_ops_mutex);
125 	list_for_each(lh, &appldata_ops_list) {
126 		ops = list_entry(lh, struct appldata_ops, list);
127 		if (ops->active == 1) {
128 			ops->callback(ops->data);
129 		}
130 	}
131 	mutex_unlock(&appldata_ops_mutex);
132 }
133 
134 static struct appldata_product_id appldata_id = {
135 	.prod_nr    = {0xD3, 0xC9, 0xD5, 0xE4,
136 		       0xE7, 0xD2, 0xD9},	/* "LINUXKR" */
137 	.prod_fn    = 0xD5D3,			/* "NL" */
138 	.version_nr = 0xF2F6,			/* "26" */
139 	.release_nr = 0xF0F1,			/* "01" */
140 };
141 
142 /*
143  * appldata_diag()
144  *
145  * prepare parameter list, issue DIAG 0xDC
146  */
147 int appldata_diag(char record_nr, u16 function, unsigned long buffer,
148 			u16 length, char *mod_lvl)
149 {
150 	struct appldata_parameter_list *parm_list;
151 	struct appldata_product_id *id;
152 	int rc;
153 
154 	parm_list = kmalloc(sizeof(*parm_list), GFP_KERNEL);
155 	id = kmemdup(&appldata_id, sizeof(appldata_id), GFP_KERNEL);
156 	rc = -ENOMEM;
157 	if (parm_list && id) {
158 		id->record_nr = record_nr;
159 		id->mod_lvl = (mod_lvl[0]) << 8 | mod_lvl[1];
160 		rc = appldata_asm(parm_list, id, function,
161 				  (void *) buffer, length);
162 	}
163 	kfree(id);
164 	kfree(parm_list);
165 	return rc;
166 }
167 /************************ timer, work, DIAG <END> ****************************/
168 
169 
170 /****************************** /proc stuff **********************************/
171 
172 #define APPLDATA_ADD_TIMER	0
173 #define APPLDATA_DEL_TIMER	1
174 #define APPLDATA_MOD_TIMER	2
175 
176 /*
177  * __appldata_vtimer_setup()
178  *
179  * Add, delete or modify virtual timers on all online cpus.
180  * The caller needs to get the appldata_timer_lock spinlock.
181  */
182 static void __appldata_vtimer_setup(int cmd)
183 {
184 	u64 timer_interval = (u64) appldata_interval * 1000 * TOD_MICRO;
185 
186 	switch (cmd) {
187 	case APPLDATA_ADD_TIMER:
188 		if (appldata_timer_active)
189 			break;
190 		appldata_timer.expires = timer_interval;
191 		add_virt_timer_periodic(&appldata_timer);
192 		appldata_timer_active = 1;
193 		break;
194 	case APPLDATA_DEL_TIMER:
195 		del_virt_timer(&appldata_timer);
196 		if (!appldata_timer_active)
197 			break;
198 		appldata_timer_active = 0;
199 		break;
200 	case APPLDATA_MOD_TIMER:
201 		if (!appldata_timer_active)
202 			break;
203 		mod_virt_timer_periodic(&appldata_timer, timer_interval);
204 	}
205 }
206 
207 /*
208  * appldata_timer_handler()
209  *
210  * Start/Stop timer, show status of timer (0 = not active, 1 = active)
211  */
212 static int
213 appldata_timer_handler(struct ctl_table *ctl, int write,
214 			   void *buffer, size_t *lenp, loff_t *ppos)
215 {
216 	int timer_active = appldata_timer_active;
217 	int rc;
218 	struct ctl_table ctl_entry = {
219 		.procname	= ctl->procname,
220 		.data		= &timer_active,
221 		.maxlen		= sizeof(int),
222 		.extra1		= SYSCTL_ZERO,
223 		.extra2		= SYSCTL_ONE,
224 	};
225 
226 	rc = proc_douintvec_minmax(&ctl_entry, write, buffer, lenp, ppos);
227 	if (rc < 0 || !write)
228 		return rc;
229 
230 	spin_lock(&appldata_timer_lock);
231 	if (timer_active)
232 		__appldata_vtimer_setup(APPLDATA_ADD_TIMER);
233 	else
234 		__appldata_vtimer_setup(APPLDATA_DEL_TIMER);
235 	spin_unlock(&appldata_timer_lock);
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 *buffer, size_t *lenp, loff_t *ppos)
248 {
249 	int interval = appldata_interval;
250 	int rc;
251 	struct ctl_table ctl_entry = {
252 		.procname	= ctl->procname,
253 		.data		= &interval,
254 		.maxlen		= sizeof(int),
255 		.extra1		= SYSCTL_ONE,
256 	};
257 
258 	rc = proc_dointvec_minmax(&ctl_entry, write, buffer, lenp, ppos);
259 	if (rc < 0 || !write)
260 		return rc;
261 
262 	spin_lock(&appldata_timer_lock);
263 	appldata_interval = interval;
264 	__appldata_vtimer_setup(APPLDATA_MOD_TIMER);
265 	spin_unlock(&appldata_timer_lock);
266 	return 0;
267 }
268 
269 /*
270  * appldata_generic_handler()
271  *
272  * Generic start/stop monitoring and DIAG, show status of
273  * monitoring (0 = not in process, 1 = in process)
274  */
275 static int
276 appldata_generic_handler(struct ctl_table *ctl, int write,
277 			   void *buffer, size_t *lenp, loff_t *ppos)
278 {
279 	struct appldata_ops *ops = NULL, *tmp_ops;
280 	struct list_head *lh;
281 	int rc, found;
282 	int active;
283 	struct ctl_table ctl_entry = {
284 		.data		= &active,
285 		.maxlen		= sizeof(int),
286 		.extra1		= SYSCTL_ZERO,
287 		.extra2		= SYSCTL_ONE,
288 	};
289 
290 	found = 0;
291 	mutex_lock(&appldata_ops_mutex);
292 	list_for_each(lh, &appldata_ops_list) {
293 		tmp_ops = list_entry(lh, struct appldata_ops, list);
294 		if (&tmp_ops->ctl_table[2] == ctl) {
295 			found = 1;
296 		}
297 	}
298 	if (!found) {
299 		mutex_unlock(&appldata_ops_mutex);
300 		return -ENODEV;
301 	}
302 	ops = ctl->data;
303 	if (!try_module_get(ops->owner)) {	// protect this function
304 		mutex_unlock(&appldata_ops_mutex);
305 		return -ENODEV;
306 	}
307 	mutex_unlock(&appldata_ops_mutex);
308 
309 	active = ops->active;
310 	rc = proc_douintvec_minmax(&ctl_entry, write, buffer, lenp, ppos);
311 	if (rc < 0 || !write) {
312 		module_put(ops->owner);
313 		return rc;
314 	}
315 
316 	mutex_lock(&appldata_ops_mutex);
317 	if (active && (ops->active == 0)) {
318 		// protect work queue callback
319 		if (!try_module_get(ops->owner)) {
320 			mutex_unlock(&appldata_ops_mutex);
321 			module_put(ops->owner);
322 			return -ENODEV;
323 		}
324 		ops->callback(ops->data);	// init record
325 		rc = appldata_diag(ops->record_nr,
326 					APPLDATA_START_INTERVAL_REC,
327 					(unsigned long) ops->data, ops->size,
328 					ops->mod_lvl);
329 		if (rc != 0) {
330 			pr_err("Starting the data collection for %s "
331 			       "failed with rc=%d\n", ops->name, rc);
332 			module_put(ops->owner);
333 		} else
334 			ops->active = 1;
335 	} else if (!active && (ops->active == 1)) {
336 		ops->active = 0;
337 		rc = appldata_diag(ops->record_nr, APPLDATA_STOP_REC,
338 				(unsigned long) ops->data, ops->size,
339 				ops->mod_lvl);
340 		if (rc != 0)
341 			pr_err("Stopping the data collection for %s "
342 			       "failed with rc=%d\n", ops->name, rc);
343 		module_put(ops->owner);
344 	}
345 	mutex_unlock(&appldata_ops_mutex);
346 	module_put(ops->owner);
347 	return 0;
348 }
349 
350 /*************************** /proc stuff <END> *******************************/
351 
352 
353 /************************* module-ops management *****************************/
354 /*
355  * appldata_register_ops()
356  *
357  * update ops list, register /proc/sys entries
358  */
359 int appldata_register_ops(struct appldata_ops *ops)
360 {
361 	if (ops->size > APPLDATA_MAX_REC_SIZE)
362 		return -EINVAL;
363 
364 	ops->ctl_table = kcalloc(4, sizeof(struct ctl_table), GFP_KERNEL);
365 	if (!ops->ctl_table)
366 		return -ENOMEM;
367 
368 	mutex_lock(&appldata_ops_mutex);
369 	list_add(&ops->list, &appldata_ops_list);
370 	mutex_unlock(&appldata_ops_mutex);
371 
372 	ops->ctl_table[0].procname = appldata_proc_name;
373 	ops->ctl_table[0].maxlen   = 0;
374 	ops->ctl_table[0].mode     = S_IRUGO | S_IXUGO;
375 	ops->ctl_table[0].child    = &ops->ctl_table[2];
376 
377 	ops->ctl_table[2].procname = ops->name;
378 	ops->ctl_table[2].mode     = S_IRUGO | S_IWUSR;
379 	ops->ctl_table[2].proc_handler = appldata_generic_handler;
380 	ops->ctl_table[2].data = ops;
381 
382 	ops->sysctl_header = register_sysctl_table(ops->ctl_table);
383 	if (!ops->sysctl_header)
384 		goto out;
385 	return 0;
386 out:
387 	mutex_lock(&appldata_ops_mutex);
388 	list_del(&ops->list);
389 	mutex_unlock(&appldata_ops_mutex);
390 	kfree(ops->ctl_table);
391 	return -ENOMEM;
392 }
393 
394 /*
395  * appldata_unregister_ops()
396  *
397  * update ops list, unregister /proc entries, stop DIAG if necessary
398  */
399 void appldata_unregister_ops(struct appldata_ops *ops)
400 {
401 	mutex_lock(&appldata_ops_mutex);
402 	list_del(&ops->list);
403 	mutex_unlock(&appldata_ops_mutex);
404 	unregister_sysctl_table(ops->sysctl_header);
405 	kfree(ops->ctl_table);
406 }
407 /********************** module-ops management <END> **************************/
408 
409 
410 /******************************* init / exit *********************************/
411 
412 /*
413  * appldata_init()
414  *
415  * init timer, register /proc entries
416  */
417 static int __init appldata_init(void)
418 {
419 	init_virt_timer(&appldata_timer);
420 	appldata_timer.function = appldata_timer_function;
421 	appldata_timer.data = (unsigned long) &appldata_work;
422 	appldata_wq = alloc_ordered_workqueue("appldata", 0);
423 	if (!appldata_wq)
424 		return -ENOMEM;
425 	appldata_sysctl_header = register_sysctl_table(appldata_dir_table);
426 	return 0;
427 }
428 
429 __initcall(appldata_init);
430 
431 /**************************** init / exit <END> ******************************/
432 
433 EXPORT_SYMBOL_GPL(appldata_register_ops);
434 EXPORT_SYMBOL_GPL(appldata_unregister_ops);
435 EXPORT_SYMBOL_GPL(appldata_diag);
436 
437 #ifdef CONFIG_SWAP
438 EXPORT_SYMBOL_GPL(si_swapinfo);
439 #endif
440 EXPORT_SYMBOL_GPL(nr_threads);
441 EXPORT_SYMBOL_GPL(nr_running);
442 EXPORT_SYMBOL_GPL(nr_iowait);
443