arch/s390/appldata/appldata_base.c

   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(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  * 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  */
  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  */
 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  */
 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  */
 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
 202 appldata_timer_handler(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
 235 appldata_interval_handler(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
 265 appldata_generic_handler(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  */
 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  */
 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  */
 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);