lustre/portals/knals/scimacnal/scimacnal_cb.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:cindent:
   3  *
   4  * Copyright (C) 2003 High Performance Computing Center North (HPC2N)
   5  *   Author: Niklas Edmundsson <nikke@hpc2n.umu.se>
   6
   7  *
   8  * This file is part of Portals, http://www.sf.net/projects/lustre/
   9  *
  10  * Portals is free software; you can redistribute it and/or
  11  * modify it under the terms of version 2 of the GNU General Public
  12  * License as published by the Free Software Foundation.
  13  *
  14  * Portals is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with Portals; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  */
  24
  25 #include "scimacnal.h"
  26
  27 static int
  28 kscimacnal_read (nal_cb_t *nal, void *private,
  29                 void *dst_addr, user_ptr src_addr, size_t len)
  30 {
  31         CDEBUG(D_NET, "0x%Lx: reading %ld bytes from %p -> %p\n",
  32                nal->ni.nid, (long)len, src_addr, dst_addr );
  33         memcpy( dst_addr, src_addr, len );
  34         return 0;
  35 }
  36
  37
  38 static int
  39 kscimacnal_write(nal_cb_t *nal, void *private,
  40                 user_ptr dst_addr, void *src_addr, size_t len)
  41 {
  42         CDEBUG(D_NET, "0x%Lx: writing %ld bytes from %p -> %p\n",
  43                nal->ni.nid, (long)len, src_addr, dst_addr );
  44         memcpy( dst_addr, src_addr, len );
  45         return 0;
  46 }
  47
  48
  49 static void *
  50 kscimacnal_malloc(nal_cb_t *nal, size_t len)
  51 {
  52         void *buf;
  53
  54         PORTAL_ALLOC(buf, len);
  55         return buf;
  56 }
  57
  58
  59 static void
  60 kscimacnal_free(nal_cb_t *nal, void *buf, size_t len)
  61 {
  62         PORTAL_FREE(buf, len);
  63 }
  64
  65
  66 static void
  67 kscimacnal_printf(nal_cb_t *nal, const char *fmt, ...)
  68 {
  69         va_list         ap;
  70         char msg[256];
  71
  72         if (portal_debug & D_NET) {
  73                 va_start( ap, fmt );
  74                 vsnprintf( msg, sizeof(msg), fmt, ap );
  75                 va_end( ap );
  76
  77                 printk("Lustre: CPUId: %d %s",smp_processor_id(), msg);
  78         }
  79 }
  80
  81
  82 static void
  83 kscimacnal_cli(nal_cb_t *nal, unsigned long *flags)
  84 {
  85         kscimacnal_data_t *data= nal->nal_data;
  86
  87         spin_lock_irqsave(&data->ksci_dispatch_lock,*flags);
  88 }
  89
  90
  91 static void
  92 kscimacnal_sti(nal_cb_t *nal, unsigned long *flags)
  93 {
  94         kscimacnal_data_t *data= nal->nal_data;
  95
  96         spin_unlock_irqrestore(&data->ksci_dispatch_lock,*flags);
  97 }
  98
  99
 100 static int
 101 kscimacnal_dist(nal_cb_t *nal, ptl_nid_t nid, unsigned long *dist)
 102 {
 103         /* FIXME: Network distance has a meaning, but is there no easy
 104          * way to figure it out (depends on routing) */
 105
 106         if ( nal->ni.nid == nid ) {
 107                 *dist = 0;
 108         } else {
 109                 *dist = 1;
 110         }
 111
 112         return 0;
 113 }
 114
 115
 116 static
 117 char * get_mac_error(mac_status_t status)
 118 {
 119         switch(status) {
 120                 case MAC_MSG_STAT_OK:
 121                         return "MAC_MSG_STAT_OK";
 122                 case MAC_MSG_STAT_FREED:
 123                         return "MAC_MSG_STAT_FREED";
 124                 case MAC_MSG_STAT_ABORTED:
 125                         return "MAC_MSG_STAT_ABORTED";
 126                 case MAC_MSG_STAT_TIMEDOUT:
 127                         return "MAC_MSG_STAT_TIMEDOUT";
 128                 case MAC_MSG_STAT_NODEUNREACH:
 129                         return "MAC_MSG_STAT_NODEUNREACH";
 130                 case MAC_MSG_STAT_NETDOWN:
 131                         return "MAC_MSG_STAT_NETDOWN";
 132                 case MAC_MSG_STAT_RESET:
 133                         return "MAC_MSG_STAT_RESET";
 134                 case MAC_MSG_STAT_INITFAILED:
 135                         return "MAC_MSG_STAT_INITFAILED";
 136                 case MAC_MSG_STAT_SYNCFAILED:
 137                         return "MAC_MSG_STAT_SYNCFAILED";
 138                 case MAC_MSG_STAT_BADPROTO:
 139                         return "MAC_MSG_STAT_BADPROTO";
 140                 case MAC_MSG_STAT_NOBUFSPACE:
 141                         return "MAC_MSG_STAT_NOBUFSPACE";
 142                 case MAC_MSG_STAT_CONGESTION:
 143                         return "MAC_MSG_STAT_CONGESTION";
 144                 case MAC_MSG_STAT_OTHER:
 145                         return "MAC_MSG_STAT_OTHER";
 146                 default:
 147                         return "Unknown error";
 148         }
 149 }
 150
 151
 152 /* FIXME add routing code here ? */
 153
 154 /* Called by ScaMac when transmission is complete  (ie. message is released) */
 155 static void
 156 kscimacnal_txrelease(mac_mblk_t *msg, mac_msg_status_t status, void *context)
 157 {
 158         kscimacnal_tx_t *ktx = (kscimacnal_tx_t *)context;
 159         int err=0, i;
 160
 161         LASSERT (ktx != NULL);
 162         /* Unmap any mapped pages */
 163         for(i=0; i<ktx->ktx_nmapped; i++) {
 164                 kunmap(ktx->ktx_kpages[i]);
 165         }
 166
 167         CDEBUG(D_NET, "kunmapped %d pages\n", ktx->ktx_nmapped);
 168
 169         /* Euh, there is no feedback when transmission fails?! */
 170         switch(status) {
 171                 case MAC_MSG_STAT_OK:        /* normal */
 172                         break;
 173                 default:
 174                         CERROR("%s (%d):\n", get_mac_error(status), status);
 175                         err = -EIO;
 176                         break;
 177         }
 178
 179         lib_finalize(ktx->ktx_nal, ktx->ktx_private, ktx->ktx_cookie,
 180                      (err == 0) ? PTL_OK : PTL_FAIL);
 181
 182         PORTAL_FREE(ktx, (sizeof(kscimacnal_tx_t)));
 183 }
 184
 185
 186 /* Called by portals when it wants to send a message.
 187  * Since ScaMAC has it's own TX thread we don't bother setting up our own. */
 188
 189 /* FIXME: Read comments in qswnal_cb.c for _sendmsg and fix return-on-error
 190  *        issues */
 191 static inline int
 192 kscimacnal_sendmsg(nal_cb_t        *nal,
 193                    void            *private,
 194                    lib_msg_t       *cookie,
 195                    ptl_hdr_t       *hdr,
 196                    int              type,
 197                    ptl_nid_t        nid,
 198                    ptl_pid_t        pid,
 199                    unsigned int     payload_niov,
 200                    struct iovec    *payload_iov,
 201                    ptl_kiov_t      *payload_kiov,
 202                    size_t           payload_len)
 203 {
 204         kscimacnal_tx_t    *ktx=NULL;
 205         kscimacnal_data_t  *ksci = nal->nal_data;
 206         int              rc=0;
 207         int              buf_len = sizeof(ptl_hdr_t) + payload_len;
 208         mac_mblk_t      *msg=NULL, *lastblk, *newblk;
 209         unsigned long   physaddr;
 210
 211
 212         CDEBUG(D_NET, "sending %d bytes from %p/%p to nid "LPX64" niov: %d\n",
 213                payload_len, payload_iov, payload_kiov, nid, payload_niov);
 214
 215         /* Basic sanity checks */
 216         LASSERT(ksci != NULL);
 217         LASSERT(hdr != NULL);
 218         LASSERT (payload_len == 0 || payload_niov > 0);
 219         LASSERT (payload_niov <= PTL_MD_MAX_IOV);
 220         /* It must be OK to kmap() if required */
 221         LASSERT (payload_kiov == NULL || !in_interrupt ());
 222         /* payload is either all vaddrs or all pages */
 223         LASSERT (!(payload_kiov != NULL && payload_iov != NULL));
 224
 225         /* Do real check if we can send this */
 226         if (buf_len > mac_get_mtusize(ksci->ksci_machandle)) {
 227                 CERROR("kscimacnal:request exceeds TX MTU size (%ld).\n",
 228                                 mac_get_mtusize(ksci->ksci_machandle));
 229                 return PTL_FAIL;
 230         }
 231
 232
 233         /* save transaction info for later finalize and cleanup */
 234         PORTAL_ALLOC(ktx, (sizeof(kscimacnal_tx_t)));
 235         if (!ktx) {
 236                 return PTL_NOSPACE;
 237         }
 238
 239         ktx->ktx_nmapped = 0; /* Start with no mapped pages :) */
 240
 241         /* *SIGH* hdr is a stack variable in the calling function, so we
 242          * need to copy it to a buffer. Zerocopy magic (or is it just
 243          * deferred memcpy?) is annoying sometimes.  */
 244         memcpy(&ktx->ktx_hdr, hdr, sizeof(ptl_hdr_t));
 245
 246         /* First, put the header in the main message mblk */
 247         msg = mac_alloc_mblk(&ktx->ktx_hdr, sizeof(ptl_hdr_t),
 248                         kscimacnal_txrelease, ktx);
 249         if (!msg) {
 250                 PORTAL_FREE(ktx, (sizeof(kscimacnal_tx_t)));
 251                 return PTL_NOSPACE;
 252         }
 253         mac_put_mblk(msg, sizeof(ptl_hdr_t));
 254         lastblk=msg;
 255
 256         /* Allocate additional mblks for each iov as needed.
 257          * Essentially lib_copy_(k)iov2buf with a twist or two */
 258         while (payload_len > 0)
 259         {
 260                 ptl_size_t       nob;
 261                 char            *addr;
 262
 263                 LASSERT (payload_niov > 0);
 264
 265                 if(payload_iov != NULL) {
 266                         nob = MIN (payload_iov->iov_len, payload_len);
 267                         addr = payload_iov->iov_base;
 268                 }
 269                 else {
 270                         nob = MIN (payload_kiov->kiov_len, payload_len);
 271                         /* Bollocks. We need to handle paged IO for things to
 272                          * work but there is no good way to do this. We
 273                          * do it by kmap():ing all pages and keep them
 274                          * mapped until scimac is done with them. */
 275                         /* FIXME: kunmap() on error */
 276                         addr = kmap(payload_kiov->kiov_page);
 277                         ktx->ktx_kpages[ktx->ktx_nmapped++] =
 278                                 payload_kiov->kiov_page;
 279                 }
 280                 /* We don't need a callback on the additional mblks,
 281                  * since all release callbacks seems to be called when
 282                  * the entire message has been sent */
 283                 newblk=mac_alloc_mblk(addr, nob, NULL, NULL);
 284
 285                 if(!newblk) {
 286                         mac_free_msg(msg);
 287                         PORTAL_FREE(ktx, (sizeof(kscimacnal_tx_t)));
 288                         return PTL_NOSPACE;
 289                 }
 290                 mac_put_mblk(newblk, nob);
 291                 mac_link_mblk(lastblk, newblk);
 292                 lastblk=newblk;
 293
 294                 payload_len -= nob;
 295                 payload_niov--;
 296                 if(payload_iov != NULL) {
 297                         payload_iov++;
 298                 }
 299                 else {
 300                         payload_kiov++;
 301                 }
 302         }
 303
 304         CDEBUG(D_NET, "kmapped %d pages\n", ktx->ktx_nmapped);
 305
 306         ktx->ktx_nal = nal;
 307         ktx->ktx_private = private;
 308         ktx->ktx_cookie = cookie;
 309
 310         CDEBUG(D_NET, "mac_send %d bytes to nid: 0x%Lx\n", buf_len, nid);
 311
 312         physaddr = htonl(nid);
 313
 314         if((rc=mac_send(ksci->ksci_machandle, msg,
 315                                         (mac_physaddr_t *) &physaddr))) {
 316                 CERROR("kscimacnal: mac_send() failed, rc=%d\n", rc);
 317                 mac_free_msg(msg);
 318                 PORTAL_FREE(ktx, (sizeof(kscimacnal_tx_t)));
 319                 return PTL_FAIL;
 320         }
 321
 322         return PTL_OK;
 323 }
 324
 325
 326 static int
 327 kscimacnal_send (nal_cb_t     *nal,
 328                  void         *private,
 329                  lib_msg_t    *cookie,
 330                  ptl_hdr_t    *hdr,
 331                  int           type,
 332                  ptl_nid_t     nid,
 333                  ptl_pid_t     pid,
 334                  unsigned int  payload_niov,
 335                  struct iovec *payload_iov,
 336                  size_t        payload_nob)
 337 {
 338         return (kscimacnal_sendmsg (nal, private, cookie, hdr, type, nid, pid,
 339                                 payload_niov, payload_iov, NULL, payload_nob));
 340 }
 341
 342 static int
 343 kscimacnal_send_pages (nal_cb_t     *nal,
 344                        void         *private,
 345                        lib_msg_t    *cookie,
 346                        ptl_hdr_t    *hdr,
 347                        int           type,
 348                        ptl_nid_t     nid,
 349                        ptl_pid_t     pid,
 350                        unsigned int  payload_niov,
 351                        ptl_kiov_t   *payload_kiov,
 352                        size_t        payload_nob)
 353 {
 354         return (kscimacnal_sendmsg (nal, private, cookie, hdr, type, nid, pid,
 355                                 payload_niov, NULL, payload_kiov, payload_nob));
 356 }
 357
 358
 359 void
 360 kscimacnal_fwd_packet (void *arg, kpr_fwd_desc_t *fwd)
 361 {
 362         CERROR ("forwarding not implemented\n");
 363 }
 364
 365
 366 /* Process a received portals packet */
 367 /* Called by the ScaMac RX thread when a packet is received */
 368 void
 369 kscimacnal_rx(mac_handle_t *handle, mac_mblk_t *msg, mac_msg_type_t type,
 370                 void *userdata)
 371 {
 372         ptl_hdr_t       *hdr = NULL;
 373         kscimacnal_rx_t     krx;
 374         mac_size_t       size;
 375         kscimacnal_data_t  *ksci = userdata;
 376
 377         LASSERT(ksci != NULL);
 378
 379         if ( !ksci->ksci_init || ksci->ksci_shuttingdown ||
 380                     type == MAC_MSG_TYPE_CTRL || type == MAC_MSG_TYPE_OTHER ) {
 381                 /* We're not interested in messages not for us, ignore */
 382                 mac_free_msg(msg);
 383                 return;
 384         }
 385
 386         size = mac_msg_size(msg);
 387
 388         CDEBUG(D_NET,"msg %p type %d, size %ld bytes (%ld mblks)\n",
 389                         msg, type, size, mac_msg_mblks(msg));
 390
 391         if( size < sizeof( ptl_hdr_t ) ) {
 392                 /* XXX what's this for? */
 393                 if (ksci->ksci_shuttingdown)
 394                         return;
 395                 CERROR("kscimacnal: did not receive complete portal header,"
 396                                 "size= %ld\n", size);
 397                 /* Free the message before exiting */
 398                 mac_free_msg(msg);
 399                 return;
 400         }
 401
 402         /* Provide everything we know */
 403         krx.handle = handle;
 404         krx.msg = msg;
 405         krx.type = type;
 406         krx.userdata = userdata;
 407
 408         /* mac_msg_next returns the next mblk with unread data */
 409         hdr = mac_get_mblk(mac_msg_next(msg), sizeof(ptl_hdr_t) );
 410
 411         if(!hdr) {
 412                 CERROR("kscimacnal: no data block in message %p\n", msg);
 413                 mac_free_msg(msg);
 414                 return;
 415         }
 416
 417         if ( hdr->dest_nid == kscimacnal_lib.ni.nid ) {
 418                 PROF_START(lib_parse);
 419                 /* sets wanted_len, iovs etc and calls our callback */
 420                 lib_parse(&kscimacnal_lib, hdr, &krx);
 421                 PROF_FINISH(lib_parse);
 422 #if 0 /* FIXME: Is it possible to detect this? */
 423         } else if (kgmnal_ispeer(hdr->dest_nid)) {
 424                 /* should have gone direct to peer */
 425                 CERROR("dropping packet from 0x%llx to 0x%llx:"
 426                                 "target is a  peer\n",
 427                                 hdr->src_nid, hdr->dest_nid);
 428                 kgmnal_requeue_rx(&krx);
 429 #endif /* if 0 FIXME */
 430         } else {
 431                 /* forward to gateway */
 432                 CERROR("forwarding not implemented, mynid=0x%llx dest=0x%llx\n",
 433                                 kscimacnal_lib.ni.nid, hdr->dest_nid);
 434         }
 435
 436         mac_free_msg(msg);
 437
 438         CDEBUG(D_NET, "msg %p: Done\n", msg);
 439 }
 440
 441
 442 /* Called by portals to process a recieved packet */
 443 inline static int
 444 kscimacnal_recvmsg(nal_cb_t     *nal,
 445                    void         *private,
 446                    lib_msg_t    *cookie,
 447                    unsigned int  niov,
 448                    struct iovec *iov,
 449                    ptl_kiov_t   *kiov,
 450                    size_t        mlen,
 451                    size_t        rlen)
 452 {
 453         kscimacnal_rx_t    *krx = private;
 454         mac_mblk_t      *mblk;
 455         void            *src;
 456         mac_size_t       pkt_len;
 457         ptl_size_t       iovused=0;
 458         char            *base=NULL;
 459
 460         LASSERT (krx != NULL);
 461         LASSERT (krx->msg != NULL);
 462
 463         CDEBUG(D_NET,"msg %p: mlen=%d, rlen=%d, niov=%d\n",
 464                         krx->msg, mlen, rlen, niov);
 465
 466         /* What was actually received must be >= what sender claims to have
 467          * sent. */
 468         LASSERT (mlen <= rlen); /* something is wrong if this isn't true */
 469         if (mac_msg_size(krx->msg) < sizeof(ptl_hdr_t)+mlen) {
 470                 /* We didn't receive everything lib thinks we did */
 471                 CERROR("Bad message size: have %d, need %d + %d\n",
 472                        mac_msg_size(krx->msg), sizeof(ptl_hdr_t), mlen);
 473                 return (PTL_FAIL);
 474         }
 475
 476         /* It must be OK to kmap() if required */
 477         LASSERT (kiov == NULL || !in_interrupt ());
 478         /* Either all pages or all vaddrs */
 479         LASSERT (!(kiov != NULL && iov != NULL));
 480
 481         PROF_START(memcpy);
 482
 483         /* mac_msg_next returns next mblk with unread data (ie. can
 484          * be same mblk */
 485         while (mlen != 0 && (mblk = mac_msg_next(krx->msg))) {
 486                 pkt_len = mac_mblk_len(mblk);
 487                 src = mac_get_mblk(mblk, pkt_len); /* Next unread block */
 488
 489                 CDEBUG(D_NET,"msg %p: mblk: %p pkt_len: %ld  src: %p\n",
 490                                 krx->msg, mblk, pkt_len, src);
 491
 492                 LASSERT(src != NULL);
 493
 494                 /* Essentially lib_copy_buf2(k)iov but with continuation
 495                  * support, we "gracefully" thrash the argument vars ;) */
 496                 while (pkt_len > 0) {
 497                         ptl_size_t  nob, len;
 498
 499                         LASSERT (niov > 0);
 500
 501                         if(iov != NULL) {
 502                                 LASSERT(iovused < iov->iov_len);
 503                                 len = iov->iov_len;
 504                                 base = iov->iov_base;
 505                         }
 506                         else {
 507                                 LASSERT(iovused < kiov->kiov_len);
 508                                 len = kiov->kiov_len;
 509                                 if(base==NULL) {
 510                                         /* New page */
 511                                         base = kmap(kiov->kiov_page);
 512                                 }
 513                         }
 514
 515                         nob = MIN (len-iovused, pkt_len);
 516                         CDEBUG(D_NET, "base: %p len: %d src: %p  nob: %d "
 517                                         "iovused: %d\n",
 518                                         base, len, src, nob, iovused);
 519
 520                         memcpy (base+iovused, src, nob);
 521                         pkt_len -= nob;
 522                         src += nob;
 523
 524                         if(nob+iovused < len) {
 525                                 /* We didn't use all of the iov */
 526                                 iovused+=nob;
 527                         }
 528                         else {
 529                                 niov--;
 530                                 iovused=0;
 531                                 if(iov != NULL) {
 532                                         iov++;
 533                                 }
 534                                 else {
 535                                         kunmap(kiov->kiov_page);
 536                                         base=NULL;
 537                                         kiov++;
 538                                 }
 539                         }
 540                 }
 541         }
 542         /* Just to make sure the last page is unmapped */
 543         if(kiov!=NULL && base!=NULL) {
 544                 kunmap(kiov->kiov_page);
 545                 base=NULL;
 546         }
 547         PROF_FINISH(memcpy);
 548
 549         CDEBUG(D_NET, "Calling lib_finalize.\n");
 550
 551         PROF_START(lib_finalize);
 552         lib_finalize(nal, private, cookie, PTL_OK);
 553         PROF_FINISH(lib_finalize);
 554
 555         CDEBUG(D_NET, "Done.\n");
 556
 557         return PTL_OK;
 558 }
 559
 560
 561 static int
 562 kscimacnal_recv(nal_cb_t     *nal,
 563              void         *private,
 564              lib_msg_t    *cookie,
 565              unsigned int  niov,
 566              struct iovec *iov,
 567              size_t        mlen,
 568              size_t        rlen)
 569 {
 570         return (kscimacnal_recvmsg (nal, private, cookie, niov, iov, NULL, mlen, rlen));
 571 }
 572
 573
 574 static int
 575 kscimacnal_recv_pages (nal_cb_t     *nal,
 576                     void         *private,
 577                     lib_msg_t    *cookie,
 578                     unsigned int  niov,
 579                     ptl_kiov_t   *kiov,
 580                     size_t        mlen,
 581                     size_t        rlen)
 582 {
 583         return (kscimacnal_recvmsg (nal, private, cookie, niov, NULL, kiov, mlen, rlen));
 584 }
 585
 586
 587 nal_cb_t kscimacnal_lib = {
 588         nal_data:       &kscimacnal_data,               /* NAL private data */
 589         cb_send:         kscimacnal_send,
 590         cb_send_pages:   kscimacnal_send_pages,
 591         cb_recv:         kscimacnal_recv,
 592         cb_recv_pages:   kscimacnal_recv_pages,
 593         cb_read:         kscimacnal_read,
 594         cb_write:        kscimacnal_write,
 595         cb_malloc:       kscimacnal_malloc,
 596         cb_free:         kscimacnal_free,
 597         cb_printf:       kscimacnal_printf,
 598         cb_cli:          kscimacnal_cli,
 599         cb_sti:          kscimacnal_sti,
 600         cb_dist:         kscimacnal_dist
 601 };