usr/src/lib/librsm/common/rsmloopback.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 1998-2001 by Sun Microsystems, Inc.
  24  * All rights reserved.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 #include <stdio.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <sys/mman.h>
  33 #include <sys/uio.h>
  34 #include <sys/sysmacros.h>
  35 #include <unistd.h>
  36 #include <fcntl.h>
  37 #include <dlfcn.h>
  38 #include <sched.h>
  39 #include <errno.h>
  40 #include <strings.h>
  41
  42 #include <rsmapi.h>
  43 #include <sys/rsm/rsmndi.h>
  44 #include <rsmlib_in.h>
  45 #include <sys/rsm/rsm.h>
  46
  47 extern int _rsm_memseg_import_map(rsm_memseg_import_handle_t,
  48     void **,
  49     rsm_attribute_t,
  50     rsm_permission_t,
  51     off_t, size_t);
  52
  53 extern int _rsm_memseg_import_unmap(rsm_memseg_import_handle_t);
  54
  55 static rsm_ndlib_attr_t _rsm_loopback_attr = {
  56         B_TRUE,         /* mapping needed for put/get */
  57         B_TRUE          /* mapping needed for putv/getv */
  58 };
  59
  60 static int
  61 loopback_get8(rsm_memseg_import_handle_t im_memseg, off_t off,
  62     uint8_t *datap,
  63     ulong_t rep_cnt,
  64     boolean_t swap)
  65 {
  66         rsmseg_handle_t *seg = (rsmseg_handle_t *)im_memseg;
  67         uint8_t *data_addr =
  68             (uint8_t *)&seg->rsmseg_vaddr[off - seg->rsmseg_mapoffset];
  69         uint_t i = 0;
  70         int     e;
  71
  72         swap = swap;
  73
  74         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
  75             "loopback_get8: enter\n"));
  76
  77         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
  78                 e = seg->rsmseg_ops->rsm_memseg_import_open_barrier(
  79                                 (rsm_barrier_handle_t)seg->rsmseg_barrier);
  80                 if (e != RSM_SUCCESS) {
  81                         return (e);
  82                 }
  83         }
  84
  85         for (i = 0; i < rep_cnt; i++) {
  86                 datap[i] = data_addr[i];
  87         }
  88
  89         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
  90                 e = seg->rsmseg_ops->rsm_memseg_import_close_barrier(
  91                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
  92                 if (e != RSM_SUCCESS) {
  93                         return (e);
  94                 }
  95         }
  96
  97         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
  98             "loopback_get8: exit\n"));
  99
 100         return (RSM_SUCCESS);
 101 }
 102
 103 static int
 104 loopback_get16(rsm_memseg_import_handle_t im_memseg, off_t off,
 105     uint16_t *datap,
 106     ulong_t rep_cnt,
 107     boolean_t swap)
 108 {
 109         rsmseg_handle_t *seg = (rsmseg_handle_t *)im_memseg;
 110         uint16_t *data_addr =
 111             /* LINTED */
 112             (uint16_t *)&seg->rsmseg_vaddr[off - seg->rsmseg_mapoffset];
 113         uint_t i = 0;
 114         int     e;
 115
 116         swap = swap;
 117
 118         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 119             "loopback_get16: enter\n"));
 120
 121         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 122                 e = seg->rsmseg_ops->rsm_memseg_import_open_barrier(
 123                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 124                 if (e != RSM_SUCCESS) {
 125                         return (e);
 126                 }
 127         }
 128
 129         for (i = 0; i < rep_cnt; i++) {
 130                 datap[i] = data_addr[i];
 131         }
 132
 133         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 134                 e = seg->rsmseg_ops->rsm_memseg_import_close_barrier(
 135                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 136                 if (e != RSM_SUCCESS) {
 137                         return (e);
 138                 }
 139         }
 140
 141         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 142             "loopback_get16: exit\n"));
 143
 144         return (RSM_SUCCESS);
 145 }
 146
 147 static int
 148 loopback_get32(rsm_memseg_import_handle_t im_memseg, off_t off,
 149     uint32_t *datap,
 150     ulong_t rep_cnt,
 151     boolean_t swap)
 152 {
 153         rsmseg_handle_t *seg = (rsmseg_handle_t *)im_memseg;
 154         uint32_t *data_addr =
 155             /* LINTED */
 156             (uint32_t *)&seg->rsmseg_vaddr[off - seg->rsmseg_mapoffset];
 157         uint_t i = 0;
 158         int     e;
 159
 160         swap = swap;
 161
 162         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 163             "loopback_get32: enter\n"));
 164
 165         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 166                 e = seg->rsmseg_ops->rsm_memseg_import_open_barrier(
 167                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 168                 if (e != RSM_SUCCESS) {
 169                         return (e);
 170                 }
 171         }
 172
 173         for (i = 0; i < rep_cnt; i++) {
 174                 datap[i] = data_addr[i];
 175         }
 176
 177         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 178                 e = seg->rsmseg_ops->rsm_memseg_import_close_barrier(
 179                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 180                 if (e != RSM_SUCCESS) {
 181                         return (e);
 182                 }
 183         }
 184
 185         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 186             "loopback_get32: exit\n"));
 187
 188         return (RSM_SUCCESS);
 189 }
 190
 191 static int
 192 loopback_get64(rsm_memseg_import_handle_t im_memseg, off_t off,
 193     uint64_t *datap,
 194     ulong_t rep_cnt,
 195     boolean_t swap)
 196 {
 197         rsmseg_handle_t *seg = (rsmseg_handle_t *)im_memseg;
 198         uint64_t *data_addr =
 199             /* LINTED */
 200             (uint64_t *)&seg->rsmseg_vaddr[off - seg->rsmseg_mapoffset];
 201         uint_t i = 0;
 202         int     e;
 203
 204         swap = swap;
 205
 206         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 207             "loopback_get64: enter\n"));
 208
 209         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 210                 e = seg->rsmseg_ops->rsm_memseg_import_open_barrier(
 211                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 212                 if (e != RSM_SUCCESS) {
 213                         return (e);
 214                 }
 215         }
 216
 217         for (i = 0; i < rep_cnt; i++) {
 218                 datap[i] = data_addr[i];
 219         }
 220
 221         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 222                 e = seg->rsmseg_ops->rsm_memseg_import_close_barrier(
 223                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 224                 if (e != RSM_SUCCESS) {
 225                         return (e);
 226                 }
 227         }
 228
 229         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 230             "loopback_get64: exit\n"));
 231
 232         return (RSM_SUCCESS);
 233 }
 234
 235 static int
 236 loopback_put8(rsm_memseg_import_handle_t im_memseg, off_t off,
 237     uint8_t *datap,
 238     ulong_t rep_cnt,
 239     boolean_t swap)
 240 {
 241         rsmseg_handle_t *seg = (rsmseg_handle_t *)im_memseg;
 242         uint8_t *data_addr =
 243                 (uint8_t *)&seg->rsmseg_vaddr[off - seg->rsmseg_mapoffset];
 244         uint_t i = 0;
 245         int     e;
 246
 247         swap = swap;
 248
 249         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 250             "loopback_put8: enter\n"));
 251
 252         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 253                 e = seg->rsmseg_ops->rsm_memseg_import_open_barrier(
 254                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 255                 if (e != RSM_SUCCESS) {
 256                         return (e);
 257                 }
 258         }
 259
 260         for (i = 0; i < rep_cnt; i++) {
 261                 data_addr[i] = datap[i];
 262         }
 263
 264         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 265                 e = seg->rsmseg_ops->rsm_memseg_import_close_barrier(
 266                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 267                 if (e != RSM_SUCCESS) {
 268                         return (e);
 269                 }
 270         }
 271
 272         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 273             "loopback_put8: exit\n"));
 274
 275         return (RSM_SUCCESS);
 276 }
 277
 278 static int
 279 loopback_put16(rsm_memseg_import_handle_t im_memseg, off_t off,
 280     uint16_t *datap,
 281     ulong_t rep_cnt,
 282     boolean_t swap)
 283 {
 284         rsmseg_handle_t *seg = (rsmseg_handle_t *)im_memseg;
 285         uint16_t *data_addr =
 286             /* LINTED */
 287             (uint16_t *)&seg->rsmseg_vaddr[off - seg->rsmseg_mapoffset];
 288         uint_t i = 0;
 289         int     e;
 290
 291         swap = swap;
 292
 293         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 294             "loopback_put16: enter\n"));
 295
 296         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 297                 e = seg->rsmseg_ops->rsm_memseg_import_open_barrier(
 298                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 299                 if (e != RSM_SUCCESS) {
 300                         return (e);
 301                 }
 302         }
 303
 304         for (i = 0; i < rep_cnt; i++) {
 305                 data_addr[i] = datap[i];
 306         }
 307
 308         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 309                 e = seg->rsmseg_ops->rsm_memseg_import_close_barrier(
 310                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 311                 if (e != RSM_SUCCESS) {
 312                         return (e);
 313                 }
 314         }
 315
 316         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 317             "loopback_put16: exit\n"));
 318
 319         return (RSM_SUCCESS);
 320 }
 321
 322 static int
 323 loopback_put32(rsm_memseg_import_handle_t im_memseg, off_t off,
 324     uint32_t *datap,
 325     ulong_t rep_cnt,
 326     boolean_t swap)
 327 {
 328         rsmseg_handle_t *seg = (rsmseg_handle_t *)im_memseg;
 329         uint32_t *data_addr =
 330             /* LINTED */
 331             (uint32_t *)&seg->rsmseg_vaddr[off - seg->rsmseg_mapoffset];
 332         uint_t i = 0;
 333         int     e;
 334
 335         swap = swap;
 336
 337         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 338             "loopback_put32: enter\n"));
 339
 340         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 341                 e = seg->rsmseg_ops->rsm_memseg_import_open_barrier(
 342                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 343                 if (e != RSM_SUCCESS) {
 344                         return (e);
 345                 }
 346         }
 347
 348         for (i = 0; i < rep_cnt; i++) {
 349                 data_addr[i] = datap[i];
 350         }
 351
 352         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 353                 e = seg->rsmseg_ops->rsm_memseg_import_close_barrier(
 354                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 355                 if (e != RSM_SUCCESS) {
 356                         return (e);
 357                 }
 358         }
 359
 360         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 361             "loopback_put32: exit\n"));
 362
 363         return (RSM_SUCCESS);
 364 }
 365
 366 static int
 367 loopback_put64(rsm_memseg_import_handle_t im_memseg, off_t off,
 368     uint64_t *datap,
 369     ulong_t rep_cnt,
 370     boolean_t swap)
 371 {
 372         rsmseg_handle_t *seg = (rsmseg_handle_t *)im_memseg;
 373         uint64_t *data_addr =
 374             /* LINTED */
 375             (uint64_t *)&seg->rsmseg_vaddr[off - seg->rsmseg_mapoffset];
 376         uint_t i = 0;
 377         int     e;
 378
 379         swap = swap;
 380
 381         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 382             "loopback_put64: enter\n"));
 383
 384         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 385                 e = seg->rsmseg_ops->rsm_memseg_import_open_barrier(
 386                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 387                 if (e != RSM_SUCCESS) {
 388                         return (e);
 389                 }
 390         }
 391
 392         for (i = 0; i < rep_cnt; i++) {
 393                 data_addr[i] = datap[i];
 394         }
 395
 396         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 397                 e = seg->rsmseg_ops->rsm_memseg_import_close_barrier(
 398                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 399                 if (e != RSM_SUCCESS) {
 400                         return (e);
 401                 }
 402         }
 403
 404         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 405             "loopback_put64: exit\n"));
 406
 407         return (RSM_SUCCESS);
 408 }
 409
 410 static int
 411 loopback_get(rsm_memseg_import_handle_t im_memseg, off_t offset, void *dst_addr,
 412     size_t length)
 413 {
 414         rsmseg_handle_t *seg = (rsmseg_handle_t *)im_memseg;
 415         int     e;
 416
 417         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 418             "loopback_get: enter\n"));
 419
 420         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 421                 e = seg->rsmseg_ops->rsm_memseg_import_open_barrier(
 422                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 423                 if (e != RSM_SUCCESS) {
 424                         return (e);
 425                 }
 426         }
 427
 428         bcopy(seg->rsmseg_vaddr + offset - seg->rsmseg_mapoffset, dst_addr,
 429                 length);
 430
 431         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 432                 e = seg->rsmseg_ops->rsm_memseg_import_close_barrier(
 433                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 434                 if (e != RSM_SUCCESS) {
 435                         return (e);
 436                 }
 437         }
 438
 439         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 440             "loopback_get: exit\n"));
 441
 442         return (RSM_SUCCESS);
 443 }
 444
 445
 446 /*
 447  * Move data to each component of the io vector from the remote segment
 448  */
 449 int
 450 loopback_getv(rsm_scat_gath_t *sg_io)
 451 {
 452         rsm_iovec_t     *iovec = sg_io->iovec;
 453         rsmseg_handle_t *im_seg = (rsmseg_handle_t *)sg_io->remote_handle;
 454         int i;
 455
 456         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 457             "loopback_getv: enter\n"));
 458
 459         /* do the vector data transfer */
 460         for (i = 0; i < sg_io->io_request_count; i++) {
 461                 (void) bcopy(im_seg->rsmseg_vaddr + iovec->remote_offset,
 462                     iovec->local.vaddr + iovec->local_offset,
 463                     iovec->transfer_length);
 464                 iovec++;
 465         }
 466
 467         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 468             "loopback_getv: exit\n"));
 469
 470         sg_io->io_residual_count = 0;
 471
 472         return (RSM_SUCCESS);
 473 }
 474
 475 static int
 476 loopback_put(rsm_memseg_import_handle_t im_memseg, off_t offset, void *src_addr,
 477     size_t length)
 478 {
 479         rsmseg_handle_t *seg = (rsmseg_handle_t *)im_memseg;
 480         int     e;
 481
 482         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 483             "loopback_put: enter\n"));
 484
 485         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 486                 e = seg->rsmseg_ops->rsm_memseg_import_open_barrier(
 487                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 488                 if (e != RSM_SUCCESS) {
 489                         return (e);
 490                 }
 491         }
 492
 493         bcopy(src_addr, seg->rsmseg_vaddr + offset - seg->rsmseg_mapoffset,
 494                 length);
 495
 496         if (seg->rsmseg_barmode == RSM_BARRIER_MODE_IMPLICIT) {
 497                 e = seg->rsmseg_ops->rsm_memseg_import_close_barrier(
 498                     (rsm_barrier_handle_t)seg->rsmseg_barrier);
 499                 if (e != RSM_SUCCESS) {
 500                         return (e);
 501                 }
 502         }
 503
 504         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 505             "loopback_put: exit\n"));
 506
 507         return (RSM_SUCCESS);
 508 }
 509
 510
 511 /*
 512  * Move data from each component of the io vector to the remote segment
 513  */
 514 int
 515 loopback_putv(rsm_scat_gath_t *sg_io)
 516 {
 517         rsm_iovec_t     *iovec = sg_io->iovec;
 518         rsmseg_handle_t *im_seg = (rsmseg_handle_t *)sg_io->remote_handle;
 519         int i;
 520
 521         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 522             "loopback_putv: enter\n"));
 523
 524         /* do the vector data transfer */
 525         for (i = 0; i < sg_io->io_request_count; i++) {
 526                 (void) bcopy(iovec->local.vaddr + iovec->local_offset,
 527                     im_seg->rsmseg_vaddr + iovec->remote_offset,
 528                     iovec->transfer_length);
 529                 iovec++;
 530         }
 531
 532         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 533             "loopback_putv: exit\n"));
 534
 535         sg_io->io_residual_count = 0;
 536
 537         return (RSM_SUCCESS);
 538 }
 539
 540 static int
 541 loopback_create_handle(rsmapi_controller_handle_t controller,
 542     rsm_localmemory_handle_t *local_handle,
 543     caddr_t vaddr, size_t len)
 544 {
 545
 546         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 547             "loopback_create_handle: enter\n"));
 548
 549         controller = controller;
 550         len = len;
 551
 552         *local_handle = (rsm_localmemory_handle_t)vaddr;
 553
 554         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 555             "loopback_create_handle: exit\n"));
 556
 557         return (RSM_SUCCESS);
 558 }
 559
 560 static int
 561 loopback_free_handle(rsm_localmemory_handle_t handle)
 562 {
 563
 564         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 565             "loopback_free_handle: enter\n"));
 566
 567         handle = handle;
 568
 569         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 570             "loopback_free_handle: exit\n"));
 571
 572         return (RSM_SUCCESS);
 573 }
 574
 575
 576         /*
 577          * import side memory segment operations (barriers):
 578          */
 579 static int
 580 loopback_init_barrier(rsm_memseg_import_handle_t im_memseg,
 581     rsm_barrier_type_t type,
 582     rsm_barrier_handle_t barrier)
 583 {
 584
 585         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 586             "loopback_init_barrier: enter\n"));
 587
 588         type = type; im_memseg = im_memseg; barrier = barrier;
 589
 590         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 591             "loopback_init_barrier: exit\n"));
 592
 593         return (RSM_SUCCESS);
 594 }
 595
 596 static int
 597 loopback_open_barrier(rsm_barrier_handle_t barrier)
 598 {
 599
 600         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 601             "loopback_open_barrier: enter\n"));
 602
 603         barrier = barrier;
 604
 605         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 606             "loopback_open_barrier: exit\n"));
 607
 608         return (RSM_SUCCESS);
 609 }
 610
 611 static int
 612 loopback_order_barrier(rsm_barrier_handle_t barrier)
 613 {
 614
 615         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 616             "loopback_order_barrier: enter\n"));
 617
 618         barrier = barrier;
 619
 620         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 621             "loopback_order_barrier: exit\n"));
 622
 623         return (RSM_SUCCESS);
 624 }
 625
 626 static int
 627 loopback_close_barrier(rsm_barrier_handle_t barrier)
 628 {
 629
 630         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 631             "loopback_close_barrier: enter\n"));
 632
 633         barrier = barrier;
 634
 635         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 636             "loopback_close_barrier: exit\n"));
 637
 638         return (RSM_SUCCESS);
 639 }
 640
 641 static int
 642 loopback_destroy_barrier(rsm_barrier_handle_t barrier)
 643 {
 644
 645         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 646             "loopback_destroy_barrier: enter\n"));
 647
 648         barrier = barrier;
 649
 650         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 651             "loopback_destroy_barrier: exit\n"));
 652
 653         return (RSM_SUCCESS);
 654 }
 655
 656 static int
 657 loopback_get_lib_attr(rsm_ndlib_attr_t **libattrp)
 658 {
 659
 660         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 661             "loopback_get_lib_attr: enter\n"));
 662
 663         *libattrp = &_rsm_loopback_attr;
 664
 665         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 666             "loopback_get_lib_attr: exit\n"));
 667
 668         return (RSM_SUCCESS);
 669 }
 670 /*
 671  * If an entry is NULL, the parent will fill it out with its entry point.
 672  */
 673 void
 674 __rsmloopback_init_ops(rsm_segops_t *segops)
 675 {
 676
 677         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 678             "__rsmloopback_init_ops: enter\n"));
 679
 680         segops->rsm_memseg_import_get8 = loopback_get8;
 681         segops->rsm_memseg_import_get16 = loopback_get16;
 682         segops->rsm_memseg_import_get32 = loopback_get32;
 683         segops->rsm_memseg_import_get64 = loopback_get64;
 684
 685         segops->rsm_memseg_import_put8 = loopback_put8;
 686         segops->rsm_memseg_import_put16 = loopback_put16;
 687         segops->rsm_memseg_import_put32 = loopback_put32;
 688         segops->rsm_memseg_import_put64 = loopback_put64;
 689
 690         segops->rsm_memseg_import_put = loopback_put;
 691         segops->rsm_memseg_import_get = loopback_get;
 692
 693         segops->rsm_memseg_import_putv = loopback_putv;
 694         segops->rsm_memseg_import_getv = loopback_getv;
 695
 696         segops->rsm_create_localmemory_handle = loopback_create_handle;
 697         segops->rsm_free_localmemory_handle = loopback_free_handle;
 698
 699         segops->rsm_memseg_import_init_barrier = loopback_init_barrier;
 700         segops->rsm_memseg_import_open_barrier = loopback_open_barrier;
 701         segops->rsm_memseg_import_order_barrier = loopback_order_barrier;
 702         segops->rsm_memseg_import_close_barrier = loopback_close_barrier;
 703         segops->rsm_memseg_import_destroy_barrier = loopback_destroy_barrier;
 704
 705         segops->rsm_get_lib_attr = loopback_get_lib_attr;
 706
 707         DBPRINTF((RSM_LIBRARY|RSM_LOOPBACK, RSM_DEBUG_VERBOSE,
 708             "__rsmloopback_init_ops: exit\n"));
 709
 710 }