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);
}