예제 #1
0
/*
 * This function may be called to close socket .
 * Paramters: a pointer to socket structure
 * Returns: None
 *
 */
void app_glue_close_socket(void *sk)
{
	struct socket *sock = (struct socket *)sk;

	if(sock->read_queue_present) {
		TAILQ_REMOVE(&read_ready_socket_list_head,sock,read_queue_entry);
		sock->read_queue_present = 0;
	}
	if(sock->write_queue_present) {
		TAILQ_REMOVE(&write_ready_socket_list_head,sock,write_queue_entry);
		sock->write_queue_present = 0;
	}
	if(sock->accept_queue_present) {
                struct socket *newsock = NULL;

	        while(kernel_accept(sock, &newsock, 0) == 0) {
                    kernel_close(newsock);
                }
		TAILQ_REMOVE(&accept_ready_socket_list_head,sock,accept_queue_entry);
		sock->accept_queue_present = 0;
	}
	if(sock->closed_queue_present) {
		TAILQ_REMOVE(&closed_socket_list_head,sock,closed_queue_entry);
		sock->closed_queue_present = 0;
	}
	if(sock->sk)
		sock->sk->sk_user_data = NULL;
	kernel_close(sock);
}
예제 #2
0
/*
 * This function walks on closable, acceptable and readable lists and calls.
 * the application's (user's) function. Called from app_glue_periodic
 * Paramters: None
 * Returns: None
 *
 */
static inline void process_rx_ready_sockets()
{
	struct socket *sock;
        uint64_t idx,limit;

	while(!TAILQ_EMPTY(&closed_socket_list_head)) {
		sock = TAILQ_FIRST(&closed_socket_list_head);
		user_on_socket_fatal(sock);
		sock->closed_queue_present = 0;
		TAILQ_REMOVE(&closed_socket_list_head,sock,closed_queue_entry);
		sock_put(sock->sk);
		kernel_close(sock);
	}
	while(!TAILQ_EMPTY(&accept_ready_socket_list_head)) {

		sock = TAILQ_FIRST(&accept_ready_socket_list_head);
		user_on_accept(sock);
		sock->accept_queue_present = 0;
		TAILQ_REMOVE(&accept_ready_socket_list_head,sock,accept_queue_entry);
		sock_put(sock->sk);
	}
        idx = 0;
        limit = read_sockets_queue_len;
	while((idx < limit)&&(!TAILQ_EMPTY(&read_ready_socket_list_head))) {
		sock = TAILQ_FIRST(&read_ready_socket_list_head);
                sock->read_queue_present = 0;
		TAILQ_REMOVE(&read_ready_socket_list_head,sock,read_queue_entry);
                user_data_available_cbk(sock);
		sock_put(sock->sk);
                read_sockets_queue_len--;
                idx++;	
	}
}
예제 #3
0
void kernel_runloop() {
	volatile TaskDescriptor* td;
	int** sp_pointer;
  idleTimeStart = 0;
  totalIdleTime = 0;
  lastReportTime = 0;
  latestIdle = 999;

	while (LIKELY((td = scheduler_get()) != (TaskDescriptor *)NULL && notQuit)) {
    if (idleTid == td->id) idleTimeStart = GET_TIMER4();

		sp_pointer = (int**)&(td->sp);
    scheduler_set_running(td);
		int is_interrupt = asm_switch_to_usermode(sp_pointer);

    unsigned int current = GET_TIMER4();
    if (idleTid == td->id) {
      totalIdleTime += current - idleTimeStart;
    }

    if ((current - lastReportTime) > 200000) {
      latestIdle = totalIdleTime*10000 / (current - lastReportTime);
      lastReportTime = current;
      totalIdleTime = 0;
    }

    if (is_interrupt) {
      scheduler_move2ready();
      kernel_handle_interrupt();
    } else {
      int *arg0 = *sp_pointer;
      int request = *arg0 & MASK_LOWER;

      ASSERT(request >= 0 && request < LAST_SYSCALL, "System call not in range.");
      (*syscall_handler[request])(*sp_pointer,
                                  (*sp_pointer)[1],
                                  (*sp_pointer)[2],
                                  (*sp_pointer)[3]);

      if (request <= SYSCALL_REPLY) {
        scheduler_move2ready();
      }

    }
	} // End kernel loop;

  kernel_close();
}
예제 #4
0
파일: init.c 프로젝트: gdarcy/scaraOS
/* Init task - the job of this task is to initialise all
 * installed drivers, mount the root filesystem and
 * bootstrap the system */
int init_task(void *priv)
{
	uint32_t ret;
	struct file *file;
	char buf[20];
	int rval;

	/* Initialise kernel subsystems */
	blk_init();
	vfs_init();
	pci_init();

	do_initcalls();

	/* Mount the root filesystem etc.. */
	if ( vfs_mount_root("ext2", "floppy0") ) {
		panic("Unable to mount root filesystem\n");
	}

	file = kernel_open("/test.txt", 0);
	if ( NULL == file ) {
		printk("init_task: open failed, returned %u\n", -1);
	} else {
		rval = kernel_read(file, buf, 16);
		if ( rval < 0 )
			printk("read error: %d\n", rval);
		else if ( rval == 0 )
			printk("read returned EOF\n");
		else {
			buf[rval] = '\0';
			printk("read: %s.\n", buf);
		}
		rval = kernel_write(file, buf, 16);
		kernel_close(file);
	}

	ret = _kernel_exec("/bin/bash");
	ret = _kernel_exec("/sbin/init");
	ret = _kernel_exec("/bin/cat");
	printk("exec: /sbin/init: %i\n", (int)ret);

	return ret;
}
예제 #5
0
int main(int argc, char *argv[])
{
	int c;
	const char *config_file = DEFAULT_CONFIG;
	const char *adm_socket = DEFAULT_ADM_SOCKET;
	int verbose = 0;
	static struct ev_loop *loop;
	static struct ev_signal signal_watcher;
	pid_t pid;

	while ((c = getopt(argc, argv, "a:c:dhp:Vv")) != -1) {
		switch (c) {
		case 'a':
			adm_socket = optarg;
			break;
		case 'c':
			config_file = optarg;
			break;
		case 'd':
			pingu_daemonize++;
			break;
		case 'h':
			return usage(basename(argv[0]));
		case 'p':
			pid_file = optarg;
			break;
		case 'V':
			print_version(basename(argv[0]));
			return 0;
		case 'v':
			verbose++;
			break;
		}
	}

	argc -= optind;
	argv += optind;

	log_init("pingu", verbose);

	pid = get_running_pid();
	if (pid)
		errx(1, "appears to be running already (pid %i)", pid);

	loop = ev_default_loop(0);

	if (pingu_conf_parse(config_file) < 0)
		return 1;

	if (pingu_iface_init(loop) < 0)
		return 1;

	if (pingu_host_init(loop) < 0)
		return 1;

	if (pingu_adm_init(loop, adm_socket) < 0)
		return 1;

	if (pingu_daemonize) {
		if (daemonize() == -1)
			return 1;
	}

	kernel_init(loop);
	ev_signal_init(&signal_watcher, sigint_cb, SIGINT);
	ev_signal_start(loop, &signal_watcher);

	ev_run(loop, 0);
	log_info("Shutting down");
	pingu_iface_cleanup(loop);
	pingu_host_cleanup();
	kernel_close();
	ev_loop_destroy(loop);
	return 0;
}