X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fio-layer%2Fshared.c;h=b0e828a222107e17c6c5f2dbb2ccf9ed4dc79d7b;hb=f3bdc8c2efd860b33615953694e61909f979fc09;hp=9243083b082f0ce8d3dde027a64e978aedbad2cc;hpb=40e2ffd5553eef59e20c3987676d303e8015f521;p=mono.git diff --git a/mono/io-layer/shared.c b/mono/io-layer/shared.c index 9243083b082..b0e828a2221 100644 --- a/mono/io-layer/shared.c +++ b/mono/io-layer/shared.c @@ -1,3 +1,12 @@ +/* + * shared.c: Shared memory handling, and daemon launching + * + * Author: + * Dick Porter (dick@ximian.com) + * + * (C) 2002 Ximian, Inc. + */ + /* * Code to support inter-process sharing of handles. * @@ -8,149 +17,431 @@ * that I may as well take advantage of sysV shared memory too. * Actually, semaphores seem to be buggy, or I was using them * incorrectly :-). I've replaced the sysV semaphore with a shared - * integer controlled with Interlocked functions. - + * integer controlled with Interlocked functions. And I've since + * replaced that with a separate process to serialise access to the + * shared memory, to avoid the possibility of DOS by leaving the + * shared memory locked, and also to allow the shared memory to be + * cleaned up. + * * mmap() files have the advantage of avoiding namespace collisions, * but have the disadvantage of needing cleaning up, and also msync(). * sysV shared memory has a really stupid way of getting random key * IDs, which can lead to collisions. * - * I deliberately don't ever delete the shared memory: I'd like to - * have been able to set the shared memory segment to destroy itself - * on last close, but it doesn't support that. (Setting IPC_RMID on a - * segment causes subsequent shmat() with the same key to get a new - * segment :-( ). The function to delete the shared memory segment is - * only called from a debugging tool (mono/handles/shmdel). + * Having tried sysv shm, I tested mmap() and found that MAP_SHARED + * makes msync() irrelevent, and both types need cleaning up. Seeing + * as mmap() doesn't suffer from the bonkers method of allocating + * segments, it seems to be the best method. * - * w32 processes do not have the POSIX parent-child relationship, so a - * process handle is available to any other process to find out exit - * status. Handles are destroyed when the last reference to them is - * closed. New handles can be created for long lasting items such as - * processes or threads, and also for named synchronisation objects so - * long as these haven't been deleted by having the last referencing - * handle closed. + * This shared memory is needed because w32 processes do not have the + * POSIX parent-child relationship, so a process handle is available + * to any other process to find out exit status. Handles are + * destroyed when the last reference to them is closed. New handles + * can be created for long lasting items such as processes or threads, + * and also for named synchronisation objects so long as these haven't + * been deleted by having the last referencing handle closed. */ + #include #include #include +#include #include +#include #include -#include -#include +#include #include #include #include #include #include +#include #undef DEBUG -gpointer _wapi_shm_attach (gboolean daemon, gboolean *success, int *shm_id) +/* Define this to make it easier to run valgrind on the daemon. Then + * the first process to start will turn into a daemon without forking + * (the debug utility mono/handles/hps is ideal for this.) + */ +#undef VALGRINDING + +guchar *_wapi_shm_file (_wapi_shm_t type, guint32 segment) { - gpointer shm_seg; - key_t key; - gboolean fork_daemon=FALSE; - struct _WapiHandleShared_list *data; - int tries; - - /* - * This is an attempt to get a unique key id. The first arg - * to ftok is a path, so when the config file support is done - * we should use that. + static guchar file[_POSIX_PATH_MAX]; + guchar *name = NULL, *filename, *dir, *wapi_dir; + gchar machine_name[256]; + + if (gethostname(machine_name, sizeof(machine_name)) != 0) + machine_name[0] = '\0'; + + /* Change the filename whenever the format of the contents + * changes */ - key=ftok (g_get_home_dir (), _WAPI_HANDLE_VERSION); + if(type==WAPI_SHM_DATA) { + name=g_strdup_printf ("shared_data-%s-%d-%d", + machine_name, _WAPI_HANDLE_VERSION, segment); + } else if (type==WAPI_SHM_SCRATCH) { + name=g_strdup_printf ("shared_scratch-%s-%d-%d", + machine_name, _WAPI_HANDLE_VERSION, segment); + } else { + g_assert_not_reached (); + } + + /* I don't know how nfs affects mmap. If mmap() of files on + * nfs mounts breaks, then there should be an option to set + * the directory. + */ + wapi_dir=getenv ("MONO_SHARED_DIR"); + if(wapi_dir==NULL) { + filename=g_build_filename (g_get_home_dir (), ".wapi", name, + NULL); + } else { + filename=g_build_filename (wapi_dir, ".wapi", name, NULL); + } + g_free (name); + + g_snprintf (file, _POSIX_PATH_MAX, "%s", filename); + g_free (filename); + + /* No need to check if the dir already exists or check + * mkdir() errors, because on any error the open() call will + * report the problem. + */ + dir=g_path_get_dirname (file); + mkdir (dir, 0755); + g_free (dir); + + return(file); +} + +gpointer _wapi_shm_file_expand (gpointer mem, _wapi_shm_t type, + guint32 segment, guint32 old_len, + guint32 new_len) +{ + int fd; + gpointer new_mem; + guchar *filename=_wapi_shm_file (type, segment); + int ret; + + if(old_len>=new_len) { + return(mem); + } + + munmap (mem, old_len); + + fd=open (filename, O_RDWR, 0600); + if(fd==-1) { + g_critical (G_GNUC_PRETTY_FUNCTION + ": shared file [%s] open error: %s", filename, + g_strerror (errno)); + return(NULL); + } + + if(lseek (fd, new_len-1, SEEK_SET)==-1) { + g_critical (G_GNUC_PRETTY_FUNCTION + ": shared file [%s] lseek error: %s", filename, + g_strerror (errno)); + return(NULL); + } + + do { + ret=write (fd, "", 1); + } + while (ret==-1 && errno==EINTR); + + if(ret==-1) { + g_critical (G_GNUC_PRETTY_FUNCTION + ": shared file [%s] write error: %s", filename, + g_strerror (errno)); + return(NULL); + } + + close (fd); + + new_mem=_wapi_shm_file_map (type, segment, NULL, NULL); + + return(new_mem); +} + +static int _wapi_shm_file_open (const guchar *filename, _wapi_shm_t type, + gboolean *created) +{ + int fd; + struct stat statbuf; + guint32 wanted_size = 0; + int ret; + + if(created) { + *created=FALSE; + } + + if(type==WAPI_SHM_DATA) { + wanted_size=sizeof(struct _WapiHandleShared_list); + } else if (type==WAPI_SHM_SCRATCH) { + wanted_size=sizeof(struct _WapiHandleScratch) + + (_WAPI_SHM_SCRATCH_SIZE - MONO_ZERO_ARRAY_LENGTH); + } else { + g_assert_not_reached (); + } try_again: - *shm_id=shmget (key, sizeof(struct _WapiHandleShared_list)+ - _WAPI_SHM_SCRATCH_SIZE, IPC_CREAT | IPC_EXCL | 0600); - if(*shm_id==-1 && errno==EEXIST) { - /* Cool, we dont have to fork the handle daemon, but - * we still need to try and get the shm_id. - */ - *shm_id=shmget (key, 0, 0600); - - /* it's possible that the shared memory segment was - * deleted in between seeing if it exists, and - * attaching it. If we got an error here, just try - * attaching it again. + /* No O_CREAT yet, because we need to initialise the file if + * we have to create it. + */ + fd=open (filename, O_RDWR, 0600); + if(fd==-1 && errno==ENOENT) { + /* OK, its up to us to create it. O_EXCL to avoid a + * race condition where two processes can + * simultaneously try and create the file */ - if(*shm_id==-1) { + fd=open (filename, O_CREAT|O_EXCL|O_RDWR, 0600); + if(fd==-1 && errno==EEXIST) { + /* It's possible that the file was created in + * between finding it didn't exist, and trying + * to create it. Just try opening it again + */ goto try_again; - } - } else if (*shm_id!=-1) { - /* We created the shared memory segment, so we need to - * fork the handle daemon too - */ - fork_daemon=TRUE; + } else if (fd==-1) { + g_critical (G_GNUC_PRETTY_FUNCTION + ": shared file [%s] open error: %s", + filename, g_strerror (errno)); + return(-1); + } else { + /* We created the file, so we need to expand + * the file and inform the caller so it can + * fork the handle daemon too. + * + * (wanted_size-1, because we're about to + * write the other byte to actually expand the + * file.) + */ + if(lseek (fd, wanted_size-1, SEEK_SET)==-1) { + g_critical (G_GNUC_PRETTY_FUNCTION ": shared file [%s] lseek error: %s", filename, g_strerror (errno)); + close (fd); + unlink (filename); + return(-1); + } + + do { + ret=write (fd, "", 1); + } + while (ret==-1 && errno==EINTR); + + if(ret==-1) { + g_critical (G_GNUC_PRETTY_FUNCTION ": shared file [%s] write error: %s", filename, g_strerror (errno)); + close (fd); + unlink (filename); + return(-1); + } + + if(created) { + *created=TRUE; + } - /* sysv shared mem is set to all zero when allocated, - * so we don't need to do any more initialisation here - */ - } else { - /* Some error other than EEXIST */ - g_message (G_GNUC_PRETTY_FUNCTION ": shmget error: %s", - strerror (errno)); - exit (-1); + /* The contents of the file is set to all + * zero, because it is opened up with lseek, + * so we don't need to do any more + * initialisation here + */ + } + } else if(fd==-1) { + g_critical (G_GNUC_PRETTY_FUNCTION + ": shared file [%s] open error: %s", filename, + g_strerror (errno)); + return(-1); } - /* From now on, we need to delete the shm segment before - * exiting on error if we created it (ie, if - * fork_daemon==TRUE) + /* From now on, we need to delete the file before exiting on + * error if we created it (ie, if *created==TRUE) */ - shm_seg=shmat (*shm_id, NULL, 0); - if(shm_seg==(gpointer)-1) { - g_message (G_GNUC_PRETTY_FUNCTION ": shmat error: %s", - strerror (errno)); - if(fork_daemon==TRUE) { - _wapi_shm_destroy (); + + /* Use stat to find the file size (instead of hard coding it) + * because we can expand the file later if needed (for more + * handles or scratch space.) + */ + if(fstat (fd, &statbuf)==-1) { + g_critical (G_GNUC_PRETTY_FUNCTION ": fstat error: %s", + g_strerror (errno)); + if(created && *created==TRUE) { + unlink (filename); } - exit (-1); + close (fd); + return(-1); } - if(daemon==TRUE) { - /* No more to do in the daemon */ - *success=TRUE; - return(shm_seg); + if(statbuf.st_size < wanted_size) { + close (fd); + if(created && *created==TRUE) { +#ifdef HAVE_LARGE_FILE_SUPPORT + /* Keep gcc quiet... */ + g_critical (G_GNUC_PRETTY_FUNCTION ": shared file [%s] is not big enough! (found %lld, need %d bytes)", filename, statbuf.st_size, wanted_size); +#else + g_critical (G_GNUC_PRETTY_FUNCTION ": shared file [%s] is not big enough! (found %ld, need %d bytes)", filename, statbuf.st_size, wanted_size); +#endif + unlink (filename); + return(-1); + } else { + /* We didn't create it, so just try opening it again */ + goto try_again; + } + } + + return(fd); +} + +gpointer _wapi_shm_file_map (_wapi_shm_t type, guint32 segment, + gboolean *created, off_t *size) +{ + gpointer shm_seg; + int fd; + struct stat statbuf; + guchar *filename=_wapi_shm_file (type, segment); + + fd=_wapi_shm_file_open (filename, type, created); + if(fd==-1) { + g_critical (G_GNUC_PRETTY_FUNCTION + ": shared file [%s] open error", filename); + return(NULL); + } + + if(fstat (fd, &statbuf)==-1) { + g_critical (G_GNUC_PRETTY_FUNCTION ": fstat error: %s", + g_strerror (errno)); + close (fd); + return(NULL); + } + if(size) { + *size=statbuf.st_size; + } + + shm_seg=mmap (NULL, statbuf.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, + fd, 0); + if(shm_seg==MAP_FAILED) { + g_critical (G_GNUC_PRETTY_FUNCTION ": mmap error: %s", + g_strerror (errno)); + close (fd); + return(NULL); } - data=shm_seg; + close (fd); + return(shm_seg); +} - if(fork_daemon==TRUE) { +/* + * _wapi_shm_attach: + * @success: Was it a success + * + * Attach to the shared memory file or create it if it did not + * exist. If it was created and daemon was FALSE a new daemon is + * forked into existence. Returns the memory area the file was mmapped + * to. + */ +gboolean _wapi_shm_attach (struct _WapiHandleShared_list **data, + struct _WapiHandleScratch **scratch) +{ + gboolean data_created=FALSE, scratch_created=FALSE; + off_t data_size, scratch_size; + int tries, closing_tries=0; + +map_again: + *data=_wapi_shm_file_map (WAPI_SHM_DATA, 0, &data_created, &data_size); + if(*data==NULL) { + return(FALSE); + } + + *scratch=_wapi_shm_file_map (WAPI_SHM_SCRATCH, 0, &scratch_created, + &scratch_size); + if(*scratch==NULL) { + if(data_created) { + _wapi_shm_destroy (); + } + return(FALSE); + } + + if(scratch_created) + (*scratch)->data_len = scratch_size - + (sizeof(struct _WapiHandleScratch) - MONO_ZERO_ARRAY_LENGTH); + + if(data_created==FALSE && (*data)->daemon_running==DAEMON_CLOSING) { + /* Daemon is closing down, give it a few ms and try + * again. + */ + + struct timespec sleepytime; + + /* Something must have gone wrong, so delete the + * shared segments and try again. + */ + _wapi_shm_destroy (); + + munmap (*data, data_size); + munmap (*scratch, scratch_size); + + if(closing_tries++ == 5) { + /* Still can't get going, so bail out */ + g_warning ("The handle daemon is stuck closing"); + return(FALSE); + } + + sleepytime.tv_sec=0; + sleepytime.tv_nsec=10000000; /* 10ms */ + + nanosleep (&sleepytime, NULL); + goto map_again; + } + + if(data_created==TRUE) { +#ifdef VALGRINDING + /* _wapi_daemon_main() does not return */ + _wapi_daemon_main (*data, *scratch); + + /* But just in case... */ + (*data)->daemon_running=DAEMON_DIED_AT_STARTUP; + exit (-1); +#else pid_t pid; pid=fork (); if(pid==-1) { - g_message (G_GNUC_PRETTY_FUNCTION ": fork error: %s", - strerror (errno)); + g_critical (G_GNUC_PRETTY_FUNCTION ": fork error: %s", + strerror (errno)); _wapi_shm_destroy (); - exit (-1); + return(FALSE); } else if (pid==0) { + int i; + /* child */ setsid (); - execl (MONO_BINDIR "/mono-handle-d", "mono-handle-d", - NULL); - g_warning (": exec of %s/mono-handle-d failed: %s", - MONO_BINDIR, strerror (errno)); - data->daemon_running=2; + + /* FIXME: Set process title to something + * informative + */ + + /* Start the daemon with a clean sheet of file + * descriptors + */ + for(i=3; idaemon_running=DAEMON_DIED_AT_STARTUP; exit (-1); } /* parent carries on */ - } else { - /* Do some sanity checking on the shared memory we - * attached - */ - if(!(data->daemon_running==0 || data->daemon_running==1 || - data->daemon_running==2) || - (strncmp (data->daemon+1, "mono-handle-daemon-", 19)!=0)) { - g_warning ("Shared memory sanity check failed."); - *success=FALSE; - return(NULL); - } +#ifdef DEBUG + g_message (G_GNUC_PRETTY_FUNCTION ": Daemon pid %d", pid); +#endif +#endif /* !VALGRINDING */ } - for(tries=0; data->daemon_running==0 && tries < 100; tries++) { + for(tries=0; (*data)->daemon_running==DAEMON_STARTING && tries < 100; + tries++) { /* wait for the daemon to sort itself out. To be * completely safe, we should have a timeout before * giving up. @@ -162,59 +453,82 @@ try_again: nanosleep (&sleepytime, NULL); } - if(tries==100 && data->daemon_running==0) { + if(tries==100 && (*data)->daemon_running==DAEMON_STARTING) { /* Daemon didnt get going */ - if(fork_daemon==TRUE) { - _wapi_shm_destroy (); + struct timespec sleepytime; + + /* Something must have gone wrong, so delete the + * shared segments and try again. + */ + _wapi_shm_destroy (); + + /* Daemon didn't get going, give it a few ms and try + * again. + */ + + munmap (*data, data_size); + munmap (*scratch, scratch_size); + + if(closing_tries++ == 5) { + /* Still can't get going, so bail out */ + g_warning ("The handle daemon didnt start up properly"); + return(FALSE); } - g_warning ("The handle daemon didnt start up properly"); - *success=FALSE; - return(NULL); + + sleepytime.tv_sec=0; + sleepytime.tv_nsec=10000000; /* 10ms */ + + nanosleep (&sleepytime, NULL); + goto map_again; } - if(data->daemon_running==2) { + if((*data)->daemon_running==DAEMON_DIED_AT_STARTUP) { /* Oh dear, the daemon had an error starting up */ - if(fork_daemon==TRUE) { + if(data_created==TRUE) { _wapi_shm_destroy (); } g_warning ("Handle daemon failed to start"); - *success=FALSE; - return(NULL); + return(FALSE); + } + + /* Do some sanity checking on the shared memory we + * attached + */ + if(((*data)->daemon_running!=DAEMON_RUNNING) || +#ifdef NEED_LINK_UNLINK + (strncmp ((*data)->daemon, "/tmp/mono-handle-daemon-", + 24)!=0)) { +#else + (strncmp ((*data)->daemon+1, "mono-handle-daemon-", 19)!=0)) { +#endif + g_warning ("Shared memory sanity check failed."); + g_warning("status: %d", (*data)->daemon_running); +#ifdef NEED_LINK_UNLINK + g_warning("daemon: [%s]", (*data)->daemon); +#else + g_warning("daemon: [%s]", (*data)->daemon+1); +#endif + return(FALSE); } /* From now on, it's up to the daemon to delete the shared * memory segment */ - *success=TRUE; - return(shm_seg); + return(TRUE); } void _wapi_shm_destroy (void) { #ifndef DISABLE_SHARED_HANDLES - int shm_id; - key_t key; - - /* - * This is an attempt to get a unique key id. The - * first arg to ftok is a path, so when the config - * file support is done we should use that. +#ifdef DEBUG + g_message (G_GNUC_PRETTY_FUNCTION ": unlinking shared data"); +#endif + /* Only delete the first segments. The daemon will destroy + * any others when it exits */ - key=ftok (g_get_home_dir (), _WAPI_HANDLE_VERSION); - - shm_id=shmget (key, 0, 0600); - if(shm_id==-1 && errno==ENOENT) { - return; - } else if (shm_id==-1) { - g_message (G_GNUC_PRETTY_FUNCTION ": shmget error: %s", - strerror (errno)); - exit (-1); - } - if(shmctl (shm_id, IPC_RMID, NULL)==-1) { - g_message (G_GNUC_PRETTY_FUNCTION ": shmctl error: %s", - strerror (errno)); - exit (-1); - } + unlink (_wapi_shm_file (WAPI_SHM_DATA, 0)); + unlink (_wapi_shm_file (WAPI_SHM_SCRATCH, 0)); #endif /* DISABLE_SHARED_HANDLES */ } +