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