STATIC union node *
pipeline() {
union node *n1, *pipenode;
struct nodelist *lp, *prev;
n1 = command();
if (readtoken() == TPIPE) {
pipenode = (union node *)stalloc(sizeof (struct npipe));
pipenode->type = NPIPE;
pipenode->npipe.backgnd = 0;
lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
pipenode->npipe.cmdlist = lp;
lp->n = n1;
do {
prev = lp;
lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
lp->n = command();
prev->next = lp;
} while (readtoken() == TPIPE);
lp->next = NULL;
n1 = pipenode;
}
tokpushback++;
return n1;
}
/**
* Initialize disk device driver. Reserves memory for data structures
* and register driver to the interrupt handler.
*
* @param desc Pointer to the YAMS IO device descriptor of the disk
*
* @return Pointer to the device structure of the disk
*/
device_t *disk_init(io_descriptor_t *desc) {
device_t *dev;
gbd_t *gbd;
disk_real_device_t *real_dev;
uint32_t irq_mask;
dev = (device_t*)stalloc(sizeof(device_t));
gbd = (gbd_t*)stalloc(sizeof(gbd_t));
real_dev = (disk_real_device_t*)stalloc(sizeof(disk_real_device_t));
if (dev == NULL || gbd == NULL || real_dev == NULL)
KERNEL_PANIC("Could not allocate memory for disk driver.");
dev->generic_device = gbd;
dev->real_device = real_dev;
dev->descriptor = desc;
dev->io_address = desc->io_area_base;
dev->type = desc->type;
gbd->device = dev;
gbd->read_block = disk_read_block;
gbd->write_block = disk_write_block;
gbd->block_size = disk_block_size;
gbd->total_blocks = disk_total_blocks;
spinlock_reset(&real_dev->slock);
real_dev->request_queue = NULL;
real_dev->request_served = NULL;
irq_mask = 1 << (desc->irq + 10);
interrupt_register(irq_mask, disk_interrupt_handle, dev);
return dev;
}
STATIC union node *
list(nlflag) {
union node *n1, *n2, *n3;
checkkwd();
if (nlflag == 0 && tokendlist[lasttoken])
return NULL;
n1 = andor();
for (;;) {
switch (readtoken()) {
case TBACKGND:
if (n1->type == NCMD || n1->type == NPIPE) {
n1->ncmd.backgnd = 1;
} else if (n1->type == NREDIR) {
n1->type = NBACKGND;
} else {
n3 = (union node *)stalloc(sizeof (struct nredir));
n3->type = NBACKGND;
n3->nredir.n = n1;
n3->nredir.redirect = NULL;
n1 = n3;
}
goto tsemi;
case TNL:
tokpushback++;
/* fall through */
tsemi: case TSEMI:
if (readtoken() == TNL) {
parseheredoc();
if (nlflag)
return n1;
} else {
tokpushback++;
}
checkkwd();
if (tokendlist[lasttoken])
return n1;
n2 = andor();
n3 = (union node *)stalloc(sizeof (struct nbinary));
n3->type = NSEMI;
n3->nbinary.ch1 = n1;
n3->nbinary.ch2 = n2;
n1 = n3;
break;
case TEOF:
if (heredoclist)
parseheredoc();
else
pungetc(); /* push back EOF on input */
return n1;
default:
if (nlflag)
synexpect(-1);
tokpushback++;
return n1;
}
}
}
void physmem_init(void *boot_info)
{
multiboot_info_t *mb_info = (multiboot_info_t*)boot_info;
uint64_t *mem_ptr = (uint64_t*)(uint64_t)mb_info->memory_map_addr;
uint64_t Itr = 0, last_address = 0;
/* Setup Memory Stuff */
highest_page = 0;
memory_size = mb_info->memory_high;
memory_size += mb_info->memory_low;
total_blocks = (memory_size * 1024) / PAGE_SIZE;
used_blocks = total_blocks;
bitmap_size = total_blocks / PMM_BLOCKS_PER_BYTE;
_mem_bitmap = (uint64_t*)stalloc(bitmap_size);
physmem_lock = (spinlock_t*)stalloc(sizeof(spinlock_t));
spinlock_reset(physmem_lock);
/* Set all memory as used, and use memory map to set free */
memoryset(_mem_bitmap, 0xF, bitmap_size);
/* Physical Page Bitmap */
kprintf("Memory size: %u Kb\n", (uint32_t)memory_size);
/* Go through regions */
for(Itr = (uint64_t)mem_ptr;
Itr < ((uint64_t)mem_ptr + mb_info->memory_map_length);
)
{
/* Get next member */
mem_region_t *mem_region = (mem_region_t*)Itr;
/* Output */
//kprintf("Memory Region: Address 0x%xL, length 0x%xL, Type %u\n",
// mem_region->base_address, mem_region->length, mem_region->Type);
/* Is it free? */
if(mem_region->type == MEMTYPE_FREE)
physmem_freeregion(mem_region->base_address,
mem_region->length);
/* Advance by one structure */
Itr += sizeof(mem_region_t);
}
/* Mark all memory up to the static allocation point as used */
last_address = (physaddr_t)stalloc(1);
stalloc_disable();
for(Itr = physmem_allocblock(); Itr < last_address;)
Itr = physmem_allocblock();
/* Debug*/
kprintf("New memory allocation starts at 0x%xl\n", Itr);
}
/**
* Initializes interrupt driven tty driver. Memory is reserved for
* data structures and tty interrupt handler is registerded.
*
* @param desc Pointer to a YAMS device descriptor data structure.
*
* @return Pointer to tty's device_t structure.
*/
device_t *tty_init(io_descriptor_t *desc) {
device_t *dev;
gcd_t *gcd;
tty_real_device_t *tty_rd;
uint32_t irq_mask;
static int num_of_inits = 0;
dev = (device_t*)stalloc(sizeof(device_t));
if(dev == NULL)
KERNEL_PANIC("Could not reserve memory for tty driver.");
gcd = (gcd_t*)stalloc(sizeof(gcd_t));
if(gcd == NULL)
KERNEL_PANIC("Could not reserve memory for tty driver.");
dev->generic_device = gcd;
dev->io_address = desc->io_area_base;
dev->type = desc->type;
gcd->device = dev;
gcd->write = tty_write;
gcd->read = tty_read;
tty_rd = (tty_real_device_t*)stalloc(sizeof(tty_real_device_t));
if(tty_rd == NULL)
KERNEL_PANIC("Could not reserve memory for tty driver.");
dev->real_device = tty_rd;
if (num_of_inits == 0) {
/* First tty driver will share the device with the polling TTY.
* That is, we use the same spinlock with it. (The spinlock is
* kprintf's because that is the only proper way to access the
* polling tty.) */
tty_rd->slock = &kprintf_slock;
} else {
tty_rd->slock = (spinlock_t*)stalloc(sizeof(spinlock_t));
if(tty_rd->slock == NULL)
KERNEL_PANIC("Could not reserve memory for tty driver spinlock.");
spinlock_reset(tty_rd->slock);
}
num_of_inits++;
tty_rd->write_head = 0;
tty_rd->write_count = 0;
tty_rd->read_head = 0;
tty_rd->read_count = 0;
irq_mask = 1 << (desc->irq + 10);
interrupt_register(irq_mask, tty_interrupt_handle, dev);
return dev;
}
STATIC void
addfname(shinstance *psh, char *name)
{
char *p;
struct strlist *sp;
p = stalloc(psh, strlen(name) + 1);
scopy(name, p);
sp = (struct strlist *)stalloc(psh, sizeof *sp);
sp->text = p;
*psh->exparg.lastp = sp;
psh->exparg.lastp = &sp->next;
}
static void
addfname(char *name)
{
char *p;
struct strlist *sp;
p = stalloc(strlen(name) + 1);
scopy(name, p);
sp = (struct strlist *)stalloc(sizeof *sp);
sp->text = p;
*exparg.lastp = sp;
exparg.lastp = &sp->next;
}
static void
addfname(cstring_t name)
{
cstring_t p;
struct strlist* sp;
size_t len;
len = strlen(name);
p = stalloc(len + 1);
memcpy(p, name, len + 1);
sp = (struct strlist*)stalloc(sizeof * sp);
sp->text = p;
*exparg.lastp = sp;
exparg.lastp = &sp->next;
}
/**
* Physical memory initialization. Finds out number of physical pages and
* number of staticly reserved physical pages. Marks reserved pages
* reserved in physmem_free_pages.
*/
void physmem_init(void *bootinfo)
{
int num_res_pages;
int i;
/* We dont use this */
bootinfo = bootinfo;
physmem_num_pages = physmem_get_size();
physmem_free_pages =
(uint32_t *)stalloc(bitmap_sizeof(physmem_num_pages));
bitmap_init(physmem_free_pages, physmem_num_pages);
/* Note that number of reserved pages must be get after we have
(staticly) reserved memory for bitmap. */
num_res_pages = physmem_get_reserved_size();
physmem_num_free_pages = physmem_num_pages - num_res_pages;
physmem_static_end = num_res_pages;
for (i = 0; i < num_res_pages; i++)
bitmap_set(physmem_free_pages, i, 1);
spinlock_reset(&physmem_slock);
kprintf("Physmem: Found %d pages of size %d\n", physmem_num_pages,
PAGE_SIZE);
kprintf("Physmem: Static allocation for kernel: %d pages\n",
num_res_pages);
}
static union node *alloc_node(struct parser *p, int type) {
union node *node;
node = stalloc(p->mark, sizeof(union node));
node->type = type;
return node;
}
/** Initializes interrupt handling. Allocates interrupt stacks for
* each processor, initializes the interrupt vectors and initializes
* the registered interrupt handler table.
*
* @param num_cpus Number of CPUs in the system
*/
void interrupt_init(int num_cpus) {
int i;
uint32_t *iv_area1 = (uint32_t *)INTERRUPT_VECTOR_ADDRESS1;
uint32_t *iv_area2 = (uint32_t *)INTERRUPT_VECTOR_ADDRESS2;
uint32_t *iv_area3 = (uint32_t *)INTERRUPT_VECTOR_ADDRESS3;
uint32_t ret;
if (num_cpus < 1 || num_cpus > CONFIG_MAX_CPUS)
KERNEL_PANIC("Too few or many CPUs found");
/* Allocate interrupt stacks for each processor */
for(i = 0; i < num_cpus; i++) {
ret = (uint32_t)stalloc(PAGE_SIZE);
if (ret == 0)
KERNEL_PANIC("Unable to allocate interrupt stacks");
interrupt_stacks[i] = ret+PAGE_SIZE-4;
}
/* Copy the interrupt vector code to its positions.All vectors
* will contain the same code.
*/
for(i = 0 ; i < INTERRUPT_VECTOR_LENGTH ; i++) {
iv_area1[i] = ((uint32_t *) (uintptr_t) &_cswitch_vector_code)[i];
iv_area2[i] = ((uint32_t *) (uintptr_t) &_cswitch_vector_code)[i];
iv_area3[i] = ((uint32_t *) (uintptr_t) &_cswitch_vector_code)[i];
}
/* Initialize the handler table to empty */
for (i=0; i<CONFIG_MAX_DEVICES; i++) {
interrupt_handlers[i].device = NULL;
interrupt_handlers[i].irq = 0;
interrupt_handlers[i].handler = NULL;
}
}
char *
padvance(const char **path, const char *name)
{
const char *p, *start;
char *q;
int len;
if (*path == NULL)
return NULL;
start = *path;
for (p = start; *p && *p != ':' && *p != '%'; p++)
; /* nothing */
len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */
while (stackblocksize() < len)
growstackblock();
q = stackblock();
if (p != start) {
memcpy(q, start, p - start);
q += p - start;
*q++ = '/';
}
strcpy(q, name);
pathopt = NULL;
if (*p == '%') {
pathopt = ++p;
while (*p && *p != ':') p++;
}
if (*p == ':')
*path = p + 1;
else
*path = NULL;
return stalloc(len);
}
STATIC union node *
simplecmd() {
union node *args, **app;
union node *redir, **rpp;
union node *n;
args = NULL;
app = &args;
rpp = &redir;
for (;;) {
if (readtoken() == TWORD) {
n = (union node *)stalloc(sizeof (struct narg));
n->type = NARG;
n->narg.text = wordtext;
n->narg.backquote = backquotelist;
*app = n;
app = &n->narg.next;
} else if (lasttoken == TREDIR) {
*rpp = n = redirnode;
rpp = &n->nfile.next;
parsefname(); /* read name of redirection file */
} else if (lasttoken == TLP && app == &args->narg.next
&& rpp == &redir) {
/* We have a function */
if (readtoken() != TRP)
synexpect(TRP);
if (! goodname(n->narg.text))
synerror("Bad function name");
n->type = NDEFUN;
n->narg.next = command();
return n;
} else {
tokpushback++;
break;
}
}
*app = NULL;
*rpp = NULL;
n = (union node *)stalloc(sizeof (struct ncmd));
n->type = NCMD;
n->ncmd.backgnd = 0;
n->ncmd.args = args;
n->ncmd.redirect = redir;
return n;
}
void
setstackmark(struct stackmark *mark)
{
mark->stackp = stackp;
mark->stacknxt = stacknxt;
mark->stacknleft = stacknleft;
/* Ensure this block stays in place. */
if (stackp != NULL && stacknxt == SPACE(stackp))
stalloc(1);
}
char *
stsavestr(const char *s)
{
char *p;
size_t len;
len = strlen(s);
p = stalloc(len + 1);
memcpy(p, s, len + 1);
return p;
}
static void
growstackblock(int min)
{
char *p;
int newlen;
char *oldspace;
int oldlen;
struct stack_block *sp;
struct stack_block *oldstackp;
struct stackmark *xmark;
if (min < stacknleft)
min = stacknleft;
if (min >= INT_MAX / 2 - ALIGN(sizeof(struct stack_block)))
error("Out of space");
min += stacknleft;
min += ALIGN(sizeof(struct stack_block));
newlen = 512;
while (newlen < min)
newlen <<= 1;
oldspace = stacknxt;
oldlen = stacknleft;
if (stackp != NULL && stacknxt == SPACE(stackp)) {
INTOFF;
oldstackp = stackp;
stackp = oldstackp->prev;
sp = ckrealloc((pointer)oldstackp, newlen);
sp->prev = stackp;
stackp = sp;
stacknxt = SPACE(sp);
stacknleft = newlen - (stacknxt - (char*)sp);
sstrend = stacknxt + stacknleft;
/*
* Stack marks pointing to the start of the old block
* must be relocated to point to the new block
*/
xmark = markp;
while (xmark != NULL && xmark->stackp == oldstackp) {
xmark->stackp = stackp;
xmark->stacknxt = stacknxt;
xmark->stacknleft = stacknleft;
xmark = xmark->marknext;
}
INTON;
} else {
newlen -= ALIGN(sizeof(struct stack_block));
p = stalloc(newlen);
if (oldlen != 0)
memcpy(p, oldspace, oldlen);
stunalloc(p);
}
}
/*
* Perform expansions on an argument, placing the resulting list of arguments
* in arglist. Parameter expansion, command substitution and arithmetic
* expansion are always performed; additional expansions can be requested
* via flag (EXP_*).
* The result is left in the stack string.
* When arglist is NULL, perform here document expansion.
*
* Caution: this function uses global state and is not reentrant.
* However, a new invocation after an interrupted invocation is safe
* and will reset the global state for the new call.
*/
void
expandarg(union node* arg, struct arglist* arglist, int32_t flag)
{
struct strlist* sp;
cstring_t p;
argbackq = arg->narg.backquote;
STARTSTACKSTR(expdest);
ifsfirst.next = NULL;
ifslastp = NULL;
argstr(arg->narg.text, flag);
if (arglist == NULL)
{
STACKSTRNUL(expdest);
return; /* here document expanded */
}
STPUTC('\0', expdest);
p = grabstackstr(expdest);
exparg.lastp = &exparg.list;
/*
* TODO - EXP_REDIR
*/
if (flag & EXP_FULL)
{
ifsbreakup(p, &exparg);
*exparg.lastp = NULL;
exparg.lastp = &exparg.list;
expandmeta(exparg.list, flag);
}
else
{
if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
rmescapes(p);
sp = (struct strlist*)stalloc(sizeof(struct strlist));
sp->text = p;
*exparg.lastp = sp;
exparg.lastp = &sp->next;
}
while (ifsfirst.next != NULL)
{
pifsregion_t ifsp;
INTOFF;
ifsp = ifsfirst.next->next;
ckfree(ifsfirst.next);
ifsfirst.next = ifsp;
INTON;
}
*exparg.lastp = NULL;
if (exparg.list)
{
*arglist->lastp = exparg.list;
arglist->lastp = exparg.lastp;
}
}
STATIC union node *
makename(void)
{
union node *n;
n = (union node *)stalloc(sizeof (struct narg));
n->type = NARG;
n->narg.next = NULL;
n->narg.text = wordtext;
n->narg.backquote = backquotelist;
return n;
}
STATIC union node *
pipeline(void)
{
union node *n1, *n2, *pipenode;
struct nodelist *lp, *prev;
int negate;
negate = 0;
TRACE(("pipeline: entered\n"));
while (readtoken() == TNOT)
negate = !negate;
tokpushback++;
n1 = command();
if (readtoken() == TPIPE) {
pipenode = (union node *)stalloc(sizeof (struct npipe));
pipenode->type = NPIPE;
pipenode->npipe.backgnd = 0;
lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
pipenode->npipe.cmdlist = lp;
lp->n = n1;
do {
prev = lp;
lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
lp->n = command();
prev->next = lp;
} while (readtoken() == TPIPE);
lp->next = NULL;
n1 = pipenode;
}
tokpushback++;
if (negate) {
n2 = (union node *)stalloc(sizeof (struct nnot));
n2->type = NNOT;
n2->nnot.com = n1;
return n2;
} else
return n1;
}
STATIC void
parsefname() {
union node *n = redirnode;
if (readtoken() != TWORD)
synexpect(-1);
if (n->type == NHERE) {
struct heredoc *here = heredoc;
struct heredoc *p;
int i;
if (quoteflag == 0)
n->type = NXHERE;
TRACE(("Here document %d\n", n->type));
if (here->striptabs) {
while (*wordtext == '\t')
wordtext++;
}
if (! noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN)
synerror("Illegal eof marker for << redirection");
rmescapes(wordtext);
here->eofmark = wordtext;
here->next = NULL;
if (heredoclist == NULL)
heredoclist = here;
else {
for (p = heredoclist ; p->next ; p = p->next);
p->next = here;
}
} else if (n->type == NTOFD || n->type == NFROMFD) {
if (is_digit(wordtext[0]))
n->ndup.dupfd = digit_val(wordtext[0]);
else if (wordtext[0] == '-')
n->ndup.dupfd = -1;
else
goto bad;
if (wordtext[1] != '\0') {
bad:
synerror("Bad fd number");
}
} else {
n->nfile.fname = (union node *)stalloc(sizeof (struct narg));
n = n->nfile.fname;
n->type = NARG;
n->narg.next = NULL;
n->narg.text = wordtext;
n->narg.backquote = backquotelist;
}
}
/* A helper to the init functions. Fills the given device structure to
* values from the given IO descriptor and uses "null" values for the
* rest. Allocates memory for the structure if it was given as NULL
*/
static device_t *fill_device_t(io_descriptor_t *desc, device_t *dev)
{
if (dev == NULL)
dev = (device_t*)stalloc(sizeof(device_t));
if (dev == NULL)
KERNEL_PANIC("Run out ouf memory when allocating struct"
" for a metadevice");
dev->real_device = NULL;
dev->generic_device = NULL;
dev->descriptor = desc;
dev->io_address = desc->io_area_base;
dev->type = desc->type;
return dev;
}
void
growstackblock(void)
{
char *p;
int newlen;
char *oldspace;
int oldlen;
struct stack_block *sp;
struct stack_block *oldstackp;
struct stackmark *xmark;
newlen = (stacknleft == 0) ? MINSIZE : stacknleft * 2 + 100;
newlen = ALIGN(newlen);
oldspace = stacknxt;
oldlen = stacknleft;
if (stackp != NULL && stacknxt == SPACE(stackp)) {
INTOFF;
oldstackp = stackp;
stackp = oldstackp->prev;
sp = ckrealloc((pointer)oldstackp, newlen);
sp->prev = stackp;
stackp = sp;
stacknxt = SPACE(sp);
stacknleft = newlen - (stacknxt - (char*)sp);
/*
* Stack marks pointing to the start of the old block
* must be relocated to point to the new block
*/
xmark = markp;
while (xmark != NULL && xmark->stackp == oldstackp) {
xmark->stackp = stackp;
xmark->stacknxt = stacknxt;
xmark->stacknleft = stacknleft;
xmark = xmark->marknext;
}
INTON;
} else {
p = stalloc(newlen);
if (oldlen != 0)
memcpy(p, oldspace, oldlen);
stunalloc(p);
}
}
void
appendarglist(struct arglist *list, char *str)
{
char **newargs;
int newcapacity;
if (list->count >= list->capacity) {
newcapacity = list->capacity * 2;
if (newcapacity < 16)
newcapacity = 16;
if (newcapacity > INT_MAX / (int)sizeof(newargs[0]))
error("Too many entries in arglist");
newargs = stalloc(newcapacity * sizeof(newargs[0]));
memcpy(newargs, list->args, list->count * sizeof(newargs[0]));
list->args = newargs;
list->capacity = newcapacity;
}
list->args[list->count++] = str;
}
/*
* Perform expansions on an argument, placing the resulting list of arguments
* in arglist. Parameter expansion, command substitution and arithmetic
* expansion are always performed; additional expansions can be requested
* via flag (EXP_*).
* The result is left in the stack string.
* When arglist is NULL, perform here document expansion.
*
* Caution: this function uses global state and is not reentrant.
* However, a new invocation after an interrupted invocation is safe
* and will reset the global state for the new call.
*/
void
expandarg(union node *arg, struct arglist *arglist, int flag)
{
struct strlist *sp;
char *p;
argbackq = arg->narg.backquote;
STARTSTACKSTR(expdest);
ifsfirst.next = NULL;
ifslastp = NULL;
argstr(arg->narg.text, flag);
if (arglist == NULL) {
STACKSTRNUL(expdest);
return; /* here document expanded */
}
STPUTC('\0', expdest);
p = grabstackstr(expdest);
exparg.lastp = &exparg.list;
if (flag & EXP_FULL) {
ifsbreakup(p, &exparg);
*exparg.lastp = NULL;
exparg.lastp = &exparg.list;
expandmeta(exparg.list);
} else {
sp = (struct strlist *)stalloc(sizeof (struct strlist));
sp->text = p;
*exparg.lastp = sp;
exparg.lastp = &sp->next;
}
while (ifsfirst.next != NULL) {
struct ifsregion *ifsp;
INTOFF;
ifsp = ifsfirst.next->next;
ckfree(ifsfirst.next);
ifsfirst.next = ifsp;
INTON;
}
*exparg.lastp = NULL;
if (exparg.list) {
*arglist->lastp = exparg.list;
arglist->lastp = exparg.lastp;
}
}
/**
* Returns the number of pages statically reserved for the kernel.
*
* @return The number of pages
*/
int physmem_get_reserved_size()
{
int num_res_pages;
uint32_t system_memory_size = 0;
physaddr_t free_start = (physaddr_t)stalloc(1);
system_memory_size = physmem_get_size() * PAGE_SIZE;
num_res_pages = (free_start - 0x80000000) / PAGE_SIZE;
if (((free_start - 0x80000000) % PAGE_SIZE) != 0)
num_res_pages++;
kprintf("Kernel size is 0x%.8x (%d) bytes\n",
(free_start - KERNEL_BOOT_ADDRESS),
(free_start - KERNEL_BOOT_ADDRESS));
kprintf("System Memory Size: 0x%x bytes\n", system_memory_size);
return num_res_pages;
}
void
growstackblock(void)
{
int newlen = SHELL_ALIGN(stacknleft * 2 + 100);
if (stacknxt == stackp->space && stackp != &stackbase) {
struct stack_block *oldstackp;
struct stackmark *xmark;
struct stack_block *sp;
INTOFF;
oldstackp = stackp;
sp = stackp;
stackp = sp->prev;
sp = ckrealloc((pointer)sp,
sizeof(struct stack_block) - MINSIZE + newlen);
sp->prev = stackp;
stackp = sp;
stacknxt = sp->space;
stacknleft = newlen;
/*
* Stack marks pointing to the start of the old block
* must be relocated to point to the new block
*/
xmark = markp;
while (xmark != NULL && xmark->stackp == oldstackp) {
xmark->stackp = stackp;
xmark->stacknxt = stacknxt;
xmark->stacknleft = stacknleft;
xmark = xmark->marknext;
}
INTON;
} else {
char *oldspace = stacknxt;
int oldlen = stacknleft;
char *p = stalloc(newlen);
(void)memcpy(p, oldspace, oldlen);
stacknxt = p; /* free the space */
stacknleft += newlen; /* we just allocated */
}
}
static void
growstackblock(int min)
{
char *p;
int newlen;
char *oldspace;
int oldlen;
struct stack_block *sp;
struct stack_block *oldstackp;
if (min < stacknleft)
min = stacknleft;
if ((unsigned int)min >=
INT_MAX / 2 - ALIGN(sizeof(struct stack_block)))
error("Out of space");
min += stacknleft;
min += ALIGN(sizeof(struct stack_block));
newlen = 512;
while (newlen < min)
newlen <<= 1;
oldspace = stacknxt;
oldlen = stacknleft;
if (stackp != NULL && stacknxt == SPACE(stackp)) {
INTOFF;
oldstackp = stackp;
stackp = oldstackp->prev;
sp = ckrealloc((pointer)oldstackp, newlen);
sp->prev = stackp;
stackp = sp;
stacknxt = SPACE(sp);
stacknleft = newlen - (stacknxt - (char*)sp);
sstrend = stacknxt + stacknleft;
INTON;
} else {
newlen -= ALIGN(sizeof(struct stack_block));
p = stalloc(newlen);
if (oldlen != 0)
memcpy(p, oldspace, oldlen);
stunalloc(p);
}
}
/** Initializes a CPU status device. These devices are currently used
* for detecting the total number of CPUs in the system. In addition
* to this a mechanism for generating interrupts on the CPU is
* supported.
*
* @param desc Pointer to the YAMS IO device descriptor of the CPU
* status device
*
* @return Pointer to the device structure of the CPU status device
*/
device_t *cpustatus_init(io_descriptor_t *desc)
{
device_t *dev;
cpu_real_device_t *cpu;
uint32_t irq_mask;
dev = fill_device_t(desc, NULL);
cpu = (cpu_real_device_t*)stalloc(sizeof(cpu_real_device_t));
if (cpu == NULL)
KERNEL_PANIC("Could not reserve memory for CPU status device driver.");
spinlock_reset(&cpu->slock);
dev->real_device = cpu;
irq_mask = 1 << (desc->irq + 10);
interrupt_register(irq_mask, cpustatus_interrupt_handle, dev);
return dev;
}
byte * sym_addr(char * s, int * c, int * v)
{
symbol * h = head;
symbol * n;
/* fprintf(stderr, "fetching %s\n", s); */
while(h != NULL)
{
if(!strcmp(s, h->id))
{
*c = h->constant;
*v = h->value;
return h->addr;
}
h = h->next;
}
/* fprintf(stderr, "Creating %s\n", s); */
n = (symbol *)malloc(sizeof(symbol));
/* fprintf(stderr, "Malloc'ed n\n"); */
if (n == NULL)
{
fprintf(stderr, "Could not allocate symbol table record\n");
} else
{
n->id = (char *)malloc(strlen(s)+1);
if (n->id == NULL)
{
fprintf(stderr, "Could not allocate lexeme\n");
} else
{
/* fprintf(stderr, "Copying %s to n->id\n", s); */
strcpy(n->id, s);
n->addr = stalloc(2);
n->constant = *c;
n->value = *v;
n->next = head;
head = n;
return n->addr;
}
}
return NULL;
}
void
expandarg(shinstance *psh, union node *arg, struct arglist *arglist, int flag)
{
struct strlist *sp;
char *p;
psh->argbackq = arg->narg.backquote;
STARTSTACKSTR(psh, psh->expdest);
psh->ifsfirst.next = NULL;
psh->ifslastp = NULL;
argstr(psh, arg->narg.text, flag);
if (arglist == NULL) {
return; /* here document expanded */
}
STPUTC(psh, '\0', psh->expdest);
p = grabstackstr(psh, psh->expdest);
TRACE2((psh, "expandarg: p='%s'\n", p));
psh->exparg.lastp = &psh->exparg.list;
/*
* TODO - EXP_REDIR
*/
if (flag & EXP_FULL) {
ifsbreakup(psh, p, &psh->exparg);
*psh->exparg.lastp = NULL;
psh->exparg.lastp = &psh->exparg.list;
expandmeta(psh, psh->exparg.list, flag);
} else {
if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
rmescapes(psh, p);
sp = (struct strlist *)stalloc(psh, sizeof (struct strlist));
sp->text = p;
*psh->exparg.lastp = sp;
psh->exparg.lastp = &sp->next;
}
ifsfree(psh);
*psh->exparg.lastp = NULL;
if (psh->exparg.list) {
*arglist->lastp = psh->exparg.list;
arglist->lastp = psh->exparg.lastp;
}
}
