APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create(apr_pool_t *p) { apr_allocator_t *allocator = apr_pool_allocator_get(p); apr_bucket_alloc_t *list; #if APR_POOL_DEBUG /* may be NULL for debug mode. */ if (allocator == NULL) { if (apr_allocator_create(&allocator) != APR_SUCCESS) { apr_abortfunc_t fn = apr_pool_abort_get(p); if (fn) (fn)(APR_ENOMEM); abort(); } } #endif list = apr_bucket_alloc_create_ex(allocator); if (list == NULL) { apr_abortfunc_t fn = apr_pool_abort_get(p); if (fn) (fn)(APR_ENOMEM); abort(); } list->pool = p; apr_pool_cleanup_register(list->pool, list, alloc_cleanup, apr_pool_cleanup_null); return list; }
heap_t *heap_make(apr_pool_t *pool) { apr_memnode_t *node; heap_t *hp = apr_palloc(pool, sizeof(*hp)); hp->allocator = apr_pool_allocator_get(pool); node = apr_allocator_alloc(hp->allocator, HEAP_INIT_SIZE); if (node == NULL) return NULL; node->next = node; node->ref = &node->next; hp->active = node; //hp->htop = node->first_avail; hp->hend = node->first_avail; hp->alloc_size = 0; // gc never run, on the first run active node will be cleansed hp->gc_last = NULL; hp->gc_spot = NULL; // make sure the memory is freed when the pool // is cleared/destroyed apr_pool_cleanup_register(pool, hp, heap_destroy, 0); return hp; }
buffer_t *buffer_make(apr_pool_t *pool, int max) { buffer_t *buf = apr_palloc(pool, sizeof(*buf)); buf->allocator = apr_pool_allocator_get(pool); buf->node = apr_allocator_alloc(buf->allocator, max); buf->offset = 0; return buf; }
static apr_status_t alloc_cleanup(void *data) { apr_bucket_alloc_t *list = data; apr_allocator_free(list->allocator, list->blocks); #if APR_POOL_DEBUG if (list->pool && list->allocator != apr_pool_allocator_get(list->pool)) { apr_allocator_destroy(list->allocator); } #endif return APR_SUCCESS; }
APU_DECLARE_NONSTD(void) apr_bucket_alloc_destroy(apr_bucket_alloc_t *list) { if (list->pool) { apr_pool_cleanup_kill(list->pool, list, alloc_cleanup); } apr_allocator_free(list->allocator, list->blocks); #if APR_POOL_DEBUG if (list->pool && list->allocator != apr_pool_allocator_get(list->pool)) { apr_allocator_destroy(list->allocator); } #endif }
apr_pool_t *nx_pool_create_child(apr_pool_t *parent) { apr_pool_t *pool; apr_allocator_t *allocator; CHECKERR(apr_pool_create_ex(&pool, parent, &abort_func, NULL)); if ( parent == NULL ) { allocator = apr_pool_allocator_get(pool); ASSERT(allocator != NULL); apr_allocator_max_free_set(allocator, NX_MAX_ALLOCATOR_SIZE); } return ( pool ); }
void LLAPRPool::createAPRPool() { if(mPool) { return ; } mStatus = apr_pool_create(&mPool, mParent); ll_apr_warn_status(mStatus) ; if(mMaxSize > 0) //size is the number of blocks (which is usually 4K), NOT bytes. { apr_allocator_t *allocator = apr_pool_allocator_get(mPool); if (allocator) { apr_allocator_max_free_set(allocator, mMaxSize) ; } } }
apr_pool_t *nx_pool_create_core() { apr_pool_t *pool; apr_allocator_t *allocator; apr_thread_mutex_t *mutex; CHECKERR(apr_allocator_create(&allocator)); #ifdef HAVE_APR_POOL_CREATE_UNMANAGED_EX // older apr does not have this CHECKERR(apr_pool_create_unmanaged_ex(&pool, &abort_func, allocator)); #else CHECKERR(apr_pool_create_ex(&pool, NULL, &abort_func, allocator)); #endif allocator = apr_pool_allocator_get(pool); apr_allocator_owner_set(allocator, pool); ASSERT(allocator != NULL); apr_allocator_max_free_set(allocator, NX_MAX_ALLOCATOR_SIZE); CHECKERR(apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_UNNESTED, pool)); apr_allocator_mutex_set(allocator, mutex); return ( pool ); }
/** * Initialize the environment for all requests. * @param env the JNI environment for this request */ bool JNIUtil::JNIGlobalInit(JNIEnv *env) { // This method has to be run only once during the run a program. static bool run = false; svn_error_t *err; if (run) // already run return true; run = true; // Do not run this part more than one time. This leaves a small // time window when two threads create their first SVNClient and // SVNAdmin at the same time, but I do not see a better option // without APR already initialized if (g_inInit) return false; g_inInit = true; g_initEnv = env; apr_status_t status; /* Initialize the APR subsystem, and register an atexit() function * to Uninitialize that subsystem at program exit. */ status = apr_initialize(); if (status) { if (stderr) { char buf[1024]; apr_strerror(status, buf, sizeof(buf) - 1); fprintf(stderr, "%s: error: cannot initialize APR: %s\n", "svnjavahl", buf); } return FALSE; } /* This has to happen before any pools are created. */ if ((err = svn_dso_initialize2())) { if (stderr && err->message) fprintf(stderr, "%s", err->message); svn_error_clear(err); return FALSE; } if (0 > atexit(apr_terminate)) { if (stderr) fprintf(stderr, "%s: error: atexit registration failed\n", "svnjavahl"); return FALSE; } /* Create our top-level pool. */ g_pool = svn_pool_create(NULL); apr_allocator_t* allocator = apr_pool_allocator_get(g_pool); if (allocator) { /* Keep a maximum of 1 free block, to release memory back to the JVM (and other modules). */ apr_allocator_max_free_set(allocator, 1); } svn_utf_initialize2(FALSE, g_pool); /* Optimize character conversions */ svn_fs_initialize(g_pool); /* Avoid some theoretical issues */ svn_ra_initialize(g_pool); /* We shouldn't fill the JVMs memory with FS cache data unless explictly requested. */ { svn_cache_config_t settings = *svn_cache_config_get(); settings.cache_size = 0; settings.file_handle_count = 0; settings.single_threaded = FALSE; svn_cache_config_set(&settings); } #ifdef ENABLE_NLS #ifdef WIN32 { WCHAR ucs2_path[MAX_PATH]; char *utf8_path; const char *internal_path; apr_pool_t *pool; apr_status_t apr_err; apr_size_t inwords, outbytes; unsigned int outlength; pool = svn_pool_create(g_pool); /* get dll name - our locale info will be in '../share/locale' */ inwords = sizeof(ucs2_path) / sizeof(ucs2_path[0]); HINSTANCE moduleHandle = GetModuleHandle("libsvnjavahl-1"); GetModuleFileNameW(moduleHandle, ucs2_path, inwords); inwords = lstrlenW(ucs2_path); outbytes = outlength = 3 * (inwords + 1); utf8_path = reinterpret_cast<char *>(apr_palloc(pool, outlength)); apr_err = apr_conv_ucs2_to_utf8((const apr_wchar_t *) ucs2_path, &inwords, utf8_path, &outbytes); if (!apr_err && (inwords > 0 || outbytes == 0)) apr_err = APR_INCOMPLETE; if (apr_err) { if (stderr) fprintf(stderr, "Can't convert module path to UTF-8"); return FALSE; } utf8_path[outlength - outbytes] = '\0'; internal_path = svn_dirent_internal_style(utf8_path, pool); /* get base path name */ internal_path = svn_dirent_dirname(internal_path, pool); internal_path = svn_dirent_join(internal_path, SVN_LOCALE_RELATIVE_PATH, pool); bindtextdomain(PACKAGE_NAME, internal_path); svn_pool_destroy(pool); } #else bindtextdomain(PACKAGE_NAME, SVN_LOCALE_DIR); #endif #endif #if defined(WIN32) || defined(__CYGWIN__) /* See http://svn.apache.org/repos/asf/subversion/trunk/notes/asp-dot-net-hack.txt */ /* ### This code really only needs to be invoked by consumers of ### the libsvn_wc library, which basically means SVNClient. */ if (getenv("SVN_ASP_DOT_NET_HACK")) { err = svn_wc_set_adm_dir("_svn", g_pool); if (err) { if (stderr) { fprintf(stderr, "%s: error: SVN_ASP_DOT_NET_HACK failed: %s\n", "svnjavahl", err->message); } svn_error_clear(err); return FALSE; } } #endif svn_error_set_malfunction_handler(svn_error_raise_on_malfunction); // Build all mutexes. g_finalizedObjectsMutex = new JNIMutex(g_pool); if (isExceptionThrown()) return false; g_logMutex = new JNIMutex(g_pool); if (isExceptionThrown()) return false; // initialized the thread local storage if (!JNIThreadData::initThreadData()) return false; setEnv(env); if (isExceptionThrown()) return false; g_initEnv = NULL; g_inInit = false; return true; }