lnet/lnet/lib-md.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * lib/lib-md.c
   5  * Memory Descriptor management routines
   6  *
   7  *  Copyright (c) 2001-2003 Cluster File Systems, Inc.
   8  *  Copyright (c) 2001-2002 Sandia National Laboratories
   9  *
  10  *   This file is part of Lustre, http://www.sf.net/projects/lustre/
  11  *
  12  *   Lustre is free software; you can redistribute it and/or
  13  *   modify it under the terms of version 2 of the GNU General Public
  14  *   License as published by the Free Software Foundation.
  15  *
  16  *   Lustre is distributed in the hope that it will be useful,
  17  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *   GNU General Public License for more details.
  20  *
  21  *   You should have received a copy of the GNU General Public License
  22  *   along with Lustre; if not, write to the Free Software
  23  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 #ifndef __KERNEL__
  27 # include <stdio.h>
  28 #else
  29 # define DEBUG_SUBSYSTEM S_PORTALS
  30 # include <linux/kp30.h>
  31 #endif
  32
  33 #include <portals/lib-p30.h>
  34
  35 /* must be called with state lock held */
  36 void
  37 lib_md_unlink(lib_nal_t *nal, lib_md_t *md)
  38 {
  39         if ((md->md_flags & PTL_MD_FLAG_ZOMBIE) == 0) {
  40                 /* first unlink attempt... */
  41                 lib_me_t *me = md->me;
  42
  43                 md->md_flags |= PTL_MD_FLAG_ZOMBIE;
  44
  45                 /* Disassociate from ME (if any), and unlink it if it was created
  46                  * with PTL_UNLINK */
  47                 if (me != NULL) {
  48                         me->md = NULL;
  49                         if (me->unlink == PTL_UNLINK)
  50                                 lib_me_unlink(nal, me);
  51                 }
  52
  53                 /* emsure all future handle lookups fail */
  54                 lib_invalidate_handle(nal, &md->md_lh);
  55         }
  56
  57         if (md->pending != 0) {
  58                 CDEBUG(D_NET, "Queueing unlink of md %p\n", md);
  59                 return;
  60         }
  61
  62         CDEBUG(D_NET, "Unlinking md %p\n", md);
  63
  64         if ((md->options & PTL_MD_KIOV) != 0) {
  65                 if (nal->libnal_unmap_pages != NULL)
  66                         nal->libnal_unmap_pages (nal,
  67                                                  md->md_niov,
  68                                                  md->md_iov.kiov,
  69                                                  &md->md_addrkey);
  70         } else if (nal->libnal_unmap != NULL) {
  71                 nal->libnal_unmap (nal,
  72                                    md->md_niov, md->md_iov.iov,
  73                                    &md->md_addrkey);
  74         }
  75
  76         if (md->eq != NULL) {
  77                 md->eq->eq_refcount--;
  78                 LASSERT (md->eq->eq_refcount >= 0);
  79         }
  80
  81         list_del (&md->md_list);
  82         lib_md_free(nal, md);
  83 }
  84
  85 /* must be called with state lock held */
  86 static int
  87 lib_md_build(lib_nal_t *nal, lib_md_t *lmd, ptl_md_t *umd, int unlink)
  88 {
  89         lib_eq_t     *eq = NULL;
  90         int           rc;
  91         int           i;
  92         int           niov;
  93         int           total_length = 0;
  94
  95         /* NB we are passed an allocated, but uninitialised/active md.
  96          * if we return success, caller may lib_md_unlink() it.
  97          * otherwise caller may only lib_md_free() it.
  98          */
  99
 100         if (!PtlHandleIsEqual (umd->eq_handle, PTL_EQ_NONE)) {
 101                 eq = ptl_handle2eq(&umd->eq_handle, nal);
 102                 if (eq == NULL)
 103                         return PTL_EQ_INVALID;
 104         }
 105
 106         /* This implementation doesn't know how to create START events or
 107          * disable END events.  Best to LASSERT our caller is compliant so
 108          * we find out quickly...  */
 109         LASSERT (eq == NULL ||
 110                  ((umd->options & PTL_MD_EVENT_START_DISABLE) != 0 &&
 111                   (umd->options & PTL_MD_EVENT_END_DISABLE) == 0));
 112
 113         lmd->me = NULL;
 114         lmd->start = umd->start;
 115         lmd->offset = 0;
 116         lmd->max_size = umd->max_size;
 117         lmd->options = umd->options;
 118         lmd->user_ptr = umd->user_ptr;
 119         lmd->eq = eq;
 120         lmd->threshold = umd->threshold;
 121         lmd->pending = 0;
 122         lmd->md_flags = (unlink == PTL_UNLINK) ? PTL_MD_FLAG_AUTO_UNLINK : 0;
 123
 124         if ((umd->options & PTL_MD_IOVEC) != 0) {
 125
 126                 if ((umd->options & PTL_MD_KIOV) != 0) /* Can't specify both */
 127                         return PTL_MD_ILLEGAL;
 128
 129                 lmd->md_niov = niov = umd->length;
 130                 memcpy(lmd->md_iov.iov, umd->start,
 131                        niov * sizeof (lmd->md_iov.iov[0]));
 132
 133                 for (i = 0; i < niov; i++) {
 134                         /* We take the base address on trust */
 135                         if (lmd->md_iov.iov[i].iov_len <= 0) /* invalid length */
 136                                 return PTL_MD_ILLEGAL;
 137
 138                         total_length += lmd->md_iov.iov[i].iov_len;
 139                 }
 140
 141                 lmd->length = total_length;
 142
 143                 if ((umd->options & PTL_MD_MAX_SIZE) != 0 && /* max size used */
 144                     (umd->max_size < 0 ||
 145                      umd->max_size > total_length)) // illegal max_size
 146                         return PTL_MD_ILLEGAL;
 147
 148                 if (nal->libnal_map != NULL) {
 149                         rc = nal->libnal_map (nal, niov, lmd->md_iov.iov,
 150                                               &lmd->md_addrkey);
 151                         if (rc != PTL_OK)
 152                                 return (rc);
 153                 }
 154         } else if ((umd->options & PTL_MD_KIOV) != 0) {
 155 #ifndef __KERNEL__
 156                 return PTL_MD_ILLEGAL;
 157 #else
 158                 /* Trap attempt to use paged I/O if unsupported early. */
 159                 if (nal->libnal_send_pages == NULL ||
 160                     nal->libnal_recv_pages == NULL)
 161                         return PTL_MD_INVALID;
 162
 163                 lmd->md_niov = niov = umd->length;
 164                 memcpy(lmd->md_iov.kiov, umd->start,
 165                        niov * sizeof (lmd->md_iov.kiov[0]));
 166
 167                 for (i = 0; i < niov; i++) {
 168                         /* We take the page pointer on trust */
 169                         if (lmd->md_iov.kiov[i].kiov_offset +
 170                             lmd->md_iov.kiov[i].kiov_len > PAGE_SIZE )
 171                                 return PTL_VAL_FAILED; /* invalid length */
 172
 173                         total_length += lmd->md_iov.kiov[i].kiov_len;
 174                 }
 175
 176                 lmd->length = total_length;
 177
 178                 if ((umd->options & PTL_MD_MAX_SIZE) != 0 && /* max size used */
 179                     (umd->max_size < 0 ||
 180                      umd->max_size > total_length)) // illegal max_size
 181                         return PTL_MD_ILLEGAL;
 182
 183                 if (nal->libnal_map_pages != NULL) {
 184                         rc = nal->libnal_map_pages (nal, niov, lmd->md_iov.kiov,
 185                                                     &lmd->md_addrkey);
 186                         if (rc != PTL_OK)
 187                                 return (rc);
 188                 }
 189 #endif
 190         } else {   /* contiguous */
 191                 lmd->length = umd->length;
 192                 lmd->md_niov = niov = 1;
 193                 lmd->md_iov.iov[0].iov_base = umd->start;
 194                 lmd->md_iov.iov[0].iov_len = umd->length;
 195
 196                 if ((umd->options & PTL_MD_MAX_SIZE) != 0 && /* max size used */
 197                     (umd->max_size < 0 ||
 198                      umd->max_size > umd->length)) // illegal max_size
 199                         return PTL_MD_ILLEGAL;
 200
 201                 if (nal->libnal_map != NULL) {
 202                         rc = nal->libnal_map (nal, niov, lmd->md_iov.iov,
 203                                               &lmd->md_addrkey);
 204                         if (rc != PTL_OK)
 205                                 return (rc);
 206                 }
 207         }
 208
 209         if (eq != NULL)
 210                 eq->eq_refcount++;
 211
 212         /* It's good; let handle2md succeed and add to active mds */
 213         lib_initialise_handle (nal, &lmd->md_lh, PTL_COOKIE_TYPE_MD);
 214         list_add (&lmd->md_list, &nal->libnal_ni.ni_active_mds);
 215
 216         return PTL_OK;
 217 }
 218
 219 /* must be called with state lock held */
 220 void
 221 lib_md_deconstruct(lib_nal_t *nal, lib_md_t *lmd, ptl_md_t *umd)
 222 {
 223         /* NB this doesn't copy out all the iov entries so when a
 224          * discontiguous MD is copied out, the target gets to know the
 225          * original iov pointer (in start) and the number of entries it had
 226          * and that's all.
 227          */
 228         umd->start = lmd->start;
 229         umd->length = ((lmd->options & (PTL_MD_IOVEC | PTL_MD_KIOV)) == 0) ?
 230                       lmd->length : lmd->md_niov;
 231         umd->threshold = lmd->threshold;
 232         umd->max_size = lmd->max_size;
 233         umd->options = lmd->options;
 234         umd->user_ptr = lmd->user_ptr;
 235         ptl_eq2handle(&umd->eq_handle, nal, lmd->eq);
 236 }
 237
 238 int
 239 lib_api_md_attach(nal_t *apinal, ptl_handle_me_t *meh,
 240                   ptl_md_t *umd, ptl_unlink_t unlink,
 241                   ptl_handle_md_t *handle)
 242 {
 243         lib_nal_t    *nal = apinal->nal_data;
 244         lib_me_t     *me;
 245         lib_md_t     *md;
 246         unsigned long flags;
 247         int           rc;
 248
 249         if ((umd->options & (PTL_MD_KIOV | PTL_MD_IOVEC)) != 0 &&
 250             umd->length > PTL_MD_MAX_IOV) /* too many fragments */
 251                 return PTL_IOV_INVALID;
 252
 253         md = lib_md_alloc(nal, umd);
 254         if (md == NULL)
 255                 return PTL_NO_SPACE;
 256
 257         LIB_LOCK(nal, flags);
 258
 259         me = ptl_handle2me(meh, nal);
 260         if (me == NULL) {
 261                 rc = PTL_ME_INVALID;
 262         } else if (me->md != NULL) {
 263                 rc = PTL_ME_IN_USE;
 264         } else {
 265                 rc = lib_md_build(nal, md, umd, unlink);
 266                 if (rc == PTL_OK) {
 267                         me->md = md;
 268                         md->me = me;
 269
 270                         ptl_md2handle(handle, nal, md);
 271
 272                         LIB_UNLOCK(nal, flags);
 273                         return (PTL_OK);
 274                 }
 275         }
 276
 277         lib_md_free (nal, md);
 278
 279         LIB_UNLOCK(nal, flags);
 280         return (rc);
 281 }
 282
 283 int
 284 lib_api_md_bind(nal_t *apinal,
 285                 ptl_md_t *umd, ptl_unlink_t unlink,
 286                 ptl_handle_md_t *handle)
 287 {
 288         lib_nal_t    *nal = apinal->nal_data;
 289         lib_md_t     *md;
 290         unsigned long flags;
 291         int           rc;
 292
 293         if ((umd->options & (PTL_MD_KIOV | PTL_MD_IOVEC)) != 0 &&
 294             umd->length > PTL_MD_MAX_IOV) /* too many fragments */
 295                 return PTL_IOV_INVALID;
 296
 297         md = lib_md_alloc(nal, umd);
 298         if (md == NULL)
 299                 return PTL_NO_SPACE;
 300
 301         LIB_LOCK(nal, flags);
 302
 303         rc = lib_md_build(nal, md, umd, unlink);
 304
 305         if (rc == PTL_OK) {
 306                 ptl_md2handle(handle, nal, md);
 307
 308                 LIB_UNLOCK(nal, flags);
 309                 return (PTL_OK);
 310         }
 311
 312         lib_md_free (nal, md);
 313
 314         LIB_UNLOCK(nal, flags);
 315         return (rc);
 316 }
 317
 318 int
 319 lib_api_md_unlink (nal_t *apinal, ptl_handle_md_t *mdh)
 320 {
 321         lib_nal_t       *nal = apinal->nal_data;
 322         ptl_event_t      ev;
 323         lib_md_t        *md;
 324         unsigned long    flags;
 325
 326         LIB_LOCK(nal, flags);
 327
 328         md = ptl_handle2md(mdh, nal);
 329         if (md == NULL) {
 330                 LIB_UNLOCK(nal, flags);
 331                 return PTL_MD_INVALID;
 332         }
 333
 334         /* If the MD is busy, lib_md_unlink just marks it for deletion, and
 335          * when the NAL is done, the completion event flags that the MD was
 336          * unlinked.  Otherwise, we enqueue an event now... */
 337
 338         if (md->eq != NULL &&
 339             md->pending == 0) {
 340                 memset(&ev, 0, sizeof(ev));
 341
 342                 ev.type = PTL_EVENT_UNLINK;
 343                 ev.ni_fail_type = PTL_OK;
 344                 ev.unlinked = 1;
 345                 lib_md_deconstruct(nal, md, &ev.md);
 346                 ptl_md2handle(&ev.md_handle, nal, md);
 347
 348                 lib_enq_event_locked(nal, NULL, md->eq, &ev);
 349         }
 350
 351         lib_md_unlink(nal, md);
 352
 353         LIB_UNLOCK(nal, flags);
 354         return PTL_OK;
 355 }
 356
 357 int
 358 lib_api_md_update (nal_t *apinal,
 359                    ptl_handle_md_t *mdh,
 360                    ptl_md_t *oldumd, ptl_md_t *newumd,
 361                    ptl_handle_eq_t *testqh)
 362 {
 363         lib_nal_t    *nal = apinal->nal_data;
 364         lib_md_t     *md;
 365         lib_eq_t     *test_eq = NULL;
 366         unsigned long flags;
 367         int           rc;
 368
 369         LIB_LOCK(nal, flags);
 370
 371         md = ptl_handle2md(mdh, nal);
 372         if (md == NULL) {
 373                  rc = PTL_MD_INVALID;
 374                  goto out;
 375         }
 376
 377         if (oldumd != NULL)
 378                 lib_md_deconstruct(nal, md, oldumd);
 379
 380         if (newumd == NULL) {
 381                 rc = PTL_OK;
 382                 goto out;
 383         }
 384
 385         /* XXX fttb, the new MD must be the same "shape" wrt fragmentation,
 386          * since we simply overwrite the old lib-md */
 387         if ((((newumd->options ^ md->options) &
 388               (PTL_MD_IOVEC | PTL_MD_KIOV)) != 0) ||
 389             ((newumd->options & (PTL_MD_IOVEC | PTL_MD_KIOV)) != 0 &&
 390              newumd->length != md->md_niov)) {
 391                 rc = PTL_IOV_INVALID;
 392                 goto out;
 393         }
 394
 395         if (!PtlHandleIsEqual (*testqh, PTL_EQ_NONE)) {
 396                 test_eq = ptl_handle2eq(testqh, nal);
 397                 if (test_eq == NULL) {
 398                         rc = PTL_EQ_INVALID;
 399                         goto out;
 400                 }
 401         }
 402
 403         if (md->pending != 0) {
 404                 rc = PTL_MD_NO_UPDATE;
 405                 goto out;
 406         }
 407
 408         if (test_eq == NULL ||
 409             test_eq->eq_deq_seq == test_eq->eq_enq_seq) {
 410                 lib_me_t *me = md->me;
 411                 int       unlink = (md->md_flags & PTL_MD_FLAG_AUTO_UNLINK) ?
 412                                    PTL_UNLINK : PTL_RETAIN;
 413
 414                 // #warning this does not track eq refcounts properly
 415                 rc = lib_md_build(nal, md, newumd, unlink);
 416
 417                 md->me = me;
 418         } else {
 419                 rc = PTL_MD_NO_UPDATE;
 420         }
 421
 422  out:
 423         LIB_UNLOCK(nal, flags);
 424
 425         return rc;
 426 }