Beispiel #1
0
/* Read count bytes (or less) from fd into the buffer buf. */
ssize_t read_syscall(int fd, void *buf, size_t count)
{
  // Check for invalid memory range or file descriptors
  if (check_mem((char *) buf, (int) count, SDRAM_START, SDRAM_END) == false)
  {
    invalid_syscall(-EFAULT);
  }
  else if (fd != STDIN_FILENO)
  {
    invalid_syscall(-EBADF);
  }

  size_t i = 0;
  char *buffer = (char *) buf;
  char read_char;

  while (i < count)
  {
    read_char = getc();

    if (read_char == 4)
    { //EOT character
      return i;
    }
    else if (((read_char == 8) || (read_char == 127)))
    { // backspace or DEL character
      buffer[i] = 0; // '\0' character
      if(i > 0)
      {
        i--;
        puts("\b \b");
      }
    }
    else if ((read_char == 10) || (read_char == 13))
    { // '\n' newline or '\r' carriage return character
      buffer[i] = '\n';
      putc('\n');
      return (i+1);
    }
    else
    {
      // put character into buffer and putc
      buffer[i] = read_char;
      i++;
      putc(read_char);
    }
  }
  return i;
}
Beispiel #2
0
/*
 * implementation of the C_SWI_Handler
 * @param: swi_num- swi number
 * @param: sp- stack pointer that points to block of user registers
 * @return: return value form swi on success, -1 on failure (swi num not 
            supported)
 */
void C_SWI_Handler(int swi_num, unsigned int *sp)
{
	unsigned int r0, r1, r2;
	switch(swi_num) {
		case READ_SWI:
			enable_interrupts();
			r0 = *sp;
			r1 = *(sp + 1);
			r2 = *(sp + 2);
			*sp = read_syscall((int)r0, (void *)r1, (size_t)r2);
			break;
		case WRITE_SWI:
			enable_interrupts();
			r0 = *sp;
			r1 = *(sp + 1);
			r2 = *(sp + 2);
			*sp = write_syscall((int)r0, (const void *)r1, (size_t)r2);
			break;
		case TIME_SWI:
			enable_interrupts();
			*sp = time_syscall();
			break;
		case SLEEP_SWI:
//			enable_interrupts();
			r0 = *sp;
		    sleep_syscall((unsigned long)r0);
			break;
		case CREATE_SWI:
			r0 = *sp;
			r1 = *(sp + 1);
			*sp = task_create((task_t *)r0, (size_t)r1);
		break;
		case EVENT_WAIT:
			printf("calling event_wait sp is %p\n", sp);
			r0 = *sp;
			*sp = event_wait((unsigned int)r0);
//			while(1);	
			printf("returned from event_wait\n");
		break;
		case MUTEX_CREATE:
			*sp = mutex_create();
		break;	
		case MUTEX_LOCK:
			r0 = *sp;
			*sp = mutex_lock((int)r0);
		break;	
		case MUTEX_UNLOCK:
			r0 = *sp;
			*sp = mutex_unlock((int)r0);
		break;	
		default:
		    printf("\n C_SWI_Handler:invalid SWI call, panic\n");
			invalid_syscall(swi_num);	
	}
	return;
}
Beispiel #3
0
//call the appropriate method based on the swi
int c_swi_handler(unsigned swi_num, unsigned * regs){
	
	int ret = 0;

	//if(debug_enabled ==1) printf ("c_swi_handler:: swi_num = %d\n", swi_num ) ;
	switch(swi_num){

		case EXIT_SWI:
			c_exit(regs[0]);
			break;

		case READ_SWI:
			ret = read_syscall(regs[0], (void *) regs[1], regs[2]);
			break;

		case WRITE_SWI:
			ret = write_syscall(regs[0], (void *) regs[1], regs[2]);
			break;

		case TIME_SWI:
			ret = time_syscall();
			break;

		case SLEEP_SWI:
			sleep_syscall(regs[0]);
			break;

		case CREATE_SWI:
			ret = task_create((task_t*)regs[0], regs[1]);
			break;

		case MUTEX_CREATE:
			ret = mutex_create();
			break;

		case MUTEX_LOCK:
			ret = mutex_lock(regs[0]);
			break;

		case MUTEX_UNLOCK:
			ret = mutex_unlock(regs[0]);
			break;

		case EVENT_WAIT:
			ret = event_wait(regs[0]);
			break;

		default:
			invalid_syscall(0x0badc0de);
			break;
	}

	
	return ret;
}
Beispiel #4
0
/* Write count bytes to fd from the buffer buf. */
ssize_t write_syscall(int fd, const void *buf, size_t count)
{
  // Check for invalid memory range or file descriptors
  if (check_mem((char *) buf, (int) count, SDRAM_START, SDRAM_END) == false &&
      check_mem((char *) buf, (int) count, SFROM_START, SFROM_END) == false)
  {
    invalid_syscall(-EFAULT);
  }
  else if (fd != STDOUT_FILENO)
  {
    invalid_syscall(-EBADF);
  }

  char *buffer = (char *) buf;
  size_t i;
  char read_char;
  for (i = 0; i < count; i++)
  {
    // put character into buffer and putc
    read_char = buffer[i];
    putc(read_char);
  }
  return i;
}
Beispiel #5
0
/* Called by assembly Swi_Handler, with a swi number and a pointer to
 * register values on the stack. 
 * requires valid swi_Num, this check is done in kernel.
 * returns a return value, depending on which swi_handler was called.
 */
int C_SWI_Handler(int swi_Num, unsigned int *regs) {
	switch( swi_Num ) {
		case READ_SWI: return read_syscall((int)regs[0], (char *)regs[1], (size_t)regs[2]);
		case WRITE_SWI: return write_syscall((int)regs[0], (char *)regs[1], (size_t)regs[2]);
		case TIME_SWI: return time_syscall();
		case SLEEP_SWI: 
			sleep_syscall((unsigned long)regs[0]);
			return 0;
		case CREATE_SWI: return task_create((task_t *)regs[0], (size_t)regs[1]);
		case MUTEX_CREATE: return mutex_create();
		case MUTEX_LOCK: return mutex_lock((int)regs[0]);
		case MUTEX_UNLOCK: return mutex_unlock((int)regs[0]);
		case EVENT_WAIT: return event_wait((unsigned int)regs[0]);
		default:
			invalid_syscall(swi_Num);
	}

	assert(0); //Should not reach here
	return(0);
}
/* 
------------------------------------------------
Function: C_SWI_Handler 
Description:
The SWI handler is called by the S_Handler assembly
code. Blocking interrupts for tasks related to context
switching/premption.
Input arguments: 
unsigned swi_num - Extracted SWI number from original
SWI call.
unsigned *regs   - Location of saved arguments from 
the caller.
------------------------------------------------
*/
void C_SWI_Handler(unsigned swi_num, unsigned *regs){                         
	switch(swi_num){                                                        
        case READ_SWI:                                                  
       		read(regs);                                             
            break;                                                  
        case WRITE_SWI:                                                 
            write(regs);                                            
            break;                                                  
	    case TIME_SWI:
		    time_swi(regs);
		    break;
	    case SLEEP_SWI:
		    sleep_swi(*((unsigned long *)regs));
		    break;           
        case CREATE_SWI:
            disable_interrupts();
            regs[0] = task_create((task_t*) regs[0], (size_t)regs[1]);         
            break;                                                  
        case EVENT_WAIT:
            disable_interrupts();
            regs[0] = event_wait((unsigned int) regs[0]);
            break;     
        case MUTEX_CREATE:
            disable_interrupts();
            regs[0] = mutex_create();
            break;                                                                                      
        case MUTEX_LOCK:
            disable_interrupts();
            regs[0] = mutex_lock(*(int*)regs);
            break;                                                                                      
        case MUTEX_UNLOCK:
            disable_interrupts();
            regs[0] = mutex_unlock(*(int*)regs);
            break;     
        default:
            regs[0] = BADCODE;
            invalid_syscall(swi_num);
            break;                                                                         
	}
}     
void C_SWI_Handler(unsigned swi_num, unsigned *regs){
    unsigned *value;
    value=regs;
    switch (swi_num) {
            case READ_SWI:
               *value= read_syscall(regs[0],(void *)regs[1],regs[2]);
                break;
            case WRITE_SWI:
                *value=write_syscall(regs[0],(void *)regs[1],regs[2]);
                break;
            case TIME_SWI:
                *value=time_syscall();
		break;
            case SLEEP_SWI:
                sleep_syscall(regs[0]);
		break;
            case CREATE_SWI:
                task_create((task_t *)regs[0],regs[1]);
		break;
            case MUTEX_CREATE:
                *value=mutex_create();
		break;
            case MUTEX_LOCK:
                *value=mutex_lock(regs[0]);
		break;
            case MUTEX_UNLOCK:
                *value=mutex_unlock(regs[0]);
		break;
            case EVENT_WAIT:
                event_wait(regs[0]);
		break;
            default:
		
                invalid_syscall(swi_num);
	} /* end switch */
    return;
}