shared_page* shmdata_getNewSharedPage(pool* p, apr_shm_t** shm_t, int segmentsize, char* path){ int overheadsize,usersize, x; shared_page* page; apr_status_t rv; overheadsize=sizeof(shared_page); usersize=segmentsize*2; rv=apr_shm_create(shm_t,overheadsize+usersize,path,p); #ifdef WIN32 if(rv==APR_EEXIST) { // try to attach it; seems windows specific behaviour rv = apr_shm_attach(shm_t,path,p); } #endif if(rv!=APR_SUCCESS){ //if failure then try to remove shm segment and try again if(apr_shm_attach(shm_t,path,p)==APR_SUCCESS){ apr_shm_destroy(*shm_t); rv=apr_shm_create(shm_t,overheadsize+usersize,path,p); //if again failure..possible bad shm file...remove and retry if(rv!=APR_SUCCESS){ rv=apr_file_remove(path,p); if(rv==APR_SUCCESS){ rv=apr_shm_create(shm_t,overheadsize+usersize,path,p); } } }else{ //if cannot attach blow file away and try again rv=apr_file_remove(path,p); if(rv==APR_SUCCESS){ rv=apr_shm_create(shm_t,overheadsize+usersize,path,p); } } } if(rv==APR_SUCCESS){ APACHE_LOG_DEBUG1("SHARED PAGES CREATED: Path=%s",path); page=apr_shm_baseaddr_get(*shm_t); page->itemmax=MAX_PAGE_ITEMS; page->segmentsize=segmentsize; page->timestamp=SHM_TIMESTAMP_INIT; page->flipcount=0; page->frontsegment=1; page->backsegment=0; page->data=(char*)(page+1); page->cursor=page->data; for(x=0;x<SEGMENTS_PER_PAGE;x++){ page->segments[x].itemcount=0; } return page; } APACHE_LOG_DEBUG("SHARED PAGE BAD"); return NULL; }
apr_status_t server_init_child_stat(dav_rawx_server_conf *conf, apr_pool_t *pool, apr_pool_t *plog) { char buff[256]; apr_status_t rc; DAV_XDEBUG_POOL(plog, 0, "%s()", __FUNCTION__); /* Attaches the mutex */ DAV_DEBUG_POOL(plog, 0, "%s : Attaching the SHM global_mutex at [%s]", __FUNCTION__, conf->shm.path); rc = apr_global_mutex_child_init(&(conf->lock.handle), conf->shm.path, pool); if (APR_SUCCESS != rc) { DAV_ERROR_POOL(plog, 0, "%s : Failed to attach the SHM global_mutex at [%s] rc=%d : %s", __FUNCTION__, conf->shm.path, rc, apr_strerror(rc, buff, sizeof(buff))); return rc; } DAV_DEBUG_POOL(plog, 0, "%s : globalmutex attached at [%s]", __FUNCTION__, conf->shm.path); /* Atatches the SHM */ if (!conf->shm.handle) { DAV_DEBUG_POOL(plog, 0, "%s : Attaching the SHM segment at [%s]", __FUNCTION__, conf->shm.path); rc = apr_shm_attach(&(conf->shm.handle), conf->shm.path, pool); if (APR_SUCCESS != rc) { DAV_ERROR_POOL(plog, 0, "%s : Failed to attach the SHM segment at [%s] rc=%d : %s", __FUNCTION__, conf->shm.path, rc, apr_strerror(rc, buff, sizeof(buff))); conf->shm.handle = NULL; return rc; } } DAV_DEBUG_POOL(plog, 0, "%s : SHM segment attached at [%s]", __FUNCTION__, conf->shm.path); return APR_SUCCESS; }
apr_status_t server_init_master_stat(dav_rawx_server_conf *conf, apr_pool_t *pool, apr_pool_t *plog) { char buff[256]; apr_status_t rc; DAV_XDEBUG_POOL(plog, 0, "%s()", __FUNCTION__); /* Try to attach to the already existing SHM segment */ rc = apr_shm_attach(&(conf->shm.handle), conf->shm.path, pool); if (APR_SUCCESS != rc) { DAV_DEBUG_POOL(plog, 0, "%s: Failed to attach to SHM segment at [%s]: %s", __FUNCTION__, conf->shm.path, apr_strerror(rc, buff, sizeof(buff))); conf->shm.handle = NULL; return rc; } DAV_DEBUG_POOL(plog, 0, "%s: Attached to existing SHM segment at [%s]", __FUNCTION__, conf->shm.path); /* Create a processus lock*/ rc = apr_global_mutex_create(&(conf->lock.handle), conf->shm.path, APR_LOCK_DEFAULT, pool); if (rc != APR_SUCCESS) { DAV_ERROR_POOL(plog, 0, "%s : Cannot create a global_mutex at [%s] rc=%d : %s", __FUNCTION__, conf->shm.path, rc, apr_strerror(rc, buff, sizeof(buff))); (void) apr_shm_destroy(conf->shm.handle); conf->shm.handle = NULL; return rc; } DAV_DEBUG_POOL(plog, 0, "%s : globalmutex created at [%s]", __FUNCTION__, conf->shm.path); return APR_SUCCESS; }
APR_DECLARE(apr_status_t) apr_shm_attach_ex(apr_shm_t **m, const char *filename, apr_pool_t *pool, apr_int32_t flags) { return apr_shm_attach(m, filename, pool); }
static shared_page* shmdata_attachToSharedPage(pool* p, apr_shm_t** shm_t, int segmentsize, char* path){ int overheadsize,usersize, x; shared_page* page; apr_status_t rv; overheadsize=sizeof(shared_page); usersize=segmentsize*2; rv = apr_shm_attach(shm_t,path,p); if(rv!=APR_SUCCESS){ APACHE_LOG_DEBUG("UNABLE TO ATTACH TO SHARED PAGE BAD"); } if(rv==APR_SUCCESS){ APACHE_LOG_DEBUG1("SHARED PAGES CREATED: Path=%s",path); page=apr_shm_baseaddr_get(*shm_t); page->itemmax=MAX_PAGE_ITEMS; page->segmentsize=segmentsize; page->timestamp=SHM_TIMESTAMP_INIT; page->flipcount=0; page->frontsegment=1; page->backsegment=0; page->data=(char*)(page+1); page->cursor=page->data; for(x=0;x<SEGMENTS_PER_PAGE;x++){ page->segments[x].itemcount=0; } return page; } APACHE_LOG_DEBUG("SHARED PAGE BAD"); return NULL; }
int main(void) { apr_status_t rv; apr_pool_t *pool; apr_shm_t *shm; int recvd; apr_initialize(); if (apr_pool_create(&pool, NULL) != APR_SUCCESS) { exit(-1); } rv = apr_shm_attach(&shm, SHARED_FILENAME, pool); if (rv != APR_SUCCESS) { exit(-2); } boxes = apr_shm_baseaddr_get(shm); /* consume messages on all of the boxes */ recvd = msgwait(30, 0, N_BOXES); /* wait for 30 seconds for messages */ rv = apr_shm_detach(shm); if (rv != APR_SUCCESS) { exit(-3); } return recvd; }
bool LLPluginSharedMemory::attach(const std::string &name, size_t size) { mName = name; mSize = size; apr_status_t status = apr_shm_attach( &(mImpl->mAprSharedMemory), mName.c_str(), gAPRPoolp ); if(ll_apr_warn_status(status)) { return false; } return map(); }
static int psgi_post_config(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s) { dTHX; const void *key; char *file; SV *app; apr_hash_index_t *hi; void *data; const char *userdata_key = "psgi_post_config"; psgi_apps_t *psgi_apps = NULL; apr_status_t rc; apr_pool_userdata_get(&data, userdata_key, s->process->pool); if (data == NULL) { apr_pool_userdata_set((const void *)1, userdata_key, apr_pool_cleanup_null, s->process->pool); return OK; } ap_add_version_component(pconf, apr_psprintf(pconf, "mod_psgi/%s", MOD_PSGI_VERSION)); mutex_name = apr_psprintf(pconf, "/tmp/psgi_mutex.%ld", (long int) getpid()); rc = apr_global_mutex_create(&psgi_mutex, (const char *) mutex_name, APR_LOCK_DEFAULT, pconf); if (rc != APR_SUCCESS) { return DECLINED; } rc = apr_global_mutex_lock(psgi_mutex); if (rc != APR_SUCCESS) { return DECLINED; } /* shared name to store apps */ shm_name = apr_pstrdup(pconf, "/tmp/psgi_shm"); rc = apr_shm_attach(&psgi_shm, (const char *) shm_name, pconf); if (rc != APR_SUCCESS) { rc = apr_shm_create(&psgi_shm, sizeof(psgi_apps_t), (const char *) shm_name, pconf); } if (rc == APR_SUCCESS) { psgi_apps = (psgi_apps_t *)apr_shm_baseaddr_get(psgi_shm); psgi_apps->apps = apr_hash_make(pconf); } apr_global_mutex_unlock(psgi_mutex); return OK; }
int reattach_dir_sync(music_globals_t* music_globals){ int i = 0; int status = 0; for(i = 0; i < music_globals->music_dirs->nelts; i++){ dir_t* dir = &(((dir_t*)music_globals->music_dirs->elts)[i]); if(dir->shm_file){ status = apr_shm_attach(&(dir->shm), dir->shm_file, music_globals->pool); if(status != APR_SUCCESS){ return status; } dir->stats = apr_shm_baseaddr_get(dir->shm); } } return status; }
static void create_shm(server_rec *s,apr_pool_t *p) { int threaded_mpm; ap_mpm_query(AP_MPMQ_IS_THREADED, &threaded_mpm); //if (threaded_mpm) { tmpnam(lock_name); apr_global_mutex_create(&lock, lock_name, APR_THREAD_MUTEX_DEFAULT, p); //DEBUGLOG("threaded!"); // } size_t size; size = sizeof(client_list_t) + table_size * sizeof(client_t); ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL, "Create or Joining shmem. name: %s, size: %zd", shmname, size); if(lock) apr_global_mutex_lock(lock); apr_status_t rc = apr_shm_attach(&shm, shmname, p); if (APR_SUCCESS != rc) { DEBUGLOG("dosdetector: Creating shared memory"); apr_shm_remove(shmname, p); rc = apr_shm_create(&shm, size, shmname, p); if (APR_SUCCESS != rc) { ap_log_error(APLOG_MARK, APLOG_ERR, 0,0, "dosdetector: failed to create shared memory %s\n", shmname); //ap_log_error(APLOG_MARK, APLOG_ERR, 0,0, "dosdetector: %s:%d: failed to create shared memory %s\n", __FILE__, __LINE__, shmname); } else { client_list = apr_shm_baseaddr_get(shm); memset(client_list, 0, size); } } else { DEBUGLOG("dosdetector: Joining shared memory"); client_list = apr_shm_baseaddr_get(shm); } apr_shm_remove(shmname, p); // Just to set destroy flag. client_list->head = client_list->base; client_t *c = client_list->base; int i; for (i = 1; i < table_size; i++) { c->next = (c + 1); c++; } c->next = NULL; if (lock) apr_global_mutex_unlock(lock); }
apr_status_t util_ldap_cache_init(apr_pool_t *pool, util_ldap_state_t *st) { #if APR_HAS_SHARED_MEMORY apr_status_t result; apr_size_t size; size = APR_ALIGN_DEFAULT(st->cache_bytes); result = apr_shm_create(&st->cache_shm, size, st->cache_file, st->pool); if (result == APR_EEXIST) { /* * The cache could have already been created (i.e. we may be a child process). See * if we can attach to the existing shared memory */ result = apr_shm_attach(&st->cache_shm, st->cache_file, st->pool); } if (result != APR_SUCCESS) { return result; } /* Determine the usable size of the shm segment. */ size = apr_shm_size_get(st->cache_shm); /* This will create a rmm "handler" to get into the shared memory area */ result = apr_rmm_init(&st->cache_rmm, NULL, apr_shm_baseaddr_get(st->cache_shm), size, st->pool); if (result != APR_SUCCESS) { return result; } #endif apr_pool_cleanup_register(st->pool, st , util_ldap_cache_module_kill, apr_pool_cleanup_null); st->util_ldap_cache = util_ald_create_cache(st, util_ldap_url_node_hash, util_ldap_url_node_compare, util_ldap_url_node_copy, util_ldap_url_node_free, util_ldap_url_node_display); return APR_SUCCESS; }
int lua_apr_shm_attach(lua_State *L) { apr_status_t status; lua_apr_shm *object; const char *filename; filename = luaL_checkstring(L, 1); object = new_object(L, &lua_apr_shm_type); status = apr_pool_create(&object->pool, NULL); if (status != APR_SUCCESS) return push_error_status(L, status); status = apr_shm_attach(&object->handle, filename, object->pool); if (status != APR_SUCCESS) return push_error_status(L, status); init_shm(L, object); return 1; }
static void test_named_remove(abts_case *tc, void *data) { apr_status_t rv; apr_shm_t *shm, *shm2; apr_shm_remove(SHARED_FILENAME, p); rv = apr_shm_create(&shm, SHARED_SIZE, SHARED_FILENAME, p); APR_ASSERT_SUCCESS(tc, "Error allocating shared memory block", rv); if (rv != APR_SUCCESS) { return; } ABTS_PTR_NOTNULL(tc, shm); rv = apr_shm_remove(SHARED_FILENAME, p); /* On platforms which acknowledge the removal of the shared resource, * ensure another of the same name may be created after removal; */ if (rv == APR_SUCCESS) { rv = apr_shm_create(&shm2, SHARED_SIZE, SHARED_FILENAME, p); APR_ASSERT_SUCCESS(tc, "Error allocating shared memory block", rv); if (rv != APR_SUCCESS) { return; } ABTS_PTR_NOTNULL(tc, shm2); rv = apr_shm_destroy(shm2); APR_ASSERT_SUCCESS(tc, "Error destroying shared memory block", rv); } rv = apr_shm_destroy(shm); APR_ASSERT_SUCCESS(tc, "Error destroying shared memory block", rv); /* Now ensure no named resource remains which we may attach to */ rv = apr_shm_attach(&shm, SHARED_FILENAME, p); ABTS_TRUE(tc, rv != 0); }
static void akismet_child_init(apr_pool_t *p, server_rec *s) { apr_status_t ret; if (!api_cache_shm) { return; } ret = apr_global_mutex_child_init(&global_lock, global_lock_file, p); if (ret != APR_SUCCESS) { ap_log_error(APLOG_MARK, APLOG_CRIT, ret, s, "failed to create lock (global_lock)"); cleanup_shm_resources(NULL); return; } if(!api_cache_shm) { ret = apr_shm_attach( &api_cache_shm, api_cache_shm_file, p); if (ret != APR_SUCCESS) { ap_log_error(APLOG_MARK, APLOG_CRIT, ret, s, "Failed to attach to shared memory file '%s'", api_cache_shm_file); return; } } key_verified_infos = apr_shm_baseaddr_get(api_cache_shm); }