~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/sunrpc/xprtrdma/svc_rdma.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 42 #include <linux/slab.h>
 43 #include <linux/fs.h>
 44 #include <linux/sysctl.h>
 45 #include <linux/workqueue.h>
 46 #include <linux/sunrpc/clnt.h>
 47 #include <linux/sunrpc/sched.h>
 48 #include <linux/sunrpc/svc_rdma.h>
 49 #include "xprt_rdma.h"
 50 
 51 #define RPCDBG_FACILITY RPCDBG_SVCXPRT
 52 
 53 /* RPC/RDMA parameters */
 54 unsigned int svcrdma_ord = RPCRDMA_ORD;
 55 static unsigned int min_ord = 1;
 56 static unsigned int max_ord = 4096;
 57 unsigned int svcrdma_max_requests = RPCRDMA_MAX_REQUESTS;
 58 static unsigned int min_max_requests = 4;
 59 static unsigned int max_max_requests = 16384;
 60 unsigned int svcrdma_max_req_size = RPCRDMA_MAX_REQ_SIZE;
 61 static unsigned int min_max_inline = 4096;
 62 static unsigned int max_max_inline = 65536;
 63 
 64 atomic_t rdma_stat_recv;
 65 atomic_t rdma_stat_read;
 66 atomic_t rdma_stat_write;
 67 atomic_t rdma_stat_sq_starve;
 68 atomic_t rdma_stat_rq_starve;
 69 atomic_t rdma_stat_rq_poll;
 70 atomic_t rdma_stat_rq_prod;
 71 atomic_t rdma_stat_sq_poll;
 72 atomic_t rdma_stat_sq_prod;
 73 
 74 /* Temporary NFS request map and context caches */
 75 struct kmem_cache *svc_rdma_map_cachep;
 76 struct kmem_cache *svc_rdma_ctxt_cachep;
 77 
 78 struct workqueue_struct *svc_rdma_wq;
 79 
 80 /*
 81  * This function implements reading and resetting an atomic_t stat
 82  * variable through read/write to a proc file. Any write to the file
 83  * resets the associated statistic to zero. Any read returns it's
 84  * current value.
 85  */
 86 static int read_reset_stat(struct ctl_table *table, int write,
 87                            void __user *buffer, size_t *lenp,
 88                            loff_t *ppos)
 89 {
 90         atomic_t *stat = (atomic_t *)table->data;
 91 
 92         if (!stat)
 93                 return -EINVAL;
 94 
 95         if (write)
 96                 atomic_set(stat, 0);
 97         else {
 98                 char str_buf[32];
 99                 char *data;
100                 int len = snprintf(str_buf, 32, "%d\n", atomic_read(stat));
101                 if (len >= 32)
102                         return -EFAULT;
103                 len = strlen(str_buf);
104                 if (*ppos > len) {
105                         *lenp = 0;
106                         return 0;
107                 }
108                 data = &str_buf[*ppos];
109                 len -= *ppos;
110                 if (len > *lenp)
111                         len = *lenp;
112                 if (len && copy_to_user(buffer, str_buf, len))
113                         return -EFAULT;
114                 *lenp = len;
115                 *ppos += len;
116         }
117         return 0;
118 }
119 
120 static struct ctl_table_header *svcrdma_table_header;
121 static struct ctl_table svcrdma_parm_table[] = {
122         {
123                 .procname       = "max_requests",
124                 .data           = &svcrdma_max_requests,
125                 .maxlen         = sizeof(unsigned int),
126                 .mode           = 0644,
127                 .proc_handler   = proc_dointvec_minmax,
128                 .extra1         = &min_max_requests,
129                 .extra2         = &max_max_requests
130         },
131         {
132                 .procname       = "max_req_size",
133                 .data           = &svcrdma_max_req_size,
134                 .maxlen         = sizeof(unsigned int),
135                 .mode           = 0644,
136                 .proc_handler   = proc_dointvec_minmax,
137                 .extra1         = &min_max_inline,
138                 .extra2         = &max_max_inline
139         },
140         {
141                 .procname       = "max_outbound_read_requests",
142                 .data           = &svcrdma_ord,
143                 .maxlen         = sizeof(unsigned int),
144                 .mode           = 0644,
145                 .proc_handler   = proc_dointvec_minmax,
146                 .extra1         = &min_ord,
147                 .extra2         = &max_ord,
148         },
149 
150         {
151                 .procname       = "rdma_stat_read",
152                 .data           = &rdma_stat_read,
153                 .maxlen         = sizeof(atomic_t),
154                 .mode           = 0644,
155                 .proc_handler   = read_reset_stat,
156         },
157         {
158                 .procname       = "rdma_stat_recv",
159                 .data           = &rdma_stat_recv,
160                 .maxlen         = sizeof(atomic_t),
161                 .mode           = 0644,
162                 .proc_handler   = read_reset_stat,
163         },
164         {
165                 .procname       = "rdma_stat_write",
166                 .data           = &rdma_stat_write,
167                 .maxlen         = sizeof(atomic_t),
168                 .mode           = 0644,
169                 .proc_handler   = read_reset_stat,
170         },
171         {
172                 .procname       = "rdma_stat_sq_starve",
173                 .data           = &rdma_stat_sq_starve,
174                 .maxlen         = sizeof(atomic_t),
175                 .mode           = 0644,
176                 .proc_handler   = read_reset_stat,
177         },
178         {
179                 .procname       = "rdma_stat_rq_starve",
180                 .data           = &rdma_stat_rq_starve,
181                 .maxlen         = sizeof(atomic_t),
182                 .mode           = 0644,
183                 .proc_handler   = read_reset_stat,
184         },
185         {
186                 .procname       = "rdma_stat_rq_poll",
187                 .data           = &rdma_stat_rq_poll,
188                 .maxlen         = sizeof(atomic_t),
189                 .mode           = 0644,
190                 .proc_handler   = read_reset_stat,
191         },
192         {
193                 .procname       = "rdma_stat_rq_prod",
194                 .data           = &rdma_stat_rq_prod,
195                 .maxlen         = sizeof(atomic_t),
196                 .mode           = 0644,
197                 .proc_handler   = read_reset_stat,
198         },
199         {
200                 .procname       = "rdma_stat_sq_poll",
201                 .data           = &rdma_stat_sq_poll,
202                 .maxlen         = sizeof(atomic_t),
203                 .mode           = 0644,
204                 .proc_handler   = read_reset_stat,
205         },
206         {
207                 .procname       = "rdma_stat_sq_prod",
208                 .data           = &rdma_stat_sq_prod,
209                 .maxlen         = sizeof(atomic_t),
210                 .mode           = 0644,
211                 .proc_handler   = read_reset_stat,
212         },
213         { },
214 };
215 
216 static struct ctl_table svcrdma_table[] = {
217         {
218                 .procname       = "svc_rdma",
219                 .mode           = 0555,
220                 .child          = svcrdma_parm_table
221         },
222         { },
223 };
224 
225 static struct ctl_table svcrdma_root_table[] = {
226         {
227                 .procname       = "sunrpc",
228                 .mode           = 0555,
229                 .child          = svcrdma_table
230         },
231         { },
232 };
233 
234 void svc_rdma_cleanup(void)
235 {
236         dprintk("SVCRDMA Module Removed, deregister RPC RDMA transport\n");
237         destroy_workqueue(svc_rdma_wq);
238         if (svcrdma_table_header) {
239                 unregister_sysctl_table(svcrdma_table_header);
240                 svcrdma_table_header = NULL;
241         }
242         svc_unreg_xprt_class(&svc_rdma_class);
243         kmem_cache_destroy(svc_rdma_map_cachep);
244         kmem_cache_destroy(svc_rdma_ctxt_cachep);
245 }
246 
247 int svc_rdma_init(void)
248 {
249         dprintk("SVCRDMA Module Init, register RPC RDMA transport\n");
250         dprintk("\tsvcrdma_ord      : %d\n", svcrdma_ord);
251         dprintk("\tmax_requests     : %d\n", svcrdma_max_requests);
252         dprintk("\tsq_depth         : %d\n",
253                 svcrdma_max_requests * RPCRDMA_SQ_DEPTH_MULT);
254         dprintk("\tmax_inline       : %d\n", svcrdma_max_req_size);
255 
256         svc_rdma_wq = alloc_workqueue("svc_rdma", 0, 0);
257         if (!svc_rdma_wq)
258                 return -ENOMEM;
259 
260         if (!svcrdma_table_header)
261                 svcrdma_table_header =
262                         register_sysctl_table(svcrdma_root_table);
263 
264         /* Create the temporary map cache */
265         svc_rdma_map_cachep = kmem_cache_create("svc_rdma_map_cache",
266                                                 sizeof(struct svc_rdma_req_map),
267                                                 0,
268                                                 SLAB_HWCACHE_ALIGN,
269                                                 NULL);
270         if (!svc_rdma_map_cachep) {
271                 printk(KERN_INFO "Could not allocate map cache.\n");
272                 goto err0;
273         }
274 
275         /* Create the temporary context cache */
276         svc_rdma_ctxt_cachep =
277                 kmem_cache_create("svc_rdma_ctxt_cache",
278                                   sizeof(struct svc_rdma_op_ctxt),
279                                   0,
280                                   SLAB_HWCACHE_ALIGN,
281                                   NULL);
282         if (!svc_rdma_ctxt_cachep) {
283                 printk(KERN_INFO "Could not allocate WR ctxt cache.\n");
284                 goto err1;
285         }
286 
287         /* Register RDMA with the SVC transport switch */
288         svc_reg_xprt_class(&svc_rdma_class);
289         return 0;
290  err1:
291         kmem_cache_destroy(svc_rdma_map_cachep);
292  err0:
293         unregister_sysctl_table(svcrdma_table_header);
294         destroy_workqueue(svc_rdma_wq);
295         return -ENOMEM;
296 }
297 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp