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