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