added a new type to mkproto.awk so it can handle shmem.c
[kai/samba.git] / source3 / locking / shmem.c
index f68059afa2c613ad68f77ee55534e73153fbff82..fc8dfbb9f39928611e0a5fbfa8570af781b08532 100644 (file)
@@ -2,7 +2,7 @@
    Unix SMB/Netbios implementation.
    Version 1.9.
    Shared memory functions
    Unix SMB/Netbios implementation.
    Version 1.9.
    Shared memory functions
-   Copyright (C) Erik Devriendt 1996
+   Copyright (C) Erik Devriendt 1996-1997
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 #include "includes.h"
 
 
 #include "includes.h"
 
 
-#if FAST_SHARE_MODES
+#ifdef FAST_SHARE_MODES
 
 
 extern int DEBUGLEVEL;
 
 
 
 
 extern int DEBUGLEVEL;
 
 
-#define SHM_MAGIC 0x53484100
+#define SMB_SHM_MAGIC 0x53484100
 /* = "SHM" in hex */
 
 /* = "SHM" in hex */
 
-#define SHM_VERSION 1
+#define SMB_SHM_VERSION 2
 
 /* WARNING : offsets are used because mmap() does not guarantee that all processes have the 
    shared memory mapped to the same address */
 
 
 /* WARNING : offsets are used because mmap() does not guarantee that all processes have the 
    shared memory mapped to the same address */
 
-struct ShmHeader
+struct SmbShmHeader
 {
 {
-   int shm_magic;
-   int shm_version;
+   int smb_shm_magic;
+   int smb_shm_version;
    int total_size;     /* in bytes */
    BOOL consistent;
    int total_size;     /* in bytes */
    BOOL consistent;
-   shm_offset_t first_free_off;
-   shm_offset_t userdef_off;    /* a userdefined offset. can be used to store root of tree or list */
-   struct {            /* a cell is a range of bytes of sizeof(struct ShmBlockDesc) size */
+   smb_shm_offset_t first_free_off;
+   smb_shm_offset_t userdef_off;    /* a userdefined offset. can be used to store root of tree or list */
+   struct {            /* a cell is a range of bytes of sizeof(struct SmbShmBlockDesc) size */
       int cells_free;
       int cells_used;
       int cells_system; /* number of cells used as allocated block descriptors */
    } statistics;
 };
 
       int cells_free;
       int cells_used;
       int cells_system; /* number of cells used as allocated block descriptors */
    } statistics;
 };
 
-#define SHM_NOT_FREE_OFF (-1)
-struct ShmBlockDesc
+#define SMB_SHM_NOT_FREE_OFF (-1)
+struct SmbShmBlockDesc
 {
 {
-   shm_offset_t next;  /* offset of next block in the free list or SHM_NOT_FREE_OFF when block in use  */
+   smb_shm_offset_t next;      /* offset of next block in the free list or SMB_SHM_NOT_FREE_OFF when block in use  */
    int          size;   /* user size in BlockDescSize units */
 };
 
    int          size;   /* user size in BlockDescSize units */
 };
 
-#define        EOList_Addr     (struct ShmBlockDesc *)( 0 )
+#define        EOList_Addr     (struct SmbShmBlockDesc *)( 0 )
 #define EOList_Off      (NULL_OFFSET)
 
 #define EOList_Off      (NULL_OFFSET)
 
-#define        CellSize        sizeof(struct ShmBlockDesc)
+#define        CellSize        sizeof(struct SmbShmBlockDesc)
 
 /* HeaderSize aligned on 8 byte boundary */
 
 /* HeaderSize aligned on 8 byte boundary */
-#define        AlignedHeaderSize       ((sizeof(struct ShmHeader)+7) & ~7)
+#define        AlignedHeaderSize       ((sizeof(struct SmbShmHeader)+7) & ~7)
 
 
-static int  shm_fd = -1;
-static pstring shm_processreg_name = "";
+static int  smb_shm_fd = -1;
+static pstring smb_shm_processreg_name = "";
 
 
-static struct ShmHeader *shm_header_p = (struct ShmHeader *)0;
-static int shm_times_locked = 0;
+static struct SmbShmHeader *smb_shm_header_p = (struct SmbShmHeader *)0;
+static int smb_shm_times_locked = 0;
 
 
-static BOOL shm_register_process(char *processreg_file, pid_t pid, BOOL *other_processes)
+static BOOL smb_shm_initialize_called = False;
+
+static BOOL smb_shm_global_lock(void)
 {
 {
-   int old_umask;
-   int shm_processes_fd = -1;
+   if (smb_shm_fd < 0)
+   {
+      DEBUG(0,("ERROR smb_shm_global_lock : bad smb_shm_fd (%d)\n",smb_shm_fd));
+      return False;
+   }
+   
+   smb_shm_times_locked++;
+   
+   if(smb_shm_times_locked > 1)
+   {
+      DEBUG(5,("smb_shm_global_lock : locked %d times\n",smb_shm_times_locked));
+      return True;
+   }
+   
+   /* Do an exclusive wait lock on the first byte of the file */
+   if (fcntl_lock(smb_shm_fd, F_SETLKW, 0, 1, F_WRLCK) == False)
+   {
+      DEBUG(0,("ERROR smb_shm_global_lock : fcntl_lock failed with code %d\n",errno));
+      smb_shm_times_locked--;
+      return False;
+   }
+   
+   return True;
+   
+}
+
+static BOOL smb_shm_global_unlock(void)
+{
+   if (smb_shm_fd < 0)
+   {
+      DEBUG(0,("ERROR smb_shm_global_unlock : bad smb_shm_fd (%d)\n",smb_shm_fd));
+      return False;
+   }
+   
+   if(smb_shm_times_locked == 0)
+   {
+      DEBUG(0,("ERROR smb_shm_global_unlock : shmem not locked\n",smb_shm_fd));
+      return False;
+   }
+   
+   smb_shm_times_locked--;
+   
+   if(smb_shm_times_locked > 0)
+   {
+      DEBUG(5,("smb_shm_global_unlock : still locked %d times\n",smb_shm_times_locked));
+      return True;
+   }
+   
+   /* Do a wait unlock on the first byte of the file */
+   if (fcntl_lock(smb_shm_fd, F_SETLKW, 0, 1, F_UNLCK) == False)
+   {
+      DEBUG(0,("ERROR smb_shm_global_unlock : fcntl_lock failed with code %d\n",errno));
+      smb_shm_times_locked++;
+      return False;
+   }
+   
+   return True;
+   
+}
+
+/* 
+ * Function to create the hash table for the share mode entries. Called
+ * when smb shared memory is global locked.
+ */
+
+BOOL smb_shm_create_hash_table( unsigned int size )
+{
+  size *= sizeof(smb_shm_offset_t);
+
+  smb_shm_global_lock();
+  smb_shm_header_p->userdef_off = smb_shm_alloc( size );
+
+  if(smb_shm_header_p->userdef_off == NULL_OFFSET)
+    {
+      DEBUG(0,("smb_shm_create_hash_table: Failed to create hash table of size %d\n",size));
+      smb_shm_global_unlock();
+      return False;
+    }
+
+  /* Clear hash buckets. */
+  memset( smb_shm_offset2addr(smb_shm_header_p->userdef_off), '\0', size);
+  smb_shm_global_unlock();
+  return True;
+}
+
+static BOOL smb_shm_register_process(char *processreg_file, pid_t pid, BOOL *other_processes)
+{
+   int smb_shm_processes_fd = -1;
    int nb_read;
    pid_t other_pid;
    int nb_read;
    pid_t other_pid;
+   int seek_back = -((int)sizeof(other_pid));
    int free_slot = -1;
    int free_slot = -1;
-   int erased_slot;
-   
+   int erased_slot;   
    
    
-   old_umask = umask(0);
-   shm_processes_fd = open(processreg_file, O_RDWR | O_CREAT, 0666);
-   umask(old_umask);
-   if ( shm_processes_fd < 0 )
+#ifndef SECURE_SHARE_MODES
+   smb_shm_processes_fd = open(processreg_file, O_RDWR | O_CREAT, 0666);
+#else /* SECURE_SHARE_MODES */
+   smb_shm_processes_fd = open(processreg_file, O_RDWR | O_CREAT, 0600);
+#endif /* SECURE_SHARE_MODES */
+   if ( smb_shm_processes_fd < 0 )
    {
    {
-      DEBUG(0,("ERROR shm_register_process : processreg_file open failed with code %d\n",errno));
+      DEBUG(0,("ERROR smb_shm_register_process : processreg_file open failed with code %d\n",errno));
       return False;
    }
    
    *other_processes = False;
    
       return False;
    }
    
    *other_processes = False;
    
-   while ((nb_read = read(shm_processes_fd, &other_pid, sizeof(other_pid))) > 0)
+   while ((nb_read = read(smb_shm_processes_fd, &other_pid, sizeof(other_pid))) > 0)
    {
       if(other_pid)
       {
    {
       if(other_pid)
       {
@@ -103,73 +193,77 @@ static BOOL shm_register_process(char *processreg_file, pid_t pid, BOOL *other_p
         else
         {
            /* erase old pid */
         else
         {
            /* erase old pid */
-            DEBUG(2,("shm_register_process : erasing stale record for pid %d\n",other_pid));
+            DEBUG(5,("smb_shm_register_process : erasing stale record for pid %d (seek_back = %d)\n",
+                      other_pid, seek_back));
            other_pid = (pid_t)0;
            other_pid = (pid_t)0;
-           erased_slot = lseek(shm_processes_fd, -sizeof(other_pid), SEEK_CUR);
-           write(shm_processes_fd, &other_pid, sizeof(other_pid));
+           erased_slot = lseek(smb_shm_processes_fd, seek_back, SEEK_CUR);
+           write(smb_shm_processes_fd, &other_pid, sizeof(other_pid));
            if(free_slot < 0)
               free_slot = erased_slot;
         }
       }
       else 
         if(free_slot < 0)
            if(free_slot < 0)
               free_slot = erased_slot;
         }
       }
       else 
         if(free_slot < 0)
-           free_slot = lseek(shm_processes_fd, -sizeof(other_pid), SEEK_CUR);
+           free_slot = lseek(smb_shm_processes_fd, seek_back, SEEK_CUR);
    }
    if (nb_read < 0)
    {
    }
    if (nb_read < 0)
    {
-      DEBUG(0,("ERROR shm_register_process : processreg_file read failed with code %d\n",errno));
-      close(shm_processes_fd);
+      DEBUG(0,("ERROR smb_shm_register_process : processreg_file read failed with code %d\n",errno));
+      close(smb_shm_processes_fd);
       return False;
    }
    
    if(free_slot < 0)
       return False;
    }
    
    if(free_slot < 0)
-      free_slot = lseek(shm_processes_fd, 0, SEEK_END);
+      free_slot = lseek(smb_shm_processes_fd, 0, SEEK_END);
 
 
-   DEBUG(2,("shm_register_process : writing record for pid %d at offset %d\n",pid,free_slot));
-   lseek(shm_processes_fd, free_slot, SEEK_SET);
-   if(write(shm_processes_fd, &pid, sizeof(pid)) < 0)
+   DEBUG(5,("smb_shm_register_process : writing record for pid %d at offset %d\n",pid,free_slot));
+   lseek(smb_shm_processes_fd, free_slot, SEEK_SET);
+   if(write(smb_shm_processes_fd, &pid, sizeof(pid)) < 0)
    {
    {
-      DEBUG(0,("ERROR shm_register_process : processreg_file write failed with code %d\n",errno));
-      close(shm_processes_fd);
+      DEBUG(0,("ERROR smb_shm_register_process : processreg_file write failed with code %d\n",errno));
+      close(smb_shm_processes_fd);
       return False;
    }
 
       return False;
    }
 
-   close(shm_processes_fd);
+   close(smb_shm_processes_fd);
 
    return True;
 }
 
 
    return True;
 }
 
-static BOOL shm_unregister_process(char *processreg_file, pid_t pid)
+static BOOL smb_shm_unregister_process(char *processreg_file, pid_t pid)
 {
    int old_umask;
 {
    int old_umask;
-   int shm_processes_fd = -1;
+   int smb_shm_processes_fd = -1;
    int nb_read;
    pid_t other_pid;
    int nb_read;
    pid_t other_pid;
+   int seek_back = -((int)sizeof(other_pid));
    int erased_slot;
    BOOL found = False;
    
    
    old_umask = umask(0);
    int erased_slot;
    BOOL found = False;
    
    
    old_umask = umask(0);
-   shm_processes_fd = open(processreg_file, O_RDWR);
+   smb_shm_processes_fd = open(processreg_file, O_RDWR);
    umask(old_umask);
    umask(old_umask);
-   if ( shm_processes_fd < 0 )
+   if ( smb_shm_processes_fd < 0 )
    {
    {
-      DEBUG(0,("ERROR shm_unregister_process : processreg_file open failed with code %d\n",errno));
+      DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file open failed with code %d\n",errno));
       return False;
    }
    
       return False;
    }
    
-   while ((nb_read = read(shm_processes_fd, &other_pid, sizeof(other_pid))) > 0)
+   while ((nb_read = read(smb_shm_processes_fd, &other_pid, sizeof(other_pid))) > 0)
    {
    {
+      DEBUG(5,("smb_shm_unregister_process : read record for pid %d\n",other_pid));
       if(other_pid == pid)
       {
         /* erase pid */
       if(other_pid == pid)
       {
         /* erase pid */
-         DEBUG(2,("shm_unregister_process : erasing record for pid %d\n",other_pid));
+         DEBUG(5,("smb_shm_unregister_process : erasing record for pid %d (seek_val = %d)\n",
+                     other_pid, seek_back));
         other_pid = (pid_t)0;
         other_pid = (pid_t)0;
-        erased_slot = lseek(shm_processes_fd, -sizeof(other_pid), SEEK_CUR);
-        if(write(shm_processes_fd, &other_pid, sizeof(other_pid)) < 0)
+        erased_slot = lseek(smb_shm_processes_fd, seek_back, SEEK_CUR);
+        if(write(smb_shm_processes_fd, &other_pid, sizeof(other_pid)) < 0)
         {
         {
-           DEBUG(0,("ERROR shm_unregister_process : processreg_file write failed with code %d\n",errno));
-           close(shm_processes_fd);
+           DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file write failed with code %d\n",errno));
+           close(smb_shm_processes_fd);
            return False;
         }
         
            return False;
         }
         
@@ -179,146 +273,152 @@ static BOOL shm_unregister_process(char *processreg_file, pid_t pid)
    }
    if (nb_read < 0)
    {
    }
    if (nb_read < 0)
    {
-      DEBUG(0,("ERROR shm_unregister_process : processreg_file read failed with code %d\n",errno));
-      close(shm_processes_fd);
+      DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file read failed with code %d\n",errno));
+      close(smb_shm_processes_fd);
       return False;
    }
    
    if(!found)
    {
       return False;
    }
    
    if(!found)
    {
-      DEBUG(0,("ERROR shm_unregister_process : couldn't find pid %d in file %s\n",pid,processreg_file));
-      close(shm_processes_fd);
+      DEBUG(0,("ERROR smb_shm_unregister_process : couldn't find pid %d in file %s\n",pid,processreg_file));
+      close(smb_shm_processes_fd);
       return False;
    }
       
    
       return False;
    }
       
    
-   close(shm_processes_fd);
+   close(smb_shm_processes_fd);
 
    return True;
 }
 
 
 
    return True;
 }
 
 
-static BOOL shm_validate_header(int size)
+static BOOL smb_shm_validate_header(int size)
 {
 {
-   if( !shm_header_p )
+   if( !smb_shm_header_p )
    {
       /* not mapped yet */
    {
       /* not mapped yet */
-      DEBUG(0,("ERROR shm_validate_header : shmem not mapped\n"));
+      DEBUG(0,("ERROR smb_shm_validate_header : shmem not mapped\n"));
       return False;
    }
    
       return False;
    }
    
-   if(shm_header_p->shm_magic != SHM_MAGIC)
+   if(smb_shm_header_p->smb_shm_magic != SMB_SHM_MAGIC)
    {
    {
-      DEBUG(0,("ERROR shm_validate_header : bad magic\n"));
+      DEBUG(0,("ERROR smb_shm_validate_header : bad magic\n"));
       return False;
    }
       return False;
    }
-   if(shm_header_p->shm_version != SHM_VERSION)
+   if(smb_shm_header_p->smb_shm_version != SMB_SHM_VERSION)
    {
    {
-      DEBUG(0,("ERROR shm_validate_header : bad version %X\n",shm_header_p->shm_version));
+      DEBUG(0,("ERROR smb_shm_validate_header : bad version %X\n",smb_shm_header_p->smb_shm_version));
       return False;
    }
    
       return False;
    }
    
-   if(shm_header_p->total_size != size)
+   if(smb_shm_header_p->total_size != size)
    {
    {
-      DEBUG(0,("ERROR shm_validate_header : shmem size mismatch (old = %d, new = %d)\n",shm_header_p->total_size,size));
+      DEBUG(0,("ERROR smb_shm_validate_header : shmem size mismatch (old = %d, new = %d)\n",smb_shm_header_p->total_size,size));
       return False;
    }
 
       return False;
    }
 
-   if(!shm_header_p->consistent)
+   if(!smb_shm_header_p->consistent)
    {
    {
-      DEBUG(0,("ERROR shm_validate_header : shmem not consistent\n"));
+      DEBUG(0,("ERROR smb_shm_validate_header : shmem not consistent\n"));
       return False;
    }
    return True;
 }
 
       return False;
    }
    return True;
 }
 
-static BOOL shm_initialize(int size)
+static BOOL smb_shm_initialize(int size)
 {
 {
-   struct ShmBlockDesc * first_free_block_p;
+   struct SmbShmBlockDesc * first_free_block_p;
    
    
-   DEBUG(2,("shm_initialize : initializing shmem file of size %d\n",size));
+   DEBUG(5,("smb_shm_initialize : initializing shmem file of size %d\n",size));
    
    
-   if( !shm_header_p )
+   if( !smb_shm_header_p )
    {
       /* not mapped yet */
    {
       /* not mapped yet */
-      DEBUG(0,("ERROR shm_initialize : shmem not mapped\n"));
+      DEBUG(0,("ERROR smb_shm_initialize : shmem not mapped\n"));
       return False;
    }
    
       return False;
    }
    
-   shm_header_p->shm_magic = SHM_MAGIC;
-   shm_header_p->shm_version = SHM_VERSION;
-   shm_header_p->total_size = size;
-   shm_header_p->first_free_off = AlignedHeaderSize;
-   shm_header_p->userdef_off = NULL_OFFSET;
+   smb_shm_header_p->smb_shm_magic = SMB_SHM_MAGIC;
+   smb_shm_header_p->smb_shm_version = SMB_SHM_VERSION;
+   smb_shm_header_p->total_size = size;
+   smb_shm_header_p->first_free_off = AlignedHeaderSize;
+   smb_shm_header_p->userdef_off = NULL_OFFSET;
    
    
-   first_free_block_p = (struct ShmBlockDesc *)shm_offset2addr(shm_header_p->first_free_off);
+   first_free_block_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(smb_shm_header_p->first_free_off);
    first_free_block_p->next = EOList_Off;
    first_free_block_p->size = ( size - AlignedHeaderSize - CellSize ) / CellSize ;
    
    first_free_block_p->next = EOList_Off;
    first_free_block_p->size = ( size - AlignedHeaderSize - CellSize ) / CellSize ;
    
-   shm_header_p->statistics.cells_free = first_free_block_p->size;
-   shm_header_p->statistics.cells_used = 0;
-   shm_header_p->statistics.cells_system = 1;
+   smb_shm_header_p->statistics.cells_free = first_free_block_p->size;
+   smb_shm_header_p->statistics.cells_used = 0;
+   smb_shm_header_p->statistics.cells_system = 1;
    
    
-   shm_header_p->consistent = True;
+   smb_shm_header_p->consistent = True;
    
    
+   smb_shm_initialize_called = True;
+
    return True;
 }
    
    return True;
 }
    
-static void shm_solve_neighbors(struct ShmBlockDesc *head_p )
+static void smb_shm_solve_neighbors(struct SmbShmBlockDesc *head_p )
 {
 {
-   struct ShmBlockDesc *next_p;
+   struct SmbShmBlockDesc *next_p;
    
    /* Check if head_p and head_p->next are neighbors and if so join them */
    if ( head_p == EOList_Addr ) return ;
    if ( head_p->next == EOList_Off ) return ;
    
    
    /* Check if head_p and head_p->next are neighbors and if so join them */
    if ( head_p == EOList_Addr ) return ;
    if ( head_p->next == EOList_Off ) return ;
    
-   next_p = (struct ShmBlockDesc *)shm_offset2addr(head_p->next);
+   next_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(head_p->next);
    if ( ( head_p + head_p->size + 1 ) == next_p)
    {
       head_p->size += next_p->size +1 ;        /* adapt size */
       head_p->next = next_p->next        ; /* link out */
       
    if ( ( head_p + head_p->size + 1 ) == next_p)
    {
       head_p->size += next_p->size +1 ;        /* adapt size */
       head_p->next = next_p->next        ; /* link out */
       
-      shm_header_p->statistics.cells_free += 1;
-      shm_header_p->statistics.cells_system -= 1;
+      smb_shm_header_p->statistics.cells_free += 1;
+      smb_shm_header_p->statistics.cells_system -= 1;
    }
 }
 
 
 
    }
 }
 
 
 
-BOOL shm_open( char *file_name, int size)
+BOOL smb_shm_open( char *file_name, int size)
 {
    int filesize;
    BOOL created_new = False;
    BOOL other_processes = True;
    int old_umask;
    
 {
    int filesize;
    BOOL created_new = False;
    BOOL other_processes = True;
    int old_umask;
    
-   DEBUG(2,("shm_open : using shmem file %s to be of size %d\n",file_name,size));
+   DEBUG(5,("smb_shm_open : using shmem file %s to be of size %d\n",file_name,size));
 
    old_umask = umask(0);
 
    old_umask = umask(0);
-   shm_fd = open(file_name, O_RDWR | O_CREAT, 0666);
+#ifndef SECURE_SHARE_MODES
+   smb_shm_fd = open(file_name, O_RDWR | O_CREAT, 0666);
+#else /* SECURE_SHARE_MODES */
+   smb_shm_fd = open(file_name, O_RDWR | O_CREAT, 0600);
+#endif /* SECURE_SHARE_MODE */
    umask(old_umask);
    umask(old_umask);
-   if ( shm_fd < 0 )
+   if ( smb_shm_fd < 0 )
    {
    {
-      DEBUG(0,("ERROR shm_open : open failed with code %d\n",errno));
+      DEBUG(0,("ERROR smb_shm_open : open failed with code %d\n",errno));
       return False;
    }
    
       return False;
    }
    
-   if (!shm_lock())
+   if (!smb_shm_global_lock())
    {
    {
-      DEBUG(0,("ERROR shm_open : can't do shm_lock\n"));
+      DEBUG(0,("ERROR smb_shm_open : can't do smb_shm_global_lock\n"));
       return False;
    }
    
       return False;
    }
    
-   if( (filesize = lseek(shm_fd, 0, SEEK_END)) < 0)
+   if( (filesize = lseek(smb_shm_fd, 0, SEEK_END)) < 0)
    {
    {
-      DEBUG(0,("ERROR shm_open : lseek failed with code %d\n",errno));
-      shm_unlock();
-      close(shm_fd);
+      DEBUG(0,("ERROR smb_shm_open : lseek failed with code %d\n",errno));
+      smb_shm_global_unlock();
+      close(smb_shm_fd);
       return False;
    }
 
    /* return the file offset to 0 to save on later seeks */
       return False;
    }
 
    /* return the file offset to 0 to save on later seeks */
-   lseek(shm_fd,0,SEEK_SET);
+   lseek(smb_shm_fd,0,SEEK_SET);
 
    if (filesize == 0)
    {
 
    if (filesize == 0)
    {
@@ -331,30 +431,30 @@ BOOL shm_open( char *file_name, int size)
       */
 
    /* construct processreg file name */
       */
 
    /* construct processreg file name */
-   strcpy(shm_processreg_name, file_name);
-   strcat(shm_processreg_name, ".processes");
+   strcpy(smb_shm_processreg_name, file_name);
+   strcat(smb_shm_processreg_name, ".processes");
 
 
-   if (! shm_register_process(shm_processreg_name, getpid(), &other_processes))
+   if (! smb_shm_register_process(smb_shm_processreg_name, getpid(), &other_processes))
    {
    {
-      shm_unlock();
-      close(shm_fd);
+      smb_shm_global_unlock();
+      close(smb_shm_fd);
       return False;
    }
 
    if (created_new || !other_processes)
    {
       /* we just created a new one, or are the first opener, lets set it size */
       return False;
    }
 
    if (created_new || !other_processes)
    {
       /* we just created a new one, or are the first opener, lets set it size */
-      if( ftruncate(shm_fd, size) <0)
+      if( ftruncate(smb_shm_fd, size) <0)
       {
       {
-         DEBUG(0,("ERROR shm_open : ftruncate failed with code %d\n",errno));
-        shm_unregister_process(shm_processreg_name, getpid());
-        shm_unlock();
-        close(shm_fd);
+         DEBUG(0,("ERROR smb_shm_open : ftruncate failed with code %d\n",errno));
+        smb_shm_unregister_process(smb_shm_processreg_name, getpid());
+        smb_shm_global_unlock();
+        close(smb_shm_fd);
         return False;
       }
 
       /* paranoia */
         return False;
       }
 
       /* paranoia */
-      lseek(shm_fd,0,SEEK_SET);
+      lseek(smb_shm_fd,0,SEEK_SET);
 
       filesize = size;
    }
 
       filesize = size;
    }
@@ -363,88 +463,98 @@ BOOL shm_open( char *file_name, int size)
    {
       /* the existing file has a different size and we are not the first opener.
         Since another process is still using it, we will use the file size */
    {
       /* the existing file has a different size and we are not the first opener.
         Since another process is still using it, we will use the file size */
-      DEBUG(0,("WARNING shm_open : filesize (%d) != expected size (%d), using filesize\n",filesize,size));
+      DEBUG(0,("WARNING smb_shm_open : filesize (%d) != expected size (%d), using filesize\n",filesize,size));
       size = filesize;
    }
    
       size = filesize;
    }
    
-   shm_header_p = (struct ShmHeader *)mmap( NULL, size, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, shm_fd, 0);
-   /* WARNING, shm_header_p can be different for different processes mapping the same file ! */
-   if (shm_header_p  == (struct ShmHeader *)(-1))
+   smb_shm_header_p = (struct SmbShmHeader *)mmap( NULL, size, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, smb_shm_fd, 0);
+   /* WARNING, smb_shm_header_p can be different for different processes mapping the same file ! */
+   if (smb_shm_header_p  == (struct SmbShmHeader *)(-1))
    {
    {
-      DEBUG(0,("ERROR shm_open : mmap failed with code %d\n",errno));
-      shm_unregister_process(shm_processreg_name, getpid());
-      shm_unlock();
-      close(shm_fd);
+      DEBUG(0,("ERROR smb_shm_open : mmap failed with code %d\n",errno));
+      smb_shm_unregister_process(smb_shm_processreg_name, getpid());
+      smb_shm_global_unlock();
+      close(smb_shm_fd);
       return False;
    }      
    
       
    if (created_new || !other_processes)
    {
       return False;
    }      
    
       
    if (created_new || !other_processes)
    {
-      shm_initialize(size);
+      smb_shm_initialize(size);
+      /* Create the hash buckets for the share file entries. */
+      smb_shm_create_hash_table( lp_shmem_hash_size() );
    }
    }
-   else if (!shm_validate_header(size) )
+   else if (!smb_shm_validate_header(size) )
    {
       /* existing file is corrupt, samba admin should remove it by hand */
    {
       /* existing file is corrupt, samba admin should remove it by hand */
-      DEBUG(0,("ERROR shm_open : corrupt shared mem file, remove it manually\n"));
-      munmap((caddr_t)shm_header_p, size);
-      shm_unregister_process(shm_processreg_name, getpid());
-      shm_unlock();
-      close(shm_fd);
+      DEBUG(0,("ERROR smb_shm_open : corrupt shared mem file, remove it manually\n"));
+      munmap((caddr_t)smb_shm_header_p, size);
+      smb_shm_unregister_process(smb_shm_processreg_name, getpid());
+      smb_shm_global_unlock();
+      close(smb_shm_fd);
       return False;
    }
    
       return False;
    }
    
-   shm_unlock();
+   smb_shm_global_unlock();
    return True;
       
 }
 
 
    return True;
       
 }
 
 
-BOOL shm_close( void )
+BOOL smb_shm_close( void )
 {
    
 {
    
-   DEBUG(2,("shm_close\n"));
-   if(shm_times_locked > 0)
-      DEBUG(0,("WARNING shm_close : shmem was still locked %d times\n",shm_times_locked));;
-   if ( munmap((caddr_t)shm_header_p, shm_header_p->total_size) < 0)
+   if(smb_shm_initialize_called == False)
+     return True;
+
+   DEBUG(5,("smb_shm_close\n"));
+   if(smb_shm_times_locked > 0)
+      DEBUG(0,("WARNING smb_shm_close : shmem was still locked %d times\n",smb_shm_times_locked));;
+   if ((smb_shm_header_p != NULL) && 
+              (munmap((caddr_t)smb_shm_header_p, smb_shm_header_p->total_size) < 0))
    {
    {
-      DEBUG(0,("ERROR shm_close : munmap failed with code %d\n",errno));
+      DEBUG(0,("ERROR smb_shm_close : munmap failed with code %d\n",errno));
    }
 
    }
 
-   shm_lock();
-   shm_unregister_process(shm_processreg_name, getpid());
-   shm_unlock();
+   smb_shm_global_lock();
+   DEBUG(5,("calling smb_shm_unregister_process(%s, %d)\n", smb_shm_processreg_name, getpid()));
+   smb_shm_unregister_process(smb_shm_processreg_name, getpid());
+   smb_shm_global_unlock();
    
    
-   close(shm_fd);
+   close(smb_shm_fd);
    
    
-   shm_fd = -1;
-   shm_processreg_name[0] = '\0';
+   smb_shm_fd = -1;
+   smb_shm_processreg_name[0] = '\0';
 
 
-   shm_header_p = (struct ShmHeader *)0;
-   shm_times_locked = 0;
+   smb_shm_header_p = (struct SmbShmHeader *)0;
+   smb_shm_times_locked = 0;
    
    return True;
 }
 
    
    return True;
 }
 
-shm_offset_t shm_alloc(int size)
+smb_shm_offset_t smb_shm_alloc(int size)
 {
    unsigned num_cells ;
 {
    unsigned num_cells ;
-   struct ShmBlockDesc *scanner_p;
-   struct ShmBlockDesc *prev_p;
-   struct ShmBlockDesc *new_p;
-   shm_offset_t result_offset;
+   struct SmbShmBlockDesc *scanner_p;
+   struct SmbShmBlockDesc *prev_p;
+   struct SmbShmBlockDesc *new_p;
+   smb_shm_offset_t result_offset;
    
    
    
    
-   if( !shm_header_p )
+   if( !smb_shm_header_p )
    {
       /* not mapped yet */
    {
       /* not mapped yet */
-      DEBUG(0,("ERROR shm_alloc : shmem not mapped\n"));
+      DEBUG(0,("ERROR smb_shm_alloc : shmem not mapped\n"));
       return NULL_OFFSET;
    }
    
       return NULL_OFFSET;
    }
    
-   if( !shm_header_p->consistent)
+   smb_shm_global_lock();
+
+   if( !smb_shm_header_p->consistent)
    {
    {
-      DEBUG(0,("ERROR shm_alloc : shmem not consistent\n"));
+      DEBUG(0,("ERROR smb_shm_alloc : shmem not consistent\n"));
+      smb_shm_global_unlock();
       return NULL_OFFSET;
    }
    
       return NULL_OFFSET;
    }
    
@@ -453,25 +563,26 @@ shm_offset_t shm_alloc(int size)
    num_cells = (size + CellSize -1) / CellSize;
 
    /* set start        of scan */
    num_cells = (size + CellSize -1) / CellSize;
 
    /* set start        of scan */
-   prev_p = (struct ShmBlockDesc *)shm_offset2addr(shm_header_p->first_free_off);
+   prev_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(smb_shm_header_p->first_free_off);
    scanner_p = prev_p ;
    
    /* scan the free list to find a matching free space */
    while ( ( scanner_p != EOList_Addr ) && ( scanner_p->size < num_cells ) )
    {
       prev_p = scanner_p;
    scanner_p = prev_p ;
    
    /* scan the free list to find a matching free space */
    while ( ( scanner_p != EOList_Addr ) && ( scanner_p->size < num_cells ) )
    {
       prev_p = scanner_p;
-      scanner_p = (struct ShmBlockDesc *)shm_offset2addr(scanner_p->next);
+      scanner_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(scanner_p->next);
    }
    
    /* at this point scanner point to a block header or to the end of the list */
    if ( scanner_p == EOList_Addr )     
    {
    }
    
    /* at this point scanner point to a block header or to the end of the list */
    if ( scanner_p == EOList_Addr )     
    {
-      DEBUG(0,("ERROR shm_alloc : alloc of %d bytes failed, no free space found\n",size));
+      DEBUG(0,("ERROR smb_shm_alloc : alloc of %d bytes failed, no free space found\n",size));
+      smb_shm_global_unlock();
       return (NULL_OFFSET);
    }
    
    /* going to modify shared mem */
       return (NULL_OFFSET);
    }
    
    /* going to modify shared mem */
-   shm_header_p->consistent = False;
+   smb_shm_header_p->consistent = False;
    
    /* if we found a good one : scanner == the good one */
    if ( scanner_p->size <= num_cells + 2 )
    
    /* if we found a good one : scanner == the good one */
    if ( scanner_p->size <= num_cells + 2 )
@@ -481,14 +592,14 @@ shm_offset_t shm_alloc(int size)
       */
       if ( prev_p == scanner_p )
       {
       */
       if ( prev_p == scanner_p )
       {
-        shm_header_p->first_free_off = scanner_p->next ;
+        smb_shm_header_p->first_free_off = scanner_p->next ;
       }
       else
       {
         prev_p->next = scanner_p->next ;
       }
       }
       else
       {
         prev_p->next = scanner_p->next ;
       }
-      shm_header_p->statistics.cells_free -= scanner_p->size;
-      shm_header_p->statistics.cells_used += scanner_p->size;
+      smb_shm_header_p->statistics.cells_free -= scanner_p->size;
+      smb_shm_header_p->statistics.cells_used += scanner_p->size;
    }
    else
    {
    }
    else
    {
@@ -497,222 +608,232 @@ shm_offset_t shm_alloc(int size)
       new_p->size = scanner_p->size - num_cells - 1;
       new_p->next = scanner_p->next;
       scanner_p->size = num_cells;
       new_p->size = scanner_p->size - num_cells - 1;
       new_p->next = scanner_p->next;
       scanner_p->size = num_cells;
-      scanner_p->next = shm_addr2offset(new_p);
+      scanner_p->next = smb_shm_addr2offset(new_p);
       
       if ( prev_p      != scanner_p )
       {
       
       if ( prev_p      != scanner_p )
       {
-        prev_p->next      = shm_addr2offset(new_p)  ;
+        prev_p->next      = smb_shm_addr2offset(new_p)  ;
       }
       else
       {
       }
       else
       {
-        shm_header_p->first_free_off = shm_addr2offset(new_p)  ;
+        smb_shm_header_p->first_free_off = smb_shm_addr2offset(new_p)  ;
       }
       }
-      shm_header_p->statistics.cells_free -= num_cells+1;
-      shm_header_p->statistics.cells_used += num_cells;
-      shm_header_p->statistics.cells_system += 1;
+      smb_shm_header_p->statistics.cells_free -= num_cells+1;
+      smb_shm_header_p->statistics.cells_used += num_cells;
+      smb_shm_header_p->statistics.cells_system += 1;
    }
 
    }
 
-   result_offset = shm_addr2offset( &(scanner_p[1]) );
-   scanner_p->next =   SHM_NOT_FREE_OFF ;
+   result_offset = smb_shm_addr2offset( &(scanner_p[1]) );
+   scanner_p->next =   SMB_SHM_NOT_FREE_OFF ;
 
    /* end modification of shared mem */
 
    /* end modification of shared mem */
-   shm_header_p->consistent = True;
+   smb_shm_header_p->consistent = True;
 
 
-   DEBUG(2,("shm_alloc : request for %d bytes, allocated %d bytes at offset %d\n",size,scanner_p->size*CellSize,result_offset ));
+   DEBUG(6,("smb_shm_alloc : request for %d bytes, allocated %d bytes at offset %d\n",size,scanner_p->size*CellSize,result_offset ));
 
 
+   smb_shm_global_unlock();
    return ( result_offset );
 }   
 
 
 
    return ( result_offset );
 }   
 
 
 
-BOOL shm_free(shm_offset_t offset)
+BOOL smb_shm_free(smb_shm_offset_t offset)
 {
 {
-   struct ShmBlockDesc *header_p  ; /* pointer to header of block to free */
-   struct ShmBlockDesc *scanner_p ; /* used to scan the list                      */
-   struct ShmBlockDesc *prev_p    ; /* holds previous in the list                 */
+   struct SmbShmBlockDesc *header_p  ; /*      pointer to header of block to free */
+   struct SmbShmBlockDesc *scanner_p ; /*      used to scan the list                      */
+   struct SmbShmBlockDesc *prev_p         ; /* holds previous in the list                 */
    
    
-   if( !shm_header_p )
+   if( !smb_shm_header_p )
    {
       /* not mapped yet */
    {
       /* not mapped yet */
-      DEBUG(0,("ERROR shm_free : shmem not mapped\n"));
+      DEBUG(0,("ERROR smb_shm_free : shmem not mapped\n"));
       return False;
    }
    
       return False;
    }
    
-   if( !shm_header_p->consistent)
+   smb_shm_global_lock();
+
+   if( !smb_shm_header_p->consistent)
    {
    {
-      DEBUG(0,("ERROR shm_free : shmem not consistent\n"));
+      DEBUG(0,("ERROR smb_shm_free : shmem not consistent\n"));
+      smb_shm_global_unlock();
       return False;
    }
    
       return False;
    }
    
-   header_p = (        (struct ShmBlockDesc *)shm_offset2addr(offset) - 1); /* make pointer to header of block */
+   header_p = (        (struct SmbShmBlockDesc *)smb_shm_offset2addr(offset) - 1); /* make pointer to header of block */
 
 
-   if (header_p->next != SHM_NOT_FREE_OFF)
+   if (header_p->next != SMB_SHM_NOT_FREE_OFF)
    {
    {
-      DEBUG(0,("ERROR shm_free : bad offset (%d)\n",offset));
+      DEBUG(0,("ERROR smb_shm_free : bad offset (%d)\n",offset));
+      smb_shm_global_unlock();
       return False;
    }
    
    /* find a place in the free_list to put the header in */
    
    /* set scanner and previous pointer to start of list */
       return False;
    }
    
    /* find a place in the free_list to put the header in */
    
    /* set scanner and previous pointer to start of list */
-   prev_p = (struct ShmBlockDesc *)shm_offset2addr(shm_header_p->first_free_off);
+   prev_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(smb_shm_header_p->first_free_off);
    scanner_p = prev_p ;
    
    while ( ( scanner_p != EOList_Addr) && (scanner_p < header_p) ) /* while we didn't scan past its position */
    {
       prev_p = scanner_p ;
    scanner_p = prev_p ;
    
    while ( ( scanner_p != EOList_Addr) && (scanner_p < header_p) ) /* while we didn't scan past its position */
    {
       prev_p = scanner_p ;
-      scanner_p = (struct ShmBlockDesc *)shm_offset2addr(scanner_p->next);
+      scanner_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(scanner_p->next);
    }
    
    }
    
-   shm_header_p->consistent = False;
+   smb_shm_header_p->consistent = False;
    
    
-   DEBUG(2,("shm_free : freeing %d bytes at offset %d\n",header_p->size*CellSize,offset));
+   DEBUG(6,("smb_shm_free : freeing %d bytes at offset %d\n",header_p->size*CellSize,offset));
 
    if ( scanner_p == prev_p )
    {
 
    if ( scanner_p == prev_p )
    {
-      shm_header_p->statistics.cells_free += header_p->size;
-      shm_header_p->statistics.cells_used -= header_p->size;
+      smb_shm_header_p->statistics.cells_free += header_p->size;
+      smb_shm_header_p->statistics.cells_used -= header_p->size;
 
       /* we must free it at the beginning of the list */
 
       /* we must free it at the beginning of the list */
-      shm_header_p->first_free_off = shm_addr2offset(header_p);                                                 /*     set     the free_list_pointer to this block_header */
+      smb_shm_header_p->first_free_off = smb_shm_addr2offset(header_p);                                                 /*     set     the free_list_pointer to this block_header */
 
       /* scanner is the one that was first in the list */
 
       /* scanner is the one that was first in the list */
-      header_p->next = shm_addr2offset(scanner_p);
-      shm_solve_neighbors( header_p ); /* if neighbors then link them */
+      header_p->next = smb_shm_addr2offset(scanner_p);
+      smb_shm_solve_neighbors( header_p ); /* if neighbors then link them */
       
       
-      shm_header_p->consistent = True;
+      smb_shm_header_p->consistent = True;
+      smb_shm_global_unlock();
       return True;
    } 
    else
    {
       return True;
    } 
    else
    {
-      shm_header_p->statistics.cells_free += header_p->size;
-      shm_header_p->statistics.cells_used -= header_p->size;
+      smb_shm_header_p->statistics.cells_free += header_p->size;
+      smb_shm_header_p->statistics.cells_used -= header_p->size;
 
 
-      prev_p->next = shm_addr2offset(header_p);
-      header_p->next = shm_addr2offset(scanner_p);
-      shm_solve_neighbors(header_p) ;
-      shm_solve_neighbors(prev_p) ;
+      prev_p->next = smb_shm_addr2offset(header_p);
+      header_p->next = smb_shm_addr2offset(scanner_p);
+      smb_shm_solve_neighbors(header_p) ;
+      smb_shm_solve_neighbors(prev_p) ;
 
 
-      shm_header_p->consistent = True;
+      smb_shm_header_p->consistent = True;
+      smb_shm_global_unlock();
       return True;
    }
 }
 
       return True;
    }
 }
 
-shm_offset_t shm_get_userdef_off(void)
+smb_shm_offset_t smb_shm_get_userdef_off(void)
 {
 {
-   if (!shm_header_p)
+   if (!smb_shm_header_p)
       return NULL_OFFSET;
    else
       return NULL_OFFSET;
    else
-      return shm_header_p->userdef_off;
+      return smb_shm_header_p->userdef_off;
 }
 
 }
 
-BOOL shm_set_userdef_off(shm_offset_t userdef_off)
+BOOL smb_shm_set_userdef_off(smb_shm_offset_t userdef_off)
 {
 {
-   if (!shm_header_p)
+   if (!smb_shm_header_p)
       return False;
    else
       return False;
    else
-      shm_header_p->userdef_off = userdef_off;
+      smb_shm_header_p->userdef_off = userdef_off;
    return True;
 }
 
    return True;
 }
 
-void * shm_offset2addr(shm_offset_t offset)
+void *smb_shm_offset2addr(smb_shm_offset_t offset)
 {
    if (offset == NULL_OFFSET )
       return (void *)(0);
    
 {
    if (offset == NULL_OFFSET )
       return (void *)(0);
    
-   if (!shm_header_p)
+   if (!smb_shm_header_p)
       return (void *)(0);
    
       return (void *)(0);
    
-   return (void *)((char *)shm_header_p + offset );
+   return (void *)((char *)smb_shm_header_p + offset );
 }
 
 }
 
-shm_offset_t shm_addr2offset(void *addr)
+smb_shm_offset_t smb_shm_addr2offset(void *addr)
 {
    if (!addr)
       return NULL_OFFSET;
    
 {
    if (!addr)
       return NULL_OFFSET;
    
-   if (!shm_header_p)
+   if (!smb_shm_header_p)
       return NULL_OFFSET;
    
       return NULL_OFFSET;
    
-   return (shm_offset_t)((char *)addr - (char *)shm_header_p);
+   return (smb_shm_offset_t)((char *)addr - (char *)smb_shm_header_p);
 }
 
 }
 
-BOOL shm_lock(void)
+/*******************************************************************
+  Lock a particular hash bucket entry.
+  ******************************************************************/
+
+BOOL smb_shm_lock_hash_entry( unsigned int entry)
 {
 {
-   if (shm_fd < 0)
-   {
-      DEBUG(0,("ERROR shm_lock : bad shm_fd (%d)\n",shm_fd));
+  int start = (smb_shm_header_p->userdef_off + (entry * sizeof(smb_shm_offset_t)));
+
+  if (smb_shm_fd < 0)
+    {
+      DEBUG(0,("ERROR smb_shm_lock_hash_entry : bad smb_shm_fd (%d)\n",smb_shm_fd));
       return False;
       return False;
-   }
-   
-   shm_times_locked++;
-   
-   if(shm_times_locked > 1)
-   {
-      DEBUG(2,("shm_lock : locked %d times\n",shm_times_locked));
-      return True;
-   }
-   
-   if (lockf(shm_fd, F_LOCK, 0) < 0)
-   {
-      DEBUG(0,("ERROR shm_lock : lockf failed with code %d\n",errno));
-      shm_times_locked--;
+    }
+
+  if(entry >= lp_shmem_hash_size())
+    {
+      DEBUG(0,("ERROR smb_shm_lock_hash_entry : hash entry size too big (%d)\n", entry));
       return False;
       return False;
-   }
-   
-   return True;
-   
+    }
+  
+  /* Do an exclusive wait lock on the 4 byte region mapping into this entry  */
+  if (fcntl_lock(smb_shm_fd, F_SETLKW, start, sizeof(smb_shm_offset_t), F_WRLCK) == False)
+    {
+      DEBUG(0,("ERROR smb_shm_lock_hash_entry : fcntl_lock failed with code %d\n",errno));
+      return False;
+    }
+  
+  DEBUG(9,("smb_shm_lock_hash_entry: locked hash bucket %d\n", entry)); 
+  return True;
 }
 
 }
 
+/*******************************************************************
+  Unlock a particular hash bucket entry.
+  ******************************************************************/
 
 
-
-BOOL shm_unlock(void)
+BOOL smb_shm_unlock_hash_entry( unsigned int entry )
 {
 {
-   if (shm_fd < 0)
-   {
-      DEBUG(0,("ERROR shm_unlock : bad shm_fd (%d)\n",shm_fd));
+  int start = (smb_shm_header_p->userdef_off + (entry * sizeof(smb_shm_offset_t)));
+
+  if (smb_shm_fd < 0)
+    {
+      DEBUG(0,("ERROR smb_shm_unlock_hash_entry : bad smb_shm_fd (%d)\n",smb_shm_fd));
       return False;
       return False;
-   }
+    }
    
    
-   if(shm_times_locked == 0)
-   {
-      DEBUG(0,("ERROR shm_unlock : shmem not locked\n",shm_fd));
+  if(entry >= lp_shmem_hash_size())
+    {
+      DEBUG(0,("ERROR smb_shm_unlock_hash_entry : hash entry size too big (%d)\n", entry));
       return False;
       return False;
-   }
-   
-   shm_times_locked--;
-   
-   if(shm_times_locked > 0)
-   {
-      DEBUG(2,("shm_unlock : still locked %d times\n",shm_times_locked));
-      return True;
-   }
-   
-   if (lockf(shm_fd, F_ULOCK, 0) < 0)
-   {
-      DEBUG(0,("ERROR shm_unlock : lockf failed with code %d\n",errno));
-      shm_times_locked++;
+    }
+
+  /* Do a wait lock on the 4 byte region mapping into this entry  */
+  if (fcntl_lock(smb_shm_fd, F_SETLKW, start, sizeof(smb_shm_offset_t), F_UNLCK) == False)
+    {
+      DEBUG(0,("ERROR smb_shm_unlock_hash_entry : fcntl_lock failed with code %d\n",errno));
       return False;
       return False;
-   }
-   
-   return True;
-   
+    }
+  
+  DEBUG(9,("smb_shm_unlock_hash_entry: unlocked hash bucket %d\n", entry)); 
+  return True;
 }
 
 }
 
+/*******************************************************************
+  Gather statistics on shared memory usage.
+  ******************************************************************/
 
 
-BOOL shm_get_usage(int *bytes_free,
+BOOL smb_shm_get_usage(int *bytes_free,
                   int *bytes_used,
                   int *bytes_overhead)
 {
                   int *bytes_used,
                   int *bytes_overhead)
 {
-   if( !shm_header_p )
+   if( !smb_shm_header_p )
    {
       /* not mapped yet */
    {
       /* not mapped yet */
-      DEBUG(0,("ERROR shm_free : shmem not mapped\n"));
+      DEBUG(0,("ERROR smb_shm_free : shmem not mapped\n"));
       return False;
    }
       return False;
    }
-   *bytes_free = shm_header_p->statistics.cells_free * CellSize;
-   *bytes_used = shm_header_p->statistics.cells_used * CellSize;
-   *bytes_overhead = shm_header_p->statistics.cells_system * CellSize + AlignedHeaderSize;
+   *bytes_free = smb_shm_header_p->statistics.cells_free * CellSize;
+   *bytes_used = smb_shm_header_p->statistics.cells_used * CellSize;
+   *bytes_overhead = smb_shm_header_p->statistics.cells_system * CellSize + AlignedHeaderSize;
    
    return True;
 }
    
    return True;
 }
@@ -720,4 +841,4 @@ BOOL shm_get_usage(int *bytes_free,
 #else /* FAST_SHARE_MODES */
  int shmem_dummy_procedure(void)
 {return 0;}
 #else /* FAST_SHARE_MODES */
  int shmem_dummy_procedure(void)
 {return 0;}
-#endif
+#endif /* FAST_SHARE_MODES */