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