| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Melissa Howland | 1386 | 92.96% | 7 | 25.93% |
| Martin Schwidefsky | 68 | 4.56% | 2 | 7.41% |
| Heiko Carstens | 11 | 0.74% | 5 | 18.52% |
| Gerald Schaefer | 8 | 0.54% | 3 | 11.11% |
| Arnd Bergmann | 5 | 0.34% | 1 | 3.70% |
| Kees Cook | 4 | 0.27% | 1 | 3.70% |
| Linus Torvalds | 2 | 0.13% | 2 | 7.41% |
| Linus Torvalds (pre-git) | 2 | 0.13% | 1 | 3.70% |
| Arjan van de Ven | 1 | 0.07% | 1 | 3.70% |
| Joe Perches | 1 | 0.07% | 1 | 3.70% |
| Peter Oberparleiter | 1 | 0.07% | 1 | 3.70% |
| Greg Kroah-Hartman | 1 | 0.07% | 1 | 3.70% |
| Vasily Gorbik | 1 | 0.07% | 1 | 3.70% |
| Total | 1491 | 27 |
// SPDX-License-Identifier: GPL-2.0 /* * Character device driver for writing z/VM *MONITOR service records. * * Copyright IBM Corp. 2006, 2009 * * Author(s): Melissa Howland <Melissa.Howland@us.ibm.com> */ #define pr_fmt(fmt) "monwriter: " fmt #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/init.h> #include <linux/errno.h> #include <linux/types.h> #include <linux/kernel.h> #include <linux/miscdevice.h> #include <linux/ctype.h> #include <linux/poll.h> #include <linux/mutex.h> #include <linux/slab.h> #include <linux/uaccess.h> #include <linux/io.h> #include <asm/machine.h> #include <asm/ebcdic.h> #include <asm/appldata.h> #include <asm/monwriter.h> #define MONWRITE_MAX_DATALEN 4010 static int mon_max_bufs = 255; static int mon_buf_count; struct mon_buf { struct list_head list; struct monwrite_hdr hdr; int diag_done; char *data; }; struct mon_private { struct list_head list; struct monwrite_hdr hdr; size_t hdr_to_read; size_t data_to_read; struct mon_buf *current_buf; struct mutex thread_mutex; }; /* * helper functions */ static int monwrite_diag(struct monwrite_hdr *myhdr, char *buffer, int fcn) { struct appldata_parameter_list *parm_list; struct appldata_product_id *id; int rc; id = kmalloc_obj(*id); parm_list = kmalloc_obj(*parm_list); rc = -ENOMEM; if (!id || !parm_list) goto out; memcpy(id->prod_nr, "LNXAPPL", 7); id->prod_fn = myhdr->applid; id->record_nr = myhdr->record_num; id->version_nr = myhdr->version; id->release_nr = myhdr->release; id->mod_lvl = myhdr->mod_level; rc = appldata_asm(parm_list, id, fcn, (void *) buffer, myhdr->datalen); if (rc <= 0) goto out; pr_err("Writing monitor data failed with rc=%i\n", rc); rc = (rc == 5) ? -EPERM : -EINVAL; out: kfree(id); kfree(parm_list); return rc; } static struct mon_buf *monwrite_find_hdr(struct mon_private *monpriv, struct monwrite_hdr *monhdr) { struct mon_buf *entry, *next; list_for_each_entry_safe(entry, next, &monpriv->list, list) if ((entry->hdr.mon_function == monhdr->mon_function || monhdr->mon_function == MONWRITE_STOP_INTERVAL) && entry->hdr.applid == monhdr->applid && entry->hdr.record_num == monhdr->record_num && entry->hdr.version == monhdr->version && entry->hdr.release == monhdr->release && entry->hdr.mod_level == monhdr->mod_level) return entry; return NULL; } static int monwrite_new_hdr(struct mon_private *monpriv) { struct monwrite_hdr *monhdr = &monpriv->hdr; struct mon_buf *monbuf; int rc = 0; if (monhdr->datalen > MONWRITE_MAX_DATALEN || monhdr->mon_function > MONWRITE_START_CONFIG || monhdr->hdrlen != sizeof(struct monwrite_hdr)) return -EINVAL; monbuf = NULL; if (monhdr->mon_function != MONWRITE_GEN_EVENT) monbuf = monwrite_find_hdr(monpriv, monhdr); if (monbuf) { if (monhdr->mon_function == MONWRITE_STOP_INTERVAL) { monhdr->datalen = monbuf->hdr.datalen; rc = monwrite_diag(monhdr, monbuf->data, APPLDATA_STOP_REC); list_del(&monbuf->list); mon_buf_count--; kfree(monbuf->data); kfree(monbuf); monbuf = NULL; } } else if (monhdr->mon_function != MONWRITE_STOP_INTERVAL) { if (mon_buf_count >= mon_max_bufs) return -ENOSPC; monbuf = kzalloc_obj(struct mon_buf); if (!monbuf) return -ENOMEM; monbuf->data = kzalloc(monhdr->datalen, GFP_KERNEL | GFP_DMA); if (!monbuf->data) { kfree(monbuf); return -ENOMEM; } monbuf->hdr = *monhdr; list_add_tail(&monbuf->list, &monpriv->list); if (monhdr->mon_function != MONWRITE_GEN_EVENT) mon_buf_count++; } monpriv->current_buf = monbuf; return rc; } static int monwrite_new_data(struct mon_private *monpriv) { struct monwrite_hdr *monhdr = &monpriv->hdr; struct mon_buf *monbuf = monpriv->current_buf; int rc = 0; switch (monhdr->mon_function) { case MONWRITE_START_INTERVAL: if (!monbuf->diag_done) { rc = monwrite_diag(monhdr, monbuf->data, APPLDATA_START_INTERVAL_REC); monbuf->diag_done = 1; } break; case MONWRITE_START_CONFIG: if (!monbuf->diag_done) { rc = monwrite_diag(monhdr, monbuf->data, APPLDATA_START_CONFIG_REC); monbuf->diag_done = 1; } break; case MONWRITE_GEN_EVENT: rc = monwrite_diag(monhdr, monbuf->data, APPLDATA_GEN_EVENT_REC); list_del(&monpriv->current_buf->list); kfree(monpriv->current_buf->data); kfree(monpriv->current_buf); monpriv->current_buf = NULL; break; default: /* monhdr->mon_function is checked in monwrite_new_hdr */ BUG(); } return rc; } /* * file operations */ static int monwrite_open(struct inode *inode, struct file *filp) { struct mon_private *monpriv; monpriv = kzalloc_obj(struct mon_private); if (!monpriv) return -ENOMEM; INIT_LIST_HEAD(&monpriv->list); monpriv->hdr_to_read = sizeof(monpriv->hdr); mutex_init(&monpriv->thread_mutex); filp->private_data = monpriv; return nonseekable_open(inode, filp); } static int monwrite_close(struct inode *inode, struct file *filp) { struct mon_private *monpriv = filp->private_data; struct mon_buf *entry, *next; list_for_each_entry_safe(entry, next, &monpriv->list, list) { if (entry->hdr.mon_function != MONWRITE_GEN_EVENT) monwrite_diag(&entry->hdr, entry->data, APPLDATA_STOP_REC); mon_buf_count--; list_del(&entry->list); kfree(entry->data); kfree(entry); } kfree(monpriv); return 0; } static ssize_t monwrite_write(struct file *filp, const char __user *data, size_t count, loff_t *ppos) { struct mon_private *monpriv = filp->private_data; size_t len, written; void *to; int rc; mutex_lock(&monpriv->thread_mutex); for (written = 0; written < count; ) { if (monpriv->hdr_to_read) { len = min(count - written, monpriv->hdr_to_read); to = (char *) &monpriv->hdr + sizeof(monpriv->hdr) - monpriv->hdr_to_read; if (copy_from_user(to, data + written, len)) { rc = -EFAULT; goto out_error; } monpriv->hdr_to_read -= len; written += len; if (monpriv->hdr_to_read > 0) continue; rc = monwrite_new_hdr(monpriv); if (rc) goto out_error; monpriv->data_to_read = monpriv->current_buf ? monpriv->current_buf->hdr.datalen : 0; } if (monpriv->data_to_read) { len = min(count - written, monpriv->data_to_read); to = monpriv->current_buf->data + monpriv->hdr.datalen - monpriv->data_to_read; if (copy_from_user(to, data + written, len)) { rc = -EFAULT; goto out_error; } monpriv->data_to_read -= len; written += len; if (monpriv->data_to_read > 0) continue; rc = monwrite_new_data(monpriv); if (rc) goto out_error; } monpriv->hdr_to_read = sizeof(monpriv->hdr); } mutex_unlock(&monpriv->thread_mutex); return written; out_error: monpriv->data_to_read = 0; monpriv->hdr_to_read = sizeof(struct monwrite_hdr); mutex_unlock(&monpriv->thread_mutex); return rc; } static const struct file_operations monwrite_fops = { .owner = THIS_MODULE, .open = &monwrite_open, .release = &monwrite_close, .write = &monwrite_write, .llseek = noop_llseek, }; static struct miscdevice mon_dev = { .name = "monwriter", .fops = &monwrite_fops, .minor = MISC_DYNAMIC_MINOR, }; /* * module init/exit */ static int __init mon_init(void) { if (!machine_is_vm()) return -ENODEV; /* * misc_register() has to be the last action in module_init(), because * file operations will be available right after this. */ return misc_register(&mon_dev); } static void __exit mon_exit(void) { misc_deregister(&mon_dev); } module_init(mon_init); module_exit(mon_exit); module_param_named(max_bufs, mon_max_bufs, int, 0644); MODULE_PARM_DESC(max_bufs, "Maximum number of sample monitor data buffers " "that can be active at one time"); MODULE_AUTHOR("Melissa Howland <Melissa.Howland@us.ibm.com>"); MODULE_DESCRIPTION("Character device driver for writing z/VM " "APPLDATA monitor records."); MODULE_LICENSE("GPL");