2 Unix SMB/Netbios implementation.
4 Shared memory functions
5 Copyright (C) Erik Devriendt 1996-1998
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.
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.
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.
26 #ifdef HAVE_SHARED_MMAP
29 extern int DEBUGLEVEL;
32 #define SMB_SHM_MAGIC 0x53484100
35 #define SMB_SHM_VERSION 2
37 /* we need world read for smbstatus to function correctly */
38 #ifdef SECURE_SHARE_MODES
39 #define SHM_FILE_MODE 0600
41 #define SHM_FILE_MODE 0644
44 #define SHMEM_HASH_SIZE 13
47 /* WARNING : offsets are used because mmap() does not guarantee that all processes have the
48 shared memory mapped to the same address */
54 int total_size; /* in bytes */
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 */
61 int cells_system; /* number of cells used as allocated block descriptors */
65 #define SMB_SHM_NOT_FREE_OFF (-1)
66 struct SmbShmBlockDesc
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 */
72 #define EOList_Addr (struct SmbShmBlockDesc *)( 0 )
75 #define CellSize sizeof(struct SmbShmBlockDesc)
77 /* HeaderSize aligned on 8 byte boundary */
78 #define AlignedHeaderSize ((sizeof(struct SmbShmHeader)+7) & ~7)
80 static int smb_shm_fd = -1;
81 static pstring smb_shm_processreg_name = "";
83 static struct SmbShmHeader *smb_shm_header_p = (struct SmbShmHeader *)0;
84 static int smb_shm_times_locked = 0;
86 static BOOL smb_shm_initialize_called = False;
90 static BOOL smb_shm_global_lock(void)
94 DEBUG(0,("ERROR smb_shm_global_lock : bad smb_shm_fd (%d)\n",smb_shm_fd));
98 smb_shm_times_locked++;
100 if(smb_shm_times_locked > 1)
102 DEBUG(5,("smb_shm_global_lock : locked %d times\n",smb_shm_times_locked));
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)
112 DEBUG(0,("ERROR smb_shm_global_lock : fcntl_lock failed with code %s\n",strerror(errno)));
113 smb_shm_times_locked--;
121 static BOOL smb_shm_global_unlock(void)
125 DEBUG(0,("ERROR smb_shm_global_unlock : bad smb_shm_fd (%d)\n",smb_shm_fd));
129 if(smb_shm_times_locked == 0)
131 DEBUG(0,("ERROR smb_shm_global_unlock : shmem not locked\n"));
135 smb_shm_times_locked--;
137 if(smb_shm_times_locked > 0)
139 DEBUG(5,("smb_shm_global_unlock : still locked %d times\n",smb_shm_times_locked));
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)
149 DEBUG(0,("ERROR smb_shm_global_unlock : fcntl_lock failed with code %s\n",strerror(errno)));
150 smb_shm_times_locked++;
159 static void *smb_shm_offset2addr(int offset)
164 if (!smb_shm_header_p)
167 return (void *)((char *)smb_shm_header_p + offset );
170 static int smb_shm_addr2offset(void *addr)
175 if (!smb_shm_header_p)
178 return (int)((char *)addr - (char *)smb_shm_header_p);
183 static int smb_shm_alloc(int size)
186 struct SmbShmBlockDesc *scanner_p;
187 struct SmbShmBlockDesc *prev_p;
188 struct SmbShmBlockDesc *new_p;
192 if( !smb_shm_header_p )
195 DEBUG(0,("ERROR smb_shm_alloc : shmem not mapped\n"));
199 smb_shm_global_lock();
201 if( !smb_shm_header_p->consistent)
203 DEBUG(0,("ERROR smb_shm_alloc : shmem not consistent\n"));
204 smb_shm_global_unlock();
209 /* calculate the number of cells */
210 num_cells = (size + CellSize -1) / CellSize;
212 /* set start of scan */
213 prev_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(smb_shm_header_p->first_free_off);
216 /* scan the free list to find a matching free space */
217 while ( ( scanner_p != EOList_Addr ) && ( scanner_p->size < num_cells ) )
220 scanner_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(scanner_p->next);
223 /* at this point scanner point to a block header or to the end of the list */
224 if ( scanner_p == EOList_Addr )
226 DEBUG(0,("ERROR smb_shm_alloc : alloc of %d bytes failed, no free space found\n",size));
227 smb_shm_global_unlock();
231 /* going to modify shared mem */
232 smb_shm_header_p->consistent = False;
234 /* if we found a good one : scanner == the good one */
235 if ( scanner_p->size <= num_cells + 2 )
237 /* there is no use in making a new one, it will be too small anyway
238 * we will link out scanner
240 if ( prev_p == scanner_p )
242 smb_shm_header_p->first_free_off = scanner_p->next ;
246 prev_p->next = scanner_p->next ;
248 smb_shm_header_p->statistics.cells_free -= scanner_p->size;
249 smb_shm_header_p->statistics.cells_used += scanner_p->size;
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);
260 if ( prev_p != scanner_p )
262 prev_p->next = smb_shm_addr2offset(new_p) ;
266 smb_shm_header_p->first_free_off = smb_shm_addr2offset(new_p) ;
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;
273 result_offset = smb_shm_addr2offset( &(scanner_p[1]) );
274 scanner_p->next = SMB_SHM_NOT_FREE_OFF ;
276 /* end modification of shared mem */
277 smb_shm_header_p->consistent = True;
279 DEBUG(6,("smb_shm_alloc : request for %d bytes, allocated %d bytes at offset %d\n",size,scanner_p->size*CellSize,result_offset ));
281 smb_shm_global_unlock();
282 return ( result_offset );
289 * Function to create the hash table for the share mode entries. Called
290 * when smb shared memory is global locked.
292 static BOOL smb_shm_create_hash_table( unsigned int size )
296 smb_shm_global_lock();
297 smb_shm_header_p->userdef_off = smb_shm_alloc( size );
299 if(smb_shm_header_p->userdef_off == 0)
301 DEBUG(0,("smb_shm_create_hash_table: Failed to create hash table of size %d\n",size));
302 smb_shm_global_unlock();
306 /* Clear hash buckets. */
307 memset( smb_shm_offset2addr(smb_shm_header_p->userdef_off), '\0', size);
308 smb_shm_global_unlock();
312 static BOOL smb_shm_register_process(char *processreg_file, pid_t pid, BOOL *other_processes)
314 int smb_shm_processes_fd = -1;
317 int seek_back = -((int)sizeof(other_pid));
321 smb_shm_processes_fd = open(processreg_file,
322 read_only?O_RDONLY:(O_RDWR|O_CREAT),
325 if ( smb_shm_processes_fd < 0 )
327 DEBUG(0,("ERROR smb_shm_register_process : processreg_file open failed with code %s\n",strerror(errno)));
331 *other_processes = False;
333 while ((nb_read = read(smb_shm_processes_fd, &other_pid, sizeof(other_pid))) > 0)
337 if(process_exists(other_pid))
338 *other_processes = True;
342 DEBUG(5,("smb_shm_register_process : erasing stale record for pid %d (seek_back = %d)\n",
343 (int)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));
348 free_slot = erased_slot;
353 free_slot = lseek(smb_shm_processes_fd, seek_back, SEEK_CUR);
357 DEBUG(0,("ERROR smb_shm_register_process : processreg_file read failed with code %s\n",strerror(errno)));
358 close(smb_shm_processes_fd);
363 free_slot = lseek(smb_shm_processes_fd, 0, SEEK_END);
365 DEBUG(5,("smb_shm_register_process : writing record for pid %d at offset %d\n",
366 (int)pid,free_slot));
367 lseek(smb_shm_processes_fd, free_slot, SEEK_SET);
368 if(write(smb_shm_processes_fd, &pid, sizeof(pid)) < 0)
370 DEBUG(0,("ERROR smb_shm_register_process : processreg_file write failed with code %s\n",strerror(errno)));
371 close(smb_shm_processes_fd);
375 close(smb_shm_processes_fd);
380 static BOOL smb_shm_unregister_process(char *processreg_file, pid_t pid)
382 int smb_shm_processes_fd = -1;
385 int seek_back = -((int)sizeof(other_pid));
390 smb_shm_processes_fd = open(processreg_file, O_RDWR);
391 if ( smb_shm_processes_fd < 0 )
393 DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file open failed with code %s\n",strerror(errno)));
397 while ((nb_read = read(smb_shm_processes_fd, &other_pid, sizeof(other_pid))) > 0)
399 DEBUG(5,("smb_shm_unregister_process : read record for pid %d\n",(int)other_pid));
403 DEBUG(5,("smb_shm_unregister_process : erasing record for pid %d (seek_val = %d)\n",
404 (int)other_pid, seek_back));
405 other_pid = (pid_t)0;
406 erased_slot = lseek(smb_shm_processes_fd, seek_back, SEEK_CUR);
407 if(write(smb_shm_processes_fd, &other_pid, sizeof(other_pid)) < 0)
409 DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file write failed with code %s\n",strerror(errno)));
410 close(smb_shm_processes_fd);
420 DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file read failed with code %s\n",strerror(errno)));
421 close(smb_shm_processes_fd);
427 DEBUG(0,("ERROR smb_shm_unregister_process : couldn't find pid %d in file %s\n",
428 (int)pid,processreg_file));
429 close(smb_shm_processes_fd);
434 close(smb_shm_processes_fd);
440 static BOOL smb_shm_validate_header(int size)
442 if( !smb_shm_header_p )
445 DEBUG(0,("ERROR smb_shm_validate_header : shmem not mapped\n"));
449 if(smb_shm_header_p->smb_shm_magic != SMB_SHM_MAGIC)
451 DEBUG(0,("ERROR smb_shm_validate_header : bad magic\n"));
454 if(smb_shm_header_p->smb_shm_version != SMB_SHM_VERSION)
456 DEBUG(0,("ERROR smb_shm_validate_header : bad version %X\n",smb_shm_header_p->smb_shm_version));
460 if(smb_shm_header_p->total_size != size)
462 DEBUG(0,("ERROR smb_shm_validate_header : shmem size mismatch (old = %d, new = %d)\n",smb_shm_header_p->total_size,size));
466 if(!smb_shm_header_p->consistent)
468 DEBUG(0,("ERROR smb_shm_validate_header : shmem not consistent\n"));
474 static BOOL smb_shm_initialize(int size)
476 struct SmbShmBlockDesc * first_free_block_p;
478 DEBUG(5,("smb_shm_initialize : initializing shmem file of size %d\n",size));
480 if( !smb_shm_header_p )
483 DEBUG(0,("ERROR smb_shm_initialize : shmem not mapped\n"));
487 smb_shm_header_p->smb_shm_magic = SMB_SHM_MAGIC;
488 smb_shm_header_p->smb_shm_version = SMB_SHM_VERSION;
489 smb_shm_header_p->total_size = size;
490 smb_shm_header_p->first_free_off = AlignedHeaderSize;
491 smb_shm_header_p->userdef_off = 0;
493 first_free_block_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(smb_shm_header_p->first_free_off);
494 first_free_block_p->next = EOList_Off;
495 first_free_block_p->size = ( size - AlignedHeaderSize - CellSize ) / CellSize ;
497 smb_shm_header_p->statistics.cells_free = first_free_block_p->size;
498 smb_shm_header_p->statistics.cells_used = 0;
499 smb_shm_header_p->statistics.cells_system = 1;
501 smb_shm_header_p->consistent = True;
503 smb_shm_initialize_called = True;
508 static void smb_shm_solve_neighbors(struct SmbShmBlockDesc *head_p )
510 struct SmbShmBlockDesc *next_p;
512 /* Check if head_p and head_p->next are neighbors and if so join them */
513 if ( head_p == EOList_Addr ) return ;
514 if ( head_p->next == EOList_Off ) return ;
516 next_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(head_p->next);
517 if ( ( head_p + head_p->size + 1 ) == next_p)
519 head_p->size += next_p->size +1 ; /* adapt size */
520 head_p->next = next_p->next ; /* link out */
522 smb_shm_header_p->statistics.cells_free += 1;
523 smb_shm_header_p->statistics.cells_system -= 1;
529 static BOOL smb_shm_close( void )
532 if(smb_shm_initialize_called == False)
535 DEBUG(5,("smb_shm_close\n"));
536 if(smb_shm_times_locked > 0)
537 DEBUG(0,("WARNING smb_shm_close : shmem was still locked %d times\n",smb_shm_times_locked));;
538 if ((smb_shm_header_p != NULL) &&
539 (munmap((caddr_t)smb_shm_header_p, smb_shm_header_p->total_size) < 0))
541 DEBUG(0,("ERROR smb_shm_close : munmap failed with code %s\n",strerror(errno)));
544 smb_shm_global_lock();
545 DEBUG(5,("calling smb_shm_unregister_process(%s, %d)\n",
546 smb_shm_processreg_name, (int)getpid()));
547 smb_shm_unregister_process(smb_shm_processreg_name, getpid());
548 smb_shm_global_unlock();
553 smb_shm_processreg_name[0] = '\0';
555 smb_shm_header_p = (struct SmbShmHeader *)0;
556 smb_shm_times_locked = 0;
562 static BOOL smb_shm_free(int offset)
564 struct SmbShmBlockDesc *header_p ; /* pointer to header of block to free */
565 struct SmbShmBlockDesc *scanner_p ; /* used to scan the list */
566 struct SmbShmBlockDesc *prev_p ; /* holds previous in the list */
568 if( !smb_shm_header_p )
571 DEBUG(0,("ERROR smb_shm_free : shmem not mapped\n"));
575 smb_shm_global_lock();
577 if( !smb_shm_header_p->consistent)
579 DEBUG(0,("ERROR smb_shm_free : shmem not consistent\n"));
580 smb_shm_global_unlock();
584 header_p = ( (struct SmbShmBlockDesc *)smb_shm_offset2addr(offset) - 1); /* make pointer to header of block */
586 if (header_p->next != SMB_SHM_NOT_FREE_OFF)
588 DEBUG(0,("ERROR smb_shm_free : bad offset (%d)\n",offset));
589 smb_shm_global_unlock();
593 /* find a place in the free_list to put the header in */
595 /* set scanner and previous pointer to start of list */
596 prev_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(smb_shm_header_p->first_free_off);
599 while ( ( scanner_p != EOList_Addr) && (scanner_p < header_p) ) /* while we didn't scan past its position */
602 scanner_p = (struct SmbShmBlockDesc *)smb_shm_offset2addr(scanner_p->next);
605 smb_shm_header_p->consistent = False;
607 DEBUG(6,("smb_shm_free : freeing %d bytes at offset %d\n",header_p->size*CellSize,offset));
609 /* zero the area being freed - this allows us to find bugs faster */
610 memset(smb_shm_offset2addr(offset), 0, header_p->size*CellSize);
612 if ( scanner_p == prev_p )
614 smb_shm_header_p->statistics.cells_free += header_p->size;
615 smb_shm_header_p->statistics.cells_used -= header_p->size;
617 /* we must free it at the beginning of the list */
618 smb_shm_header_p->first_free_off = smb_shm_addr2offset(header_p); /* set the free_list_pointer to this block_header */
620 /* scanner is the one that was first in the list */
621 header_p->next = smb_shm_addr2offset(scanner_p);
622 smb_shm_solve_neighbors( header_p ); /* if neighbors then link them */
624 smb_shm_header_p->consistent = True;
625 smb_shm_global_unlock();
630 smb_shm_header_p->statistics.cells_free += header_p->size;
631 smb_shm_header_p->statistics.cells_used -= header_p->size;
633 prev_p->next = smb_shm_addr2offset(header_p);
634 header_p->next = smb_shm_addr2offset(scanner_p);
635 smb_shm_solve_neighbors(header_p) ;
636 smb_shm_solve_neighbors(prev_p) ;
638 smb_shm_header_p->consistent = True;
639 smb_shm_global_unlock();
644 static int smb_shm_get_userdef_off(void)
646 if (!smb_shm_header_p)
649 return smb_shm_header_p->userdef_off;
652 /*******************************************************************
653 Lock a particular hash bucket entry.
654 ******************************************************************/
655 static BOOL smb_shm_lock_hash_entry( unsigned int entry)
657 int start = (smb_shm_header_p->userdef_off + (entry * sizeof(int)));
661 DEBUG(0,("ERROR smb_shm_lock_hash_entry : bad smb_shm_fd (%d)\n",smb_shm_fd));
668 /* Do an exclusive wait lock on the 4 byte region mapping into this entry */
669 if (fcntl_lock(smb_shm_fd, F_SETLKW, start, sizeof(int), F_WRLCK) == False)
671 DEBUG(0,("ERROR smb_shm_lock_hash_entry : fcntl_lock failed with code %s\n",strerror(errno)));
675 DEBUG(9,("smb_shm_lock_hash_entry: locked hash bucket %d\n", entry));
679 /*******************************************************************
680 Unlock a particular hash bucket entry.
681 ******************************************************************/
682 static BOOL smb_shm_unlock_hash_entry( unsigned int entry )
684 int start = (smb_shm_header_p->userdef_off + (entry * sizeof(int)));
688 DEBUG(0,("ERROR smb_shm_unlock_hash_entry : bad smb_shm_fd (%d)\n",smb_shm_fd));
695 /* Do a wait lock on the 4 byte region mapping into this entry */
696 if (fcntl_lock(smb_shm_fd, F_SETLKW, start, sizeof(int), F_UNLCK) == False)
698 DEBUG(0,("ERROR smb_shm_unlock_hash_entry : fcntl_lock failed with code %s\n",strerror(errno)));
702 DEBUG(9,("smb_shm_unlock_hash_entry: unlocked hash bucket %d\n", entry));
706 /*******************************************************************
707 Gather statistics on shared memory usage.
708 ******************************************************************/
709 static BOOL smb_shm_get_usage(int *bytes_free,
713 if( !smb_shm_header_p )
716 DEBUG(0,("ERROR smb_shm_free : shmem not mapped\n"));
719 *bytes_free = smb_shm_header_p->statistics.cells_free * CellSize;
720 *bytes_used = smb_shm_header_p->statistics.cells_used * CellSize;
721 *bytes_overhead = smb_shm_header_p->statistics.cells_system * CellSize + AlignedHeaderSize;
726 /*******************************************************************
727 hash a number into a hash_entry
728 ******************************************************************/
729 static unsigned smb_shm_hash_size(void)
731 return SHMEM_HASH_SIZE;
734 static struct shmem_ops shmops = {
738 smb_shm_get_userdef_off,
741 smb_shm_lock_hash_entry,
742 smb_shm_unlock_hash_entry,
747 /*******************************************************************
748 open the shared memory
749 ******************************************************************/
750 struct shmem_ops *smb_shm_open(int ronly)
754 BOOL created_new = False;
755 BOOL other_processes = True;
756 int size = lp_shmem_size();
760 pstrcpy(file_name,lp_lockdir());
761 if (!directory_exist(file_name,NULL)) {
762 if (read_only) return NULL;
763 mkdir(file_name,0755);
765 trim_string(file_name,"","/");
766 if (!*file_name) return(False);
767 pstrcat(file_name, "/SHARE_MEM_FILE");
769 DEBUG(5,("smb_shm_open : using shmem file %s to be of size %d\n",file_name,size));
771 smb_shm_fd = open(file_name, read_only?O_RDONLY:(O_RDWR|O_CREAT),
774 if ( smb_shm_fd < 0 )
776 DEBUG(0,("ERROR smb_shm_open : open failed with code %s\n",strerror(errno)));
780 if (!smb_shm_global_lock())
782 DEBUG(0,("ERROR smb_shm_open : can't do smb_shm_global_lock\n"));
786 if( (filesize = lseek(smb_shm_fd, 0, SEEK_END)) < 0)
788 DEBUG(0,("ERROR smb_shm_open : lseek failed with code %s\n",strerror(errno)));
789 smb_shm_global_unlock();
794 /* return the file offset to 0 to save on later seeks */
795 lseek(smb_shm_fd,0,SEEK_SET);
799 /* we just created a new one */
803 /* to find out if some other process is already mapping the file,
804 we use a registration file containing the processids of the file mapping processes
807 /* construct processreg file name */
808 pstrcpy(smb_shm_processreg_name, file_name);
809 pstrcat(smb_shm_processreg_name, ".processes");
812 !smb_shm_register_process(smb_shm_processreg_name, getpid(), &other_processes))
814 smb_shm_global_unlock();
819 if (!read_only && (created_new || !other_processes))
821 /* we just created a new one, or are the first opener, lets set it size */
822 if( ftruncate(smb_shm_fd, size) <0)
824 DEBUG(0,("ERROR smb_shm_open : ftruncate failed with code %s\n",strerror(errno)));
825 smb_shm_unregister_process(smb_shm_processreg_name, getpid());
826 smb_shm_global_unlock();
832 lseek(smb_shm_fd,0,SEEK_SET);
837 if (size != filesize )
839 /* the existing file has a different size and we are not the first opener.
840 Since another process is still using it, we will use the file size */
841 DEBUG(0,("WARNING smb_shm_open : filesize (%d) != expected size (%d), using filesize\n",filesize,size));
845 smb_shm_header_p = (struct SmbShmHeader *)mmap(NULL, size,
847 (PROT_READ | PROT_WRITE),
848 MAP_FILE | MAP_SHARED,
850 /* WARNING, smb_shm_header_p can be different for different processes mapping the same file ! */
851 if (smb_shm_header_p == (struct SmbShmHeader *)(-1))
853 DEBUG(0,("ERROR smb_shm_open : mmap failed with code %s\n",strerror(errno)));
854 smb_shm_unregister_process(smb_shm_processreg_name, getpid());
855 smb_shm_global_unlock();
861 if (!read_only && (created_new || !other_processes))
863 smb_shm_initialize(size);
864 /* Create the hash buckets for the share file entries. */
865 smb_shm_create_hash_table(SHMEM_HASH_SIZE);
867 else if (!smb_shm_validate_header(size) )
869 /* existing file is corrupt, samba admin should remove it by hand */
870 DEBUG(0,("ERROR smb_shm_open : corrupt shared mem file, remove it manually\n"));
871 munmap((caddr_t)smb_shm_header_p, size);
872 smb_shm_unregister_process(smb_shm_processreg_name, getpid());
873 smb_shm_global_unlock();
878 smb_shm_global_unlock();
883 #else /* HAVE_SHARED_MMAP */
884 int shmem_dummy_procedure(void)
886 #endif /* HAVE_SHARED_MMAP */