static bool
new_last(pipe *p, void *ptr)
{
queue_item *q, *aux_q;
if (p->count >= p->limit && p->limit != -1)
return false;
if (p->items == NULL)
{
if (NULL == (p->items = ora_salloc(sizeof(queue_item))))
return false;
p->items->next_item = NULL;
p->items->ptr = ptr;
p->count = 1;
return true;
}
q = p->items;
while (q->next_item != NULL)
q = q->next_item;
if (NULL == (aux_q = ora_salloc(sizeof(queue_item))))
return false;
q->next_item = aux_q;
aux_q->next_item = NULL;
aux_q->ptr = ptr;
p->count += 1;
return true;
}
void*
ora_srealloc(void *ptr, size_t size)
{
void *result;
size_t aux_s = 0;
int i;
for (i = 0; i < *list_c; i++)
if (list[i].first_byte_ptr == ptr)
{
if (align_size(size) <= list[i].size)
return ptr;
aux_s = list[i].size;
}
if (aux_s == 0)
ereport(ERROR,
(errcode(ERRCODE_INTERNAL_ERROR),
errmsg("corrupted pointer"),
errdetail("Failed while reallocating memory block in shared memory."),
errhint("Report this bug to autors.")));
if (NULL != (result = ora_salloc(size)))
{
memcpy(result, ptr, aux_s);
ora_sfree(ptr);
}
return result;
}
void*
salloc(size_t size)
{
void* result;
if (NULL == (result = ora_salloc(size)))
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory"),
errdetail("Failed while allocation block %lu bytes in shared memory.", (unsigned long) size),
errhint("Increase SHMEMMSGSZ and recompile package.")));
return result;
}
static bool
add_to_pipe(text *pipe_name, message_buffer *ptr, int limit, bool limit_is_valid)
{
pipe *p;
bool created;
bool result = false;
message_buffer *sh_ptr;
if (!ora_lock_shmem(SHMEMMSGSZ, MAX_PIPES, MAX_EVENTS, MAX_LOCKS,false))
return false;
for (;;)
{
if (NULL != (p = find_pipe(pipe_name, &created, false)))
{
if (created)
p->registered = ptr == NULL;
if (limit_is_valid && (created || (p->limit < limit)))
p->limit = limit;
if (ptr != NULL)
{
if (NULL != (sh_ptr = ora_salloc(ptr->size)))
{
memcpy(sh_ptr,ptr,ptr->size);
if (new_last(p, sh_ptr))
{
p->size += ptr->size;
result = true;
break;
}
ora_sfree(sh_ptr);
}
if (created)
{
/* I created new pipe, but haven't memory for new value */
ora_sfree(p->pipe_name);
p->is_valid = false;
result = false;
}
}
else
result = true;
}
break;
}
LWLockRelease(shmem_lockid);
return result;
}
char *
ora_sstrcpy(char *str)
{
int len;
char *result;
len = strlen(str);
if (NULL != (result = ora_salloc(len+1)))
memcpy(result, str, len + 1);
else
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory"),
errdetail("Failed while allocation block %d bytes in shared memory.", len+1),
errhint("Increase SHMEMMSGSZ and recompile package.")));
return result;
}
char *
ora_scstring(text *str)
{
int len;
char *result;
len = VARSIZE_ANY_EXHDR(str);
if (NULL != (result = ora_salloc(len+1)))
{
memcpy(result, VARDATA_ANY(str), len);
result[len] = '\0';
}
else
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory"),
errdetail("Failed while allocation block %d bytes in shared memory.", len+1),
errhint("Increase SHMEMMSGSZ and recompile package.")));
return result;
}
bool
ora_lock_shmem(size_t size, int max_pipes, int max_events, int max_locks, bool reset)
{
int i;
bool found;
sh_memory *sh_mem;
if (pipes == NULL)
{
sh_mem = ShmemInitStruct("dbms_pipe", size, &found);
if (sh_mem == NULL)
ereport(FATAL,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory"),
errdetail("Failed while allocation block %lu bytes in shared memory.", (unsigned long) size)));
if (!found)
{
#if PG_VERSION_NUM >= 90600
sh_mem->tranche_id = LWLockNewTrancheId();
LWLockInitialize(&sh_mem->shmem_lock, sh_mem->tranche_id);
{
#if PG_VERSION_NUM >= 100000
LWLockRegisterTranche(sh_mem->tranche_id, "orafce");
#else
static LWLockTranche tranche;
tranche.name = "orafce";
tranche.array_base = &sh_mem->shmem_lock;
tranche.array_stride = sizeof(LWLock);
LWLockRegisterTranche(sh_mem->tranche_id, &tranche);
#endif
shmem_lockid = &sh_mem->shmem_lock;
}
#else
shmem_lockid = sh_mem->shmem_lockid = LWLockAssign();
#endif
LWLockAcquire(shmem_lockid, LW_EXCLUSIVE);
sh_mem->size = size - sh_memory_size;
ora_sinit(sh_mem->data, size, true);
pipes = sh_mem->pipes = ora_salloc(max_pipes*sizeof(pipe));
sid = sh_mem->sid = 1;
for (i = 0; i < max_pipes; i++)
pipes[i].is_valid = false;
events = sh_mem->events = ora_salloc(max_events*sizeof(alert_event));
locks = sh_mem->locks = ora_salloc(max_locks*sizeof(alert_lock));
for (i = 0; i < max_events; i++)
{
events[i].event_name = NULL;
events[i].max_receivers = 0;
events[i].receivers = NULL;
events[i].messages = NULL;
}
for (i = 0; i < max_locks; i++)
{
locks[i].sid = -1;
locks[i].echo = NULL;
}
}
else if (pipes == NULL)
{
#if PG_VERSION_NUM >= 90600
#if PG_VERSION_NUM >= 100000
LWLockRegisterTranche(sh_mem->tranche_id, "orafce");
#else
static LWLockTranche tranche;
tranche.name = "orafce";
tranche.array_base = &sh_mem->shmem_lock;
tranche.array_stride = sizeof(LWLock);
LWLockRegisterTranche(sh_mem->tranche_id, &tranche);
#endif
shmem_lockid = &sh_mem->shmem_lock;
#else
shmem_lockid = sh_mem->shmem_lockid;
#endif
pipes = sh_mem->pipes;
LWLockAcquire(shmem_lockid, LW_EXCLUSIVE);
ora_sinit(sh_mem->data, sh_mem->size, reset);
sid = ++(sh_mem->sid);
events = sh_mem->events;
locks = sh_mem->locks;
}
}
else
{
LWLockAcquire(shmem_lockid, LW_EXCLUSIVE);
}
return pipes != NULL;
}
