void
proxytask(void *v)
{
int fd, remotefd;
fd = (int)v;
if((remotefd = netdial(TCP, server, port)) < 0) {
close(fd);
return;
}
fprintf(stderr, "connected to %s:%d\n", server, port);
taskcreate(rwtask, mkfd2(fd, remotefd), STACK);
taskcreate(rwtask, mkfd2(remotefd, fd), STACK);
}
void taskmain(int argc, char **argv)
{
dbg_set_log(stderr);
int rc = 0;
check(argc == 3 || argc == 4, "usage: %s config.sqlite server_uuid [config_module.so]", m2program);
if(argc == 4) {
log_info("Using configuration module %s to load configs.", argv[3]);
rc = Config_module_load(argv[3]);
check(rc != -1, "Failed to load the config module: %s", argv[3]);
}
Server_queue_init();
Server *srv = load_server(argv[1], argv[2], NULL);
check(srv != NULL, "Aborting since can't load server.");
Server_queue_push(srv);
SuperPoll_get_max_fd();
rc = clear_pid_file(srv);
check(rc == 0, "PID file failure, aborting rather than trying to start.");
rc = attempt_chroot_drop(srv);
check(rc == 0, "Major failure in chroot/droppriv, aborting.");
final_setup();
taskcreate(tickertask, NULL, TICKER_TASK_STACK);
struct ServerTask *srv_data = calloc(1, sizeof(struct ServerTask));
srv_data->db_file = bfromcstr(argv[1]);
srv_data->server_id = bfromcstr(argv[2]);
taskcreate(reload_task, srv_data, RELOAD_TASK_STACK);
rc = Server_run();
check(rc != -1, "Server had a failure and exited early.");
log_info("Server run exited, goodbye.");
srv = Server_queue_latest();
complete_shutdown(srv);
return;
error:
log_err("Exiting due to error.");
taskexitall(1);
}
int
main(int argc, char **argv)
{
struct sigaction sa, osa;
memset(&sa, 0, sizeof sa);
sa.sa_handler = taskinfo;
sa.sa_flags = SA_RESTART;
sigaction(SIGQUIT, &sa, &osa);
#ifdef SIGINFO
sigaction(SIGINFO, &sa, &osa);
#endif
argv0 = argv[0];
taskargc = argc;
taskargv = argv;
if(mainstacksize == 0)
mainstacksize = 256*1024;
taskcreate(taskmainstart, nil, mainstacksize);//创建初始协程，调用应用层的taskmain函数，此时taskmainstart协程还没有运行，等待调度
taskscheduler();//进行协程调度
fprint(2, "taskscheduler returned in main!\n");
abort();
return 0;
}
void
fdwait(int fd, int rw)
{
if(!startedfdtask){
startedfdtask = 1;
epfd = epoll_create(1);
assert(epfd >= 0);
taskcreate(fdtask, 0, 32768 * 10);
}
taskstate("fdwait for %s", rw=='r' ? "read" : rw=='w' ? "write" : "error");
struct epoll_event ev = {0};
ev.data.ptr = taskrunning;
switch(rw){
case 'r':
ev.events |= EPOLLIN | EPOLLPRI;
break;
case 'w':
ev.events |= EPOLLOUT;
break;
}
int r = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
int duped = 0;
if (r < 0 || errno == EEXIST) {
duped = 1;
fd = dup(fd);
int r = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
assert(r == 0);
}
taskswitch();
epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev);
if (duped)
close(fd);
}
void Thread::start()
{
ASSERT(m_state == JOINED);
m_state = STARTING;
Log::debug("clc.thread", "Thread \"%s\" is starting", m_name.c_str());
bool ok;
#ifdef USE_LIBTASK
taskcreate(bootstrap, this, 32768);
ok = true;
#elif defined(__BEOS__) || defined(__HAIKU__)
m_stateChange.lock();
m_thread = spawn_thread(bootstrap, m_name.c_str(), B_NORMAL_PRIORITY, this);
ok = (m_thread != B_NO_MORE_THREADS && m_thread != B_NO_MEMORY);
if (ok)
resume_thread(m_thread);
m_stateChange.unlock();
#else
m_stateChange.lock();
ok = (pthread_create(&m_thread, NULL, bootstrap, this) == 0);
m_stateChange.unlock();
#endif
if (! ok) {
Log::debug("clc.thread", "Thread \"%s\" failed to start; is joined", m_name.c_str());
m_state = JOINED;
m_thread = 0;
throw std::bad_alloc();
}
}
void server_task(void* arg) {
struct cornet_config_t* config;
struct client_config_t cconfig;
int cfd, fd;
char remote[16];
int rport;
config = (struct cornet_config_t*)arg;
if (!config->name) {
config->name = "server_task";
}
taskname(config->name);
if ((fd = netannounce(config->istcp, config->server, config->port)) < 0) {
fprintf(stderr, "cannot announce on tcp port %d: %s\n", config->port, strerror(errno));
taskexitall(1);
}
cconfig.h = config->h;
while((cfd = netaccept(fd, remote, &rport)) >= 0){
fprintf(stderr, "connection from %s:%d\n", remote, rport);
cconfig.fd = cfd;
taskcreate(client_task, &cconfig, config->stack_size);
}
close(fd);
printf("Exiting server task: %d\n", taskid());
}
int
main(int argc, char **argv)
{
struct sigaction sa, osa;
memset(&sa, 0, sizeof sa);
sa.sa_handler = taskinfo;
sa.sa_flags = SA_RESTART;
sigaction(SIGQUIT, &sa, &osa);
#ifdef SIGINFO
sigaction(SIGINFO, &sa, &osa);
#endif
taskargc = argc;
taskargv = argv;
if (mainstacksize == 0)
mainstacksize = 256 * 1024;
taskcreate(taskmainstart, nil, mainstacksize);
taskscheduler();
fprintf(stderr, "taskscheduler returned in main!\n");
abort();
return 0;
}
int
main(int argc, char **argv)
{
struct sigaction sa, osa;
memset(&sa, 0, sizeof sa);
// 设置 quit 信号时，对应处理函数为 taskinfo
// 这个函数会在收到退出信号时, 打印当前的所有协程信息
sa.sa_handler = taskinfo;
sa.sa_flags = SA_RESTART;
sigaction(SIGQUIT, &sa, &osa);
#ifdef SIGINFO
sigaction(SIGINFO, &sa, &osa);
#endif
argv0 = argv[0];
taskargc = argc;
taskargv = argv;
// 设置默认的最小栈大小
if(mainstacksize == 0)
mainstacksize = 256*1024;
// 创建一个主协程
taskcreate(taskmainstart, nil, mainstacksize);
// 开始协程调度
taskscheduler();
fprint(2, "taskscheduler returned in main!\n");
abort();
return 0;
}
int Connection_accept(Connection *conn)
{
check(Register_connect(IOBuf_fd(conn->iob), (void*)conn) != -1,
"Failed to register connection.");
check(taskcreate(Connection_task, conn, CONNECTION_STACK) != -1,
"Failed to create connection task.");
check(taskcreate(Connection_deliver_task, conn, CONNECTION_STACK) != -1,
"Failed to create connection task.");
conn->deliverTaskStatus=DT_RUNNING;
return 0;
error:
IOBuf_register_disconnect(conn->iob);
return -1;
}
int Server_start_handlers(Server *srv, Server *copy_from)
{
int i = 0;
int rc = 0;
if(copy_from != NULL) {
rc = Server_copy_active_handlers(srv, copy_from);
check(rc != -1, "Failed to copy old handlers to new server config.");
}
for(i = 0; i < darray_end(srv->handlers); i++) {
Handler *handler = darray_get(srv->handlers, i);
check(handler != NULL, "Invalid handler, can't be NULL.");
if(!handler->running) {
log_info("LOADING Handler %s", bdata(handler->send_spec));
rc = taskcreate(Handler_task, handler, HANDLER_STACK);
check(rc != -1, "Failed to start handler task.");
handler->running = 1;
}
}
return 0;
error:
return -1;
}
static inline void startfdtask()
{
if(!STARTED_FDTASK) {
FDSTACK = Setting_get_int("limits.fdtask_stack", 100 * 1024);
log_info("MAX limits.fdtask_stack=%d", FDSTACK);
POLL = SuperPoll_create();
STARTED_FDTASK = 1;
taskcreate(fdtask, 0, FDSTACK);
}
}
void
fdwait(int fd, int rw)
{
int bits;
#ifdef maysam_dbg
fprintf(stderr,"fdwait on fd=%d 1 startedfdtask=%d\n",fd, startedfdtask);
#endif
if(!startedfdtask){
startedfdtask = 1;
taskcreate(fdtask, 0, 32768);
}
#ifdef maysam_dbg
fprintf(stderr,"fdwait on fd=%d 2\n",fd);
#endif
if(npollfd >= MAXFD){
fprint(2, "too many poll file descriptors\n");
abort();
}
#ifdef maysam_dbg
fprintf(stderr,"fdwait on fd=%d 3\n",fd);
#endif
taskstate("fdwait for %s", rw=='r' ? "read" : rw=='w' ? "write" : "error");
bits = 0;
switch(rw){
case 'r':
bits |= POLLIN;
break;
case 'w':
bits |= POLLOUT;
break;
}
#ifdef maysam_dbg
fprintf(stderr,"fdwait on fd=%d 4\n",fd);
#endif
polltask[npollfd] = taskrunning;
pollfd[npollfd].fd = fd;
pollfd[npollfd].events = bits;
pollfd[npollfd].revents = 0;
npollfd++;
#ifdef maysam_dbg
fprintf(stderr,"fdwait on fd=%d before taskswitch\n");
#endif
taskswitch();
}
uint
taskdelay(uint ms)
{
uvlong when, now;
Task *t;
if(!startedfdtask){
startedfdtask = 1;
epfd = epoll_create(1);
assert(epfd >= 0);
taskcreate(fdtask, 0, 32768 * 10);
}
now = nsec();
when = now+(uvlong)ms*1000000;
for(t=sleeping.head; t!=nil && t->alarmtime < when; t=t->next)
;
if(t){
taskrunning->prev = t->prev;
taskrunning->next = t;
}else{
taskrunning->prev = sleeping.tail;
taskrunning->next = nil;
}
t = taskrunning;
t->alarmtime = when;
if(t->prev)
t->prev->next = t;
else
sleeping.head = t;
if(t->next)
t->next->prev = t;
else
sleeping.tail = t;
if(!t->system && sleepingcounted++ == 0)
taskcount++;
taskswitch();
return (nsec() - now)/1000000;
}
void taskmain(int argc, char **argv)
{
int i, n;
if (argc != 4) {
fprintf(stderr, "usage: httpload n server url\n");
taskexitall(1);
}
n = atoi(argv[1]);
server = argv[2];
url = argv[3];
for (i = 0; i < n; i++) {
taskcreate(fetchtask, 0, STACK); // 创建协程, 设置为可以运行的状态
// 其实fetchtask不是上下文切换的第一个函数, taskstart才是, 后者立即调用fetchtask
while (taskyield() > 1) // 主动释放CPU, 这里循环其实是为了给其他协程足够的机会
;
sleep(1);
}
}
void
taskmain(int argc, char **argv)
{
int i, n;
if(argc != 4){
fprintf(stderr, "usage: httpload n server url\n");
taskexitall(1);
}
n = atoi(argv[1]);
server = argv[2];
url = argv[3];
for(i=0; i<n; i++){
taskcreate(fetchtask, 0, STACK);
while(taskyield() > 1)
;
sleep(1);
}
}
static void
taskmain(ltctx *lt, void *unused)
{
int i, n;
if(argc != 4) {
fprintf(stderr, "usage: httpload n server url\n");
fprintf(stderr, " ex: httpload 4 127.0.0.1 /\n");
taskexit(lt, 1);
}
n = atoi(argv[1]);
server = argv[2];
url = argv[3];
for(i=0; i<n; i++) {
taskcreate(lt, fetchtask, 0, STACK);
while(taskyield(lt) > 1)
;
//taskdelay(lt, 1/*ms*/);
}
}
void
taskmain(int argc, char **argv)
{
int i, n;
c = chancreate(sizeof(unsigned long), 0);
n = 0;
for (i = 1; i < argc; i++) {
n++;
printf("x");
taskcreate(delaytask, (void *) atoi(argv[i]), STACK);
}
/* wait for n tasks to finish */
for (i = 0; i < n; i++) {
printf("y");
chanrecvul(c);
}
taskexitall(0);
}
void
taskmain(int argc, char **argv)
{
int cfd, fd;
int rport;
char remote[16];
if(argc != 2){
fprintf(stderr, "usage: tcplongconnection localport \n");
taskexitall(1);
}
if((fd = netannounce(TCP, 0, atoi(argv[1]))) < 0){
fprintf(stderr, "cannot announce on tcp port %d: %s\n", atoi(argv[1]), strerror(errno));
taskexitall(1);
}
fdnoblock(fd);
while((cfd = netaccept(&fd, remote, &rport)) >= 0){
fprintf(stderr, "connection from %s:%d\n", remote, rport);
taskcreate(proxytask, (void*)cfd, STACK);
}
}
void
taskmain(int argc, char **argv)
{
int i, n;
if(argc != 4){
fprintf(stderr, "usage: httpload n server url\n");
taskexitall(1);
}
n = atoi(argv[1]);
server = argv[2];
url = argv[3];
for(i=0; i<n; i++){
taskcreate(fetchtask, 0, STACK);
//while(taskyield() > 1)
// ;
//taskdelay(500);
}
for(;;){
taskdelay(1000);
fprintf(stderr,"sucess:%d, fail:%d,rate:%f%%\n",sucess,fail,((float)sucess)/(sucess+fail)*100);
}
}
int cornet_add_server(struct cornet_config_t* config) {
return taskcreate(server_task, config, config->stack_size);
}
void Connection_accept(Connection *conn)
{
taskcreate(Connection_task, conn, CONNECTION_STACK);
}
void Action_start(Action *action)
{
taskcreate(Action_task, action, 32 * 1024);
}
