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