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(nal_cb_t *nal_cb, 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 nal_cb [%p], private[%p], cookie[%p],
  39                niov[%d], iov [%p], mlen["LPSZ"], rlen["LPSZ"]\n",
  40                nal_cb, 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(nal_cb, 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(nal_cb, 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(nal_cb_t *nal_cb, 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
  68
  69         CDEBUG(D_TRACE, "gmnal_cb_recv_pages nal_cb [%p],private[%p],
  70                cookie[%p], kniov[%d], kiov [%p], mlen["LPSZ"], rlen["LPSZ"]\n",
  71                nal_cb, private, cookie, kniov, kiov, mlen, rlen);
  72
  73         if (srxd->type == GMNAL_SMALL_MESSAGE) {
  74                 PORTAL_ALLOC(iovec, sizeof(struct iovec)*kniov);
  75                 if (!iovec) {
  76                         CDEBUG(D_ERROR, "Can't malloc\n");
  77                         return(GMNAL_STATUS_FAIL);
  78                 }
  79                 iovec_dup = iovec;
  80
  81                 /*
  82                  *      map each page and create an iovec for it
  83                  */
  84                 for (i=0; i<kniov; i++) {
  85                         CDEBUG(D_INFO, "processing kniov [%d] [%p]\n", i, kiov);
  86                         CDEBUG(D_INFO, "kniov page [%p] len [%d] offset[%d]\n",
  87                                kiov->kiov_page, kiov->kiov_len,
  88                                kiov->kiov_offset);
  89                         iovec->iov_len = kiov->kiov_len;
  90                         CDEBUG(D_INFO, "Calling kmap[%p]", kiov->kiov_page);
  91
  92                         iovec->iov_base = kmap(kiov->kiov_page) +
  93                                                   kiov->kiov_offset;
  94
  95                         CDEBUG(D_INFO, "iov_base is [%p]\n", iovec->iov_base);
  96                         iovec++;
  97                         kiov++;
  98                 }
  99                 CDEBUG(D_INFO, "calling gmnal_small_rx\n");
 100                 status = gmnal_small_rx(nal_cb, private, cookie, kniov,
 101                                          iovec_dup, mlen, rlen);
 102                 PORTAL_FREE(iovec_dup, sizeof(struct iovec)*kniov);
 103         }
 104
 105
 106         CDEBUG(D_INFO, "gmnal_return status [%d]\n", status);
 107         return(status);
 108 }
 109
 110
 111 int gmnal_cb_send(nal_cb_t *nal_cb, void *private, lib_msg_t *cookie,
 112                    ptl_hdr_t *hdr, int type, ptl_nid_t nid, ptl_pid_t pid,
 113                    unsigned int niov, struct iovec *iov, size_t len)
 114 {
 115
 116         gmnal_data_t    *nal_data;
 117
 118
 119         CDEBUG(D_TRACE, "gmnal_cb_send niov[%d] len["LPSZ"] nid["LPU64"]\n",
 120                niov, len, nid);
 121         nal_data = nal_cb->nal_data;
 122
 123         if (GMNAL_IS_SMALL_MESSAGE(nal_data, niov, iov, len)) {
 124                 CDEBUG(D_INFO, "This is a small message send\n");
 125                 gmnal_small_tx(nal_cb, private, cookie, hdr, type, nid, pid,
 126                                 niov, iov, len);
 127         } else {
 128                 CDEBUG(D_ERROR, "Large message send it is not supported\n");
 129                 return(PTL_FAIL);
 130                 gmnal_large_tx(nal_cb, private, cookie, hdr, type, nid, pid,
 131                                 niov, iov, len);
 132         }
 133         return(PTL_OK);
 134 }
 135
 136 int gmnal_cb_send_pages(nal_cb_t *nal_cb, void *private, lib_msg_t *cookie,
 137                          ptl_hdr_t *hdr, int type, ptl_nid_t nid, ptl_pid_t pid,                         unsigned int kniov, ptl_kiov_t *kiov, size_t len)
 138 {
 139
 140         int     i = 0;
 141         gmnal_data_t    *nal_data;
 142         struct  iovec   *iovec = NULL, *iovec_dup = NULL;
 143
 144         CDEBUG(D_TRACE, "gmnal_cb_send_pages nid ["LPU64"] niov[%d] len["LPSZ"]\n", nid, kniov, len);
 145         nal_data = nal_cb->nal_data;
 146         PORTAL_ALLOC(iovec, kniov*sizeof(struct iovec));
 147         iovec_dup = iovec;
 148         if (GMNAL_IS_SMALL_MESSAGE(nal_data, 0, NULL, len)) {
 149                 CDEBUG(D_INFO, "This is a small message send\n");
 150
 151                 for (i=0; i<kniov; i++) {
 152                         CDEBUG(D_INFO, "processing kniov [%d] [%p]\n", i, kiov);
 153                         CDEBUG(D_INFO, "kniov page [%p] len [%d] offset[%d]\n",
 154                                kiov->kiov_page, kiov->kiov_len,
 155                                kiov->kiov_offset);
 156
 157                         iovec->iov_base = kmap(kiov->kiov_page)
 158                                                 + kiov->kiov_offset;
 159
 160                         iovec->iov_len = kiov->kiov_len;
 161                         iovec++;
 162                         kiov++;
 163                 }
 164                 gmnal_small_tx(nal_cb, private, cookie, hdr, type, nid,
 165                                 pid, kniov, iovec_dup, len);
 166         } else {
 167                 CDEBUG(D_ERROR, "Large message send it is not supported yet\n");
 168                 return(PTL_FAIL);
 169                 for (i=0; i<kniov; i++) {
 170                         CDEBUG(D_INFO, "processing kniov [%d] [%p]\n", i, kiov);
 171                         CDEBUG(D_INFO, "kniov page [%p] len [%d] offset[%d]\n",
 172                                kiov->kiov_page, kiov->kiov_len,
 173                                kiov->kiov_offset);
 174
 175                         iovec->iov_base = kmap(kiov->kiov_page)
 176                                                  + kiov->kiov_offset;
 177                         iovec->iov_len = kiov->kiov_len;
 178                         iovec++;
 179                         kiov++;
 180                 }
 181                 gmnal_large_tx(nal_cb, private, cookie, hdr, type, nid,
 182                                 pid, kniov, iovec, len);
 183         }
 184         PORTAL_FREE(iovec_dup, kniov*sizeof(struct iovec));
 185         return(PTL_OK);
 186 }
 187
 188 int gmnal_cb_read(nal_cb_t *nal_cb, void *private, void *dst,
 189                    user_ptr src, size_t len)
 190 {
 191         gm_bcopy(src, dst, len);
 192         return(PTL_OK);
 193 }
 194
 195 int gmnal_cb_write(nal_cb_t *nal_cb, void *private, user_ptr dst,
 196                     void *src, size_t len)
 197 {
 198         gm_bcopy(src, dst, len);
 199         return(PTL_OK);
 200 }
 201
 202 void *gmnal_cb_malloc(nal_cb_t *nal_cb, size_t len)
 203 {
 204         void *ptr = NULL;
 205         CDEBUG(D_TRACE, "gmnal_cb_malloc len["LPSZ"]\n", len);
 206         PORTAL_ALLOC(ptr, len);
 207         return(ptr);
 208 }
 209
 210 void gmnal_cb_free(nal_cb_t *nal_cb, void *buf, size_t len)
 211 {
 212         CDEBUG(D_TRACE, "gmnal_cb_free :: buf[%p] len["LPSZ"]\n", buf, len);
 213         PORTAL_FREE(buf, len);
 214         return;
 215 }
 216
 217 void gmnal_cb_unmap(nal_cb_t *nal_cb, unsigned int niov, struct iovec *iov,
 218                      void **addrkey)
 219 {
 220         return;
 221 }
 222
 223 int  gmnal_cb_map(nal_cb_t *nal_cb, unsigned int niov, struct iovec *iov,
 224                    void**addrkey)
 225 {
 226         return(PTL_OK);
 227 }
 228
 229 void gmnal_cb_printf(nal_cb_t *nal_cb, const char *fmt, ...)
 230 {
 231         CDEBUG(D_TRACE, "gmnal_cb_printf\n");
 232         printk(fmt);
 233         return;
 234 }
 235
 236 void gmnal_cb_cli(nal_cb_t *nal_cb, unsigned long *flags)
 237 {
 238         gmnal_data_t    *nal_data = (gmnal_data_t*)nal_cb->nal_data;
 239
 240         spin_lock_irqsave(&nal_data->cb_lock, *flags);
 241         return;
 242 }
 243
 244 void gmnal_cb_sti(nal_cb_t *nal_cb, unsigned long *flags)
 245 {
 246         gmnal_data_t    *nal_data = (gmnal_data_t*)nal_cb->nal_data;
 247
 248         spin_unlock_irqrestore(&nal_data->cb_lock, *flags);
 249         return;
 250 }
 251
 252 int gmnal_cb_dist(nal_cb_t *nal_cb, ptl_nid_t nid, unsigned long *dist)
 253 {
 254         CDEBUG(D_TRACE, "gmnal_cb_dist\n");
 255         if (dist)
 256                 *dist = 27;
 257         return(PTL_OK);
 258 }