| /* Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* Memory handler for a plain memory divided in slot. |
| * This one uses plain memory. |
| */ |
| |
| #include "ap_slotmem.h" |
| |
| #define AP_SLOTMEM_IS_PREGRAB(t) (t->type & AP_SLOTMEM_TYPE_PREGRAB) |
| |
| struct ap_slotmem_instance_t { |
| char *name; /* per segment name */ |
| void *base; /* data set start */ |
| apr_size_t size; /* size of each memory slot */ |
| unsigned int num; /* number of mem slots */ |
| apr_pool_t *gpool; /* per segment global pool */ |
| char *inuse; /* in-use flag table*/ |
| ap_slotmem_type_t type; /* type-specific flags */ |
| struct ap_slotmem_instance_t *next; /* location of next allocated segment */ |
| }; |
| |
| |
| /* global pool and list of slotmem we are handling */ |
| static struct ap_slotmem_instance_t *globallistmem = NULL; |
| static apr_pool_t *gpool = NULL; |
| |
| static apr_status_t slotmem_do(ap_slotmem_instance_t *mem, ap_slotmem_callback_fn_t *func, void *data, apr_pool_t *pool) |
| { |
| unsigned int i; |
| char *ptr; |
| char *inuse; |
| apr_status_t retval = APR_SUCCESS; |
| |
| |
| if (!mem) |
| return APR_ENOSHMAVAIL; |
| |
| ptr = (char *)mem->base; |
| inuse = mem->inuse; |
| for (i = 0; i < mem->num; i++, inuse++) { |
| if (!AP_SLOTMEM_IS_PREGRAB(mem) || |
| (AP_SLOTMEM_IS_PREGRAB(mem) && *inuse)) { |
| retval = func((void *) ptr, data, pool); |
| if (retval != APR_SUCCESS) |
| break; |
| } |
| ptr += mem->size; |
| } |
| return retval; |
| } |
| |
| static apr_status_t slotmem_create(ap_slotmem_instance_t **new, const char *name, apr_size_t item_size, unsigned int item_num, ap_slotmem_type_t type, apr_pool_t *pool) |
| { |
| ap_slotmem_instance_t *res; |
| ap_slotmem_instance_t *next = globallistmem; |
| apr_size_t basesize = (item_size * item_num); |
| |
| const char *fname; |
| |
| if (name) { |
| if (name[0] == ':') |
| fname = name; |
| else |
| fname = ap_runtime_dir_relative(pool, name); |
| |
| /* first try to attach to existing slotmem */ |
| if (next) { |
| for (;;) { |
| if (strcmp(next->name, fname) == 0) { |
| /* we already have it */ |
| *new = next; |
| return APR_SUCCESS; |
| } |
| if (!next->next) { |
| break; |
| } |
| next = next->next; |
| } |
| } |
| } |
| else |
| fname = "anonymous"; |
| |
| /* create the memory using the gpool */ |
| res = (ap_slotmem_instance_t *) apr_pcalloc(gpool, sizeof(ap_slotmem_instance_t)); |
| res->base = apr_pcalloc(gpool, basesize + (item_num * sizeof(char))); |
| if (!res->base) |
| return APR_ENOSHMAVAIL; |
| |
| /* For the chained slotmem stuff */ |
| res->name = apr_pstrdup(gpool, fname); |
| res->size = item_size; |
| res->num = item_num; |
| res->next = NULL; |
| res->type = type; |
| res->inuse = (char *)res->base + basesize; |
| if (globallistmem == NULL) |
| globallistmem = res; |
| else |
| next->next = res; |
| |
| *new = res; |
| return APR_SUCCESS; |
| } |
| |
| static apr_status_t slotmem_attach(ap_slotmem_instance_t **new, const char *name, apr_size_t *item_size, unsigned int *item_num, apr_pool_t *pool) |
| { |
| ap_slotmem_instance_t *next = globallistmem; |
| const char *fname; |
| |
| if (name) { |
| if (name[0] == ':') |
| fname = name; |
| else |
| fname = ap_runtime_dir_relative(pool, name); |
| } |
| else |
| return APR_ENOSHMAVAIL; |
| |
| /* first try to attach to existing slotmem */ |
| while (next) { |
| if (strcmp(next->name, fname) == 0) { |
| /* we already have it */ |
| *new = next; |
| *item_size = next->size; |
| *item_num = next->num; |
| return APR_SUCCESS; |
| } |
| next = next->next; |
| } |
| |
| return APR_ENOSHMAVAIL; |
| } |
| |
| static apr_status_t slotmem_dptr(ap_slotmem_instance_t *score, unsigned int id, void **mem) |
| { |
| |
| char *ptr; |
| |
| if (!score) |
| return APR_ENOSHMAVAIL; |
| if (id >= score->num) |
| return APR_EINVAL; |
| |
| ptr = (char *)score->base + score->size * id; |
| if (!ptr) |
| return APR_ENOSHMAVAIL; |
| *mem = ptr; |
| return APR_SUCCESS; |
| } |
| |
| static apr_status_t slotmem_get(ap_slotmem_instance_t *slot, unsigned int id, unsigned char *dest, apr_size_t dest_len) |
| { |
| void *ptr; |
| char *inuse; |
| apr_status_t ret; |
| |
| if (!slot) { |
| return APR_ENOSHMAVAIL; |
| } |
| |
| inuse = slot->inuse + id; |
| if (id >= slot->num) { |
| return APR_EINVAL; |
| } |
| if (AP_SLOTMEM_IS_PREGRAB(slot) && !*inuse) { |
| return APR_NOTFOUND; |
| } |
| ret = slotmem_dptr(slot, id, &ptr); |
| if (ret != APR_SUCCESS) { |
| return ret; |
| } |
| *inuse=1; |
| memcpy(dest, ptr, dest_len); /* bounds check? */ |
| return APR_SUCCESS; |
| } |
| |
| static apr_status_t slotmem_put(ap_slotmem_instance_t *slot, unsigned int id, unsigned char *src, apr_size_t src_len) |
| { |
| void *ptr; |
| char *inuse; |
| apr_status_t ret; |
| |
| if (!slot) { |
| return APR_ENOSHMAVAIL; |
| } |
| |
| inuse = slot->inuse + id; |
| if (id >= slot->num) { |
| return APR_EINVAL; |
| } |
| if (AP_SLOTMEM_IS_PREGRAB(slot) && !*inuse) { |
| return APR_NOTFOUND; |
| } |
| ret = slotmem_dptr(slot, id, &ptr); |
| if (ret != APR_SUCCESS) { |
| return ret; |
| } |
| *inuse=1; |
| memcpy(ptr, src, src_len); /* bounds check? */ |
| return APR_SUCCESS; |
| } |
| |
| static unsigned int slotmem_num_slots(ap_slotmem_instance_t *slot) |
| { |
| return slot->num; |
| } |
| |
| static unsigned int slotmem_num_free_slots(ap_slotmem_instance_t *slot) |
| { |
| unsigned int i, counter=0; |
| char *inuse = slot->inuse; |
| for (i = 0; i < slot->num; i++, inuse++) { |
| if (!*inuse) |
| counter++; |
| } |
| return counter; |
| } |
| |
| static apr_size_t slotmem_slot_size(ap_slotmem_instance_t *slot) |
| { |
| return slot->size; |
| } |
| |
| /* |
| * XXXX: if !AP_SLOTMEM_IS_PREGRAB, then still worry about |
| * inuse for grab and return? |
| */ |
| static apr_status_t slotmem_grab(ap_slotmem_instance_t *slot, unsigned int *id) |
| { |
| unsigned int i; |
| char *inuse; |
| |
| if (!slot) { |
| return APR_ENOSHMAVAIL; |
| } |
| |
| inuse = slot->inuse; |
| |
| for (i = 0; i < slot->num; i++, inuse++) { |
| if (!*inuse) { |
| break; |
| } |
| } |
| if (i >= slot->num) { |
| return APR_EINVAL; |
| } |
| *inuse = 1; |
| *id = i; |
| return APR_SUCCESS; |
| } |
| |
| static apr_status_t slotmem_fgrab(ap_slotmem_instance_t *slot, unsigned int id) |
| { |
| char *inuse; |
| |
| if (!slot) { |
| return APR_ENOSHMAVAIL; |
| } |
| |
| if (id >= slot->num) { |
| return APR_EINVAL; |
| } |
| inuse = slot->inuse + id; |
| *inuse = 1; |
| return APR_SUCCESS; |
| } |
| |
| static apr_status_t slotmem_release(ap_slotmem_instance_t *slot, unsigned int id) |
| { |
| char *inuse; |
| |
| if (!slot) { |
| return APR_ENOSHMAVAIL; |
| } |
| |
| inuse = slot->inuse; |
| |
| if (id >= slot->num) { |
| return APR_EINVAL; |
| } |
| if (!inuse[id] ) { |
| return APR_NOTFOUND; |
| } |
| inuse[id] = 0; |
| return APR_SUCCESS; |
| } |
| |
| static const ap_slotmem_provider_t storage = { |
| "plainmem", |
| &slotmem_do, |
| &slotmem_create, |
| &slotmem_attach, |
| &slotmem_dptr, |
| &slotmem_get, |
| &slotmem_put, |
| &slotmem_num_slots, |
| &slotmem_num_free_slots, |
| &slotmem_slot_size, |
| &slotmem_grab, |
| &slotmem_release, |
| &slotmem_fgrab |
| }; |
| |
| static int pre_config(apr_pool_t *p, apr_pool_t *plog, |
| apr_pool_t *ptemp) |
| { |
| gpool = p; |
| return OK; |
| } |
| |
| static void ap_slotmem_plain_register_hook(apr_pool_t *p) |
| { |
| /* XXX: static const char * const prePos[] = { "mod_slotmem.c", NULL }; */ |
| ap_register_provider(p, AP_SLOTMEM_PROVIDER_GROUP, "plain", |
| AP_SLOTMEM_PROVIDER_VERSION, &storage); |
| ap_hook_pre_config(pre_config, NULL, NULL, APR_HOOK_MIDDLE); |
| } |
| |
| AP_DECLARE_MODULE(slotmem_plain) = { |
| STANDARD20_MODULE_STUFF, |
| NULL, /* create per-directory config structure */ |
| NULL, /* merge per-directory config structures */ |
| NULL, /* create per-server config structure */ |
| NULL, /* merge per-server config structures */ |
| NULL, /* command apr_table_t */ |
| ap_slotmem_plain_register_hook /* register hooks */ |
| }; |
| |
