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 PtlLoopback (ptl_handle_ni_t interface, int set, int *enabled)
  90 {
  91         nal_t     *nal;
  92
  93         if (!ptl_init)
  94                 return PTL_NO_INIT;
  95
  96         nal = ptl_hndl2nal(&interface);
  97         if (nal == NULL)
  98                 return PTL_NI_INVALID;
  99
 100         return nal->nal_loopback(nal, set, enabled);
 101 }
 102
 103 int PtlNIStatus(ptl_handle_ni_t interface_in, ptl_sr_index_t register_in,
 104                 ptl_sr_value_t *status_out)
 105 {
 106         nal_t     *nal;
 107
 108         if (!ptl_init)
 109                 return PTL_NO_INIT;
 110
 111         nal = ptl_hndl2nal(&interface_in);
 112         if (nal == NULL)
 113                 return PTL_NI_INVALID;
 114
 115         return nal->nal_ni_status(nal, register_in, status_out);
 116 }
 117
 118 int PtlNIDist(ptl_handle_ni_t interface_in, ptl_process_id_t process_in,
 119               unsigned long *distance_out)
 120 {
 121         nal_t     *nal;
 122
 123         if (!ptl_init)
 124                 return PTL_NO_INIT;
 125
 126         nal = ptl_hndl2nal(&interface_in);
 127         if (nal == NULL)
 128                 return PTL_NI_INVALID;
 129
 130         return nal->nal_ni_dist(nal, &process_in, distance_out);
 131 }
 132
 133 int PtlMEAttach(ptl_handle_ni_t interface_in, ptl_pt_index_t index_in,
 134                 ptl_process_id_t match_id_in, ptl_match_bits_t match_bits_in,
 135                 ptl_match_bits_t ignore_bits_in, ptl_unlink_t unlink_in,
 136                 ptl_ins_pos_t pos_in, ptl_handle_me_t *handle_out)
 137 {
 138         nal_t     *nal;
 139
 140         if (!ptl_init)
 141                 return PTL_NO_INIT;
 142
 143         nal = ptl_hndl2nal(&interface_in);
 144         if (nal == NULL)
 145                 return PTL_NI_INVALID;
 146
 147         return nal->nal_me_attach(nal, index_in, match_id_in,
 148                                   match_bits_in, ignore_bits_in,
 149                                   unlink_in, pos_in, handle_out);
 150 }
 151
 152 int PtlMEInsert(ptl_handle_me_t current_in, ptl_process_id_t match_id_in,
 153                 ptl_match_bits_t match_bits_in, ptl_match_bits_t ignore_bits_in,
 154                 ptl_unlink_t unlink_in, ptl_ins_pos_t position_in,
 155                 ptl_handle_me_t * handle_out)
 156 {
 157         nal_t     *nal;
 158
 159         if (!ptl_init)
 160                 return PTL_NO_INIT;
 161
 162         nal = ptl_hndl2nal(&current_in);
 163         if (nal == NULL)
 164                 return PTL_ME_INVALID;
 165
 166         return nal->nal_me_insert(nal, &current_in, match_id_in,
 167                                   match_bits_in, ignore_bits_in,
 168                                   unlink_in, position_in, handle_out);
 169 }
 170
 171 int PtlMEUnlink(ptl_handle_me_t current_in)
 172 {
 173         nal_t     *nal;
 174
 175         if (!ptl_init)
 176                 return PTL_NO_INIT;
 177
 178         nal = ptl_hndl2nal(&current_in);
 179         if (nal == NULL)
 180                 return PTL_ME_INVALID;
 181
 182         return nal->nal_me_unlink(nal, &current_in);
 183 }
 184
 185 int PtlMDAttach(ptl_handle_me_t me_in, ptl_md_t md_in,
 186                 ptl_unlink_t unlink_in, ptl_handle_md_t * handle_out)
 187 {
 188         nal_t     *nal;
 189
 190         if (!ptl_init)
 191                 return PTL_NO_INIT;
 192
 193         nal = ptl_hndl2nal(&me_in);
 194         if (nal == NULL)
 195                 return PTL_ME_INVALID;
 196
 197         if (!PtlHandleIsEqual(md_in.eq_handle, PTL_EQ_NONE) &&
 198             ptl_hndl2nal(&md_in.eq_handle) != nal)
 199                 return PTL_MD_ILLEGAL;
 200
 201         return (nal->nal_md_attach)(nal, &me_in, &md_in,
 202                                     unlink_in, handle_out);
 203 }
 204
 205 int PtlMDBind(ptl_handle_ni_t ni_in, ptl_md_t md_in,
 206               ptl_unlink_t unlink_in, ptl_handle_md_t *handle_out)
 207 {
 208         nal_t     *nal;
 209
 210         if (!ptl_init)
 211                 return PTL_NO_INIT;
 212
 213         nal = ptl_hndl2nal(&ni_in);
 214         if (nal == NULL)
 215                 return PTL_NI_INVALID;
 216
 217         if (!PtlHandleIsEqual(md_in.eq_handle, PTL_EQ_NONE) &&
 218             ptl_hndl2nal(&md_in.eq_handle) != nal)
 219                 return PTL_MD_ILLEGAL;
 220
 221         return (nal->nal_md_bind)(nal, &md_in, unlink_in, handle_out);
 222 }
 223
 224 int PtlMDUpdate(ptl_handle_md_t md_in, ptl_md_t *old_inout,
 225                 ptl_md_t *new_inout, ptl_handle_eq_t testq_in)
 226 {
 227         nal_t    *nal;
 228
 229         if (!ptl_init)
 230                 return PTL_NO_INIT;
 231
 232         nal = ptl_hndl2nal(&md_in);
 233         if (nal == NULL)
 234                 return PTL_MD_INVALID;
 235
 236         if (!PtlHandleIsEqual(testq_in, PTL_EQ_NONE) &&
 237             ptl_hndl2nal(&testq_in) != nal)
 238                 return PTL_EQ_INVALID;
 239
 240         return (nal->nal_md_update)(nal, &md_in,
 241                                     old_inout, new_inout, &testq_in);
 242 }
 243
 244 int PtlMDUnlink(ptl_handle_md_t md_in)
 245 {
 246         nal_t    *nal;
 247
 248         if (!ptl_init)
 249                 return PTL_NO_INIT;
 250
 251         nal = ptl_hndl2nal(&md_in);
 252         if (nal == NULL)
 253                 return PTL_MD_INVALID;
 254
 255         return (nal->nal_md_unlink)(nal, &md_in);
 256 }
 257
 258 int PtlEQAlloc(ptl_handle_ni_t interface, ptl_size_t count,
 259                ptl_eq_handler_t callback,
 260                ptl_handle_eq_t *handle_out)
 261 {
 262         nal_t    *nal;
 263
 264         if (!ptl_init)
 265                 return PTL_NO_INIT;
 266
 267         nal = ptl_hndl2nal(&interface);
 268         if (nal == NULL)
 269                 return PTL_NI_INVALID;
 270
 271         return (nal->nal_eq_alloc)(nal, count, callback, handle_out);
 272 }
 273
 274 int PtlEQFree(ptl_handle_eq_t eventq)
 275 {
 276         nal_t       *nal;
 277
 278         if (!ptl_init)
 279                 return PTL_NO_INIT;
 280
 281         nal = ptl_hndl2nal(&eventq);
 282         if (nal == NULL)
 283                 return PTL_EQ_INVALID;
 284
 285         return (nal->nal_eq_free)(nal, &eventq);
 286 }
 287
 288 int PtlEQGet(ptl_handle_eq_t eventq, ptl_event_t *ev)
 289 {
 290         int which;
 291
 292         return (PtlEQPoll (&eventq, 1, 0, ev, &which));
 293 }
 294
 295 int PtlEQWait(ptl_handle_eq_t eventq_in, ptl_event_t *event_out)
 296 {
 297         int which;
 298
 299         return (PtlEQPoll (&eventq_in, 1, PTL_TIME_FOREVER,
 300                            event_out, &which));
 301 }
 302
 303 int PtlEQPoll(ptl_handle_eq_t *eventqs_in, int neq_in, int timeout,
 304               ptl_event_t *event_out, int *which_out)
 305 {
 306         int           i;
 307         nal_t        *nal;
 308
 309         if (!ptl_init)
 310                 return PTL_NO_INIT;
 311
 312         if (neq_in < 1)
 313                 return PTL_EQ_INVALID;
 314
 315         nal = ptl_hndl2nal(&eventqs_in[0]);
 316         if (nal == NULL)
 317                 return PTL_EQ_INVALID;
 318
 319         for (i = 1; i < neq_in; i++)
 320                 if (ptl_hndl2nal(&eventqs_in[i]) != nal)
 321                         return PTL_EQ_INVALID;
 322
 323         return (nal->nal_eq_poll)(nal, eventqs_in, neq_in, timeout,
 324                                   event_out, which_out);
 325 }
 326
 327
 328 int PtlACEntry(ptl_handle_ni_t ni_in, ptl_ac_index_t index_in,
 329                ptl_process_id_t match_id_in, ptl_pt_index_t portal_in)
 330 {
 331         nal_t    *nal;
 332
 333         if (!ptl_init)
 334                 return PTL_NO_INIT;
 335
 336         nal = ptl_hndl2nal(&ni_in);
 337         if (nal == NULL)
 338                 return PTL_NI_INVALID;
 339
 340         return (nal->nal_ace_entry)(nal, index_in, match_id_in, portal_in);
 341 }
 342
 343 int PtlPut(ptl_handle_md_t md_in, ptl_ack_req_t ack_req_in,
 344            ptl_process_id_t target_in, ptl_pt_index_t portal_in,
 345            ptl_ac_index_t ac_in, ptl_match_bits_t match_bits_in,
 346            ptl_size_t offset_in, ptl_hdr_data_t hdr_data_in)
 347 {
 348         nal_t    *nal;
 349
 350         if (!ptl_init)
 351                 return PTL_NO_INIT;
 352
 353         nal = ptl_hndl2nal(&md_in);
 354         if (nal == NULL)
 355                 return PTL_MD_INVALID;
 356
 357         return (nal->nal_put)(nal, &md_in, ack_req_in,
 358                               &target_in, portal_in, ac_in,
 359                               match_bits_in, offset_in, hdr_data_in);
 360 }
 361
 362 int PtlGet(ptl_handle_md_t md_in, ptl_process_id_t target_in,
 363            ptl_pt_index_t portal_in, ptl_ac_index_t ac_in,
 364            ptl_match_bits_t match_bits_in, ptl_size_t offset_in)
 365 {
 366         nal_t  *nal;
 367
 368         if (!ptl_init)
 369                 return PTL_NO_INIT;
 370
 371         nal = ptl_hndl2nal(&md_in);
 372         if (nal == NULL)
 373                 return PTL_MD_INVALID;
 374
 375         return (nal->nal_get)(nal, &md_in,
 376                               &target_in, portal_in, ac_in,
 377                               match_bits_in, offset_in);
 378 }
 379