void
set_random_state(unsigned int x)
{
unsigned char seed[8];
int i;
for (i=0; i<8; i++) {
seed[i]= (unsigned char)(x & 0xFF);
x >>= 8;
}
isaac_init(&mon_rng,seed,8);
isaac_init(&default_rng,seed,8);
}
/*
* Generate a random number with the ISAAC CSPRNG of
* given size
*
* out output array of with size >= given size
* size the size of the random number to generate in bytes
*/
void isaac_rand(unsigned char *out, const int size)
{
int i;
if(initRand !=1){
isaac_init();
initRand = 1;
}
for(i = 0; ((size)/32) > i; i++){
if(count < 1){
isaac();
count = 256;
}
count--;
memcpy(out+4*i, randrsl+count, 4);
}
if(size % 32 > 0){
if(count < 1){
isaac();
count = 256;
}
count--;
memcpy(out+4*i, randrsl+count, (size-1)/8+1);
}
}
rust_scheduler::rust_scheduler(rust_kernel *kernel,
rust_message_queue *message_queue, rust_srv *srv,
const char *name) :
interrupt_flag(0),
_log(srv, this),
log_lvl(log_note),
srv(srv),
name(name),
newborn_tasks(this, "newborn"),
running_tasks(this, "running"),
blocked_tasks(this, "blocked"),
dead_tasks(this, "dead"),
cache(this),
root_task(NULL),
curr_task(NULL),
rval(0),
kernel(kernel),
message_queue(message_queue)
{
LOGPTR(this, "new dom", (uintptr_t)this);
isaac_init(this, &rctx);
#ifndef __WIN32__
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 1024 * 1024);
pthread_attr_setdetachstate(&attr, true);
#endif
root_task = create_task(NULL, name);
}
rust_dom::rust_dom(rust_srv *srv, rust_crate const *root_crate,
const char *name) :
interrupt_flag(0),
root_crate(root_crate),
_log(srv, this),
srv(srv),
local_region(&srv->local_region),
synchronized_region(&srv->synchronized_region),
name(name),
running_tasks(this),
blocked_tasks(this),
dead_tasks(this),
caches(this),
root_task(NULL),
curr_task(NULL),
rval(0)
{
logptr("new dom", (uintptr_t)this);
isaac_init(this, &rctx);
#ifndef __WIN32__
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 1024 * 1024);
pthread_attr_setdetachstate(&attr, true);
#endif
root_task = new (this) rust_task(this, NULL, name);
if (_live_domains.replace(NULL, this) == false) {
_live_domains.append(this);
}
}
rust_scheduler::rust_scheduler(rust_kernel *kernel,
rust_srv *srv,
int id) :
ref_count(1),
interrupt_flag(0),
_log(srv, this),
log_lvl(log_debug),
srv(srv),
// TODO: calculate a per scheduler name.
name("main"),
newborn_tasks(this, "newborn"),
running_tasks(this, "running"),
blocked_tasks(this, "blocked"),
dead_tasks(this, "dead"),
cache(this),
kernel(kernel),
id(id),
min_stack_size(kernel->env->min_stack_size),
env(kernel->env)
{
LOGPTR(this, "new dom", (uintptr_t)this);
isaac_init(this, &rctx);
#ifndef __WIN32__
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 1024 * 1024);
pthread_attr_setdetachstate(&attr, true);
#endif
if (!tls_initialized)
init_tls();
}
/*
* Server manager
*/
TadsServerManager::TadsServerManager()
{
/* initialize our ISAAC context */
ic = new isaacctx();
isaac_init(ic, TRUE);
/* create our mutex */
mutex = new OS_Mutex();
}
extern "C" CDECL void *
rand_new() {
rust_task *task = rust_get_current_task();
rust_sched_loop *thread = task->sched_loop;
randctx *rctx = (randctx *) task->malloc(sizeof(randctx), "rand_new");
if (!rctx) {
task->fail();
return NULL;
}
isaac_init(thread->kernel, rctx, NULL);
return rctx;
}
rk_error rk_isaac_randomseed(rk_isaac_state *state)
{
if(rk_devfill(state->randrsl, sizeof(state->randrsl), 1) == RK_NOERR)
{
isaac_init(state);
return RK_NOERR;
}
rk_isaac_seed(rk_seedfromsystem(), state);
return RK_ENODEV;
}
extern "C" CDECL void *
rand_new() {
rust_task *task = rust_scheduler::get_task();
rust_scheduler *sched = task->sched;
randctx *rctx = (randctx *) task->malloc(sizeof(randctx), "randctx");
if (!rctx) {
task->fail();
return NULL;
}
isaac_init(sched, rctx);
return rctx;
}
extern "C" CDECL void *
rand_new(rust_task *task)
{
rust_dom *dom = task->dom;
randctx *rctx = (randctx *) task->malloc(sizeof(randctx));
if (!rctx) {
task->fail(1);
return NULL;
}
isaac_init(dom, rctx);
return rctx;
}
void clib_random_buffer_init_multiseed (clib_random_buffer_t * b, u8 * seed)
{
int i;
memset (b, 0, sizeof (b[0]));
/* Seed ISAAC. */
for (i = 0; i < ARRAY_LEN (b->ctx); i++)
{
uword s[ISAAC_SIZE];
memcpy (s, seed + i*sizeof(s), sizeof (s));
isaac_init (&b->ctx[i], s);
}
}
rust_scheduler::rust_scheduler(rust_kernel *kernel,
rust_srv *srv,
size_t num_threads,
rust_sched_id id) :
kernel(kernel),
srv(srv),
env(srv->env),
live_threads(num_threads),
live_tasks(0),
num_threads(num_threads),
id(id)
{
isaac_init(kernel, &rctx);
create_task_threads();
}
void clib_random_buffer_init (clib_random_buffer_t * b, uword seed)
{
uword i, j;
memset (b, 0, sizeof (b[0]));
/* Seed ISAAC. */
for (i = 0; i < ARRAY_LEN (b->ctx); i++)
{
uword s[ISAAC_SIZE];
for (j = 0; j < ARRAY_LEN (s); j++)
s[j] = ARRAY_LEN (b->ctx) * (seed + j) + i;
isaac_init (&b->ctx[i], s);
}
}
void rk_isaac_seed(unsigned long seed, rk_isaac_state *state)
{
rk_knuth_fill(seed, state->randrsl, RK_ISAAC_STATE_LEN);
isaac_init(state);
}
void
rng_init(rust_rng* rng, char* env_seed,
uint8_t *user_seed, size_t seed_len) {
isaac_init(&rng->rctx, env_seed, user_seed, seed_len);
rng->reseedable = !user_seed && !env_seed;
}
void
rng_init(rust_kernel* kernel, rust_rng* rng,
uint8_t *user_seed, size_t seed_len) {
isaac_init(kernel, &rng->rctx, user_seed, seed_len);
rng->reseedable = !user_seed && !kernel->env->rust_seed;
}
