1 /* 2 * arch/s390/appldata/appldata_base.c 3 * 4 * Base infrastructure for Linux-z/VM Monitor Stream, Stage 1. 5 * Exports appldata_register_ops() and appldata_unregister_ops() for the 6 * data gathering modules. 7 * 8 * Copyright (C) 2003 IBM Corporation, IBM Deutschland Entwicklung GmbH. 9 * 10 * Author: Gerald Schaefer <geraldsc@de.ibm.com> 11 */ 12 13 #include <linux/config.h> 14 #include <linux/module.h> 15 #include <linux/init.h> 16 #include <linux/slab.h> 17 #include <linux/errno.h> 18 #include <asm/uaccess.h> 19 #include <asm/io.h> 20 #include <asm/smp.h> 21 #include <linux/interrupt.h> 22 #include <linux/proc_fs.h> 23 #include <linux/page-flags.h> 24 #include <linux/swap.h> 25 #include <linux/pagemap.h> 26 #include <linux/sysctl.h> 27 #include <asm/timer.h> 28 //#include <linux/kernel_stat.h> 29 #include <linux/notifier.h> 30 #include <linux/cpu.h> 31 #include <linux/workqueue.h> 32 33 #include "appldata.h" 34 35 36 #define MY_PRINT_NAME "appldata" /* for debug messages, etc. */ 37 #define APPLDATA_CPU_INTERVAL 10000 /* default (CPU) time for 38 sampling interval in 39 milliseconds */ 40 41 #define TOD_MICRO 0x01000 /* nr. of TOD clock units 42 for 1 microsecond */ 43 #ifndef CONFIG_64BIT 44 45 #define APPLDATA_START_INTERVAL_REC 0x00 /* Function codes for */ 46 #define APPLDATA_STOP_REC 0x01 /* DIAG 0xDC */ 47 #define APPLDATA_GEN_EVENT_RECORD 0x02 48 #define APPLDATA_START_CONFIG_REC 0x03 49 50 #else 51 52 #define APPLDATA_START_INTERVAL_REC 0x80 53 #define APPLDATA_STOP_REC 0x81 54 #define APPLDATA_GEN_EVENT_RECORD 0x82 55 #define APPLDATA_START_CONFIG_REC 0x83 56 57 #endif /* CONFIG_64BIT */ 58 59 60 /* 61 * Parameter list for DIAGNOSE X'DC' 62 */ 63 #ifndef CONFIG_64BIT 64 struct appldata_parameter_list { 65 u16 diag; /* The DIAGNOSE code X'00DC' */ 66 u8 function; /* The function code for the DIAGNOSE */ 67 u8 parlist_length; /* Length of the parameter list */ 68 u32 product_id_addr; /* Address of the 16-byte product ID */ 69 u16 reserved; 70 u16 buffer_length; /* Length of the application data buffer */ 71 u32 buffer_addr; /* Address of the application data buffer */ 72 }; 73 #else 74 struct appldata_parameter_list { 75 u16 diag; 76 u8 function; 77 u8 parlist_length; 78 u32 unused01; 79 u16 reserved; 80 u16 buffer_length; 81 u32 unused02; 82 u64 product_id_addr; 83 u64 buffer_addr; 84 }; 85 #endif /* CONFIG_64BIT */ 86 87 /* 88 * /proc entries (sysctl) 89 */ 90 static const char appldata_proc_name[APPLDATA_PROC_NAME_LENGTH] = "appldata"; 91 static int appldata_timer_handler(ctl_table *ctl, int write, struct file *filp, 92 void __user *buffer, size_t *lenp, loff_t *ppos); 93 static int appldata_interval_handler(ctl_table *ctl, int write, 94 struct file *filp, 95 void __user *buffer, 96 size_t *lenp, loff_t *ppos); 97 98 static struct ctl_table_header *appldata_sysctl_header; 99 static struct ctl_table appldata_table[] = { 100 { 101 .ctl_name = CTL_APPLDATA_TIMER, 102 .procname = "timer", 103 .mode = S_IRUGO | S_IWUSR, 104 .proc_handler = &appldata_timer_handler, 105 }, 106 { 107 .ctl_name = CTL_APPLDATA_INTERVAL, 108 .procname = "interval", 109 .mode = S_IRUGO | S_IWUSR, 110 .proc_handler = &appldata_interval_handler, 111 }, 112 { .ctl_name = 0 } 113 }; 114 115 static struct ctl_table appldata_dir_table[] = { 116 { 117 .ctl_name = CTL_APPLDATA, 118 .procname = appldata_proc_name, 119 .maxlen = 0, 120 .mode = S_IRUGO | S_IXUGO, 121 .child = appldata_table, 122 }, 123 { .ctl_name = 0 } 124 }; 125 126 /* 127 * Timer 128 */ 129 DEFINE_PER_CPU(struct vtimer_list, appldata_timer); 130 static atomic_t appldata_expire_count = ATOMIC_INIT(0); 131 132 static DEFINE_SPINLOCK(appldata_timer_lock); 133 static int appldata_interval = APPLDATA_CPU_INTERVAL; 134 static int appldata_timer_active; 135 136 /* 137 * Work queue 138 */ 139 static struct workqueue_struct *appldata_wq; 140 static void appldata_work_fn(void *data); 141 static DECLARE_WORK(appldata_work, appldata_work_fn, NULL); 142 143 144 /* 145 * Ops list 146 */ 147 static DEFINE_SPINLOCK(appldata_ops_lock); 148 static LIST_HEAD(appldata_ops_list); 149 150 151 /*************************** timer, work, DIAG *******************************/ 152 /* 153 * appldata_timer_function() 154 * 155 * schedule work and reschedule timer 156 */ 157 static void appldata_timer_function(unsigned long data, struct pt_regs *regs) 158 { 159 P_DEBUG(" -= Timer =-\n"); 160 P_DEBUG("CPU: %i, expire_count: %i\n", smp_processor_id(), 161 atomic_read(&appldata_expire_count)); 162 if (atomic_dec_and_test(&appldata_expire_count)) { 163 atomic_set(&appldata_expire_count, num_online_cpus()); 164 queue_work(appldata_wq, (struct work_struct *) data); 165 } 166 } 167 168 /* 169 * appldata_work_fn() 170 * 171 * call data gathering function for each (active) module 172 */ 173 static void appldata_work_fn(void *data) 174 { 175 struct list_head *lh; 176 struct appldata_ops *ops; 177 int i; 178 179 P_DEBUG(" -= Work Queue =-\n"); 180 i = 0; 181 spin_lock(&appldata_ops_lock); 182 list_for_each(lh, &appldata_ops_list) { 183 ops = list_entry(lh, struct appldata_ops, list); 184 P_DEBUG("list_for_each loop: %i) active = %u, name = %s\n", 185 ++i, ops->active, ops->name); 186 if (ops->active == 1) { 187 ops->callback(ops->data); 188 } 189 } 190 spin_unlock(&appldata_ops_lock); 191 } 192 193 /* 194 * appldata_diag() 195 * 196 * prepare parameter list, issue DIAG 0xDC 197 */ 198 static int appldata_diag(char record_nr, u16 function, unsigned long buffer, 199 u16 length) 200 { 201 unsigned long ry; 202 struct appldata_product_id { 203 char prod_nr[7]; /* product nr. */ 204 char prod_fn[2]; /* product function */ 205 char record_nr; /* record nr. */ 206 char version_nr[2]; /* version */ 207 char release_nr[2]; /* release */ 208 char mod_lvl[2]; /* modification lvl. */ 209 } appldata_product_id = { 210 /* all strings are EBCDIC, record_nr is byte */ 211 .prod_nr = {0xD3, 0xC9, 0xD5, 0xE4, 212 0xE7, 0xD2, 0xD9}, /* "LINUXKR" */ 213 .prod_fn = {0xD5, 0xD3}, /* "NL" */ 214 .record_nr = record_nr, 215 .version_nr = {0xF2, 0xF6}, /* "26" */ 216 .release_nr = {0xF0, 0xF1}, /* "01" */ 217 .mod_lvl = {0xF0, 0xF0}, /* "00" */ 218 }; 219 struct appldata_parameter_list appldata_parameter_list = { 220 .diag = 0xDC, 221 .function = function, 222 .parlist_length = 223 sizeof(appldata_parameter_list), 224 .buffer_length = length, 225 .product_id_addr = 226 (unsigned long) &appldata_product_id, 227 .buffer_addr = virt_to_phys((void *) buffer) 228 }; 229 230 if (!MACHINE_IS_VM) 231 return -ENOSYS; 232 ry = -1; 233 asm volatile( 234 "diag %1,%0,0xDC\n\t" 235 : "=d" (ry) 236 : "d" (&appldata_parameter_list), 237 "m" (appldata_parameter_list), 238 "m" (appldata_product_id) 239 : "cc"); 240 return (int) ry; 241 } 242 /************************ timer, work, DIAG <END> ****************************/ 243 244 245 /****************************** /proc stuff **********************************/ 246 247 /* 248 * appldata_mod_vtimer_wrap() 249 * 250 * wrapper function for mod_virt_timer(), because smp_call_function_on() 251 * accepts only one parameter. 252 */ 253 static void __appldata_mod_vtimer_wrap(void *p) { 254 struct { 255 struct vtimer_list *timer; 256 u64 expires; 257 } *args = p; 258 mod_virt_timer(args->timer, args->expires); 259 } 260 261 #define APPLDATA_ADD_TIMER 0 262 #define APPLDATA_DEL_TIMER 1 263 #define APPLDATA_MOD_TIMER 2 264 265 /* 266 * __appldata_vtimer_setup() 267 * 268 * Add, delete or modify virtual timers on all online cpus. 269 * The caller needs to get the appldata_timer_lock spinlock. 270 */ 271 static void 272 __appldata_vtimer_setup(int cmd) 273 { 274 u64 per_cpu_interval; 275 int i; 276 277 switch (cmd) { 278 case APPLDATA_ADD_TIMER: 279 if (appldata_timer_active) 280 break; 281 per_cpu_interval = (u64) (appldata_interval*1000 / 282 num_online_cpus()) * TOD_MICRO; 283 for_each_online_cpu(i) { 284 per_cpu(appldata_timer, i).expires = per_cpu_interval; 285 smp_call_function_on(add_virt_timer_periodic, 286 &per_cpu(appldata_timer, i), 287 0, 1, i); 288 } 289 appldata_timer_active = 1; 290 P_INFO("Monitoring timer started.\n"); 291 break; 292 case APPLDATA_DEL_TIMER: 293 for_each_online_cpu(i) 294 del_virt_timer(&per_cpu(appldata_timer, i)); 295 if (!appldata_timer_active) 296 break; 297 appldata_timer_active = 0; 298 atomic_set(&appldata_expire_count, num_online_cpus()); 299 P_INFO("Monitoring timer stopped.\n"); 300 break; 301 case APPLDATA_MOD_TIMER: 302 per_cpu_interval = (u64) (appldata_interval*1000 / 303 num_online_cpus()) * TOD_MICRO; 304 if (!appldata_timer_active) 305 break; 306 for_each_online_cpu(i) { 307 struct { 308 struct vtimer_list *timer; 309 u64 expires; 310 } args; 311 args.timer = &per_cpu(appldata_timer, i); 312 args.expires = per_cpu_interval; 313 smp_call_function_on(__appldata_mod_vtimer_wrap, 314 &args, 0, 1, i); 315 } 316 } 317 } 318 319 /* 320 * appldata_timer_handler() 321 * 322 * Start/Stop timer, show status of timer (0 = not active, 1 = active) 323 */ 324 static int 325 appldata_timer_handler(ctl_table *ctl, int write, struct file *filp, 326 void __user *buffer, size_t *lenp, loff_t *ppos) 327 { 328 int len; 329 char buf[2]; 330 331 if (!*lenp || *ppos) { 332 *lenp = 0; 333 return 0; 334 } 335 if (!write) { 336 len = sprintf(buf, appldata_timer_active ? "1\n" : "0\n"); 337 if (len > *lenp) 338 len = *lenp; 339 if (copy_to_user(buffer, buf, len)) 340 return -EFAULT; 341 goto out; 342 } 343 len = *lenp; 344 if (copy_from_user(buf, buffer, len > sizeof(buf) ? sizeof(buf) : len)) 345 return -EFAULT; 346 spin_lock(&appldata_timer_lock); 347 if (buf[0] == '1') 348 __appldata_vtimer_setup(APPLDATA_ADD_TIMER); 349 else if (buf[0] == '0') 350 __appldata_vtimer_setup(APPLDATA_DEL_TIMER); 351 spin_unlock(&appldata_timer_lock); 352 out: 353 *lenp = len; 354 *ppos += len; 355 return 0; 356 } 357 358 /* 359 * appldata_interval_handler() 360 * 361 * Set (CPU) timer interval for collection of data (in milliseconds), show 362 * current timer interval. 363 */ 364 static int 365 appldata_interval_handler(ctl_table *ctl, int write, struct file *filp, 366 void __user *buffer, size_t *lenp, loff_t *ppos) 367 { 368 int len, interval; 369 char buf[16]; 370 371 if (!*lenp || *ppos) { 372 *lenp = 0; 373 return 0; 374 } 375 if (!write) { 376 len = sprintf(buf, "%i\n", appldata_interval); 377 if (len > *lenp) 378 len = *lenp; 379 if (copy_to_user(buffer, buf, len)) 380 return -EFAULT; 381 goto out; 382 } 383 len = *lenp; 384 if (copy_from_user(buf, buffer, len > sizeof(buf) ? sizeof(buf) : len)) { 385 return -EFAULT; 386 } 387 sscanf(buf, "%i", &interval); 388 if (interval <= 0) { 389 P_ERROR("Timer CPU interval has to be > 0!\n"); 390 return -EINVAL; 391 } 392 393 spin_lock(&appldata_timer_lock); 394 appldata_interval = interval; 395 __appldata_vtimer_setup(APPLDATA_MOD_TIMER); 396 spin_unlock(&appldata_timer_lock); 397 398 P_INFO("Monitoring CPU interval set to %u milliseconds.\n", 399 interval); 400 out: 401 *lenp = len; 402 *ppos += len; 403 return 0; 404 } 405 406 /* 407 * appldata_generic_handler() 408 * 409 * Generic start/stop monitoring and DIAG, show status of 410 * monitoring (0 = not in process, 1 = in process) 411 */ 412 static int 413 appldata_generic_handler(ctl_table *ctl, int write, struct file *filp, 414 void __user *buffer, size_t *lenp, loff_t *ppos) 415 { 416 struct appldata_ops *ops = NULL, *tmp_ops; 417 int rc, len, found; 418 char buf[2]; 419 struct list_head *lh; 420 421 found = 0; 422 spin_lock(&appldata_ops_lock); 423 list_for_each(lh, &appldata_ops_list) { 424 tmp_ops = list_entry(lh, struct appldata_ops, list); 425 if (&tmp_ops->ctl_table[2] == ctl) { 426 found = 1; 427 } 428 } 429 if (!found) { 430 spin_unlock(&appldata_ops_lock); 431 return -ENODEV; 432 } 433 ops = ctl->data; 434 if (!try_module_get(ops->owner)) { // protect this function 435 spin_unlock(&appldata_ops_lock); 436 return -ENODEV; 437 } 438 spin_unlock(&appldata_ops_lock); 439 440 if (!*lenp || *ppos) { 441 *lenp = 0; 442 module_put(ops->owner); 443 return 0; 444 } 445 if (!write) { 446 len = sprintf(buf, ops->active ? "1\n" : "0\n"); 447 if (len > *lenp) 448 len = *lenp; 449 if (copy_to_user(buffer, buf, len)) { 450 module_put(ops->owner); 451 return -EFAULT; 452 } 453 goto out; 454 } 455 len = *lenp; 456 if (copy_from_user(buf, buffer, 457 len > sizeof(buf) ? sizeof(buf) : len)) { 458 module_put(ops->owner); 459 return -EFAULT; 460 } 461 462 spin_lock(&appldata_ops_lock); 463 if ((buf[0] == '1') && (ops->active == 0)) { 464 // protect work queue callback 465 if (!try_module_get(ops->owner)) { 466 spin_unlock(&appldata_ops_lock); 467 module_put(ops->owner); 468 return -ENODEV; 469 } 470 ops->active = 1; 471 ops->callback(ops->data); // init record 472 rc = appldata_diag(ops->record_nr, 473 APPLDATA_START_INTERVAL_REC, 474 (unsigned long) ops->data, ops->size); 475 if (rc != 0) { 476 P_ERROR("START DIAG 0xDC for %s failed, " 477 "return code: %d\n", ops->name, rc); 478 module_put(ops->owner); 479 ops->active = 0; 480 } else { 481 P_INFO("Monitoring %s data enabled, " 482 "DIAG 0xDC started.\n", ops->name); 483 } 484 } else if ((buf[0] == '0') && (ops->active == 1)) { 485 ops->active = 0; 486 rc = appldata_diag(ops->record_nr, APPLDATA_STOP_REC, 487 (unsigned long) ops->data, ops->size); 488 if (rc != 0) { 489 P_ERROR("STOP DIAG 0xDC for %s failed, " 490 "return code: %d\n", ops->name, rc); 491 } else { 492 P_INFO("Monitoring %s data disabled, " 493 "DIAG 0xDC stopped.\n", ops->name); 494 } 495 module_put(ops->owner); 496 } 497 spin_unlock(&appldata_ops_lock); 498 out: 499 *lenp = len; 500 *ppos += len; 501 module_put(ops->owner); 502 return 0; 503 } 504 505 /*************************** /proc stuff <END> *******************************/ 506 507 508 /************************* module-ops management *****************************/ 509 /* 510 * appldata_register_ops() 511 * 512 * update ops list, register /proc/sys entries 513 */ 514 int appldata_register_ops(struct appldata_ops *ops) 515 { 516 struct list_head *lh; 517 struct appldata_ops *tmp_ops; 518 int i; 519 520 i = 0; 521 522 if ((ops->size > APPLDATA_MAX_REC_SIZE) || 523 (ops->size < 0)){ 524 P_ERROR("Invalid size of %s record = %i, maximum = %i!\n", 525 ops->name, ops->size, APPLDATA_MAX_REC_SIZE); 526 return -ENOMEM; 527 } 528 if ((ops->ctl_nr == CTL_APPLDATA) || 529 (ops->ctl_nr == CTL_APPLDATA_TIMER) || 530 (ops->ctl_nr == CTL_APPLDATA_INTERVAL)) { 531 P_ERROR("ctl_nr %i already in use!\n", ops->ctl_nr); 532 return -EBUSY; 533 } 534 ops->ctl_table = kzalloc(4*sizeof(struct ctl_table), GFP_KERNEL); 535 if (ops->ctl_table == NULL) { 536 P_ERROR("Not enough memory for %s ctl_table!\n", ops->name); 537 return -ENOMEM; 538 } 539 540 spin_lock(&appldata_ops_lock); 541 list_for_each(lh, &appldata_ops_list) { 542 tmp_ops = list_entry(lh, struct appldata_ops, list); 543 P_DEBUG("register_ops loop: %i) name = %s, ctl = %i\n", 544 ++i, tmp_ops->name, tmp_ops->ctl_nr); 545 P_DEBUG("Comparing %s (ctl %i) with %s (ctl %i)\n", 546 tmp_ops->name, tmp_ops->ctl_nr, ops->name, 547 ops->ctl_nr); 548 if (strncmp(tmp_ops->name, ops->name, 549 APPLDATA_PROC_NAME_LENGTH) == 0) { 550 P_ERROR("Name \"%s\" already registered!\n", ops->name); 551 kfree(ops->ctl_table); 552 spin_unlock(&appldata_ops_lock); 553 return -EBUSY; 554 } 555 if (tmp_ops->ctl_nr == ops->ctl_nr) { 556 P_ERROR("ctl_nr %i already registered!\n", ops->ctl_nr); 557 kfree(ops->ctl_table); 558 spin_unlock(&appldata_ops_lock); 559 return -EBUSY; 560 } 561 } 562 list_add(&ops->list, &appldata_ops_list); 563 spin_unlock(&appldata_ops_lock); 564 565 ops->ctl_table[0].ctl_name = CTL_APPLDATA; 566 ops->ctl_table[0].procname = appldata_proc_name; 567 ops->ctl_table[0].maxlen = 0; 568 ops->ctl_table[0].mode = S_IRUGO | S_IXUGO; 569 ops->ctl_table[0].child = &ops->ctl_table[2]; 570 571 ops->ctl_table[1].ctl_name = 0; 572 573 ops->ctl_table[2].ctl_name = ops->ctl_nr; 574 ops->ctl_table[2].procname = ops->name; 575 ops->ctl_table[2].mode = S_IRUGO | S_IWUSR; 576 ops->ctl_table[2].proc_handler = appldata_generic_handler; 577 ops->ctl_table[2].data = ops; 578 579 ops->ctl_table[3].ctl_name = 0; 580 581 ops->sysctl_header = register_sysctl_table(ops->ctl_table,1); 582 583 P_INFO("%s-ops registered!\n", ops->name); 584 return 0; 585 } 586 587 /* 588 * appldata_unregister_ops() 589 * 590 * update ops list, unregister /proc entries, stop DIAG if necessary 591 */ 592 void appldata_unregister_ops(struct appldata_ops *ops) 593 { 594 void *table; 595 spin_lock(&appldata_ops_lock); 596 list_del(&ops->list); 597 /* at that point any incoming access will fail */ 598 table = ops->ctl_table; 599 ops->ctl_table = NULL; 600 spin_unlock(&appldata_ops_lock); 601 unregister_sysctl_table(ops->sysctl_header); 602 kfree(table); 603 P_INFO("%s-ops unregistered!\n", ops->name); 604 } 605 /********************** module-ops management <END> **************************/ 606 607 608 /******************************* init / exit *********************************/ 609 610 static void 611 appldata_online_cpu(int cpu) 612 { 613 init_virt_timer(&per_cpu(appldata_timer, cpu)); 614 per_cpu(appldata_timer, cpu).function = appldata_timer_function; 615 per_cpu(appldata_timer, cpu).data = (unsigned long) 616 &appldata_work; 617 atomic_inc(&appldata_expire_count); 618 spin_lock(&appldata_timer_lock); 619 __appldata_vtimer_setup(APPLDATA_MOD_TIMER); 620 spin_unlock(&appldata_timer_lock); 621 } 622 623 static void 624 appldata_offline_cpu(int cpu) 625 { 626 del_virt_timer(&per_cpu(appldata_timer, cpu)); 627 if (atomic_dec_and_test(&appldata_expire_count)) { 628 atomic_set(&appldata_expire_count, num_online_cpus()); 629 queue_work(appldata_wq, &appldata_work); 630 } 631 spin_lock(&appldata_timer_lock); 632 __appldata_vtimer_setup(APPLDATA_MOD_TIMER); 633 spin_unlock(&appldata_timer_lock); 634 } 635 636 static int 637 appldata_cpu_notify(struct notifier_block *self, 638 unsigned long action, void *hcpu) 639 { 640 switch (action) { 641 case CPU_ONLINE: 642 appldata_online_cpu((long) hcpu); 643 break; 644 #ifdef CONFIG_HOTPLUG_CPU 645 case CPU_DEAD: 646 appldata_offline_cpu((long) hcpu); 647 break; 648 #endif 649 default: 650 break; 651 } 652 return NOTIFY_OK; 653 } 654 655 static struct notifier_block __devinitdata appldata_nb = { 656 .notifier_call = appldata_cpu_notify, 657 }; 658 659 /* 660 * appldata_init() 661 * 662 * init timer, register /proc entries 663 */ 664 static int __init appldata_init(void) 665 { 666 int i; 667 668 P_DEBUG("sizeof(parameter_list) = %lu\n", 669 sizeof(struct appldata_parameter_list)); 670 671 appldata_wq = create_singlethread_workqueue("appldata"); 672 if (!appldata_wq) { 673 P_ERROR("Could not create work queue\n"); 674 return -ENOMEM; 675 } 676 677 for_each_online_cpu(i) 678 appldata_online_cpu(i); 679 680 /* Register cpu hotplug notifier */ 681 register_cpu_notifier(&appldata_nb); 682 683 appldata_sysctl_header = register_sysctl_table(appldata_dir_table, 1); 684 #ifdef MODULE 685 appldata_dir_table[0].de->owner = THIS_MODULE; 686 appldata_table[0].de->owner = THIS_MODULE; 687 appldata_table[1].de->owner = THIS_MODULE; 688 #endif 689 690 P_DEBUG("Base interface initialized.\n"); 691 return 0; 692 } 693 694 /* 695 * appldata_exit() 696 * 697 * stop timer, unregister /proc entries 698 */ 699 static void __exit appldata_exit(void) 700 { 701 struct list_head *lh; 702 struct appldata_ops *ops; 703 int rc, i; 704 705 P_DEBUG("Unloading module ...\n"); 706 /* 707 * ops list should be empty, but just in case something went wrong... 708 */ 709 spin_lock(&appldata_ops_lock); 710 list_for_each(lh, &appldata_ops_list) { 711 ops = list_entry(lh, struct appldata_ops, list); 712 rc = appldata_diag(ops->record_nr, APPLDATA_STOP_REC, 713 (unsigned long) ops->data, ops->size); 714 if (rc != 0) { 715 P_ERROR("STOP DIAG 0xDC for %s failed, " 716 "return code: %d\n", ops->name, rc); 717 } 718 } 719 spin_unlock(&appldata_ops_lock); 720 721 for_each_online_cpu(i) 722 appldata_offline_cpu(i); 723 724 appldata_timer_active = 0; 725 726 unregister_sysctl_table(appldata_sysctl_header); 727 728 destroy_workqueue(appldata_wq); 729 P_DEBUG("... module unloaded!\n"); 730 } 731 /**************************** init / exit <END> ******************************/ 732 733 734 module_init(appldata_init); 735 module_exit(appldata_exit); 736 MODULE_LICENSE("GPL"); 737 MODULE_AUTHOR("Gerald Schaefer"); 738 MODULE_DESCRIPTION("Linux-VM Monitor Stream, base infrastructure"); 739 740 EXPORT_SYMBOL_GPL(appldata_register_ops); 741 EXPORT_SYMBOL_GPL(appldata_unregister_ops); 742 743 #ifdef MODULE 744 /* 745 * Kernel symbols needed by appldata_mem and appldata_os modules. 746 * However, if this file is compiled as a module (for testing only), these 747 * symbols are not exported. In this case, we define them locally and export 748 * those. 749 */ 750 void si_swapinfo(struct sysinfo *val) 751 { 752 val->freeswap = -1ul; 753 val->totalswap = -1ul; 754 } 755 756 unsigned long avenrun[3] = {-1 - FIXED_1/200, -1 - FIXED_1/200, 757 -1 - FIXED_1/200}; 758 int nr_threads = -1; 759 760 void get_full_page_state(struct page_state *ps) 761 { 762 memset(ps, -1, sizeof(struct page_state)); 763 } 764 765 unsigned long nr_running(void) 766 { 767 return -1; 768 } 769 770 unsigned long nr_iowait(void) 771 { 772 return -1; 773 } 774 775 /*unsigned long nr_context_switches(void) 776 { 777 return -1; 778 }*/ 779 #endif /* MODULE */ 780 EXPORT_SYMBOL_GPL(si_swapinfo); 781 EXPORT_SYMBOL_GPL(nr_threads); 782 EXPORT_SYMBOL_GPL(avenrun); 783 EXPORT_SYMBOL_GPL(get_full_page_state); 784 EXPORT_SYMBOL_GPL(nr_running); 785 EXPORT_SYMBOL_GPL(nr_iowait); 786 //EXPORT_SYMBOL_GPL(nr_context_switches); 787