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