lnet/klnds/gmlnd/gmlnd_cb.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (c) 2003 Los Alamos National Laboratory (LANL)
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org/
   7  *
   8  *   Lustre is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2 of the GNU General Public
  10  *   License as published by the Free Software Foundation.
  11  *
  12  *   Lustre is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with Lustre; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22
  23 /*
  24  *      This file implements the nal cb functions
  25  */
  26
  27
  28 #include "gmnal.h"
  29
  30 int gmnal_cb_recv(lib_nal_t *libnal, void *private, lib_msg_t *cookie,
  31                    unsigned int niov, struct iovec *iov, size_t mlen,
  32                    size_t rlen)
  33 {
  34         gmnal_srxd_t    *srxd = (gmnal_srxd_t*)private;
  35         int             status = PTL_OK;
  36
  37
  38         CDEBUG(D_TRACE, "gmnal_cb_recv libnal [%p], private[%p], cookie[%p], "
  39                "niov[%d], iov [%p], mlen["LPSZ"], rlen["LPSZ"]\n",
  40                libnal, private, cookie, niov, iov, mlen, rlen);
  41
  42         switch(srxd->type) {
  43         case(GMNAL_SMALL_MESSAGE):
  44                 CDEBUG(D_INFO, "gmnal_cb_recv got small message\n");
  45                 status = gmnal_small_rx(libnal, private, cookie, niov,
  46                                          iov, mlen, rlen);
  47         break;
  48         case(GMNAL_LARGE_MESSAGE_INIT):
  49                 CDEBUG(D_INFO, "gmnal_cb_recv got large message init\n");
  50                 status = gmnal_large_rx(libnal, private, cookie, niov,
  51                                          iov, mlen, rlen);
  52         }
  53
  54
  55         CDEBUG(D_INFO, "gmnal_cb_recv gmnal_return status [%d]\n", status);
  56         return(status);
  57 }
  58
  59 int gmnal_cb_recv_pages(lib_nal_t *libnal, void *private, lib_msg_t *cookie,
  60                          unsigned int kniov, ptl_kiov_t *kiov, size_t mlen,
  61                          size_t rlen)
  62 {
  63         gmnal_srxd_t    *srxd = (gmnal_srxd_t*)private;
  64         int             status = PTL_OK;
  65         struct iovec    *iovec = NULL, *iovec_dup = NULL;
  66         int             i = 0;
  67         ptl_kiov_t      *kiov_dup = kiov;;
  68
  69
  70         CDEBUG(D_TRACE, "gmnal_cb_recv_pages libnal [%p],private[%p], "
  71                "cookie[%p], kniov[%d], kiov [%p], mlen["LPSZ"], rlen["LPSZ"]\n",
  72                libnal, private, cookie, kniov, kiov, mlen, rlen);
  73
  74         if (srxd->type == GMNAL_SMALL_MESSAGE) {
  75                 PORTAL_ALLOC(iovec, sizeof(struct iovec)*kniov);
  76                 if (!iovec) {
  77                         CDEBUG(D_ERROR, "Can't malloc\n");
  78                         return(GMNAL_STATUS_FAIL);
  79                 }
  80                 iovec_dup = iovec;
  81
  82                 /*
  83                  *      map each page and create an iovec for it
  84                  */
  85                 for (i=0; i<kniov; i++) {
  86                         CDEBUG(D_INFO, "processing kniov [%d] [%p]\n", i, kiov);
  87                         CDEBUG(D_INFO, "kniov page [%p] len [%d] offset[%d]\n",
  88                                kiov->kiov_page, kiov->kiov_len,
  89                                kiov->kiov_offset);
  90                         iovec->iov_len = kiov->kiov_len;
  91                         CDEBUG(D_INFO, "Calling kmap[%p]", kiov->kiov_page);
  92
  93                         iovec->iov_base = kmap(kiov->kiov_page) +
  94                                                   kiov->kiov_offset;
  95
  96                         CDEBUG(D_INFO, "iov_base is [%p]\n", iovec->iov_base);
  97                         iovec++;
  98                         kiov++;
  99                 }
 100                 CDEBUG(D_INFO, "calling gmnal_small_rx\n");
 101                 status = gmnal_small_rx(libnal, private, cookie, kniov,
 102                                          iovec_dup, mlen, rlen);
 103                 for (i=0; i<kniov; i++) {
 104                         kunmap(kiov_dup->kiov_page);
 105                         kiov_dup++;
 106                 }
 107                 PORTAL_FREE(iovec_dup, sizeof(struct iovec)*kniov);
 108         }
 109
 110
 111         CDEBUG(D_INFO, "gmnal_return status [%d]\n", status);
 112         return(status);
 113 }
 114
 115
 116 int gmnal_cb_send(lib_nal_t *libnal, void *private, lib_msg_t *cookie,
 117                    ptl_hdr_t *hdr, int type, ptl_nid_t nid, ptl_pid_t pid,
 118                    unsigned int niov, struct iovec *iov, size_t len)
 119 {
 120
 121         gmnal_data_t    *nal_data;
 122
 123
 124         CDEBUG(D_TRACE, "gmnal_cb_send niov[%d] len["LPSZ"] nid["LPU64"]\n",
 125                niov, len, nid);
 126         nal_data = libnal->libnal_data;
 127
 128         if (GMNAL_IS_SMALL_MESSAGE(nal_data, niov, iov, len)) {
 129                 CDEBUG(D_INFO, "This is a small message send\n");
 130                 gmnal_small_tx(libnal, private, cookie, hdr, type, nid, pid,
 131                                 niov, iov, len);
 132         } else {
 133                 CDEBUG(D_ERROR, "Large message send it is not supported\n");
 134                 lib_finalize(libnal, private, cookie, PTL_FAIL);
 135                 return(PTL_FAIL);
 136                 gmnal_large_tx(libnal, private, cookie, hdr, type, nid, pid,
 137                                 niov, iov, len);
 138         }
 139         return(PTL_OK);
 140 }
 141
 142 int gmnal_cb_send_pages(lib_nal_t *libnal, void *private, lib_msg_t *cookie,
 143                          ptl_hdr_t *hdr, int type, ptl_nid_t nid, ptl_pid_t pid,
 144                          unsigned int kniov, ptl_kiov_t *kiov, size_t len)
 145 {
 146
 147         int     i = 0;
 148         gmnal_data_t    *nal_data;
 149         struct  iovec   *iovec = NULL, *iovec_dup = NULL;
 150         ptl_kiov_t      *kiov_dup = kiov;
 151
 152         CDEBUG(D_TRACE, "gmnal_cb_send_pages nid ["LPU64"] niov[%d] len["LPSZ"]\n", nid, kniov, len);
 153         nal_data = libnal->libnal_data;
 154         PORTAL_ALLOC(iovec, kniov*sizeof(struct iovec));
 155         iovec_dup = iovec;
 156         if (GMNAL_IS_SMALL_MESSAGE(nal_data, 0, NULL, len)) {
 157                 CDEBUG(D_INFO, "This is a small message send\n");
 158
 159                 for (i=0; i<kniov; i++) {
 160                         CDEBUG(D_INFO, "processing kniov [%d] [%p]\n", i, kiov);
 161                         CDEBUG(D_INFO, "kniov page [%p] len [%d] offset[%d]\n",
 162                                kiov->kiov_page, kiov->kiov_len,
 163                                kiov->kiov_offset);
 164
 165                         iovec->iov_base = kmap(kiov->kiov_page)
 166                                                 + kiov->kiov_offset;
 167
 168                         iovec->iov_len = kiov->kiov_len;
 169                         iovec++;
 170                         kiov++;
 171                 }
 172                 gmnal_small_tx(libnal, private, cookie, hdr, type, nid,
 173                                 pid, kniov, iovec_dup, len);
 174         } else {
 175                 CDEBUG(D_ERROR, "Large message send it is not supported yet\n");
 176                 return(PTL_FAIL);
 177                 for (i=0; i<kniov; i++) {
 178                         CDEBUG(D_INFO, "processing kniov [%d] [%p]\n", i, kiov);
 179                         CDEBUG(D_INFO, "kniov page [%p] len [%d] offset[%d]\n",
 180                                kiov->kiov_page, kiov->kiov_len,
 181                                kiov->kiov_offset);
 182
 183                         iovec->iov_base = kmap(kiov->kiov_page)
 184                                                  + kiov->kiov_offset;
 185                         iovec->iov_len = kiov->kiov_len;
 186                         iovec++;
 187                         kiov++;
 188                 }
 189                 gmnal_large_tx(libnal, private, cookie, hdr, type, nid,
 190                                 pid, kniov, iovec, len);
 191         }
 192         for (i=0; i<kniov; i++) {
 193                 kunmap(kiov_dup->kiov_page);
 194                 kiov_dup++;
 195         }
 196         PORTAL_FREE(iovec_dup, kniov*sizeof(struct iovec));
 197         return(PTL_OK);
 198 }
 199
 200 int gmnal_cb_dist(lib_nal_t *libnal, ptl_nid_t nid, unsigned long *dist)
 201 {
 202         CDEBUG(D_TRACE, "gmnal_cb_dist\n");
 203         if (dist)
 204                 *dist = 27;
 205         return(PTL_OK);
 206 }