lnet/lnet/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  *
   9  *   This file is part of Lustre, http://www.sf.net/projects/lustre/
  10  *
  11  *   Lustre is free software; you can redistribute it and/or
  12  *   modify it under the terms of version 2 of the GNU General Public
  13  *   License as published by the Free Software Foundation.
  14  *
  15  *   Lustre is distributed in the hope that it will be useful,
  16  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *   GNU General Public License for more details.
  19  *
  20  *   You should have received a copy of the GNU General Public License
  21  *   along with Lustre; if not, write to the Free Software
  22  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #define DEBUG_SUBSYSTEM S_PORTALS
  26 #include <portals/api-support.h>
  27
  28 void PtlSnprintHandle(char *str, int len, ptl_handle_any_t h)
  29 {
  30         snprintf(str, len, "0x%lx."LPX64, h.nal_idx, h.cookie);
  31 }
  32
  33 int PtlNIHandle(ptl_handle_any_t handle_in, ptl_handle_ni_t *ni_out)
  34 {
  35         if (!ptl_init)
  36                 return PTL_NO_INIT;
  37
  38         if (ptl_hndl2nal(&handle_in) == NULL)
  39                 return PTL_HANDLE_INVALID;
  40
  41         *ni_out = handle_in;
  42         return PTL_OK;
  43 }
  44
  45 int PtlGetId(ptl_handle_ni_t ni_handle, ptl_process_id_t *id)
  46 {
  47         nal_t     *nal;
  48
  49         if (!ptl_init)
  50                 return PTL_NO_INIT;
  51
  52         nal = ptl_hndl2nal(&ni_handle);
  53         if (nal == NULL)
  54                 return PTL_NI_INVALID;
  55
  56         return nal->nal_get_id(nal, id);
  57 }
  58
  59 int PtlGetUid(ptl_handle_ni_t ni_handle, ptl_uid_t *uid)
  60 {
  61         nal_t     *nal;
  62
  63         if (!ptl_init)
  64                 return PTL_NO_INIT;
  65
  66         nal = ptl_hndl2nal(&ni_handle);
  67         if (nal == NULL)
  68                 return PTL_NI_INVALID;
  69
  70         /* We don't support different uids yet */
  71         *uid = 0;
  72         return PTL_OK;
  73 }
  74
  75 int PtlFailNid (ptl_handle_ni_t interface, ptl_nid_t nid, unsigned int threshold)
  76 {
  77         nal_t     *nal;
  78
  79         if (!ptl_init)
  80                 return PTL_NO_INIT;
  81
  82         nal = ptl_hndl2nal(&interface);
  83         if (nal == NULL)
  84                 return PTL_NI_INVALID;
  85
  86         return nal->nal_fail_nid(nal, nid, threshold);
  87 }
  88
  89 int PtlNIStatus(ptl_handle_ni_t interface_in, ptl_sr_index_t register_in,
  90                 ptl_sr_value_t *status_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_status(nal, register_in, status_out);
 102 }
 103
 104 int PtlNIDist(ptl_handle_ni_t interface_in, ptl_process_id_t process_in,
 105               unsigned long *distance_out)
 106 {
 107         nal_t     *nal;
 108
 109         if (!ptl_init)
 110                 return PTL_NO_INIT;
 111
 112         nal = ptl_hndl2nal(&interface_in);
 113         if (nal == NULL)
 114                 return PTL_NI_INVALID;
 115
 116         return nal->nal_ni_dist(nal, &process_in, distance_out);
 117 }
 118
 119 int PtlMEAttach(ptl_handle_ni_t interface_in, ptl_pt_index_t index_in,
 120                 ptl_process_id_t match_id_in, ptl_match_bits_t match_bits_in,
 121                 ptl_match_bits_t ignore_bits_in, ptl_unlink_t unlink_in,
 122                 ptl_ins_pos_t pos_in, ptl_handle_me_t *handle_out)
 123 {
 124         nal_t     *nal;
 125
 126         if (!ptl_init)
 127                 return PTL_NO_INIT;
 128
 129         nal = ptl_hndl2nal(&interface_in);
 130         if (nal == NULL)
 131                 return PTL_NI_INVALID;
 132
 133         return nal->nal_me_attach(nal, index_in, match_id_in,
 134                                   match_bits_in, ignore_bits_in,
 135                                   unlink_in, pos_in, handle_out);
 136 }
 137
 138 int PtlMEInsert(ptl_handle_me_t current_in, ptl_process_id_t match_id_in,
 139                 ptl_match_bits_t match_bits_in, ptl_match_bits_t ignore_bits_in,
 140                 ptl_unlink_t unlink_in, ptl_ins_pos_t position_in,
 141                 ptl_handle_me_t * handle_out)
 142 {
 143         nal_t     *nal;
 144
 145         if (!ptl_init)
 146                 return PTL_NO_INIT;
 147
 148         nal = ptl_hndl2nal(&current_in);
 149         if (nal == NULL)
 150                 return PTL_ME_INVALID;
 151
 152         return nal->nal_me_insert(nal, &current_in, match_id_in,
 153                                   match_bits_in, ignore_bits_in,
 154                                   unlink_in, position_in, handle_out);
 155 }
 156
 157 int PtlMEUnlink(ptl_handle_me_t current_in)
 158 {
 159         nal_t     *nal;
 160
 161         if (!ptl_init)
 162                 return PTL_NO_INIT;
 163
 164         nal = ptl_hndl2nal(&current_in);
 165         if (nal == NULL)
 166                 return PTL_ME_INVALID;
 167
 168         return nal->nal_me_unlink(nal, &current_in);
 169 }
 170
 171 int PtlMDAttach(ptl_handle_me_t me_in, ptl_md_t md_in,
 172                 ptl_unlink_t unlink_in, ptl_handle_md_t * handle_out)
 173 {
 174         nal_t     *nal;
 175
 176         if (!ptl_init)
 177                 return PTL_NO_INIT;
 178
 179         nal = ptl_hndl2nal(&me_in);
 180         if (nal == NULL)
 181                 return PTL_ME_INVALID;
 182
 183         if (!PtlHandleIsEqual(md_in.eq_handle, PTL_EQ_NONE) &&
 184             ptl_hndl2nal(&md_in.eq_handle) != nal)
 185                 return PTL_MD_ILLEGAL;
 186
 187         return (nal->nal_md_attach)(nal, &me_in, &md_in,
 188                                     unlink_in, handle_out);
 189 }
 190
 191 int PtlMDBind(ptl_handle_ni_t ni_in, ptl_md_t md_in,
 192               ptl_unlink_t unlink_in, ptl_handle_md_t *handle_out)
 193 {
 194         nal_t     *nal;
 195
 196         if (!ptl_init)
 197                 return PTL_NO_INIT;
 198
 199         nal = ptl_hndl2nal(&ni_in);
 200         if (nal == NULL)
 201                 return PTL_NI_INVALID;
 202
 203         if (!PtlHandleIsEqual(md_in.eq_handle, PTL_EQ_NONE) &&
 204             ptl_hndl2nal(&md_in.eq_handle) != nal)
 205                 return PTL_MD_ILLEGAL;
 206
 207         return (nal->nal_md_bind)(nal, &md_in, unlink_in, handle_out);
 208 }
 209
 210 int PtlMDUpdate(ptl_handle_md_t md_in, ptl_md_t *old_inout,
 211                 ptl_md_t *new_inout, ptl_handle_eq_t testq_in)
 212 {
 213         nal_t    *nal;
 214
 215         if (!ptl_init)
 216                 return PTL_NO_INIT;
 217
 218         nal = ptl_hndl2nal(&md_in);
 219         if (nal == NULL)
 220                 return PTL_MD_INVALID;
 221
 222         if (!PtlHandleIsEqual(testq_in, PTL_EQ_NONE) &&
 223             ptl_hndl2nal(&testq_in) != nal)
 224                 return PTL_EQ_INVALID;
 225
 226         return (nal->nal_md_update)(nal, &md_in,
 227                                     old_inout, new_inout, &testq_in);
 228 }
 229
 230 int PtlMDUnlink(ptl_handle_md_t md_in)
 231 {
 232         nal_t    *nal;
 233
 234         if (!ptl_init)
 235                 return PTL_NO_INIT;
 236
 237         nal = ptl_hndl2nal(&md_in);
 238         if (nal == NULL)
 239                 return PTL_MD_INVALID;
 240
 241         return (nal->nal_md_unlink)(nal, &md_in);
 242 }
 243
 244 int PtlEQAlloc(ptl_handle_ni_t interface, ptl_size_t count,
 245                ptl_eq_handler_t callback,
 246                ptl_handle_eq_t *handle_out)
 247 {
 248         nal_t    *nal;
 249
 250         if (!ptl_init)
 251                 return PTL_NO_INIT;
 252
 253         nal = ptl_hndl2nal(&interface);
 254         if (nal == NULL)
 255                 return PTL_NI_INVALID;
 256
 257         return (nal->nal_eq_alloc)(nal, count, callback, handle_out);
 258 }
 259
 260 int PtlEQFree(ptl_handle_eq_t eventq)
 261 {
 262         nal_t       *nal;
 263
 264         if (!ptl_init)
 265                 return PTL_NO_INIT;
 266
 267         nal = ptl_hndl2nal(&eventq);
 268         if (nal == NULL)
 269                 return PTL_EQ_INVALID;
 270
 271         return (nal->nal_eq_free)(nal, &eventq);
 272 }
 273
 274 int PtlEQGet(ptl_handle_eq_t eventq, ptl_event_t *ev)
 275 {
 276         int which;
 277
 278         return (PtlEQPoll (&eventq, 1, 0, ev, &which));
 279 }
 280
 281 int PtlEQWait(ptl_handle_eq_t eventq_in, ptl_event_t *event_out)
 282 {
 283         int which;
 284
 285         return (PtlEQPoll (&eventq_in, 1, PTL_TIME_FOREVER,
 286                            event_out, &which));
 287 }
 288
 289 int PtlEQPoll(ptl_handle_eq_t *eventqs_in, int neq_in, int timeout,
 290               ptl_event_t *event_out, int *which_out)
 291 {
 292         int           i;
 293         nal_t        *nal;
 294
 295         if (!ptl_init)
 296                 return PTL_NO_INIT;
 297
 298         if (neq_in < 1)
 299                 return PTL_EQ_INVALID;
 300
 301         nal = ptl_hndl2nal(&eventqs_in[0]);
 302         if (nal == NULL)
 303                 return PTL_EQ_INVALID;
 304
 305         for (i = 1; i < neq_in; i++)
 306                 if (ptl_hndl2nal(&eventqs_in[i]) != nal)
 307                         return PTL_EQ_INVALID;
 308
 309         return (nal->nal_eq_poll)(nal, eventqs_in, neq_in, timeout,
 310                                   event_out, which_out);
 311 }
 312
 313
 314 int PtlACEntry(ptl_handle_ni_t ni_in, ptl_ac_index_t index_in,
 315                ptl_process_id_t match_id_in, ptl_pt_index_t portal_in)
 316 {
 317         nal_t    *nal;
 318
 319         if (!ptl_init)
 320                 return PTL_NO_INIT;
 321
 322         nal = ptl_hndl2nal(&ni_in);
 323         if (nal == NULL)
 324                 return PTL_NI_INVALID;
 325
 326         return (nal->nal_ace_entry)(nal, index_in, match_id_in, portal_in);
 327 }
 328
 329 int PtlPut(ptl_handle_md_t md_in, ptl_ack_req_t ack_req_in,
 330            ptl_process_id_t target_in, ptl_pt_index_t portal_in,
 331            ptl_ac_index_t ac_in, ptl_match_bits_t match_bits_in,
 332            ptl_size_t offset_in, ptl_hdr_data_t hdr_data_in)
 333 {
 334         nal_t    *nal;
 335
 336         if (!ptl_init)
 337                 return PTL_NO_INIT;
 338
 339         nal = ptl_hndl2nal(&md_in);
 340         if (nal == NULL)
 341                 return PTL_MD_INVALID;
 342
 343         return (nal->nal_put)(nal, &md_in, ack_req_in,
 344                               &target_in, portal_in, ac_in,
 345                               match_bits_in, offset_in, hdr_data_in);
 346 }
 347
 348 int PtlGet(ptl_handle_md_t md_in, ptl_process_id_t target_in,
 349            ptl_pt_index_t portal_in, ptl_ac_index_t ac_in,
 350            ptl_match_bits_t match_bits_in, ptl_size_t offset_in)
 351 {
 352         nal_t  *nal;
 353
 354         if (!ptl_init)
 355                 return PTL_NO_INIT;
 356
 357         nal = ptl_hndl2nal(&md_in);
 358         if (nal == NULL)
 359                 return PTL_MD_INVALID;
 360
 361         return (nal->nal_get)(nal, &md_in,
 362                               &target_in, portal_in, ac_in,
 363                               match_bits_in, offset_in);
 364 }
 365