ssize_t Sio_puts(char s[])
{
ssize_t n;
if ((n = sio_puts(s)) < 0)
sio_error("Sio_puts error");
return n;
}
/*******************************
* Wrappers for the SIO routines
******************************/
ssize_t Sio_putl(long v)
{
ssize_t n;
if ((n = sio_putl(v)) < 0)
sio_error("Sio_putl error");
return n;
}
/*
* eval - Evaluate the command line that the user has just typed in.
*
* If the user has requested a built-in command (quit, jobs, bg or fg)
* then execute it immediately. Otherwise, fork a child process and
* run the job in the context of the child. If the job is running in
* the foreground, wait for it to terminate and then return. Note:
* each child process must have a unique process group ID so that our
* background children don't receive SIGINT (SIGTSTP) from the kernel
* when we type ctrl-c (ctrl-z) at the keyboard.
*
* Requires:
* "cmdline" is a NUL ('\0') terminated string with a trailing
* '\n' character. "cmdline" must contain less than MAXARGS
* arguments.
*
* Effects:
* A built-in command is executed immediately. Otherwise, it attempts
* to fork a child process and execute the job. If necessary, the
* executable program is searched through the directories of the
* search path. If not found, an error is thrown. If the job is
* running as a foreground job, it waits until completion.
*/
static void
eval(const char *cmdline)
{
char *argv[MAXARGS];
int bg = parseline(cmdline, argv);
pid_t pid;
sigset_t mask;
// Checks command line is not empty.
if (!argv[0]) {
return;
}
// Checks that the command is not a built-in command.
if(!builtin_cmd(argv)){
sigemptyset(&mask);
sigaddset(&mask, SIGCHLD);
sigprocmask(SIG_BLOCK, &mask, NULL);
// A child is forked.
pid = fork();
if (pid == 0) {
// Put child in new group whose ID is identical to child’s PID.
setpgid(0, 0);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
if (execve(argv[0], argv, environ) == -1) {
int index = 0;
// Run through directories in search path to execute program.
while (argv[0][0] != '.' && index < directoryCount) {
if (execve(strcat(directories[index],argv[0]), argv, environ) != -1) {
break;
}
index++;
}
// Command not found.
char *print;
asprintf(&print, "%s: Command not found\n", argv[0]);
sio_error(print);
}
}
if (bg == 0) {
addjob(jobs,pid,FG,cmdline);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
// Wait for foreground jobs to complete.
waitfg(pid);
}
else {
addjob(jobs,pid,BG,cmdline);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
}
}
return;
}
/*
* This is the serial driver's interrupt routine.
*
* Arjan thinks the old way was overly complex, so it got simplified.
* Alan disagrees, saying that need the complexity to handle the weird
* nature of ISA shared interrupts. (This is a special exception.)
*
* In order to handle ISA shared interrupts properly, we need to check
* that all ports have been serviced, and therefore the ISA interrupt
* line has been de-asserted.
*
* This means we need to loop through all ports. checking that they
* don't have an interrupt pending.
*/
static irqreturn_t m32r_sio_interrupt(int irq, void *dev_id)
{
struct irq_info *i = dev_id;
struct list_head *l, *end = NULL;
int pass_counter = 0;
pr_debug("m32r_sio_interrupt(%d)...\n", irq);
#ifdef CONFIG_SERIAL_M32R_PLDSIO
// if (irq == PLD_IRQ_SIO0_SND)
// irq = PLD_IRQ_SIO0_RCV;
#else
if (irq == M32R_IRQ_SIO0_S)
irq = M32R_IRQ_SIO0_R;
#endif
spin_lock(&i->lock);
l = i->head;
do {
struct uart_sio_port *up;
unsigned int sts;
up = list_entry(l, struct uart_sio_port, list);
sts = sio_in(up, SIOSTS);
if (sts & 0x5) {
spin_lock(&up->port.lock);
m32r_sio_handle_port(up, sts);
spin_unlock(&up->port.lock);
end = NULL;
} else if (end == NULL)
end = l;
l = l->next;
if (l == i->head && pass_counter++ > PASS_LIMIT) {
if (sts & 0xe0)
sio_error(&sts);
break;
}
} while (l != end);
spin_unlock(&i->lock);
pr_debug("end.\n");
return IRQ_HANDLED;
}
void Sio_error(char s[])
{
sio_error(s);
}
/**
* segment fault signal handler
*/
void sigsegv_handler(int sig) {
sio_error("Caught segment fault\n");
pthread_exit(NULL);
return;
}