source3/locking/shmem.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Shared memory functions
   5    Copyright (C) Erik Devriendt 1996
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21 */
  22
  23 #include "includes.h"
  24
  25
  26 #if FAST_SHARE_MODES
  27
  28
  29 extern int DEBUGLEVEL;
  30
  31
  32 #define SHM_MAGIC 0x53484100
  33 /* = "SHM" in hex */
  34
  35 #define SHM_VERSION 1
  36
  37 /* WARNING : offsets are used because mmap() does not guarantee that all processes have the
  38    shared memory mapped to the same address */
  39
  40 struct ShmHeader
  41 {
  42    int shm_magic;
  43    int shm_version;
  44    int total_size;      /* in bytes */
  45    BOOL consistent;
  46    shm_offset_t first_free_off;
  47    shm_offset_t userdef_off;    /* a userdefined offset. can be used to store root of tree or list */
  48    struct {             /* a cell is a range of bytes of sizeof(struct ShmBlockDesc) size */
  49       int cells_free;
  50       int cells_used;
  51       int cells_system; /* number of cells used as allocated block descriptors */
  52    } statistics;
  53 };
  54
  55 #define SHM_NOT_FREE_OFF (-1)
  56 struct ShmBlockDesc
  57 {
  58    shm_offset_t next;   /* offset of next block in the free list or SHM_NOT_FREE_OFF when block in use  */
  59    int          size;   /* user size in BlockDescSize units */
  60 };
  61
  62 #define EOList_Addr     (struct ShmBlockDesc *)( 0 )
  63 #define EOList_Off      (NULL_OFFSET)
  64
  65 #define CellSize        sizeof(struct ShmBlockDesc)
  66
  67 /* HeaderSize aligned on 8 byte boundary */
  68 #define AlignedHeaderSize       ((sizeof(struct ShmHeader)+7) & ~7)
  69
  70 static int  shm_fd = -1;
  71 static pstring shm_processreg_name = "";
  72
  73 static struct ShmHeader *shm_header_p = (struct ShmHeader *)0;
  74 static int shm_times_locked = 0;
  75
  76 static BOOL shm_register_process(char *processreg_file, pid_t pid, BOOL *other_processes)
  77 {
  78    int old_umask;
  79    int shm_processes_fd = -1;
  80    int nb_read;
  81    pid_t other_pid;
  82    int free_slot = -1;
  83    int erased_slot;
  84
  85
  86    old_umask = umask(0);
  87    shm_processes_fd = open(processreg_file, O_RDWR | O_CREAT, 0666);
  88    umask(old_umask);
  89    if ( shm_processes_fd < 0 )
  90    {
  91       DEBUG(0,("ERROR shm_register_process : processreg_file open failed with code %d\n",errno));
  92       return False;
  93    }
  94
  95    *other_processes = False;
  96
  97    while ((nb_read = read(shm_processes_fd, &other_pid, sizeof(other_pid))) > 0)
  98    {
  99       if(other_pid)
 100       {
 101          if(process_exists(other_pid))
 102             *other_processes = True;
 103          else
 104          {
 105             /* erase old pid */
 106             DEBUG(2,("shm_register_process : erasing stale record for pid %d\n",other_pid));
 107             other_pid = (pid_t)0;
 108             erased_slot = lseek(shm_processes_fd, -sizeof(other_pid), SEEK_CUR);
 109             write(shm_processes_fd, &other_pid, sizeof(other_pid));
 110             if(free_slot < 0)
 111                free_slot = erased_slot;
 112          }
 113       }
 114       else
 115          if(free_slot < 0)
 116             free_slot = lseek(shm_processes_fd, -sizeof(other_pid), SEEK_CUR);
 117    }
 118    if (nb_read < 0)
 119    {
 120       DEBUG(0,("ERROR shm_register_process : processreg_file read failed with code %d\n",errno));
 121       close(shm_processes_fd);
 122       return False;
 123    }
 124
 125    if(free_slot < 0)
 126       free_slot = lseek(shm_processes_fd, 0, SEEK_END);
 127
 128    DEBUG(2,("shm_register_process : writing record for pid %d at offset %d\n",pid,free_slot));
 129    lseek(shm_processes_fd, free_slot, SEEK_SET);
 130    if(write(shm_processes_fd, &pid, sizeof(pid)) < 0)
 131    {
 132       DEBUG(0,("ERROR shm_register_process : processreg_file write failed with code %d\n",errno));
 133       close(shm_processes_fd);
 134       return False;
 135    }
 136
 137    close(shm_processes_fd);
 138
 139    return True;
 140 }
 141
 142 static BOOL shm_unregister_process(char *processreg_file, pid_t pid)
 143 {
 144    int old_umask;
 145    int shm_processes_fd = -1;
 146    int nb_read;
 147    pid_t other_pid;
 148    int erased_slot;
 149    BOOL found = False;
 150
 151
 152    old_umask = umask(0);
 153    shm_processes_fd = open(processreg_file, O_RDWR);
 154    umask(old_umask);
 155    if ( shm_processes_fd < 0 )
 156    {
 157       DEBUG(0,("ERROR shm_unregister_process : processreg_file open failed with code %d\n",errno));
 158       return False;
 159    }
 160
 161    while ((nb_read = read(shm_processes_fd, &other_pid, sizeof(other_pid))) > 0)
 162    {
 163       if(other_pid == pid)
 164       {
 165          /* erase pid */
 166          DEBUG(2,("shm_unregister_process : erasing record for pid %d\n",other_pid));
 167          other_pid = (pid_t)0;
 168          erased_slot = lseek(shm_processes_fd, -sizeof(other_pid), SEEK_CUR);
 169          if(write(shm_processes_fd, &other_pid, sizeof(other_pid)) < 0)
 170          {
 171             DEBUG(0,("ERROR shm_unregister_process : processreg_file write failed with code %d\n",errno));
 172             close(shm_processes_fd);
 173             return False;
 174          }
 175
 176          found = True;
 177          break;
 178       }
 179    }
 180    if (nb_read < 0)
 181    {
 182       DEBUG(0,("ERROR shm_unregister_process : processreg_file read failed with code %d\n",errno));
 183       close(shm_processes_fd);
 184       return False;
 185    }
 186
 187    if(!found)
 188    {
 189       DEBUG(0,("ERROR shm_unregister_process : couldn't find pid %d in file %s\n",pid,processreg_file));
 190       close(shm_processes_fd);
 191       return False;
 192    }
 193
 194
 195    close(shm_processes_fd);
 196
 197    return True;
 198 }
 199
 200
 201 static BOOL shm_validate_header(int size)
 202 {
 203    if( !shm_header_p )
 204    {
 205       /* not mapped yet */
 206       DEBUG(0,("ERROR shm_validate_header : shmem not mapped\n"));
 207       return False;
 208    }
 209
 210    if(shm_header_p->shm_magic != SHM_MAGIC)
 211    {
 212       DEBUG(0,("ERROR shm_validate_header : bad magic\n"));
 213       return False;
 214    }
 215    if(shm_header_p->shm_version != SHM_VERSION)
 216    {
 217       DEBUG(0,("ERROR shm_validate_header : bad version %X\n",shm_header_p->shm_version));
 218       return False;
 219    }
 220
 221    if(shm_header_p->total_size != size)
 222    {
 223       DEBUG(0,("ERROR shm_validate_header : shmem size mismatch (old = %d, new = %d)\n",shm_header_p->total_size,size));
 224       return False;
 225    }
 226
 227    if(!shm_header_p->consistent)
 228    {
 229       DEBUG(0,("ERROR shm_validate_header : shmem not consistent\n"));
 230       return False;
 231    }
 232    return True;
 233 }
 234
 235 static BOOL shm_initialize(int size)
 236 {
 237    struct ShmBlockDesc * first_free_block_p;
 238
 239    DEBUG(2,("shm_initialize : initializing shmem file of size %d\n",size));
 240
 241    if( !shm_header_p )
 242    {
 243       /* not mapped yet */
 244       DEBUG(0,("ERROR shm_initialize : shmem not mapped\n"));
 245       return False;
 246    }
 247
 248    shm_header_p->shm_magic = SHM_MAGIC;
 249    shm_header_p->shm_version = SHM_VERSION;
 250    shm_header_p->total_size = size;
 251    shm_header_p->first_free_off = AlignedHeaderSize;
 252    shm_header_p->userdef_off = NULL_OFFSET;
 253
 254    first_free_block_p = (struct ShmBlockDesc *)shm_offset2addr(shm_header_p->first_free_off);
 255    first_free_block_p->next = EOList_Off;
 256    first_free_block_p->size = ( size - AlignedHeaderSize - CellSize ) / CellSize ;
 257
 258    shm_header_p->statistics.cells_free = first_free_block_p->size;
 259    shm_header_p->statistics.cells_used = 0;
 260    shm_header_p->statistics.cells_system = 1;
 261
 262    shm_header_p->consistent = True;
 263
 264    return True;
 265 }
 266
 267 static void shm_solve_neighbors(struct ShmBlockDesc *head_p )
 268 {
 269    struct ShmBlockDesc *next_p;
 270
 271    /* Check if head_p and head_p->next are neighbors and if so join them */
 272    if ( head_p == EOList_Addr ) return ;
 273    if ( head_p->next == EOList_Off ) return ;
 274
 275    next_p = (struct ShmBlockDesc *)shm_offset2addr(head_p->next);
 276    if ( ( head_p + head_p->size + 1 ) == next_p)
 277    {
 278       head_p->size += next_p->size +1 ; /* adapt size */
 279       head_p->next = next_p->next         ; /* link out */
 280
 281       shm_header_p->statistics.cells_free += 1;
 282       shm_header_p->statistics.cells_system -= 1;
 283    }
 284 }
 285
 286
 287
 288 BOOL shm_open( char *file_name, int size)
 289 {
 290    int filesize;
 291    BOOL created_new = False;
 292    BOOL other_processes = True;
 293    int old_umask;
 294
 295    DEBUG(2,("shm_open : using shmem file %s to be of size %d\n",file_name,size));
 296
 297    old_umask = umask(0);
 298    shm_fd = open(file_name, O_RDWR | O_CREAT, 0666);
 299    umask(old_umask);
 300    if ( shm_fd < 0 )
 301    {
 302       DEBUG(0,("ERROR shm_open : open failed with code %d\n",errno));
 303       return False;
 304    }
 305
 306    if (!shm_lock())
 307    {
 308       DEBUG(0,("ERROR shm_open : can't do shm_lock\n"));
 309       return False;
 310    }
 311
 312    if( (filesize = lseek(shm_fd, 0, SEEK_END)) < 0)
 313    {
 314       DEBUG(0,("ERROR shm_open : lseek failed with code %d\n",errno));
 315       shm_unlock();
 316       close(shm_fd);
 317       return False;
 318    }
 319
 320    /* return the file offset to 0 to save on later seeks */
 321    lseek(shm_fd,0,SEEK_SET);
 322
 323    if (filesize == 0)
 324    {
 325       /* we just created a new one */
 326       created_new = True;
 327    }
 328
 329    /* to find out if some other process is already mapping the file,
 330       we use a registration file containing the processids of the file mapping processes
 331       */
 332
 333    /* construct processreg file name */
 334    strcpy(shm_processreg_name, file_name);
 335    strcat(shm_processreg_name, ".processes");
 336
 337    if (! shm_register_process(shm_processreg_name, getpid(), &other_processes))
 338    {
 339       shm_unlock();
 340       close(shm_fd);
 341       return False;
 342    }
 343
 344    if (created_new || !other_processes)
 345    {
 346       /* we just created a new one, or are the first opener, lets set it size */
 347       if( ftruncate(shm_fd, size) <0)
 348       {
 349          DEBUG(0,("ERROR shm_open : ftruncate failed with code %d\n",errno));
 350          shm_unregister_process(shm_processreg_name, getpid());
 351          shm_unlock();
 352          close(shm_fd);
 353          return False;
 354       }
 355
 356       /* paranoia */
 357       lseek(shm_fd,0,SEEK_SET);
 358
 359       filesize = size;
 360    }
 361
 362    if (size != filesize )
 363    {
 364       /* the existing file has a different size and we are not the first opener.
 365          Since another process is still using it, we will use the file size */
 366       DEBUG(0,("WARNING shm_open : filesize (%d) != expected size (%d), using filesize\n",filesize,size));
 367       size = filesize;
 368    }
 369
 370    shm_header_p = (struct ShmHeader *)mmap( NULL, size, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, shm_fd, 0);
 371    /* WARNING, shm_header_p can be different for different processes mapping the same file ! */
 372    if (shm_header_p  == (struct ShmHeader *)(-1))
 373    {
 374       DEBUG(0,("ERROR shm_open : mmap failed with code %d\n",errno));
 375       shm_unregister_process(shm_processreg_name, getpid());
 376       shm_unlock();
 377       close(shm_fd);
 378       return False;
 379    }
 380
 381
 382    if (created_new || !other_processes)
 383    {
 384       shm_initialize(size);
 385    }
 386    else if (!shm_validate_header(size) )
 387    {
 388       /* existing file is corrupt, samba admin should remove it by hand */
 389       DEBUG(0,("ERROR shm_open : corrupt shared mem file, remove it manually\n"));
 390       munmap((caddr_t)shm_header_p, size);
 391       shm_unregister_process(shm_processreg_name, getpid());
 392       shm_unlock();
 393       close(shm_fd);
 394       return False;
 395    }
 396
 397    shm_unlock();
 398    return True;
 399
 400 }
 401
 402
 403 BOOL shm_close( void )
 404 {
 405
 406    DEBUG(2,("shm_close\n"));
 407    if(shm_times_locked > 0)
 408       DEBUG(0,("WARNING shm_close : shmem was still locked %d times\n",shm_times_locked));;
 409    if ( munmap((caddr_t)shm_header_p, shm_header_p->total_size) < 0)
 410    {
 411       DEBUG(0,("ERROR shm_close : munmap failed with code %d\n",errno));
 412    }
 413
 414    shm_lock();
 415    shm_unregister_process(shm_processreg_name, getpid());
 416    shm_unlock();
 417
 418    close(shm_fd);
 419
 420    shm_fd = -1;
 421    shm_processreg_name[0] = '\0';
 422
 423    shm_header_p = (struct ShmHeader *)0;
 424    shm_times_locked = 0;
 425
 426    return True;
 427 }
 428
 429 shm_offset_t shm_alloc(int size)
 430 {
 431    unsigned num_cells ;
 432    struct ShmBlockDesc *scanner_p;
 433    struct ShmBlockDesc *prev_p;
 434    struct ShmBlockDesc *new_p;
 435    shm_offset_t result_offset;
 436
 437
 438    if( !shm_header_p )
 439    {
 440       /* not mapped yet */
 441       DEBUG(0,("ERROR shm_alloc : shmem not mapped\n"));
 442       return NULL_OFFSET;
 443    }
 444
 445    if( !shm_header_p->consistent)
 446    {
 447       DEBUG(0,("ERROR shm_alloc : shmem not consistent\n"));
 448       return NULL_OFFSET;
 449    }
 450
 451
 452    /* calculate the number of cells */
 453    num_cells = (size + CellSize -1) / CellSize;
 454
 455    /* set start of scan */
 456    prev_p = (struct ShmBlockDesc *)shm_offset2addr(shm_header_p->first_free_off);
 457    scanner_p =  prev_p ;
 458
 459    /* scan the free list to find a matching free space */
 460    while ( ( scanner_p != EOList_Addr ) && ( scanner_p->size < num_cells ) )
 461    {
 462       prev_p = scanner_p;
 463       scanner_p = (struct ShmBlockDesc *)shm_offset2addr(scanner_p->next);
 464    }
 465
 466    /* at this point scanner point to a block header or to the end of the list */
 467    if ( scanner_p == EOList_Addr )
 468    {
 469       DEBUG(0,("ERROR shm_alloc : alloc of %d bytes failed, no free space found\n",size));
 470       return (NULL_OFFSET);
 471    }
 472
 473    /* going to modify shared mem */
 474    shm_header_p->consistent = False;
 475
 476    /* if we found a good one : scanner == the good one */
 477    if ( scanner_p->size <= num_cells + 2 )
 478    {
 479       /* there is no use in making a new one, it will be too small anyway
 480       *  we will link out scanner
 481       */
 482       if ( prev_p == scanner_p )
 483       {
 484          shm_header_p->first_free_off = scanner_p->next ;
 485       }
 486       else
 487       {
 488          prev_p->next = scanner_p->next ;
 489       }
 490       shm_header_p->statistics.cells_free -= scanner_p->size;
 491       shm_header_p->statistics.cells_used += scanner_p->size;
 492    }
 493    else
 494    {
 495       /* Make a new one */
 496       new_p = scanner_p + 1 + num_cells;
 497       new_p->size = scanner_p->size - num_cells - 1;
 498       new_p->next = scanner_p->next;
 499       scanner_p->size = num_cells;
 500       scanner_p->next = shm_addr2offset(new_p);
 501
 502       if ( prev_p       != scanner_p )
 503       {
 504          prev_p->next      = shm_addr2offset(new_p)  ;
 505       }
 506       else
 507       {
 508          shm_header_p->first_free_off = shm_addr2offset(new_p)  ;
 509       }
 510       shm_header_p->statistics.cells_free -= num_cells+1;
 511       shm_header_p->statistics.cells_used += num_cells;
 512       shm_header_p->statistics.cells_system += 1;
 513    }
 514
 515    result_offset = shm_addr2offset( &(scanner_p[1]) );
 516    scanner_p->next =    SHM_NOT_FREE_OFF ;
 517
 518    /* end modification of shared mem */
 519    shm_header_p->consistent = True;
 520
 521    DEBUG(2,("shm_alloc : request for %d bytes, allocated %d bytes at offset %d\n",size,scanner_p->size*CellSize,result_offset ));
 522
 523    return ( result_offset );
 524 }
 525
 526
 527
 528 BOOL shm_free(shm_offset_t offset)
 529 {
 530    struct ShmBlockDesc *header_p  ; /*  pointer to header of block to free */
 531    struct ShmBlockDesc *scanner_p ; /*  used to scan the list                      */
 532    struct ShmBlockDesc *prev_p     ; /* holds previous in the list                 */
 533
 534    if( !shm_header_p )
 535    {
 536       /* not mapped yet */
 537       DEBUG(0,("ERROR shm_free : shmem not mapped\n"));
 538       return False;
 539    }
 540
 541    if( !shm_header_p->consistent)
 542    {
 543       DEBUG(0,("ERROR shm_free : shmem not consistent\n"));
 544       return False;
 545    }
 546
 547    header_p = ( (struct ShmBlockDesc *)shm_offset2addr(offset) - 1); /* make pointer to header of block */
 548
 549    if (header_p->next != SHM_NOT_FREE_OFF)
 550    {
 551       DEBUG(0,("ERROR shm_free : bad offset (%d)\n",offset));
 552       return False;
 553    }
 554
 555    /* find a place in the free_list to put the header in */
 556
 557    /* set scanner and previous pointer to start of list */
 558    prev_p = (struct ShmBlockDesc *)shm_offset2addr(shm_header_p->first_free_off);
 559    scanner_p = prev_p ;
 560
 561    while ( ( scanner_p != EOList_Addr) && (scanner_p < header_p) ) /* while we didn't scan past its position */
 562    {
 563       prev_p = scanner_p ;
 564       scanner_p = (struct ShmBlockDesc *)shm_offset2addr(scanner_p->next);
 565    }
 566
 567    shm_header_p->consistent = False;
 568
 569    DEBUG(2,("shm_free : freeing %d bytes at offset %d\n",header_p->size*CellSize,offset));
 570
 571    if ( scanner_p == prev_p )
 572    {
 573       shm_header_p->statistics.cells_free += header_p->size;
 574       shm_header_p->statistics.cells_used -= header_p->size;
 575
 576       /* we must free it at the beginning of the list */
 577       shm_header_p->first_free_off = shm_addr2offset(header_p);                                          /*     set     the free_list_pointer to this block_header */
 578
 579       /* scanner is the one that was first in the list */
 580       header_p->next = shm_addr2offset(scanner_p);
 581       shm_solve_neighbors( header_p ); /* if neighbors then link them */
 582
 583       shm_header_p->consistent = True;
 584       return True;
 585    }
 586    else
 587    {
 588       shm_header_p->statistics.cells_free += header_p->size;
 589       shm_header_p->statistics.cells_used -= header_p->size;
 590
 591       prev_p->next = shm_addr2offset(header_p);
 592       header_p->next = shm_addr2offset(scanner_p);
 593       shm_solve_neighbors(header_p) ;
 594       shm_solve_neighbors(prev_p) ;
 595
 596       shm_header_p->consistent = True;
 597       return True;
 598    }
 599 }
 600
 601 shm_offset_t shm_get_userdef_off(void)
 602 {
 603    if (!shm_header_p)
 604       return NULL_OFFSET;
 605    else
 606       return shm_header_p->userdef_off;
 607 }
 608
 609 BOOL shm_set_userdef_off(shm_offset_t userdef_off)
 610 {
 611    if (!shm_header_p)
 612       return False;
 613    else
 614       shm_header_p->userdef_off = userdef_off;
 615    return True;
 616 }
 617
 618 void * shm_offset2addr(shm_offset_t offset)
 619 {
 620    if (offset == NULL_OFFSET )
 621       return (void *)(0);
 622
 623    if (!shm_header_p)
 624       return (void *)(0);
 625
 626    return (void *)((char *)shm_header_p + offset );
 627 }
 628
 629 shm_offset_t shm_addr2offset(void *addr)
 630 {
 631    if (!addr)
 632       return NULL_OFFSET;
 633
 634    if (!shm_header_p)
 635       return NULL_OFFSET;
 636
 637    return (shm_offset_t)((char *)addr - (char *)shm_header_p);
 638 }
 639
 640 BOOL shm_lock(void)
 641 {
 642    if (shm_fd < 0)
 643    {
 644       DEBUG(0,("ERROR shm_lock : bad shm_fd (%d)\n",shm_fd));
 645       return False;
 646    }
 647
 648    shm_times_locked++;
 649
 650    if(shm_times_locked > 1)
 651    {
 652       DEBUG(2,("shm_lock : locked %d times\n",shm_times_locked));
 653       return True;
 654    }
 655
 656    if (lockf(shm_fd, F_LOCK, 0) < 0)
 657    {
 658       DEBUG(0,("ERROR shm_lock : lockf failed with code %d\n",errno));
 659       shm_times_locked--;
 660       return False;
 661    }
 662
 663    return True;
 664
 665 }
 666
 667
 668
 669 BOOL shm_unlock(void)
 670 {
 671    if (shm_fd < 0)
 672    {
 673       DEBUG(0,("ERROR shm_unlock : bad shm_fd (%d)\n",shm_fd));
 674       return False;
 675    }
 676
 677    if(shm_times_locked == 0)
 678    {
 679       DEBUG(0,("ERROR shm_unlock : shmem not locked\n",shm_fd));
 680       return False;
 681    }
 682
 683    shm_times_locked--;
 684
 685    if(shm_times_locked > 0)
 686    {
 687       DEBUG(2,("shm_unlock : still locked %d times\n",shm_times_locked));
 688       return True;
 689    }
 690
 691    if (lockf(shm_fd, F_ULOCK, 0) < 0)
 692    {
 693       DEBUG(0,("ERROR shm_unlock : lockf failed with code %d\n",errno));
 694       shm_times_locked++;
 695       return False;
 696    }
 697
 698    return True;
 699
 700 }
 701
 702
 703 BOOL shm_get_usage(int *bytes_free,
 704                    int *bytes_used,
 705                    int *bytes_overhead)
 706 {
 707    if( !shm_header_p )
 708    {
 709       /* not mapped yet */
 710       DEBUG(0,("ERROR shm_free : shmem not mapped\n"));
 711       return False;
 712    }
 713    *bytes_free = shm_header_p->statistics.cells_free * CellSize;
 714    *bytes_used = shm_header_p->statistics.cells_used * CellSize;
 715    *bytes_overhead = shm_header_p->statistics.cells_system * CellSize + AlignedHeaderSize;
 716
 717    return True;
 718 }
 719
 720 #else /* FAST_SHARE_MODES */
 721  int shmem_dummy_procedure(void)
 722 {return 0;}
 723 #endif