first cut at using the tdb code for the connections structure, the
[tprouty/samba.git] / source / locking / shmem.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    Shared memory functions
5    Copyright (C) Erik Devriendt 1996-1998
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 #ifdef USE_SHARED_MMAP
27
28
29 extern int DEBUGLEVEL;
30
31
32 #define SMB_SHM_MAGIC 0x53484100
33 /* = "SHM" in hex */
34
35 #define SMB_SHM_VERSION 2
36
37 /* we need world read for smbstatus to function correctly */
38 #ifdef SECURE_SHARE_MODES
39 #define SHM_FILE_MODE 0600
40 #else
41 #define SHM_FILE_MODE 0644
42 #endif
43
44 #define SHMEM_HASH_SIZE 13
45
46
47 /* WARNING : offsets are used because mmap() does not guarantee that all processes have the 
48    shared memory mapped to the same address */
49
50 struct SmbShmHeader
51 {
52    int smb_shm_magic;
53    int smb_shm_version;
54    int total_size;      /* in bytes */
55    BOOL consistent;
56    int first_free_off;
57    int userdef_off;    /* a userdefined offset. can be used to store root of tree or list */
58    struct {             /* a cell is a range of bytes of sizeof(struct SmbShmBlockDesc) size */
59       int cells_free;
60       int cells_used;
61       int cells_system; /* number of cells used as allocated block descriptors */
62    } statistics;
63 };
64
65 #define SMB_SHM_NOT_FREE_OFF (-1)
66 struct SmbShmBlockDesc
67 {
68    int next;    /* offset of next block in the free list or SMB_SHM_NOT_FREE_OFF when block in use  */
69    int          size;   /* user size in BlockDescSize units */
70 };
71
72 #define EOList_Addr     (struct SmbShmBlockDesc *)( 0 )
73 #define EOList_Off      0
74
75 #define CellSize        sizeof(struct SmbShmBlockDesc)
76
77 /* HeaderSize aligned on 8 byte boundary */
78 #define AlignedHeaderSize       ((sizeof(struct SmbShmHeader)+7) & ~7)
79
80 static int  smb_shm_fd = -1;
81 static pstring smb_shm_processreg_name = "";
82
83 static struct SmbShmHeader *smb_shm_header_p = (struct SmbShmHeader *)0;
84 static int smb_shm_times_locked = 0;
85
86 static BOOL smb_shm_initialize_called = False;
87
88 static int read_only;
89
90 static BOOL smb_shm_global_lock(void)
91 {
92    if (smb_shm_fd < 0)
93    {
94       DEBUG(0,("ERROR smb_shm_global_lock : bad smb_shm_fd (%d)\n",smb_shm_fd));
95       return False;
96    }
97    
98    smb_shm_times_locked++;
99    
100    if(smb_shm_times_locked > 1)
101    {
102       DEBUG(5,("smb_shm_global_lock : locked %d times\n",smb_shm_times_locked));
103       return True;
104    }
105
106    if (read_only)
107            return True;
108    
109    /* Do an exclusive wait lock on the first byte of the file */
110    if (fcntl_lock(smb_shm_fd, SMB_F_SETLKW, 0, 1, F_WRLCK) == False)
111    {
112       DEBUG(0,("ERROR smb_shm_global_lock : fcntl_lock failed with code %s\n",strerror(errno)));
113       smb_shm_times_locked--;
114       return False;
115    }
116    
117    return True;
118    
119 }
120
121 static BOOL smb_shm_global_unlock(void)
122 {
123    if (smb_shm_fd < 0)
124    {
125       DEBUG(0,("ERROR smb_shm_global_unlock : bad smb_shm_fd (%d)\n",smb_shm_fd));
126       return False;
127    }
128    
129    if(smb_shm_times_locked == 0)
130    {
131       DEBUG(0,("ERROR smb_shm_global_unlock : shmem not locked\n"));
132       return False;
133    }
134    
135    smb_shm_times_locked--;
136    
137    if(smb_shm_times_locked > 0)
138    {
139       DEBUG(5,("smb_shm_global_unlock : still locked %d times\n",smb_shm_times_locked));
140       return True;
141    }
142
143    if (read_only)
144            return True;
145    
146    /* Do a wait unlock on the first byte of the file */
147    if (fcntl_lock(smb_shm_fd, SMB_F_SETLKW, 0, 1, F_UNLCK) == False)
148    {
149       DEBUG(0,("ERROR smb_shm_global_unlock : fcntl_lock failed with code %s\n",strerror(errno)));
150       smb_shm_times_locked++;
151       return False;
152    }
153    
154    return True;
155    
156 }
157
158
159 static void *smb_shm_offset2addr(int offset)
160 {
161    if (offset == 0 )
162       return (void *)(0);
163    
164    if (!smb_shm_header_p)
165       return (void *)(0);
166    
167    return (void *)((char *)smb_shm_header_p + offset );
168 }
169
170 static int smb_shm_addr2offset(void *addr)
171 {
172    if (!addr)
173       return 0;
174    
175    if (!smb_shm_header_p)
176       return 0;
177    
178    return (int)((char *)addr - (char *)smb_shm_header_p);
179 }
180
181
182
183 static int smb_shm_alloc(int size)
184 {
185    unsigned num_cells ;
186    struct SmbShmBlockDesc *scanner_p;
187    struct SmbShmBlockDesc *prev_p;
188    struct SmbShmBlockDesc *new_p;
189    int result_offset;
190    
191    
192    if( !smb_shm_header_p )
193    {
194       /* not mapped yet */
195       DEBUG(0,("ERROR smb_shm_alloc : shmem not mapped\n"));
196       return 0;
197    }
198    
199    smb_shm_global_lock();
200
201    if( !smb_shm_header_p->consistent)
202    {
203       DEBUG(0,("ERROR smb_shm_alloc : shmem not consistent\n"));
204       smb_shm_global_unlock();
205       return 0;
206    }
207    
208    
209    /* calculate the number of cells */
210    num_cells = (size + CellSize -1) / CellSize;
211
212    /* set start of scan */
213    prev_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(smb_shm_header_p->first_free_off);
214    scanner_p =  prev_p ;
215    
216    /* scan the free list to find a matching free space */
217    while ( ( scanner_p != EOList_Addr ) && ( scanner_p->size < num_cells ) )
218    {
219       prev_p = scanner_p;
220       scanner_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(scanner_p->next);
221    }
222    
223    /* at this point scanner point to a block header or to the end of the list */
224    if ( scanner_p == EOList_Addr )      
225    {
226       DEBUG(0,("ERROR smb_shm_alloc : alloc of %d bytes failed, no free space found\n",size));
227       smb_shm_global_unlock();
228       return (0);
229    }
230    
231    /* going to modify shared mem */
232    smb_shm_header_p->consistent = False;
233    
234    /* if we found a good one : scanner == the good one */
235    if ( scanner_p->size <= num_cells + 2 )
236    {
237       /* there is no use in making a new one, it will be too small anyway 
238       *  we will link out scanner
239       */
240       if ( prev_p == scanner_p )
241       {
242          smb_shm_header_p->first_free_off = scanner_p->next ;
243       }
244       else
245       {
246          prev_p->next = scanner_p->next ;
247       }
248       smb_shm_header_p->statistics.cells_free -= scanner_p->size;
249       smb_shm_header_p->statistics.cells_used += scanner_p->size;
250    }
251    else
252    {
253       /* Make a new one */
254       new_p = scanner_p + 1 + num_cells;
255       new_p->size = scanner_p->size - num_cells - 1;
256       new_p->next = scanner_p->next;
257       scanner_p->size = num_cells;
258       scanner_p->next = smb_shm_addr2offset(new_p);
259       
260       if ( prev_p       != scanner_p )
261       {
262          prev_p->next      = smb_shm_addr2offset(new_p)  ;
263       }
264       else
265       {
266          smb_shm_header_p->first_free_off = smb_shm_addr2offset(new_p)  ;
267       }
268       smb_shm_header_p->statistics.cells_free -= num_cells+1;
269       smb_shm_header_p->statistics.cells_used += num_cells;
270       smb_shm_header_p->statistics.cells_system += 1;
271    }
272
273    result_offset = smb_shm_addr2offset( &(scanner_p[1]) );
274    scanner_p->next =    SMB_SHM_NOT_FREE_OFF ;
275
276    /* end modification of shared mem */
277    smb_shm_header_p->consistent = True;
278
279    DEBUG(6,("smb_shm_alloc : request for %d bytes, allocated %d bytes at offset %d\n",size,scanner_p->size*CellSize,result_offset ));
280
281    smb_shm_global_unlock();
282    return ( result_offset );
283 }   
284
285
286
287
288 /* 
289  * Function to create the hash table for the share mode entries. Called
290  * when smb shared memory is global locked.
291  */
292 static BOOL smb_shm_create_hash_table( unsigned int size )
293 {
294   size *= sizeof(int);
295
296   smb_shm_global_lock();
297   smb_shm_header_p->userdef_off = smb_shm_alloc( size );
298
299   if(smb_shm_header_p->userdef_off == 0)
300     {
301       DEBUG(0,("smb_shm_create_hash_table: Failed to create hash table of size %d\n",size));
302       smb_shm_global_unlock();
303       return False;
304     }
305
306   /* Clear hash buckets. */
307   memset( smb_shm_offset2addr(smb_shm_header_p->userdef_off), '\0', size);
308   smb_shm_global_unlock();
309   return True;
310 }
311
312 static BOOL smb_shm_register_process(char *processreg_file, pid_t pid, BOOL *other_processes)
313 {
314   int smb_shm_processes_fd = -1;
315   int nb_read;
316   pid_t other_pid;
317   SMB_OFF_T seek_back = -((SMB_OFF_T)sizeof(other_pid));
318   SMB_OFF_T free_slot = -1;
319   SMB_OFF_T erased_slot;   
320    
321   smb_shm_processes_fd = sys_open(processreg_file, 
322                               read_only?O_RDONLY:(O_RDWR|O_CREAT), 
323                               SHM_FILE_MODE);
324
325   if ( smb_shm_processes_fd < 0 )
326   {
327      DEBUG(0, ("ERROR smb_shm_register_process : processreg_file \
328 open failed with code %s\n",strerror(errno)));
329      return False;
330   }
331    
332   *other_processes = False;
333    
334   while ((nb_read = read(smb_shm_processes_fd, &other_pid, sizeof(other_pid))) > 0)
335   {
336     if(other_pid)
337     {
338       if(process_exists(other_pid))
339         *other_processes = True;
340       else
341       {
342         /* erase old pid */
343         DEBUG(5,("smb_shm_register_process : erasing stale record \
344 for pid %d (seek_back = %.0f)\n", (int)other_pid, (double)seek_back));
345         other_pid = (pid_t)0;
346         if((erased_slot = sys_lseek(smb_shm_processes_fd,
347                                     seek_back, SEEK_CUR)) == -1)
348         {
349           DEBUG(0, ("ERROR smb_shm_register_process : sys_lseek failed \
350 with error %s\n", strerror(errno)));
351           close(smb_shm_processes_fd);
352           return False;
353         }
354         
355         if(write(smb_shm_processes_fd, &other_pid, sizeof(other_pid)) == -1)
356         {
357            DEBUG(0, ("ERROR smb_shm_register_process : write failed \
358 with error %s\n", strerror(errno)));
359            close(smb_shm_processes_fd);
360            return False;
361         }
362
363         if(free_slot < 0)
364           free_slot = erased_slot;
365       }
366     }
367     else 
368     {
369       if(free_slot < 0)
370       {
371         if((free_slot = sys_lseek(smb_shm_processes_fd, 
372                                   seek_back, SEEK_CUR))==-1)
373         {
374           DEBUG(0, ("ERROR smb_shm_register_process : sys_lseek \
375 failed with error %s\n", strerror(errno)));
376           close(smb_shm_processes_fd);
377           return False; 
378         }
379       } /* end if free_slot */
380     } /* end else */
381   } /* end if other_pid */
382
383   if (nb_read < 0)
384   {
385     DEBUG(0,("ERROR smb_shm_register_process : processreg_file read \
386 failed with code %s\n",strerror(errno)));
387     close(smb_shm_processes_fd);
388     return False;
389   }
390    
391   if(free_slot < 0)
392   {
393     if((free_slot = sys_lseek(smb_shm_processes_fd, 0, SEEK_END)) == -1)
394     {
395       DEBUG(0,("ERROR smb_shm_register_process : sys_lseek failed with code %s\n",strerror(errno)));
396       close(smb_shm_processes_fd);
397       return False;
398     }
399   }
400
401   DEBUG(5,("smb_shm_register_process : writing record for pid %d at offset %.0f\n",
402          (int)pid, (double)free_slot));
403
404   if(sys_lseek(smb_shm_processes_fd, free_slot, SEEK_SET) == -1)
405   {
406     DEBUG(0,("ERROR smb_shm_register_process : sys_lseek failed with code %s\n",strerror(errno)));
407     close(smb_shm_processes_fd);
408     return False;
409   }
410
411   if(write(smb_shm_processes_fd, &pid, sizeof(pid)) == -1)
412   {
413     DEBUG(0,("ERROR smb_shm_register_process : processreg_file write failed with code %s\n",strerror(errno)));
414     close(smb_shm_processes_fd);
415     return False;
416   }
417
418   close(smb_shm_processes_fd);
419
420   return True;
421 }
422
423 static BOOL smb_shm_unregister_process(char *processreg_file, pid_t pid)
424 {
425    int smb_shm_processes_fd = -1;
426    int nb_read;
427    pid_t other_pid;
428    SMB_OFF_T seek_back = -((SMB_OFF_T)sizeof(other_pid));
429    BOOL found = False;
430    
431    
432    smb_shm_processes_fd = sys_open(processreg_file, O_RDWR, 0);
433    if ( smb_shm_processes_fd < 0 )
434    {
435       DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file open failed with code %s\n",strerror(errno)));
436       return False;
437    }
438    
439    while ((nb_read = read(smb_shm_processes_fd, &other_pid, sizeof(other_pid))) > 0)
440    {
441       DEBUG(5,("smb_shm_unregister_process : read record for pid %d\n",(int)other_pid));
442       if(other_pid == pid)
443       {
444         /* erase pid */
445         DEBUG(5,("smb_shm_unregister_process : erasing record for pid %d (seek_val = %.0f)\n",
446                      (int)other_pid, (double)seek_back));
447         other_pid = (pid_t)0;
448         if(sys_lseek(smb_shm_processes_fd, seek_back, SEEK_CUR) == -1)
449         {
450           DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file sys_lseek failed with code %s\n",strerror(errno)));
451           close(smb_shm_processes_fd);
452           return False;
453         }
454         if(write(smb_shm_processes_fd, &other_pid, sizeof(other_pid)) < 0)
455         {
456           DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file write failed with code %s\n",strerror(errno)));
457           close(smb_shm_processes_fd);
458           return False;
459         }
460          
461         found = True;
462         break;
463       }
464    }
465    if (nb_read < 0)
466    {
467       DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file read failed with code %s\n",strerror(errno)));
468       close(smb_shm_processes_fd);
469       return False;
470    }
471    
472    if(!found)
473    {
474       DEBUG(0,("ERROR smb_shm_unregister_process : couldn't find pid %d in file %s\n",
475             (int)pid,processreg_file));
476       close(smb_shm_processes_fd);
477       return False;
478    }
479       
480    
481    close(smb_shm_processes_fd);
482
483    return True;
484 }
485
486
487 static BOOL smb_shm_validate_header(int size)
488 {
489    if( !smb_shm_header_p )
490    {
491       /* not mapped yet */
492       DEBUG(0,("ERROR smb_shm_validate_header : shmem not mapped\n"));
493       return False;
494    }
495    
496    if(smb_shm_header_p->smb_shm_magic != SMB_SHM_MAGIC)
497    {
498       DEBUG(0,("ERROR smb_shm_validate_header : bad magic\n"));
499       return False;
500    }
501    if(smb_shm_header_p->smb_shm_version != SMB_SHM_VERSION)
502    {
503       DEBUG(0,("ERROR smb_shm_validate_header : bad version %X\n",smb_shm_header_p->smb_shm_version));
504       return False;
505    }
506    
507    if(smb_shm_header_p->total_size != size)
508    {
509       DEBUG(0,("ERROR smb_shm_validate_header : shmem size mismatch (old = %d, new = %d)\n",smb_shm_header_p->total_size,size));
510       return False;
511    }
512
513    if(!smb_shm_header_p->consistent)
514    {
515       DEBUG(0,("ERROR smb_shm_validate_header : shmem not consistent\n"));
516       return False;
517    }
518    return True;
519 }
520
521 static BOOL smb_shm_initialize(int size)
522 {
523    struct SmbShmBlockDesc * first_free_block_p;
524    
525    DEBUG(5,("smb_shm_initialize : initializing shmem file of size %d\n",size));
526    
527    if( !smb_shm_header_p )
528    {
529       /* not mapped yet */
530       DEBUG(0,("ERROR smb_shm_initialize : shmem not mapped\n"));
531       return False;
532    }
533    
534    smb_shm_header_p->smb_shm_magic = SMB_SHM_MAGIC;
535    smb_shm_header_p->smb_shm_version = SMB_SHM_VERSION;
536    smb_shm_header_p->total_size = size;
537    smb_shm_header_p->first_free_off = AlignedHeaderSize;
538    smb_shm_header_p->userdef_off = 0;
539    
540    first_free_block_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(smb_shm_header_p->first_free_off);
541    first_free_block_p->next = EOList_Off;
542    first_free_block_p->size = ( size - AlignedHeaderSize - CellSize ) / CellSize ;
543    
544    smb_shm_header_p->statistics.cells_free = first_free_block_p->size;
545    smb_shm_header_p->statistics.cells_used = 0;
546    smb_shm_header_p->statistics.cells_system = 1;
547    
548    smb_shm_header_p->consistent = True;
549    
550    smb_shm_initialize_called = True;
551
552    return True;
553 }
554    
555 static void smb_shm_solve_neighbors(struct SmbShmBlockDesc *head_p )
556 {
557    struct SmbShmBlockDesc *next_p;
558    
559    /* Check if head_p and head_p->next are neighbors and if so join them */
560    if ( head_p == EOList_Addr ) return ;
561    if ( head_p->next == EOList_Off ) return ;
562    
563    next_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(head_p->next);
564    if ( ( head_p + head_p->size + 1 ) == next_p)
565    {
566       head_p->size += next_p->size +1 ; /* adapt size */
567       head_p->next = next_p->next         ; /* link out */
568       
569       smb_shm_header_p->statistics.cells_free += 1;
570       smb_shm_header_p->statistics.cells_system -= 1;
571    }
572 }
573
574
575
576 static BOOL smb_shm_close( void )
577 {
578    
579    if(smb_shm_initialize_called == False)
580      return True;
581
582    DEBUG(5,("smb_shm_close\n"));
583    if(smb_shm_times_locked > 0)
584       DEBUG(0,("WARNING smb_shm_close : shmem was still locked %d times\n",smb_shm_times_locked));;
585    if ((smb_shm_header_p != NULL) && 
586               (munmap((caddr_t)smb_shm_header_p, smb_shm_header_p->total_size) < 0))
587    {
588       DEBUG(0,("ERROR smb_shm_close : munmap failed with code %s\n",strerror(errno)));
589    }
590
591    smb_shm_global_lock();
592    DEBUG(5,("calling smb_shm_unregister_process(%s, %d)\n", 
593          smb_shm_processreg_name, (int)getpid()));
594    smb_shm_unregister_process(smb_shm_processreg_name, getpid());
595    smb_shm_global_unlock();
596    
597    close(smb_shm_fd);
598    
599    smb_shm_fd = -1;
600    smb_shm_processreg_name[0] = '\0';
601
602    smb_shm_header_p = (struct SmbShmHeader *)0;
603    smb_shm_times_locked = 0;
604    
605    return True;
606 }
607
608
609 static BOOL smb_shm_free(int offset)
610 {
611    struct SmbShmBlockDesc *header_p  ; /*       pointer to header of block to free */
612    struct SmbShmBlockDesc *scanner_p ; /*       used to scan the list                      */
613    struct SmbShmBlockDesc *prev_p          ; /* holds previous in the list                 */
614    
615    if( !smb_shm_header_p )
616    {
617       /* not mapped yet */
618       DEBUG(0,("ERROR smb_shm_free : shmem not mapped\n"));
619       return False;
620    }
621    
622    smb_shm_global_lock();
623
624    if( !smb_shm_header_p->consistent)
625    {
626       DEBUG(0,("ERROR smb_shm_free : shmem not consistent\n"));
627       smb_shm_global_unlock();
628       return False;
629    }
630    
631    header_p = ( (struct SmbShmBlockDesc *)smb_shm_offset2addr(offset) - 1); /* make pointer to header of block */
632
633    if (header_p->next != SMB_SHM_NOT_FREE_OFF)
634    {
635       DEBUG(0,("ERROR smb_shm_free : bad offset (%d)\n",offset));
636       smb_shm_global_unlock();
637       return False;
638    }
639    
640    /* find a place in the free_list to put the header in */
641    
642    /* set scanner and previous pointer to start of list */
643    prev_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(smb_shm_header_p->first_free_off);
644    scanner_p = prev_p ;
645    
646    while ( ( scanner_p != EOList_Addr) && (scanner_p < header_p) ) /* while we didn't scan past its position */
647    {
648       prev_p = scanner_p ;
649       scanner_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(scanner_p->next);
650    }
651    
652    smb_shm_header_p->consistent = False;
653    
654    DEBUG(6,("smb_shm_free : freeing %d bytes at offset %d\n",header_p->size*CellSize,offset));
655
656    /* zero the area being freed - this allows us to find bugs faster */
657    memset(smb_shm_offset2addr(offset), 0, header_p->size*CellSize);
658
659    if ( scanner_p == prev_p )
660    {
661       smb_shm_header_p->statistics.cells_free += header_p->size;
662       smb_shm_header_p->statistics.cells_used -= header_p->size;
663
664       /* we must free it at the beginning of the list */
665       smb_shm_header_p->first_free_off = smb_shm_addr2offset(header_p);                                          /*     set     the free_list_pointer to this block_header */
666
667       /* scanner is the one that was first in the list */
668       header_p->next = smb_shm_addr2offset(scanner_p);
669       smb_shm_solve_neighbors( header_p ); /* if neighbors then link them */
670       
671       smb_shm_header_p->consistent = True;
672       smb_shm_global_unlock();
673       return True;
674    } 
675    else
676    {
677       smb_shm_header_p->statistics.cells_free += header_p->size;
678       smb_shm_header_p->statistics.cells_used -= header_p->size;
679
680       prev_p->next = smb_shm_addr2offset(header_p);
681       header_p->next = smb_shm_addr2offset(scanner_p);
682       smb_shm_solve_neighbors(header_p) ;
683       smb_shm_solve_neighbors(prev_p) ;
684
685       smb_shm_header_p->consistent = True;
686       smb_shm_global_unlock();
687       return True;
688    }
689 }
690
691 static int smb_shm_get_userdef_off(void)
692 {
693    if (!smb_shm_header_p)
694       return 0;
695    else
696       return smb_shm_header_p->userdef_off;
697 }
698
699 /*******************************************************************
700   Lock a particular hash bucket entry.
701   ******************************************************************/
702 static BOOL smb_shm_lock_hash_entry( unsigned int entry)
703 {
704   int start = (smb_shm_header_p->userdef_off + (entry * sizeof(int)));
705
706   if (smb_shm_fd < 0)
707     {
708       DEBUG(0,("ERROR smb_shm_lock_hash_entry : bad smb_shm_fd (%d)\n",smb_shm_fd));
709       return False;
710     }
711
712   if (read_only)
713           return True;
714
715   /* Do an exclusive wait lock on the 4 byte region mapping into this entry  */
716   if (fcntl_lock(smb_shm_fd, SMB_F_SETLKW, start, sizeof(int), F_WRLCK) == False)
717     {
718       DEBUG(0,("ERROR smb_shm_lock_hash_entry : fcntl_lock failed with code %s\n",strerror(errno)));
719       return False;
720     }
721   
722   DEBUG(9,("smb_shm_lock_hash_entry: locked hash bucket %d\n", entry)); 
723   return True;
724 }
725
726 /*******************************************************************
727   Unlock a particular hash bucket entry.
728   ******************************************************************/
729 static BOOL smb_shm_unlock_hash_entry( unsigned int entry )
730 {
731   int start = (smb_shm_header_p->userdef_off + (entry * sizeof(int)));
732
733   if (smb_shm_fd < 0)
734     {
735       DEBUG(0,("ERROR smb_shm_unlock_hash_entry : bad smb_shm_fd (%d)\n",smb_shm_fd));
736       return False;
737     }
738
739   if (read_only)
740           return True;
741    
742   /* Do a wait lock on the 4 byte region mapping into this entry  */
743   if (fcntl_lock(smb_shm_fd, SMB_F_SETLKW, start, sizeof(int), F_UNLCK) == False)
744     {
745       DEBUG(0,("ERROR smb_shm_unlock_hash_entry : fcntl_lock failed with code %s\n",strerror(errno)));
746       return False;
747     }
748   
749   DEBUG(9,("smb_shm_unlock_hash_entry: unlocked hash bucket %d\n", entry)); 
750   return True;
751 }
752
753 /*******************************************************************
754   Gather statistics on shared memory usage.
755   ******************************************************************/
756 static BOOL smb_shm_get_usage(int *bytes_free,
757                    int *bytes_used,
758                    int *bytes_overhead)
759 {
760    if( !smb_shm_header_p )
761    {
762       /* not mapped yet */
763       DEBUG(0,("ERROR smb_shm_free : shmem not mapped\n"));
764       return False;
765    }
766    *bytes_free = smb_shm_header_p->statistics.cells_free * CellSize;
767    *bytes_used = smb_shm_header_p->statistics.cells_used * CellSize;
768    *bytes_overhead = smb_shm_header_p->statistics.cells_system * CellSize + AlignedHeaderSize;
769    
770    return True;
771 }
772
773 /*******************************************************************
774 hash a number into a hash_entry
775   ******************************************************************/
776 static unsigned smb_shm_hash_size(void)
777 {
778         return SHMEM_HASH_SIZE;
779 }
780
781 static struct shmem_ops shmops = {
782         smb_shm_close,
783         smb_shm_alloc,
784         smb_shm_free,
785         smb_shm_get_userdef_off,
786         smb_shm_offset2addr,
787         smb_shm_addr2offset,
788         smb_shm_lock_hash_entry,
789         smb_shm_unlock_hash_entry,
790         smb_shm_get_usage,
791         smb_shm_hash_size,
792 };
793
794 /*******************************************************************
795   open the shared memory
796   ******************************************************************/
797 struct shmem_ops *smb_shm_open(int ronly)
798 {
799   pstring file_name;
800   SMB_OFF_T filesize;
801   BOOL created_new = False;
802   BOOL other_processes = True;
803   SMB_OFF_T size = (SMB_OFF_T)lp_shmem_size();
804
805   read_only = ronly;
806
807   pstrcpy(file_name,lp_lockdir());
808   if (!directory_exist(file_name,NULL)) {
809     if (read_only)
810       return NULL;
811     mkdir(file_name,0755);
812   }
813   trim_string(file_name,"","/");
814   if (!*file_name)
815     return(False);
816   pstrcat(file_name, "/SHARE_MEM_FILE");
817    
818   DEBUG(5,("smb_shm_open : using shmem file %s to be of size %.0f\n",
819         file_name,(double)size));
820
821   smb_shm_fd = sys_open(file_name, read_only?O_RDONLY:(O_RDWR|O_CREAT),
822                     SHM_FILE_MODE);
823
824   if ( smb_shm_fd < 0 )
825   {
826     DEBUG(0,("ERROR smb_shm_open : open failed with code %s\n",strerror(errno)));
827     return NULL;
828   }
829    
830   if (!smb_shm_global_lock())
831   {
832     DEBUG(0,("ERROR smb_shm_open : can't do smb_shm_global_lock\n"));
833     return NULL;
834   }
835    
836   if( (filesize = sys_lseek(smb_shm_fd, 0, SEEK_END)) == -1)
837   {
838     DEBUG(0,("ERROR smb_shm_open : sys_lseek failed with code %s\n",
839           strerror(errno)));
840     smb_shm_global_unlock();
841     close(smb_shm_fd);
842     return NULL;
843   }
844
845   /* 
846    * Return the file offset to 0 to save on later seeks.
847    */
848   if(sys_lseek(smb_shm_fd,0,SEEK_SET) == -1)
849   {
850     DEBUG(0,("ERROR smb_shm_open : sys_lseek failed with code %s\n",
851           strerror(errno)));
852     smb_shm_global_unlock();
853     close(smb_shm_fd);
854     return NULL;
855   }
856
857   if (filesize == 0)
858   {
859     /* 
860      * We just created a new one.
861      */
862     created_new = True;
863   }
864    
865   /* 
866    * To find out if some other process is already mapping the file,
867    * we use a registration file containing the processids of the file
868    * mapping processes.
869    */
870
871   /* construct processreg file name */
872   pstrcpy(smb_shm_processreg_name, file_name);
873   pstrcat(smb_shm_processreg_name, ".processes");
874
875   if (!read_only && !smb_shm_register_process(smb_shm_processreg_name,
876                                               getpid(), &other_processes))
877   {
878     smb_shm_global_unlock();
879     close(smb_shm_fd);
880     return NULL;
881   }
882
883   if (!read_only && (created_new || !other_processes))
884   {
885     /* we just created a new one, or are the first opener, lets set it size */
886     if( sys_ftruncate(smb_shm_fd, size) <0)
887     {
888       DEBUG(0,("ERROR smb_shm_open : ftruncate failed with code %s\n",
889             strerror(errno)));
890       smb_shm_unregister_process(smb_shm_processreg_name, getpid());
891       smb_shm_global_unlock();
892       close(smb_shm_fd);
893       return NULL;
894     }
895
896     /* paranoia */
897     if(sys_lseek(smb_shm_fd,0,SEEK_SET) == -1)
898     {
899       DEBUG(0,("ERROR smb_shm_open : sys_lseek failed with code %s\n",
900             strerror(errno)));
901       smb_shm_unregister_process(smb_shm_processreg_name, getpid());
902       smb_shm_global_unlock();
903       close(smb_shm_fd);
904       return NULL;
905     }
906
907     filesize = size;
908   }
909    
910   if (size != filesize )
911   {
912     /* the existing file has a different size and we are not the first opener.
913       Since another process is still using it, we will use the file size */
914     DEBUG(0,("WARNING smb_shm_open : filesize (%.0f) != expected \
915 size (%.0f), using filesize\n", (double)filesize, (double)size));
916
917     size = filesize;
918   }
919    
920   smb_shm_header_p = (struct SmbShmHeader *)sys_mmap(NULL, size, 
921                                read_only?PROT_READ: (PROT_READ | PROT_WRITE), 
922                                MAP_FILE | MAP_SHARED, smb_shm_fd, (SMB_OFF_T)0);
923
924   /* 
925    * WARNING, smb_shm_header_p can be different for different
926    * processes mapping the same file !
927    */
928   if (smb_shm_header_p  == (struct SmbShmHeader *)(-1))
929   {
930     DEBUG(0,("ERROR smb_shm_open : mmap failed with code %s\n",strerror(errno)));
931     smb_shm_unregister_process(smb_shm_processreg_name, getpid());
932     smb_shm_global_unlock();
933     close(smb_shm_fd);
934     return NULL;
935   }      
936    
937       
938   if (!read_only && (created_new || !other_processes))
939   {
940     smb_shm_initialize(size);
941     /* Create the hash buckets for the share file entries. */
942     smb_shm_create_hash_table(SHMEM_HASH_SIZE);
943   }
944   else if (!smb_shm_validate_header(size) )
945   {
946     /* existing file is corrupt, samba admin should remove it by hand */
947     DEBUG(0,("ERROR smb_shm_open : corrupt shared mem file, remove it manually\n"));
948     munmap((caddr_t)smb_shm_header_p, size);
949     smb_shm_unregister_process(smb_shm_processreg_name, getpid());
950     smb_shm_global_unlock();
951     close(smb_shm_fd);
952     return NULL;
953   }
954    
955   smb_shm_global_unlock();
956   return &shmops;
957 }
958
959
960 #else /* HAVE_SHARED_MMAP */
961  int shmem_dummy_procedure(void)
962 {return 0;}
963 #endif /* HAVE_SHARED_MMAP */