Branch data     Line data    Source code

       1                 :            : /******************************************************************************
       2                 :            : 
       3                 :            : (c) 2007 Network Appliance, Inc.  All Rights Reserved.
       4                 :            : (c) 2009 NetApp.  All Rights Reserved.
       5                 :            : 
       6                 :            : NetApp provides this source code under the GPL v2 License.
       7                 :            : The GPL v2 license is available at
       8                 :            : http://opensource.org/licenses/gpl-license.php.
       9                 :            : 
      10                 :            : THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      11                 :            : "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      12                 :            : LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      13                 :            : A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
      14                 :            : CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
      15                 :            : EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
      16                 :            : PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
      17                 :            : PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
      18                 :            : LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
      19                 :            : NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
      20                 :            : SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      21                 :            : 
      22                 :            : ******************************************************************************/
      23                 :            : 
      24                 :            : #include <linux/tcp.h>
      25                 :            : #include <linux/slab.h>
      26                 :            : #include <linux/sunrpc/xprt.h>
      27                 :            : #include <linux/export.h>
      28                 :            : #include <linux/sunrpc/bc_xprt.h>
      29                 :            : 
      30                 :            : #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
      31                 :            : #define RPCDBG_FACILITY RPCDBG_TRANS
      32                 :            : #endif
      33                 :            : 
      34                 :            : #define BC_MAX_SLOTS    64U
      35                 :            : 
      36                 :          0 : unsigned int xprt_bc_max_slots(struct rpc_xprt *xprt)
      37                 :            : {
      38                 :          0 :         return BC_MAX_SLOTS;
      39                 :            : }
      40                 :            : 
      41                 :            : /*
      42                 :            :  * Helper routines that track the number of preallocation elements
      43                 :            :  * on the transport.
      44                 :            :  */
      45                 :            : static inline int xprt_need_to_requeue(struct rpc_xprt *xprt)
      46                 :            : {
      47                 :          0 :         return xprt->bc_alloc_count < xprt->bc_alloc_max;
      48                 :            : }
      49                 :            : 
      50                 :            : /*
      51                 :            :  * Free the preallocated rpc_rqst structure and the memory
      52                 :            :  * buffers hanging off of it.
      53                 :            :  */
      54                 :          0 : static void xprt_free_allocation(struct rpc_rqst *req)
      55                 :            : {
      56                 :            :         struct xdr_buf *xbufp;
      57                 :            : 
      58                 :            :         dprintk("RPC:        free allocations for req= %p\n", req);
      59                 :          0 :         WARN_ON_ONCE(test_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state));
      60                 :            :         xbufp = &req->rq_rcv_buf;
      61                 :          0 :         free_page((unsigned long)xbufp->head[0].iov_base);
      62                 :            :         xbufp = &req->rq_snd_buf;
      63                 :          0 :         free_page((unsigned long)xbufp->head[0].iov_base);
      64                 :          0 :         kfree(req);
      65                 :          0 : }
      66                 :            : 
      67                 :          0 : static int xprt_alloc_xdr_buf(struct xdr_buf *buf, gfp_t gfp_flags)
      68                 :            : {
      69                 :            :         struct page *page;
      70                 :            :         /* Preallocate one XDR receive buffer */
      71                 :            :         page = alloc_page(gfp_flags);
      72                 :          0 :         if (page == NULL)
      73                 :            :                 return -ENOMEM;
      74                 :            :         xdr_buf_init(buf, page_address(page), PAGE_SIZE);
      75                 :          0 :         return 0;
      76                 :            : }
      77                 :            : 
      78                 :            : static
      79                 :          0 : struct rpc_rqst *xprt_alloc_bc_req(struct rpc_xprt *xprt, gfp_t gfp_flags)
      80                 :            : {
      81                 :            :         struct rpc_rqst *req;
      82                 :            : 
      83                 :            :         /* Pre-allocate one backchannel rpc_rqst */
      84                 :          0 :         req = kzalloc(sizeof(*req), gfp_flags);
      85                 :          0 :         if (req == NULL)
      86                 :            :                 return NULL;
      87                 :            : 
      88                 :          0 :         req->rq_xprt = xprt;
      89                 :          0 :         INIT_LIST_HEAD(&req->rq_bc_list);
      90                 :            : 
      91                 :            :         /* Preallocate one XDR receive buffer */
      92                 :          0 :         if (xprt_alloc_xdr_buf(&req->rq_rcv_buf, gfp_flags) < 0) {
      93                 :          0 :                 printk(KERN_ERR "Failed to create bc receive xbuf\n");
      94                 :          0 :                 goto out_free;
      95                 :            :         }
      96                 :          0 :         req->rq_rcv_buf.len = PAGE_SIZE;
      97                 :            : 
      98                 :            :         /* Preallocate one XDR send buffer */
      99                 :          0 :         if (xprt_alloc_xdr_buf(&req->rq_snd_buf, gfp_flags) < 0) {
     100                 :          0 :                 printk(KERN_ERR "Failed to create bc snd xbuf\n");
     101                 :          0 :                 goto out_free;
     102                 :            :         }
     103                 :            :         return req;
     104                 :            : out_free:
     105                 :          0 :         xprt_free_allocation(req);
     106                 :          0 :         return NULL;
     107                 :            : }
     108                 :            : 
     109                 :            : /*
     110                 :            :  * Preallocate up to min_reqs structures and related buffers for use
     111                 :            :  * by the backchannel.  This function can be called multiple times
     112                 :            :  * when creating new sessions that use the same rpc_xprt.  The
     113                 :            :  * preallocated buffers are added to the pool of resources used by
     114                 :            :  * the rpc_xprt.  Anyone of these resources may be used used by an
     115                 :            :  * incoming callback request.  It's up to the higher levels in the
     116                 :            :  * stack to enforce that the maximum number of session slots is not
     117                 :            :  * being exceeded.
     118                 :            :  *
     119                 :            :  * Some callback arguments can be large.  For example, a pNFS server
     120                 :            :  * using multiple deviceids.  The list can be unbound, but the client
     121                 :            :  * has the ability to tell the server the maximum size of the callback
     122                 :            :  * requests.  Each deviceID is 16 bytes, so allocate one page
     123                 :            :  * for the arguments to have enough room to receive a number of these
     124                 :            :  * deviceIDs.  The NFS client indicates to the pNFS server that its
     125                 :            :  * callback requests can be up to 4096 bytes in size.
     126                 :            :  */
     127                 :          0 : int xprt_setup_backchannel(struct rpc_xprt *xprt, unsigned int min_reqs)
     128                 :            : {
     129                 :          0 :         if (!xprt->ops->bc_setup)
     130                 :            :                 return 0;
     131                 :          0 :         return xprt->ops->bc_setup(xprt, min_reqs);
     132                 :            : }
     133                 :            : EXPORT_SYMBOL_GPL(xprt_setup_backchannel);
     134                 :            : 
     135                 :          0 : int xprt_setup_bc(struct rpc_xprt *xprt, unsigned int min_reqs)
     136                 :            : {
     137                 :            :         struct rpc_rqst *req;
     138                 :            :         struct list_head tmp_list;
     139                 :            :         int i;
     140                 :            : 
     141                 :            :         dprintk("RPC:       setup backchannel transport\n");
     142                 :            : 
     143                 :          0 :         if (min_reqs > BC_MAX_SLOTS)
     144                 :            :                 min_reqs = BC_MAX_SLOTS;
     145                 :            : 
     146                 :            :         /*
     147                 :            :          * We use a temporary list to keep track of the preallocated
     148                 :            :          * buffers.  Once we're done building the list we splice it
     149                 :            :          * into the backchannel preallocation list off of the rpc_xprt
     150                 :            :          * struct.  This helps minimize the amount of time the list
     151                 :            :          * lock is held on the rpc_xprt struct.  It also makes cleanup
     152                 :            :          * easier in case of memory allocation errors.
     153                 :            :          */
     154                 :            :         INIT_LIST_HEAD(&tmp_list);
     155                 :          0 :         for (i = 0; i < min_reqs; i++) {
     156                 :            :                 /* Pre-allocate one backchannel rpc_rqst */
     157                 :          0 :                 req = xprt_alloc_bc_req(xprt, GFP_KERNEL);
     158                 :          0 :                 if (req == NULL) {
     159                 :          0 :                         printk(KERN_ERR "Failed to create bc rpc_rqst\n");
     160                 :            :                         goto out_free;
     161                 :            :                 }
     162                 :            : 
     163                 :            :                 /* Add the allocated buffer to the tmp list */
     164                 :            :                 dprintk("RPC:       adding req= %p\n", req);
     165                 :          0 :                 list_add(&req->rq_bc_pa_list, &tmp_list);
     166                 :            :         }
     167                 :            : 
     168                 :            :         /*
     169                 :            :          * Add the temporary list to the backchannel preallocation list
     170                 :            :          */
     171                 :            :         spin_lock(&xprt->bc_pa_lock);
     172                 :          0 :         list_splice(&tmp_list, &xprt->bc_pa_list);
     173                 :          0 :         xprt->bc_alloc_count += min_reqs;
     174                 :          0 :         xprt->bc_alloc_max += min_reqs;
     175                 :          0 :         atomic_add(min_reqs, &xprt->bc_slot_count);
     176                 :            :         spin_unlock(&xprt->bc_pa_lock);
     177                 :            : 
     178                 :            :         dprintk("RPC:       setup backchannel transport done\n");
     179                 :          0 :         return 0;
     180                 :            : 
     181                 :            : out_free:
     182                 :            :         /*
     183                 :            :          * Memory allocation failed, free the temporary list
     184                 :            :          */
     185                 :          0 :         while (!list_empty(&tmp_list)) {
     186                 :          0 :                 req = list_first_entry(&tmp_list,
     187                 :            :                                 struct rpc_rqst,
     188                 :            :                                 rq_bc_pa_list);
     189                 :            :                 list_del(&req->rq_bc_pa_list);
     190                 :          0 :                 xprt_free_allocation(req);
     191                 :            :         }
     192                 :            : 
     193                 :            :         dprintk("RPC:       setup backchannel transport failed\n");
     194                 :            :         return -ENOMEM;
     195                 :            : }
     196                 :            : 
     197                 :            : /**
     198                 :            :  * xprt_destroy_backchannel - Destroys the backchannel preallocated structures.
     199                 :            :  * @xprt:       the transport holding the preallocated strucures
     200                 :            :  * @max_reqs:   the maximum number of preallocated structures to destroy
     201                 :            :  *
     202                 :            :  * Since these structures may have been allocated by multiple calls
     203                 :            :  * to xprt_setup_backchannel, we only destroy up to the maximum number
     204                 :            :  * of reqs specified by the caller.
     205                 :            :  */
     206                 :          0 : void xprt_destroy_backchannel(struct rpc_xprt *xprt, unsigned int max_reqs)
     207                 :            : {
     208                 :          0 :         if (xprt->ops->bc_destroy)
     209                 :          0 :                 xprt->ops->bc_destroy(xprt, max_reqs);
     210                 :          0 : }
     211                 :            : EXPORT_SYMBOL_GPL(xprt_destroy_backchannel);
     212                 :            : 
     213                 :          0 : void xprt_destroy_bc(struct rpc_xprt *xprt, unsigned int max_reqs)
     214                 :            : {
     215                 :            :         struct rpc_rqst *req = NULL, *tmp = NULL;
     216                 :            : 
     217                 :            :         dprintk("RPC:        destroy backchannel transport\n");
     218                 :            : 
     219                 :          0 :         if (max_reqs == 0)
     220                 :            :                 goto out;
     221                 :            : 
     222                 :            :         spin_lock_bh(&xprt->bc_pa_lock);
     223                 :          0 :         xprt->bc_alloc_max -= min(max_reqs, xprt->bc_alloc_max);
     224                 :          0 :         list_for_each_entry_safe(req, tmp, &xprt->bc_pa_list, rq_bc_pa_list) {
     225                 :            :                 dprintk("RPC:        req=%p\n", req);
     226                 :            :                 list_del(&req->rq_bc_pa_list);
     227                 :          0 :                 xprt_free_allocation(req);
     228                 :          0 :                 xprt->bc_alloc_count--;
     229                 :          0 :                 atomic_dec(&xprt->bc_slot_count);
     230                 :          0 :                 if (--max_reqs == 0)
     231                 :            :                         break;
     232                 :            :         }
     233                 :            :         spin_unlock_bh(&xprt->bc_pa_lock);
     234                 :            : 
     235                 :            : out:
     236                 :            :         dprintk("RPC:        backchannel list empty= %s\n",
     237                 :            :                 list_empty(&xprt->bc_pa_list) ? "true" : "false");
     238                 :          0 : }
     239                 :            : 
     240                 :          0 : static struct rpc_rqst *xprt_get_bc_request(struct rpc_xprt *xprt, __be32 xid,
     241                 :            :                 struct rpc_rqst *new)
     242                 :            : {
     243                 :            :         struct rpc_rqst *req = NULL;
     244                 :            : 
     245                 :            :         dprintk("RPC:       allocate a backchannel request\n");
     246                 :          0 :         if (list_empty(&xprt->bc_pa_list)) {
     247                 :          0 :                 if (!new)
     248                 :            :                         goto not_found;
     249                 :          0 :                 if (atomic_read(&xprt->bc_slot_count) >= BC_MAX_SLOTS)
     250                 :            :                         goto not_found;
     251                 :          0 :                 list_add_tail(&new->rq_bc_pa_list, &xprt->bc_pa_list);
     252                 :          0 :                 xprt->bc_alloc_count++;
     253                 :          0 :                 atomic_inc(&xprt->bc_slot_count);
     254                 :            :         }
     255                 :          0 :         req = list_first_entry(&xprt->bc_pa_list, struct rpc_rqst,
     256                 :            :                                 rq_bc_pa_list);
     257                 :          0 :         req->rq_reply_bytes_recvd = 0;
     258                 :          0 :         memcpy(&req->rq_private_buf, &req->rq_rcv_buf,
     259                 :            :                         sizeof(req->rq_private_buf));
     260                 :          0 :         req->rq_xid = xid;
     261                 :          0 :         req->rq_connect_cookie = xprt->connect_cookie;
     262                 :            :         dprintk("RPC:       backchannel req=%p\n", req);
     263                 :            : not_found:
     264                 :          0 :         return req;
     265                 :            : }
     266                 :            : 
     267                 :            : /*
     268                 :            :  * Return the preallocated rpc_rqst structure and XDR buffers
     269                 :            :  * associated with this rpc_task.
     270                 :            :  */
     271                 :          0 : void xprt_free_bc_request(struct rpc_rqst *req)
     272                 :            : {
     273                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
     274                 :            : 
     275                 :          0 :         xprt->ops->bc_free_rqst(req);
     276                 :          0 : }
     277                 :            : 
     278                 :          0 : void xprt_free_bc_rqst(struct rpc_rqst *req)
     279                 :            : {
     280                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
     281                 :            : 
     282                 :            :         dprintk("RPC:       free backchannel req=%p\n", req);
     283                 :            : 
     284                 :          0 :         req->rq_connect_cookie = xprt->connect_cookie - 1;
     285                 :          0 :         smp_mb__before_atomic();
     286                 :          0 :         clear_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state);
     287                 :          0 :         smp_mb__after_atomic();
     288                 :            : 
     289                 :            :         /*
     290                 :            :          * Return it to the list of preallocations so that it
     291                 :            :          * may be reused by a new callback request.
     292                 :            :          */
     293                 :            :         spin_lock_bh(&xprt->bc_pa_lock);
     294                 :          0 :         if (xprt_need_to_requeue(xprt)) {
     295                 :          0 :                 list_add_tail(&req->rq_bc_pa_list, &xprt->bc_pa_list);
     296                 :          0 :                 xprt->bc_alloc_count++;
     297                 :          0 :                 atomic_inc(&xprt->bc_slot_count);
     298                 :            :                 req = NULL;
     299                 :            :         }
     300                 :            :         spin_unlock_bh(&xprt->bc_pa_lock);
     301                 :          0 :         if (req != NULL) {
     302                 :            :                 /*
     303                 :            :                  * The last remaining session was destroyed while this
     304                 :            :                  * entry was in use.  Free the entry and don't attempt
     305                 :            :                  * to add back to the list because there is no need to
     306                 :            :                  * have anymore preallocated entries.
     307                 :            :                  */
     308                 :            :                 dprintk("RPC:       Last session removed req=%p\n", req);
     309                 :          0 :                 xprt_free_allocation(req);
     310                 :            :         }
     311                 :          0 :         xprt_put(xprt);
     312                 :          0 : }
     313                 :            : 
     314                 :            : /*
     315                 :            :  * One or more rpc_rqst structure have been preallocated during the
     316                 :            :  * backchannel setup.  Buffer space for the send and private XDR buffers
     317                 :            :  * has been preallocated as well.  Use xprt_alloc_bc_request to allocate
     318                 :            :  * to this request.  Use xprt_free_bc_request to return it.
     319                 :            :  *
     320                 :            :  * We know that we're called in soft interrupt context, grab the spin_lock
     321                 :            :  * since there is no need to grab the bottom half spin_lock.
     322                 :            :  *
     323                 :            :  * Return an available rpc_rqst, otherwise NULL if non are available.
     324                 :            :  */
     325                 :          0 : struct rpc_rqst *xprt_lookup_bc_request(struct rpc_xprt *xprt, __be32 xid)
     326                 :            : {
     327                 :            :         struct rpc_rqst *req, *new = NULL;
     328                 :            : 
     329                 :            :         do {
     330                 :            :                 spin_lock(&xprt->bc_pa_lock);
     331                 :          0 :                 list_for_each_entry(req, &xprt->bc_pa_list, rq_bc_pa_list) {
     332                 :          0 :                         if (req->rq_connect_cookie != xprt->connect_cookie)
     333                 :          0 :                                 continue;
     334                 :          0 :                         if (req->rq_xid == xid)
     335                 :            :                                 goto found;
     336                 :            :                 }
     337                 :          0 :                 req = xprt_get_bc_request(xprt, xid, new);
     338                 :            : found:
     339                 :            :                 spin_unlock(&xprt->bc_pa_lock);
     340                 :          0 :                 if (new) {
     341                 :          0 :                         if (req != new)
     342                 :          0 :                                 xprt_free_allocation(new);
     343                 :            :                         break;
     344                 :          0 :                 } else if (req)
     345                 :            :                         break;
     346                 :          0 :                 new = xprt_alloc_bc_req(xprt, GFP_KERNEL);
     347                 :          0 :         } while (new);
     348                 :          0 :         return req;
     349                 :            : }
     350                 :            : 
     351                 :            : /*
     352                 :            :  * Add callback request to callback list.  The callback
     353                 :            :  * service sleeps on the sv_cb_waitq waiting for new
     354                 :            :  * requests.  Wake it up after adding enqueing the
     355                 :            :  * request.
     356                 :            :  */
     357                 :          0 : void xprt_complete_bc_request(struct rpc_rqst *req, uint32_t copied)
     358                 :            : {
     359                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
     360                 :          0 :         struct svc_serv *bc_serv = xprt->bc_serv;
     361                 :            : 
     362                 :            :         spin_lock(&xprt->bc_pa_lock);
     363                 :            :         list_del(&req->rq_bc_pa_list);
     364                 :          0 :         xprt->bc_alloc_count--;
     365                 :            :         spin_unlock(&xprt->bc_pa_lock);
     366                 :            : 
     367                 :          0 :         req->rq_private_buf.len = copied;
     368                 :          0 :         set_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state);
     369                 :            : 
     370                 :            :         dprintk("RPC:       add callback request to list\n");
     371                 :          0 :         xprt_get(xprt);
     372                 :            :         spin_lock(&bc_serv->sv_cb_lock);
     373                 :          0 :         list_add(&req->rq_bc_list, &bc_serv->sv_cb_list);
     374                 :          0 :         wake_up(&bc_serv->sv_cb_waitq);
     375                 :            :         spin_unlock(&bc_serv->sv_cb_lock);
     376                 :          0 : }