/*@-internalglobs@*/
rpmioPool rpmioNewPool(const char * name, size_t size, int limit, int flags,
char * (*dbg) (void *item),
void (*init) (void *item),
void (*fini) (void *item))
/*@*/
{
rpmioPool pool = xcalloc(1, sizeof(*pool));
#if defined(WITH_VALGRIND)
static int rzB = 0; /* size of red-zones (if any) */
static int is_zeroed = 0; /* does pool return zero'd allocations? */
rzB = rzB; /* XXX CentOS5 valgrind doesn't use. */
is_zeroed = is_zeroed; /* XXX CentOS5 valgrind doesn't use. */
#endif
VALGRIND_CREATE_MEMPOOL(pool, rzB, is_zeroed);
pool->have = yarnNewLock(0);
pool->pool = NULL;
pool->head = NULL;
pool->tail = &pool->head;
pool->size = size;
pool->limit = limit;
pool->flags = flags;
pool->dbg = (void *) dbg;
pool->init = init;
pool->fini = fini;
pool->reused = 0;
pool->made = 0;
pool->name = name;
pool->zlog = NULL;
rpmlog(RPMLOG_DEBUG, D_("pool %s:\tcreated size %u limit %d flags %d\n"), pool->name, (unsigned)pool->size, pool->limit, pool->flags);
return pool;
}
/*@only@*/
static rpmvf rpmvfNew(rpmts ts, rpmfi fi, int i, rpmVerifyAttrs omitMask)
/*@*/
{
rpmvf vf = DRD_xcalloc(1, sizeof(*vf));
#ifdef NOTYET
vf->_item.use = yarnNewLock(1);
vf->_item.pool = NULL;
#endif
/*@-mods@*/
vf->fn = rpmGetPath(rpmtsRootDir(ts), fi->dnl[fi->dil[i]], fi->bnl[i], NULL);
/*@=mods@*/
vf->flink = fi->flinks[i];
vf->fuser = fi->fuser[i];
vf->fgroup = fi->fgroup[i];
{ struct stat *st = &vf->sb;
st->st_dev =
st->st_rdev = fi->frdevs[i];
st->st_ino = fi->finodes[i];
st->st_mode = fi->fmodes[i];
#ifdef NOTNEEDED
st->st_nlink = rpmfiFNlink(fi) + (int)S_ISDIR(st->st_mode);
#endif
if (unameToUid(vf->fuser, &st->st_uid) == -1)
st->st_uid = 0; /* XXX */
if (gnameToGid(vf->fgroup, &st->st_gid) == -1)
st->st_gid = 0; /* XXX */
st->st_size = fi->fsizes[i];
st->st_blksize = 4 * 1024; /* XXX */
st->st_blocks = (st->st_size + (st->st_blksize - 1)) / st->st_blksize;
st->st_atime =
st->st_ctime =
st->st_mtime = fi->fmtimes[i];
}
vf->fflags = fi->fflags[i];
vf->fstate = fi->fstates[i];
vf->vflags = fi->vflags[i];
vf->dalgo = fi->fdigestalgos
? fi->fdigestalgos[i]
: fi->digestalgo;
vf->dlen = fi->digestlen;
vf->digest = fi->digests + (fi->digestlen * i);
/* Don't verify any features in omitMask. */
vf->vflags &= ~(omitMask | RPMVERIFY_FAILURES);
/* Content checks of %ghost files are meaningless. */
if (vf->fflags & RPMFILE_GHOST)
vf->vflags &= ~(RPMVERIFY_FDIGEST | RPMVERIFY_FILESIZE | RPMVERIFY_MTIME |
RPMVERIFY_LINKTO | RPMVERIFY_HMAC);
return vf;
}
rpmzLog rpmzLogNew(struct timeval *tv)
{
rpmzLog zlog = (rpmzLog) xcalloc(1, sizeof(*zlog));
zlog->_item.use = yarnNewLock(0);
zlog->msg_head = NULL;
zlog->msg_tail = &zlog->msg_head;
/* starting time for log entries */
/*@-assignexpose@*/
if (tv != NULL)
zlog->start = *tv; /* structure assignment */
else
(void) gettimeofday(&zlog->start, NULL);
/*@=assignexpose@*/
/*@-nullret@*/
return rpmzLogLink(zlog);
/*@=nullret@*/
}
/*@-internalglobs@*/
rpmioItem rpmioGetPool(rpmioPool pool, size_t size)
{
rpmioItem item;
if (pool != NULL) {
/* if can't create any more, wait for a space to show up */
yarnPossess(pool->have);
if (pool->limit == 0)
yarnWaitFor(pool->have, NOT_TO_BE, 0);
/* if a space is available, pull it from the list and return it */
if (pool->head != NULL) {
item = pool->head;
pool->head = item->pool; /* XXX pool == next */
if (pool->head == NULL)
pool->tail = &pool->head;
pool->reused++;
item->pool = pool; /* remember the pool this belongs to */
yarnTwist(pool->have, BY, -1); /* one less in pool */
VALGRIND_MEMPOOL_ALLOC(pool,
item + 1,
size - sizeof(struct rpmioItem_s));
return item;
}
/* nothing available, don't want to wait, make a new item */
assert(pool->limit != 0);
if (pool->limit > 0)
pool->limit--;
pool->made++;
yarnRelease(pool->have);
}
item = xcalloc(1, size);
item->use = yarnNewLock(0); /* XXX newref? */
item->pool = pool;
VALGRIND_MEMPOOL_ALLOC(pool,
item + 1,
size - sizeof(struct rpmioItem_s));
return item;
}
rpmruby rpmrubyNew(char ** av, uint32_t flags)
{
static char * _av[] = { "rpmruby", NULL };
rpmruby ruby = (flags & 0x80000000)
? rpmrubyI() : rpmrubyGetPool(_rpmrubyPool);
int xx;
RUBYDBG((stderr, "--> %s(%p,0x%x) ruby %p\n", __FUNCTION__, av, flags, ruby));
/* If failure, or retrieving already initialized _rpmrubyI, just exit. */
if (ruby == NULL || ruby == _rpmrubyI)
goto exit;
if (av == NULL) av = _av;
ruby->flags = flags;
xx = argvAppend(&ruby->av, (ARGV_t)av);
ruby->ac = argvCount(ruby->av);
/* XXX FIXME: 0x40000000 => xruby.c wrapper without interpreter. */
if (ruby->flags & 0x40000000) {
static size_t _rpmrubyStackSize = 4 * 1024 * 1024;
/* XXX save as global interpreter. */
_rpmrubyI = ruby;
ruby->nstack = _rpmrubyStackSize;
ruby->stack = malloc(ruby->nstack);
assert(ruby->stack != NULL);
gettimeofday(&ruby->start, NULL); /* starting time for log entries */
if (_rpmruby_debug)
ruby->zlog = rpmzLogNew(&ruby->start); /* initialize logging */
/* initialize the relay mechanism */
ruby->ruby_coroutine_lock = yarnNewLock(0);
ruby->main_coroutine_lock = yarnNewLock(0);
} else {
#if defined(WITH_RUBYEMBED)
VALUE variable_in_this_stack_frame; /* RUBY_INIT_STSCK */
#if defined(HAVE_RUBY_DEFINES_H) /* XXX ruby-1.9.2 */
ruby_sysinit(&ruby->ac, (char ***) &ruby->av);
/* XXX ruby-1.9.2p0 ruby_bind_stack() patch needed */
{
uint8_t * b = ruby->stack;
uint8_t * e = b + ruby->nstack;
ruby_bind_stack((VALUE *)b, (VALUE *) e);
}
#endif /* NOTYET */
ruby_init_stack(&variable_in_this_stack_frame); /* RUBY_INIT_STACK */
ruby_init();
ruby_init_loadpath();
ruby_script((char *)av[0]);
if (av[1])
ruby_set_argv(argvCount((ARGV_t)av)-1, av+1);
rb_gv_set("$result", rb_str_new2(""));
#if !defined(HAVE_RUBY_DEFINES_H) /* XXX ruby-1.8.6 */
(void) rpmrubyRun(ruby, rpmrubyInitStringIO, NULL);
#endif
#endif /* WITH_RUBYEMBED */
}
exit:
return rpmrubyLink(ruby);
}
