lustre/portals/portals/api-wrap.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * api/api-wrap.c
   5  * User-level wrappers that dispatch across the protection boundaries
   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 # define DEBUG_SUBSYSTEM S_PORTALS
  27 #include <portals/api-support.h>
  28
  29 void PtlSnprintHandle(char *str, int len, ptl_handle_any_t h)
  30 {
  31         snprintf(str, len, "0x%lx."LPX64, h.nal_idx, h.cookie);
  32 }
  33
  34 int PtlNIHandle(ptl_handle_any_t handle_in, ptl_handle_ni_t *ni_out)
  35 {
  36         if (!ptl_init)
  37                 return PTL_NO_INIT;
  38
  39         if (ptl_hndl2nal(&handle_in) == NULL)
  40                 return PTL_HANDLE_INVALID;
  41
  42         *ni_out = handle_in;
  43         return PTL_OK;
  44 }
  45
  46 int PtlGetId(ptl_handle_ni_t ni_handle, ptl_process_id_t *id)
  47 {
  48         nal_t     *nal;
  49
  50         if (!ptl_init)
  51                 return PTL_NO_INIT;
  52
  53         nal = ptl_hndl2nal(&ni_handle);
  54         if (nal == NULL)
  55                 return PTL_NI_INVALID;
  56
  57         return nal->nal_get_id(nal, id);
  58 }
  59
  60 int PtlFailNid (ptl_handle_ni_t interface, ptl_nid_t nid, unsigned int threshold)
  61 {
  62         nal_t     *nal;
  63
  64         if (!ptl_init)
  65                 return PTL_NO_INIT;
  66
  67         nal = ptl_hndl2nal(&interface);
  68         if (nal == NULL)
  69                 return PTL_NI_INVALID;
  70
  71         return nal->nal_fail_nid(nal, nid, threshold);
  72 }
  73
  74 int PtlNIStatus(ptl_handle_ni_t interface_in, ptl_sr_index_t register_in,
  75                 ptl_sr_value_t *status_out)
  76 {
  77         nal_t     *nal;
  78
  79         if (!ptl_init)
  80                 return PTL_NO_INIT;
  81
  82         nal = ptl_hndl2nal(&interface_in);
  83         if (nal == NULL)
  84                 return PTL_NI_INVALID;
  85
  86         return nal->nal_ni_status(nal, register_in, status_out);
  87 }
  88
  89 int PtlNIDist(ptl_handle_ni_t interface_in, ptl_process_id_t process_in,
  90               unsigned long *distance_out)
  91 {
  92         nal_t     *nal;
  93
  94         if (!ptl_init)
  95                 return PTL_NO_INIT;
  96
  97         nal = ptl_hndl2nal(&interface_in);
  98         if (nal == NULL)
  99                 return PTL_NI_INVALID;
 100
 101         return nal->nal_ni_dist(nal, &process_in, distance_out);
 102 }
 103
 104 int PtlMEAttach(ptl_handle_ni_t interface_in, ptl_pt_index_t index_in,
 105                 ptl_process_id_t match_id_in, ptl_match_bits_t match_bits_in,
 106                 ptl_match_bits_t ignore_bits_in, ptl_unlink_t unlink_in,
 107                 ptl_ins_pos_t pos_in, ptl_handle_me_t *handle_out)
 108 {
 109         nal_t     *nal;
 110
 111         if (!ptl_init)
 112                 return PTL_NO_INIT;
 113
 114         nal = ptl_hndl2nal(&interface_in);
 115         if (nal == NULL)
 116                 return PTL_NI_INVALID;
 117
 118         return nal->nal_me_attach(nal, index_in, match_id_in,
 119                                   match_bits_in, ignore_bits_in,
 120                                   unlink_in, pos_in, handle_out);
 121 }
 122
 123 int PtlMEInsert(ptl_handle_me_t current_in, ptl_process_id_t match_id_in,
 124                 ptl_match_bits_t match_bits_in, ptl_match_bits_t ignore_bits_in,
 125                 ptl_unlink_t unlink_in, ptl_ins_pos_t position_in,
 126                 ptl_handle_me_t * handle_out)
 127 {
 128         nal_t     *nal;
 129
 130         if (!ptl_init)
 131                 return PTL_NO_INIT;
 132
 133         nal = ptl_hndl2nal(&current_in);
 134         if (nal == NULL)
 135                 return PTL_ME_INVALID;
 136
 137         return nal->nal_me_insert(nal, &current_in, match_id_in,
 138                                   match_bits_in, ignore_bits_in,
 139                                   unlink_in, position_in, handle_out);
 140 }
 141
 142 int PtlMEUnlink(ptl_handle_me_t current_in)
 143 {
 144         nal_t     *nal;
 145
 146         if (!ptl_init)
 147                 return PTL_NO_INIT;
 148
 149         nal = ptl_hndl2nal(&current_in);
 150         if (nal == NULL)
 151                 return PTL_ME_INVALID;
 152
 153         return nal->nal_me_unlink(nal, &current_in);
 154 }
 155
 156 int PtlMDAttach(ptl_handle_me_t me_in, ptl_md_t md_in,
 157                 ptl_unlink_t unlink_in, ptl_handle_md_t * handle_out)
 158 {
 159         nal_t     *nal;
 160
 161         if (!ptl_init)
 162                 return PTL_NO_INIT;
 163
 164         nal = ptl_hndl2nal(&me_in);
 165         if (nal == NULL)
 166                 return PTL_ME_INVALID;
 167
 168         if (!PtlHandleIsEqual(md_in.eventq, PTL_EQ_NONE) &&
 169             ptl_hndl2nal(&md_in.eventq) != nal)
 170                 return PTL_MD_ILLEGAL;
 171
 172         return (nal->nal_md_attach)(nal, &me_in, &md_in,
 173                                     unlink_in, handle_out);
 174 }
 175
 176 int PtlMDBind(ptl_handle_ni_t ni_in, ptl_md_t md_in,
 177               ptl_unlink_t unlink_in, ptl_handle_md_t *handle_out)
 178 {
 179         nal_t     *nal;
 180
 181         if (!ptl_init)
 182                 return PTL_NO_INIT;
 183
 184         nal = ptl_hndl2nal(&ni_in);
 185         if (nal == NULL)
 186                 return PTL_NI_INVALID;
 187
 188         if (!PtlHandleIsEqual(md_in.eventq, PTL_EQ_NONE) &&
 189             ptl_hndl2nal(&md_in.eventq) != nal)
 190                 return PTL_MD_ILLEGAL;
 191
 192         return (nal->nal_md_bind)(nal, &md_in, unlink_in, handle_out);
 193 }
 194
 195 int PtlMDUpdate(ptl_handle_md_t md_in, ptl_md_t *old_inout,
 196                 ptl_md_t *new_inout, ptl_handle_eq_t testq_in)
 197 {
 198         nal_t    *nal;
 199
 200         if (!ptl_init)
 201                 return PTL_NO_INIT;
 202
 203         nal = ptl_hndl2nal(&md_in);
 204         if (nal == NULL)
 205                 return PTL_MD_INVALID;
 206
 207         if (!PtlHandleIsEqual(testq_in, PTL_EQ_NONE) &&
 208             ptl_hndl2nal(&testq_in) != nal)
 209                 return PTL_EQ_INVALID;
 210
 211         return (nal->nal_md_update)(nal, &md_in,
 212                                     old_inout, new_inout, &testq_in);
 213 }
 214
 215 int PtlMDUnlink(ptl_handle_md_t md_in)
 216 {
 217         nal_t    *nal;
 218
 219         if (!ptl_init)
 220                 return PTL_NO_INIT;
 221
 222         nal = ptl_hndl2nal(&md_in);
 223         if (nal == NULL)
 224                 return PTL_MD_INVALID;
 225
 226         return (nal->nal_md_unlink)(nal, &md_in);
 227 }
 228
 229 int PtlEQAlloc(ptl_handle_ni_t interface, ptl_size_t count,
 230                ptl_eq_handler_t callback,
 231                ptl_handle_eq_t *handle_out)
 232 {
 233         nal_t    *nal;
 234
 235         if (!ptl_init)
 236                 return PTL_NO_INIT;
 237
 238         nal = ptl_hndl2nal(&interface);
 239         if (nal == NULL)
 240                 return PTL_NI_INVALID;
 241
 242         return (nal->nal_eq_alloc)(nal, count, callback, handle_out);
 243 }
 244
 245 int PtlEQFree(ptl_handle_eq_t eventq)
 246 {
 247         nal_t       *nal;
 248
 249         if (!ptl_init)
 250                 return PTL_NO_INIT;
 251
 252         nal = ptl_hndl2nal(&eventq);
 253         if (nal == NULL)
 254                 return PTL_EQ_INVALID;
 255
 256         return (nal->nal_eq_free)(nal, &eventq);
 257 }
 258
 259 int PtlEQGet(ptl_handle_eq_t eventq, ptl_event_t *ev)
 260 {
 261         int which;
 262
 263         return (PtlEQPoll (&eventq, 1, 0, ev, &which));
 264 }
 265
 266 int PtlEQWait(ptl_handle_eq_t eventq_in, ptl_event_t *event_out)
 267 {
 268         int which;
 269
 270         return (PtlEQPoll (&eventq_in, 1, PTL_TIME_FOREVER,
 271                            event_out, &which));
 272 }
 273
 274 int PtlEQPoll(ptl_handle_eq_t *eventqs_in, int neq_in, int timeout,
 275               ptl_event_t *event_out, int *which_out)
 276 {
 277         int           i;
 278         nal_t        *nal;
 279
 280         if (!ptl_init)
 281                 return PTL_NO_INIT;
 282
 283         if (neq_in < 1)
 284                 return PTL_EQ_INVALID;
 285
 286         nal = ptl_hndl2nal(&eventqs_in[0]);
 287         if (nal == NULL)
 288                 return PTL_EQ_INVALID;
 289
 290         for (i = 1; i < neq_in; i++)
 291                 if (ptl_hndl2nal(&eventqs_in[i]) != nal)
 292                         return PTL_EQ_INVALID;
 293
 294         return (nal->nal_eq_poll)(nal, eventqs_in, neq_in, timeout,
 295                                   event_out, which_out);
 296 }
 297
 298
 299 int PtlACEntry(ptl_handle_ni_t ni_in, ptl_ac_index_t index_in,
 300                ptl_process_id_t match_id_in, ptl_pt_index_t portal_in)
 301 {
 302         nal_t    *nal;
 303
 304         if (!ptl_init)
 305                 return PTL_NO_INIT;
 306
 307         nal = ptl_hndl2nal(&ni_in);
 308         if (nal == NULL)
 309                 return PTL_NI_INVALID;
 310
 311         return (nal->nal_ace_entry)(nal, index_in, match_id_in, portal_in);
 312 }
 313
 314 int PtlPut(ptl_handle_md_t md_in, ptl_ack_req_t ack_req_in,
 315            ptl_process_id_t target_in, ptl_pt_index_t portal_in,
 316            ptl_ac_index_t ac_in, ptl_match_bits_t match_bits_in,
 317            ptl_size_t offset_in, ptl_hdr_data_t hdr_data_in)
 318 {
 319         nal_t    *nal;
 320
 321         if (!ptl_init)
 322                 return PTL_NO_INIT;
 323
 324         nal = ptl_hndl2nal(&md_in);
 325         if (nal == NULL)
 326                 return PTL_MD_INVALID;
 327
 328         return (nal->nal_put)(nal, &md_in, ack_req_in,
 329                               &target_in, portal_in, ac_in,
 330                               match_bits_in, offset_in, hdr_data_in);
 331 }
 332
 333 int PtlGet(ptl_handle_md_t md_in, ptl_process_id_t target_in,
 334            ptl_pt_index_t portal_in, ptl_ac_index_t ac_in,
 335            ptl_match_bits_t match_bits_in, ptl_size_t offset_in)
 336 {
 337         nal_t  *nal;
 338
 339         if (!ptl_init)
 340                 return PTL_NO_INIT;
 341
 342         nal = ptl_hndl2nal(&md_in);
 343         if (nal == NULL)
 344                 return PTL_MD_INVALID;
 345
 346         return (nal->nal_get)(nal, &md_in,
 347                               &target_in, portal_in, ac_in,
 348                               match_bits_in, offset_in);
 349 }
 350