litmus-rt.git - The LITMUS^RT kernel.

diff options

author	K. Y. Srinivasan <kys@microsoft.com>	2014-02-13 19:24:33 -0500
committer	Greg Kroah-Hartman <gregkh@linuxfoundation.org>	2014-02-15 15:08:38 -0500
commit	5dba4c56dfa660a85dc8e897990948cdec3734bf (patch)
tree	550921e5e327327eed124949ac577ffd6b8f58a2 /drivers/misc/lattice-ecp3-config.c
parent	0b336cea56ccd9949dc9bd6f24bd3bb9d212ffad (diff)

Drivers: hv: Ballon: Make pressure posting thread sleep interruptibly

The non-interruptible sleep of the memory pressure posting thread results in higher reported load average. Make this sleep interruptible. Signed-off-by: K. Y. Srinivasan <kys@microsoft.com> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Diffstat (limited to 'drivers/misc/lattice-ecp3-config.c')

0 files changed, 0 insertions, 0 deletions

/* * zfcp device driver * * Module interface and handling of zfcp data structures. * * Copyright IBM Corp. 2002, 2013 */ /* * Driver authors: * Martin Peschke (originator of the driver) * Raimund Schroeder * Aron Zeh * Wolfgang Taphorn * Stefan Bader * Heiko Carstens (kernel 2.6 port of the driver) * Andreas Herrmann * Maxim Shchetynin * Volker Sameske * Ralph Wuerthner * Michael Loehr * Swen Schillig * Christof Schmitt * Martin Petermann * Sven Schuetz * Steffen Maier */ #define KMSG_COMPONENT "zfcp" #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt #include <linux/miscdevice.h> #include <linux/seq_file.h> #include <linux/slab.h> #include <linux/module.h> #include "zfcp_ext.h" #include "zfcp_fc.h" #include "zfcp_reqlist.h" #define ZFCP_BUS_ID_SIZE 20 MODULE_AUTHOR("IBM Deutschland Entwicklung GmbH - linux390@de.ibm.com"); MODULE_DESCRIPTION("FCP HBA driver"); MODULE_LICENSE("GPL"); static char *init_device; module_param_named(device, init_device, charp, 0400); MODULE_PARM_DESC(device, "specify initial device"); static struct kmem_cache * __init zfcp_cache_hw_align(const char *name, unsigned long size) { return kmem_cache_create(name, size, roundup_pow_of_two(size), 0, NULL); } static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun) { struct ccw_device *cdev; struct zfcp_adapter *adapter; struct zfcp_port *port; cdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid); if (!cdev) return; if (ccw_device_set_online(cdev)) goto out_ccw_device; adapter = zfcp_ccw_adapter_by_cdev(cdev); if (!adapter) goto out_ccw_device; port = zfcp_get_port_by_wwpn(adapter, wwpn); if (!port) goto out_port; flush_work(&port->rport_work); zfcp_unit_add(port, lun); put_device(&port->dev); out_port: zfcp_ccw_adapter_put(adapter); out_ccw_device: put_device(&cdev->dev); return; } static void __init zfcp_init_device_setup(char *devstr) { char *token; char *str, *str_saved; char busid[ZFCP_BUS_ID_SIZE]; u64 wwpn, lun; /* duplicate devstr and keep the original for sysfs presentation*/ str_saved = kstrdup(devstr, GFP_KERNEL); str = str_saved; if (!str) return; token = strsep(&str, ","); if (!token || strlen(token) >= ZFCP_BUS_ID_SIZE) goto err_out; strncpy(busid, token, ZFCP_BUS_ID_SIZE); token = strsep(&str, ","); if (!token || kstrtoull(token, 0, (unsigned long long *) &wwpn)) goto err_out; token = strsep(&str, ","); if (!token || kstrtoull(token, 0, (unsigned long long *) &lun)) goto err_out; kfree(str_saved); zfcp_init_device_configure(busid, wwpn, lun); return; err_out: kfree(str_saved); pr_err("%s is not a valid SCSI device\n", devstr); } static int __init zfcp_module_init(void) { int retval = -ENOMEM; zfcp_fsf_qtcb_cache = zfcp_cache_hw_align("zfcp_fsf_qtcb", sizeof(struct fsf_qtcb)); if (!zfcp_fsf_qtcb_cache) goto out_qtcb_cache; zfcp_fc_req_cache = zfcp_cache_hw_align("zfcp_fc_req", sizeof(struct zfcp_fc_req)); if (!zfcp_fc_req_cache) goto out_fc_cache; zfcp_scsi_transport_template = fc_attach_transport(&zfcp_transport_functions); if (!zfcp_scsi_transport_template) goto out_transport; scsi_transport_reserve_device(zfcp_scsi_transport_template, sizeof(struct zfcp_scsi_dev)); retval = ccw_driver_register(&zfcp_ccw_driver); if (retval) { pr_err("The zfcp device driver could not register with " "the common I/O layer\n"); goto out_ccw_register; } if (init_device) zfcp_init_device_setup(init_device); return 0; out_ccw_register: fc_release_transport(zfcp_scsi_transport_template); out_transport: kmem_cache_destroy(zfcp_fc_req_cache); out_fc_cache: kmem_cache_destroy(zfcp_fsf_qtcb_cache); out_qtcb_cache: return retval; } module_init(zfcp_module_init); static void __exit zfcp_module_exit(void) { ccw_driver_unregister(&zfcp_ccw_driver); fc_release_transport(zfcp_scsi_transport_template); kmem_cache_destroy(zfcp_fc_req_cache); kmem_cache_destroy(zfcp_fsf_qtcb_cache); } module_exit(zfcp_module_exit); /** * zfcp_get_port_by_wwpn - find port in port list of adapter by wwpn * @adapter: pointer to adapter to search for port * @wwpn: wwpn to search for * * Returns: pointer to zfcp_port or NULL */ struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter, u64 wwpn) { unsigned long flags; struct zfcp_port *port; read_lock_irqsave(&adapter->port_list_lock, flags); list_for_each_entry(port, &adapter->port_list, list) if (port->wwpn == wwpn) { if (!get_device(&port->dev)) port = NULL; read_unlock_irqrestore(&adapter->port_list_lock, flags); return port; } read_unlock_irqrestore(&adapter->port_list_lock, flags); return NULL; } static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter) { adapter->pool.erp_req = mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req)); if (!adapter->pool.erp_req) return -ENOMEM; adapter->pool.gid_pn_req = mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req)); if (!adapter->pool.gid_pn_req) return -ENOMEM; adapter->pool.scsi_req = mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req)); if (!adapter->pool.scsi_req) return -ENOMEM; adapter->pool.scsi_abort = mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req)); if (!adapter->pool.scsi_abort) return -ENOMEM; adapter->pool.status_read_req = mempool_create_kmalloc_pool(FSF_STATUS_READS_RECOM, sizeof(struct zfcp_fsf_req)); if (!adapter->pool.status_read_req) return -ENOMEM; adapter->pool.qtcb_pool = mempool_create_slab_pool(4, zfcp_fsf_qtcb_cache); if (!adapter->pool.qtcb_pool) return -ENOMEM; BUILD_BUG_ON(sizeof(struct fsf_status_read_buffer) > PAGE_SIZE); adapter->pool.sr_data = mempool_create_page_pool(FSF_STATUS_READS_RECOM, 0); if (!adapter->pool.sr_data) return -ENOMEM; adapter->pool.gid_pn = mempool_create_slab_pool(1, zfcp_fc_req_cache); if (!adapter->pool.gid_pn) return -ENOMEM; return 0; } static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter) { if (adapter->pool.erp_req)


context:
space:
mode: