1/* 2 * Copyright (c) 2005-2006 Network Appliance, Inc. All rights reserved. 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the BSD-type 8 * license below: 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 14 * Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 17 * Redistributions in binary form must reproduce the above 18 * copyright notice, this list of conditions and the following 19 * disclaimer in the documentation and/or other materials provided 20 * with the distribution. 21 * 22 * Neither the name of the Network Appliance, Inc. nor the names of 23 * its contributors may be used to endorse or promote products 24 * derived from this software without specific prior written 25 * permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 30 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 31 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 32 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 33 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 34 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 35 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 36 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 37 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 38 * 39 * Author: Tom Tucker <tom@opengridcomputing.com> 40 */ 41#include <linux/module.h> 42#include <linux/init.h> 43#include <linux/slab.h> 44#include <linux/fs.h> 45#include <linux/sysctl.h> 46#include <linux/sunrpc/clnt.h> 47#include <linux/sunrpc/sched.h> 48#include <linux/sunrpc/svc_rdma.h> 49 50#define RPCDBG_FACILITY RPCDBG_SVCXPRT 51 52/* RPC/RDMA parameters */ 53unsigned int svcrdma_ord = RPCRDMA_ORD; 54static unsigned int min_ord = 1; 55static unsigned int max_ord = 4096; 56unsigned int svcrdma_max_requests = RPCRDMA_MAX_REQUESTS; 57static unsigned int min_max_requests = 4; 58static unsigned int max_max_requests = 16384; 59unsigned int svcrdma_max_req_size = RPCRDMA_MAX_REQ_SIZE; 60static unsigned int min_max_inline = 4096; 61static unsigned int max_max_inline = 65536; 62 63atomic_t rdma_stat_recv; 64atomic_t rdma_stat_read; 65atomic_t rdma_stat_write; 66atomic_t rdma_stat_sq_starve; 67atomic_t rdma_stat_rq_starve; 68atomic_t rdma_stat_rq_poll; 69atomic_t rdma_stat_rq_prod; 70atomic_t rdma_stat_sq_poll; 71atomic_t rdma_stat_sq_prod; 72 73/* Temporary NFS request map and context caches */ 74struct kmem_cache *svc_rdma_map_cachep; 75struct kmem_cache *svc_rdma_ctxt_cachep; 76 77/* 78 * This function implements reading and resetting an atomic_t stat 79 * variable through read/write to a proc file. Any write to the file 80 * resets the associated statistic to zero. Any read returns it's 81 * current value. 82 */ 83static int read_reset_stat(ctl_table *table, int write, 84 void __user *buffer, size_t *lenp, 85 loff_t *ppos) 86{ 87 atomic_t *stat = (atomic_t *)table->data; 88 89 if (!stat) 90 return -EINVAL; 91 92 if (write) 93 atomic_set(stat, 0); 94 else { 95 char str_buf[32]; 96 char *data; 97 int len = snprintf(str_buf, 32, "%d\n", atomic_read(stat)); 98 if (len >= 32) 99 return -EFAULT; 100 len = strlen(str_buf); 101 if (*ppos > len) { 102 *lenp = 0; 103 return 0; 104 } 105 data = &str_buf[*ppos]; 106 len -= *ppos; 107 if (len > *lenp) 108 len = *lenp; 109 if (len && copy_to_user(buffer, str_buf, len)) 110 return -EFAULT; 111 *lenp = len; 112 *ppos += len; 113 } 114 return 0; 115} 116 117static struct ctl_table_header *svcrdma_table_header; 118static ctl_table svcrdma_parm_table[] = { 119 { 120 .procname = "max_requests", 121 .data = &svcrdma_max_requests, 122 .maxlen = sizeof(unsigned int), 123 .mode = 0644, 124 .proc_handler = proc_dointvec_minmax, 125 .extra1 = &min_max_requests, 126 .extra2 = &max_max_requests 127 }, 128 { 129 .procname = "max_req_size", 130 .data = &svcrdma_max_req_size, 131 .maxlen = sizeof(unsigned int), 132 .mode = 0644, 133 .proc_handler = proc_dointvec_minmax, 134 .extra1 = &min_max_inline, 135 .extra2 = &max_max_inline 136 }, 137 { 138 .procname = "max_outbound_read_requests", 139 .data = &svcrdma_ord, 140 .maxlen = sizeof(unsigned int), 141 .mode = 0644, 142 .proc_handler = proc_dointvec_minmax, 143 .extra1 = &min_ord, 144 .extra2 = &max_ord, 145 }, 146 147 { 148 .procname = "rdma_stat_read", 149 .data = &rdma_stat_read, 150 .maxlen = sizeof(atomic_t), 151 .mode = 0644, 152 .proc_handler = read_reset_stat, 153 }, 154 { 155 .procname = "rdma_stat_recv", 156 .data = &rdma_stat_recv, 157 .maxlen = sizeof(atomic_t), 158 .mode = 0644, 159 .proc_handler = read_reset_stat, 160 }, 161 { 162 .procname = "rdma_stat_write", 163 .data = &rdma_stat_write, 164 .maxlen = sizeof(atomic_t), 165 .mode = 0644, 166 .proc_handler = read_reset_stat, 167 }, 168 { 169 .procname = "rdma_stat_sq_starve", 170 .data = &rdma_stat_sq_starve, 171 .maxlen = sizeof(atomic_t), 172 .mode = 0644, 173 .proc_handler = read_reset_stat, 174 }, 175 { 176 .procname = "rdma_stat_rq_starve", 177 .data = &rdma_stat_rq_starve, 178 .maxlen = sizeof(atomic_t), 179 .mode = 0644, 180 .proc_handler = read_reset_stat, 181 }, 182 { 183 .procname = "rdma_stat_rq_poll", 184 .data = &rdma_stat_rq_poll, 185 .maxlen = sizeof(atomic_t), 186 .mode = 0644, 187 .proc_handler = read_reset_stat, 188 }, 189 { 190 .procname = "rdma_stat_rq_prod", 191 .data = &rdma_stat_rq_prod, 192 .maxlen = sizeof(atomic_t), 193 .mode = 0644, 194 .proc_handler = read_reset_stat, 195 }, 196 { 197 .procname = "rdma_stat_sq_poll", 198 .data = &rdma_stat_sq_poll, 199 .maxlen = sizeof(atomic_t), 200 .mode = 0644, 201 .proc_handler = read_reset_stat, 202 }, 203 { 204 .procname = "rdma_stat_sq_prod", 205 .data = &rdma_stat_sq_prod, 206 .maxlen = sizeof(atomic_t), 207 .mode = 0644, 208 .proc_handler = read_reset_stat, 209 }, 210 { }, 211}; 212 213static ctl_table svcrdma_table[] = { 214 { 215 .procname = "svc_rdma", 216 .mode = 0555, 217 .child = svcrdma_parm_table 218 }, 219 { }, 220}; 221 222static ctl_table svcrdma_root_table[] = { 223 { 224 .procname = "sunrpc", 225 .mode = 0555, 226 .child = svcrdma_table 227 }, 228 { }, 229}; 230 231void svc_rdma_cleanup(void) 232{ 233 dprintk("SVCRDMA Module Removed, deregister RPC RDMA transport\n"); 234 flush_scheduled_work(); 235 if (svcrdma_table_header) { 236 unregister_sysctl_table(svcrdma_table_header); 237 svcrdma_table_header = NULL; 238 } 239 svc_unreg_xprt_class(&svc_rdma_class); 240 kmem_cache_destroy(svc_rdma_map_cachep); 241 kmem_cache_destroy(svc_rdma_ctxt_cachep); 242} 243 244int svc_rdma_init(void) 245{ 246 dprintk("SVCRDMA Module Init, register RPC RDMA transport\n"); 247 dprintk("\tsvcrdma_ord : %d\n", svcrdma_ord); 248 dprintk("\tmax_requests : %d\n", svcrdma_max_requests); 249 dprintk("\tsq_depth : %d\n", 250 svcrdma_max_requests * RPCRDMA_SQ_DEPTH_MULT); 251 dprintk("\tmax_inline : %d\n", svcrdma_max_req_size); 252 if (!svcrdma_table_header) 253 svcrdma_table_header = 254 register_sysctl_table(svcrdma_root_table); 255 256 /* Create the temporary map cache */ 257 svc_rdma_map_cachep = kmem_cache_create("svc_rdma_map_cache", 258 sizeof(struct svc_rdma_req_map), 259 0, 260 SLAB_HWCACHE_ALIGN, 261 NULL); 262 if (!svc_rdma_map_cachep) { 263 printk(KERN_INFO "Could not allocate map cache.\n"); 264 goto err0; 265 } 266 267 /* Create the temporary context cache */ 268 svc_rdma_ctxt_cachep = 269 kmem_cache_create("svc_rdma_ctxt_cache", 270 sizeof(struct svc_rdma_op_ctxt), 271 0, 272 SLAB_HWCACHE_ALIGN, 273 NULL); 274 if (!svc_rdma_ctxt_cachep) { 275 printk(KERN_INFO "Could not allocate WR ctxt cache.\n"); 276 goto err1; 277 } 278 279 /* Register RDMA with the SVC transport switch */ 280 svc_reg_xprt_class(&svc_rdma_class); 281 return 0; 282 err1: 283 kmem_cache_destroy(svc_rdma_map_cachep); 284 err0: 285 unregister_sysctl_table(svcrdma_table_header); 286 return -ENOMEM; 287} 288MODULE_AUTHOR("Tom Tucker <tom@opengridcomputing.com>"); 289MODULE_DESCRIPTION("SVC RDMA Transport"); 290MODULE_LICENSE("Dual BSD/GPL"); 291module_init(svc_rdma_init); 292module_exit(svc_rdma_cleanup); 293