Ok - this is the 64 bit widening check in. It changes the configure
[ira/wip.git] / source3 / 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 HAVE_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, 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, 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 = 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 open failed with code %s\n",strerror(errno)));
328       return False;
329    }
330    
331    *other_processes = False;
332    
333    while ((nb_read = read(smb_shm_processes_fd, &other_pid, sizeof(other_pid))) > 0)
334    {
335       if(other_pid)
336       {
337          if(process_exists(other_pid))
338             *other_processes = True;
339          else
340          {
341             /* erase old pid */
342 #ifdef LARGE_SMB_OFF_T
343             DEBUG(5,("smb_shm_register_process : erasing stale record for pid %d (seek_back = %.0f)\n",
344                       (int)other_pid, (double)seek_back));
345 #else
346             DEBUG(5,("smb_shm_register_process : erasing stale record for pid %d (seek_back = %d)\n",
347                       (int)other_pid, seek_back));
348 #endif
349             other_pid = (pid_t)0;
350             erased_slot = sys_lseek(smb_shm_processes_fd, seek_back, SEEK_CUR);
351             write(smb_shm_processes_fd, &other_pid, sizeof(other_pid));
352             if(free_slot < 0)
353                free_slot = erased_slot;
354          }
355       }
356       else 
357          if(free_slot < 0)
358             free_slot = sys_lseek(smb_shm_processes_fd, seek_back, SEEK_CUR);
359    }
360    if (nb_read < 0)
361    {
362       DEBUG(0,("ERROR smb_shm_register_process : processreg_file read failed with code %s\n",strerror(errno)));
363       close(smb_shm_processes_fd);
364       return False;
365    }
366    
367    if(free_slot < 0)
368       free_slot = sys_lseek(smb_shm_processes_fd, 0, SEEK_END);
369
370 #ifdef LARGE_SMB_OFF_T
371    DEBUG(5,("smb_shm_register_process : writing record for pid %d at offset %.0f\n",
372          (int)pid, (double)free_slot));
373 #else /* LARGE_SMB_OFF_T */
374    DEBUG(5,("smb_shm_register_process : writing record for pid %d at offset %d\n",
375          (int)pid,free_slot));
376 #endif /* LARGE_SMB_OFF_T */
377
378    sys_lseek(smb_shm_processes_fd, free_slot, SEEK_SET);
379    if(write(smb_shm_processes_fd, &pid, sizeof(pid)) < 0)
380    {
381       DEBUG(0,("ERROR smb_shm_register_process : processreg_file write failed with code %s\n",strerror(errno)));
382       close(smb_shm_processes_fd);
383       return False;
384    }
385
386    close(smb_shm_processes_fd);
387
388    return True;
389 }
390
391 static BOOL smb_shm_unregister_process(char *processreg_file, pid_t pid)
392 {
393    int smb_shm_processes_fd = -1;
394    int nb_read;
395    pid_t other_pid;
396    SMB_OFF_T seek_back = -((SMB_OFF_T)sizeof(other_pid));
397    SMB_OFF_T erased_slot;
398    BOOL found = False;
399    
400    
401    smb_shm_processes_fd = open(processreg_file, O_RDWR);
402    if ( smb_shm_processes_fd < 0 )
403    {
404       DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file open failed with code %s\n",strerror(errno)));
405       return False;
406    }
407    
408    while ((nb_read = read(smb_shm_processes_fd, &other_pid, sizeof(other_pid))) > 0)
409    {
410       DEBUG(5,("smb_shm_unregister_process : read record for pid %d\n",(int)other_pid));
411       if(other_pid == pid)
412       {
413         /* erase pid */
414 #ifdef LARGE_SMB_OFF_T
415         DEBUG(5,("smb_shm_unregister_process : erasing record for pid %d (seek_val = %.0f)\n",
416                      (int)other_pid, (double)seek_back));
417 #else /* LARGE_SMB_OFF_T */
418         DEBUG(5,("smb_shm_unregister_process : erasing record for pid %d (seek_val = %d)\n",
419                      (int)other_pid, seek_back));
420 #endif /* LARGE_SMB_OFF_T */
421         other_pid = (pid_t)0;
422         erased_slot = sys_lseek(smb_shm_processes_fd, seek_back, SEEK_CUR);
423         if(write(smb_shm_processes_fd, &other_pid, sizeof(other_pid)) < 0)
424         {
425           DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file write failed with code %s\n",strerror(errno)));
426           close(smb_shm_processes_fd);
427           return False;
428         }
429          
430         found = True;
431         break;
432       }
433    }
434    if (nb_read < 0)
435    {
436       DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file read failed with code %s\n",strerror(errno)));
437       close(smb_shm_processes_fd);
438       return False;
439    }
440    
441    if(!found)
442    {
443       DEBUG(0,("ERROR smb_shm_unregister_process : couldn't find pid %d in file %s\n",
444             (int)pid,processreg_file));
445       close(smb_shm_processes_fd);
446       return False;
447    }
448       
449    
450    close(smb_shm_processes_fd);
451
452    return True;
453 }
454
455
456 static BOOL smb_shm_validate_header(int size)
457 {
458    if( !smb_shm_header_p )
459    {
460       /* not mapped yet */
461       DEBUG(0,("ERROR smb_shm_validate_header : shmem not mapped\n"));
462       return False;
463    }
464    
465    if(smb_shm_header_p->smb_shm_magic != SMB_SHM_MAGIC)
466    {
467       DEBUG(0,("ERROR smb_shm_validate_header : bad magic\n"));
468       return False;
469    }
470    if(smb_shm_header_p->smb_shm_version != SMB_SHM_VERSION)
471    {
472       DEBUG(0,("ERROR smb_shm_validate_header : bad version %X\n",smb_shm_header_p->smb_shm_version));
473       return False;
474    }
475    
476    if(smb_shm_header_p->total_size != size)
477    {
478       DEBUG(0,("ERROR smb_shm_validate_header : shmem size mismatch (old = %d, new = %d)\n",smb_shm_header_p->total_size,size));
479       return False;
480    }
481
482    if(!smb_shm_header_p->consistent)
483    {
484       DEBUG(0,("ERROR smb_shm_validate_header : shmem not consistent\n"));
485       return False;
486    }
487    return True;
488 }
489
490 static BOOL smb_shm_initialize(int size)
491 {
492    struct SmbShmBlockDesc * first_free_block_p;
493    
494    DEBUG(5,("smb_shm_initialize : initializing shmem file of size %d\n",size));
495    
496    if( !smb_shm_header_p )
497    {
498       /* not mapped yet */
499       DEBUG(0,("ERROR smb_shm_initialize : shmem not mapped\n"));
500       return False;
501    }
502    
503    smb_shm_header_p->smb_shm_magic = SMB_SHM_MAGIC;
504    smb_shm_header_p->smb_shm_version = SMB_SHM_VERSION;
505    smb_shm_header_p->total_size = size;
506    smb_shm_header_p->first_free_off = AlignedHeaderSize;
507    smb_shm_header_p->userdef_off = 0;
508    
509    first_free_block_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(smb_shm_header_p->first_free_off);
510    first_free_block_p->next = EOList_Off;
511    first_free_block_p->size = ( size - AlignedHeaderSize - CellSize ) / CellSize ;
512    
513    smb_shm_header_p->statistics.cells_free = first_free_block_p->size;
514    smb_shm_header_p->statistics.cells_used = 0;
515    smb_shm_header_p->statistics.cells_system = 1;
516    
517    smb_shm_header_p->consistent = True;
518    
519    smb_shm_initialize_called = True;
520
521    return True;
522 }
523    
524 static void smb_shm_solve_neighbors(struct SmbShmBlockDesc *head_p )
525 {
526    struct SmbShmBlockDesc *next_p;
527    
528    /* Check if head_p and head_p->next are neighbors and if so join them */
529    if ( head_p == EOList_Addr ) return ;
530    if ( head_p->next == EOList_Off ) return ;
531    
532    next_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(head_p->next);
533    if ( ( head_p + head_p->size + 1 ) == next_p)
534    {
535       head_p->size += next_p->size +1 ; /* adapt size */
536       head_p->next = next_p->next         ; /* link out */
537       
538       smb_shm_header_p->statistics.cells_free += 1;
539       smb_shm_header_p->statistics.cells_system -= 1;
540    }
541 }
542
543
544
545 static BOOL smb_shm_close( void )
546 {
547    
548    if(smb_shm_initialize_called == False)
549      return True;
550
551    DEBUG(5,("smb_shm_close\n"));
552    if(smb_shm_times_locked > 0)
553       DEBUG(0,("WARNING smb_shm_close : shmem was still locked %d times\n",smb_shm_times_locked));;
554    if ((smb_shm_header_p != NULL) && 
555               (munmap((caddr_t)smb_shm_header_p, smb_shm_header_p->total_size) < 0))
556    {
557       DEBUG(0,("ERROR smb_shm_close : munmap failed with code %s\n",strerror(errno)));
558    }
559
560    smb_shm_global_lock();
561    DEBUG(5,("calling smb_shm_unregister_process(%s, %d)\n", 
562          smb_shm_processreg_name, (int)getpid()));
563    smb_shm_unregister_process(smb_shm_processreg_name, getpid());
564    smb_shm_global_unlock();
565    
566    close(smb_shm_fd);
567    
568    smb_shm_fd = -1;
569    smb_shm_processreg_name[0] = '\0';
570
571    smb_shm_header_p = (struct SmbShmHeader *)0;
572    smb_shm_times_locked = 0;
573    
574    return True;
575 }
576
577
578 static BOOL smb_shm_free(int offset)
579 {
580    struct SmbShmBlockDesc *header_p  ; /*       pointer to header of block to free */
581    struct SmbShmBlockDesc *scanner_p ; /*       used to scan the list                      */
582    struct SmbShmBlockDesc *prev_p          ; /* holds previous in the list                 */
583    
584    if( !smb_shm_header_p )
585    {
586       /* not mapped yet */
587       DEBUG(0,("ERROR smb_shm_free : shmem not mapped\n"));
588       return False;
589    }
590    
591    smb_shm_global_lock();
592
593    if( !smb_shm_header_p->consistent)
594    {
595       DEBUG(0,("ERROR smb_shm_free : shmem not consistent\n"));
596       smb_shm_global_unlock();
597       return False;
598    }
599    
600    header_p = ( (struct SmbShmBlockDesc *)smb_shm_offset2addr(offset) - 1); /* make pointer to header of block */
601
602    if (header_p->next != SMB_SHM_NOT_FREE_OFF)
603    {
604       DEBUG(0,("ERROR smb_shm_free : bad offset (%d)\n",offset));
605       smb_shm_global_unlock();
606       return False;
607    }
608    
609    /* find a place in the free_list to put the header in */
610    
611    /* set scanner and previous pointer to start of list */
612    prev_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(smb_shm_header_p->first_free_off);
613    scanner_p = prev_p ;
614    
615    while ( ( scanner_p != EOList_Addr) && (scanner_p < header_p) ) /* while we didn't scan past its position */
616    {
617       prev_p = scanner_p ;
618       scanner_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(scanner_p->next);
619    }
620    
621    smb_shm_header_p->consistent = False;
622    
623    DEBUG(6,("smb_shm_free : freeing %d bytes at offset %d\n",header_p->size*CellSize,offset));
624
625    /* zero the area being freed - this allows us to find bugs faster */
626    memset(smb_shm_offset2addr(offset), 0, header_p->size*CellSize);
627
628    if ( scanner_p == prev_p )
629    {
630       smb_shm_header_p->statistics.cells_free += header_p->size;
631       smb_shm_header_p->statistics.cells_used -= header_p->size;
632
633       /* we must free it at the beginning of the list */
634       smb_shm_header_p->first_free_off = smb_shm_addr2offset(header_p);                                          /*     set     the free_list_pointer to this block_header */
635
636       /* scanner is the one that was first in the list */
637       header_p->next = smb_shm_addr2offset(scanner_p);
638       smb_shm_solve_neighbors( header_p ); /* if neighbors then link them */
639       
640       smb_shm_header_p->consistent = True;
641       smb_shm_global_unlock();
642       return True;
643    } 
644    else
645    {
646       smb_shm_header_p->statistics.cells_free += header_p->size;
647       smb_shm_header_p->statistics.cells_used -= header_p->size;
648
649       prev_p->next = smb_shm_addr2offset(header_p);
650       header_p->next = smb_shm_addr2offset(scanner_p);
651       smb_shm_solve_neighbors(header_p) ;
652       smb_shm_solve_neighbors(prev_p) ;
653
654       smb_shm_header_p->consistent = True;
655       smb_shm_global_unlock();
656       return True;
657    }
658 }
659
660 static int smb_shm_get_userdef_off(void)
661 {
662    if (!smb_shm_header_p)
663       return 0;
664    else
665       return smb_shm_header_p->userdef_off;
666 }
667
668 /*******************************************************************
669   Lock a particular hash bucket entry.
670   ******************************************************************/
671 static BOOL smb_shm_lock_hash_entry( unsigned int entry)
672 {
673   int start = (smb_shm_header_p->userdef_off + (entry * sizeof(int)));
674
675   if (smb_shm_fd < 0)
676     {
677       DEBUG(0,("ERROR smb_shm_lock_hash_entry : bad smb_shm_fd (%d)\n",smb_shm_fd));
678       return False;
679     }
680
681   if (read_only)
682           return True;
683
684   /* Do an exclusive wait lock on the 4 byte region mapping into this entry  */
685   if (fcntl_lock(smb_shm_fd, F_SETLKW, start, sizeof(int), F_WRLCK) == False)
686     {
687       DEBUG(0,("ERROR smb_shm_lock_hash_entry : fcntl_lock failed with code %s\n",strerror(errno)));
688       return False;
689     }
690   
691   DEBUG(9,("smb_shm_lock_hash_entry: locked hash bucket %d\n", entry)); 
692   return True;
693 }
694
695 /*******************************************************************
696   Unlock a particular hash bucket entry.
697   ******************************************************************/
698 static BOOL smb_shm_unlock_hash_entry( unsigned int entry )
699 {
700   int start = (smb_shm_header_p->userdef_off + (entry * sizeof(int)));
701
702   if (smb_shm_fd < 0)
703     {
704       DEBUG(0,("ERROR smb_shm_unlock_hash_entry : bad smb_shm_fd (%d)\n",smb_shm_fd));
705       return False;
706     }
707
708   if (read_only)
709           return True;
710    
711   /* Do a wait lock on the 4 byte region mapping into this entry  */
712   if (fcntl_lock(smb_shm_fd, F_SETLKW, start, sizeof(int), F_UNLCK) == False)
713     {
714       DEBUG(0,("ERROR smb_shm_unlock_hash_entry : fcntl_lock failed with code %s\n",strerror(errno)));
715       return False;
716     }
717   
718   DEBUG(9,("smb_shm_unlock_hash_entry: unlocked hash bucket %d\n", entry)); 
719   return True;
720 }
721
722 /*******************************************************************
723   Gather statistics on shared memory usage.
724   ******************************************************************/
725 static BOOL smb_shm_get_usage(int *bytes_free,
726                    int *bytes_used,
727                    int *bytes_overhead)
728 {
729    if( !smb_shm_header_p )
730    {
731       /* not mapped yet */
732       DEBUG(0,("ERROR smb_shm_free : shmem not mapped\n"));
733       return False;
734    }
735    *bytes_free = smb_shm_header_p->statistics.cells_free * CellSize;
736    *bytes_used = smb_shm_header_p->statistics.cells_used * CellSize;
737    *bytes_overhead = smb_shm_header_p->statistics.cells_system * CellSize + AlignedHeaderSize;
738    
739    return True;
740 }
741
742 /*******************************************************************
743 hash a number into a hash_entry
744   ******************************************************************/
745 static unsigned smb_shm_hash_size(void)
746 {
747         return SHMEM_HASH_SIZE;
748 }
749
750 static struct shmem_ops shmops = {
751         smb_shm_close,
752         smb_shm_alloc,
753         smb_shm_free,
754         smb_shm_get_userdef_off,
755         smb_shm_offset2addr,
756         smb_shm_addr2offset,
757         smb_shm_lock_hash_entry,
758         smb_shm_unlock_hash_entry,
759         smb_shm_get_usage,
760         smb_shm_hash_size,
761 };
762
763 /*******************************************************************
764   open the shared memory
765   ******************************************************************/
766 struct shmem_ops *smb_shm_open(int ronly)
767 {
768         pstring file_name;
769         SMB_OFF_T filesize;
770         BOOL created_new = False;
771         BOOL other_processes = True;
772         SMB_OFF_T size = (SMB_OFF_T)lp_shmem_size();
773
774         read_only = ronly;
775
776         pstrcpy(file_name,lp_lockdir());
777         if (!directory_exist(file_name,NULL)) {
778                 if (read_only) return NULL;
779                 mkdir(file_name,0755);
780         }
781         trim_string(file_name,"","/");
782         if (!*file_name) return(False);
783         pstrcat(file_name, "/SHARE_MEM_FILE");
784    
785 #ifdef LARGE_SMB_OFF_T
786    DEBUG(5,("smb_shm_open : using shmem file %s to be of size %.0f\n",file_name,(double)size));
787 #else /* LARGE_SMB_OFF_T */
788    DEBUG(5,("smb_shm_open : using shmem file %s to be of size %d\n",file_name,size));
789 #endif /* LARGE_SMB_OFF_T */
790
791    smb_shm_fd = open(file_name, read_only?O_RDONLY:(O_RDWR|O_CREAT),
792                      SHM_FILE_MODE);
793
794    if ( smb_shm_fd < 0 )
795    {
796       DEBUG(0,("ERROR smb_shm_open : open failed with code %s\n",strerror(errno)));
797       return NULL;
798    }
799    
800    if (!smb_shm_global_lock())
801    {
802       DEBUG(0,("ERROR smb_shm_open : can't do smb_shm_global_lock\n"));
803       return NULL;
804    }
805    
806    if( (filesize = sys_lseek(smb_shm_fd, 0, SEEK_END)) < 0)
807    {
808       DEBUG(0,("ERROR smb_shm_open : lseek failed with code %s\n",strerror(errno)));
809       smb_shm_global_unlock();
810       close(smb_shm_fd);
811       return NULL;
812    }
813
814    /* return the file offset to 0 to save on later seeks */
815    sys_lseek(smb_shm_fd,0,SEEK_SET);
816
817    if (filesize == 0)
818    {
819       /* we just created a new one */
820       created_new = True;
821    }
822    
823    /* to find out if some other process is already mapping the file,
824       we use a registration file containing the processids of the file mapping processes
825       */
826
827    /* construct processreg file name */
828    pstrcpy(smb_shm_processreg_name, file_name);
829    pstrcat(smb_shm_processreg_name, ".processes");
830
831    if (!read_only && 
832        !smb_shm_register_process(smb_shm_processreg_name, getpid(), &other_processes))
833    {
834       smb_shm_global_unlock();
835       close(smb_shm_fd);
836       return NULL;
837    }
838
839    if (!read_only && (created_new || !other_processes))
840    {
841       /* we just created a new one, or are the first opener, lets set it size */
842       if( sys_ftruncate(smb_shm_fd, size) <0)
843       {
844         DEBUG(0,("ERROR smb_shm_open : ftruncate failed with code %s\n",strerror(errno)));
845         smb_shm_unregister_process(smb_shm_processreg_name, getpid());
846         smb_shm_global_unlock();
847         close(smb_shm_fd);
848         return NULL;
849       }
850
851       /* paranoia */
852       sys_lseek(smb_shm_fd,0,SEEK_SET);
853
854       filesize = size;
855    }
856    
857    if (size != filesize )
858    {
859       /* the existing file has a different size and we are not the first opener.
860          Since another process is still using it, we will use the file size */
861 #ifdef LARGE_SMB_OFF_T
862       DEBUG(0,("WARNING smb_shm_open : filesize (%.0f) != expected size (%.0f), using filesize\n",
863             (double)filesize, (double)size));
864 #else /* LARGE_SMB_OFF_T */
865       DEBUG(0,("WARNING smb_shm_open : filesize (%d) != expected size (%d), using filesize\n",
866             filesize,size));
867 #endif /* LARGE_SMB_OFF_T */
868
869       size = filesize;
870    }
871    
872    smb_shm_header_p = (struct SmbShmHeader *)mmap(NULL, size, 
873                                                   read_only?PROT_READ:
874                                                   (PROT_READ | PROT_WRITE), 
875                                                   MAP_FILE | MAP_SHARED, 
876                                                   smb_shm_fd, 0);
877    /* WARNING, smb_shm_header_p can be different for different processes mapping the same file ! */
878    if (smb_shm_header_p  == (struct SmbShmHeader *)(-1))
879    {
880       DEBUG(0,("ERROR smb_shm_open : mmap failed with code %s\n",strerror(errno)));
881       smb_shm_unregister_process(smb_shm_processreg_name, getpid());
882       smb_shm_global_unlock();
883       close(smb_shm_fd);
884       return NULL;
885    }      
886    
887       
888    if (!read_only && (created_new || !other_processes))
889    {
890       smb_shm_initialize(size);
891       /* Create the hash buckets for the share file entries. */
892       smb_shm_create_hash_table(SHMEM_HASH_SIZE);
893    }
894    else if (!smb_shm_validate_header(size) )
895    {
896       /* existing file is corrupt, samba admin should remove it by hand */
897       DEBUG(0,("ERROR smb_shm_open : corrupt shared mem file, remove it manually\n"));
898       munmap((caddr_t)smb_shm_header_p, size);
899       smb_shm_unregister_process(smb_shm_processreg_name, getpid());
900       smb_shm_global_unlock();
901       close(smb_shm_fd);
902       return NULL;
903    }
904    
905    smb_shm_global_unlock();
906    return &shmops;
907 }
908
909
910 #else /* HAVE_SHARED_MMAP */
911  int shmem_dummy_procedure(void)
912 {return 0;}
913 #endif /* HAVE_SHARED_MMAP */