int lthread_init()
{
/* kswap thread */
kswap_tid = lthread_create(kswp_thread_fn);
/* kreclaim thread */
kreclaim_tid = lthread_create(kreclaim_thread_fn);
}
int
main(int argc, char **argv)
{
lthread_t *lt = NULL;
int pipes[2];
lthread_pipe(pipes);
lthread_create(<, read_pipe, pipes);
lthread_create(<, write_pipe, pipes);
lthread_run();
return 0;
}
void
bd_lt_listener(lthread_t *lt, int args)
{
lthread_t *lt_new;
socklen_t addrlen;
int s_fd, c_fd;
struct sockaddr_in cin;
DEFINE_LTHREAD(lt);
s_fd = e_listener("0.0.0.0", 5557);
if (!s_fd) {
perror("Cannot listen on socket");
return;
}
while (1) {
c_fd = lthread_accept(lt, s_fd, (struct sockaddr *)&cin,
&addrlen);
if (!c_fd) {
continue;
}
lthread_create(lthread_get_sched(lt), <_new, bd_lt_cli,
(void *)c_fd);
}
}
int
main(void)
{
lthread_t *lt;
lthread_create(<, udp_server, NULL);
lthread_run();
return 0;
}
static void lt_proxy_loop(void* arg)
{
lthread_t *lt = NULL;
proxy_conn_t *proxy = (proxy_conn_t*)arg;
fprintf(stderr, "proxy loop\n");
lthread_create(<, (void*)lt_proxy_loop_read, proxy);
lt_proxy_loop_write(arg);
lthread_join(lt, NULL, LTHREAD_FOREVER);
}
static void lt_request_cli(void *arg)
{
int ret;
lthread_t *lt = NULL;
proxy_conn_t *priv_conn = proxy_conn_create(-1, 1);
proxy_conn_t *proxy_conn = (proxy_conn_t*)arg;
DEFINE_LTHREAD;
lthread_detach();
fprintf(stderr, "request new client\n");
ret = tcp_dial_ipv4(&priv_conn->conn, "192.168.6.1:80");
if(0 != ret) {
proxy_conn_free(priv_conn);
proxy_conn_free(proxy_conn);
return;
}
fprintf(stderr, "dial priv conn ok\n");
priv_conn->other = proxy_conn;
proxy_conn->other = priv_conn;
//lthread_create(<1, (void*)lt_proxy_loop, (void*)priv_conn);
lthread_create(<, (void*)lt_proxy_loop, (void*)proxy_conn);
lt_proxy_loop(priv_conn);
lthread_join(lt, NULL, LTHREAD_FOREVER);
void* data = NULL;
kstring_t *buf = NULL;
while(0 == chan_recv(priv_conn->write_ch, &data)) {
if(data != NULL) {
buf = (kstring_t*)data;
ks_free(buf);
free(buf);
} else {
//mark as end
break;
}
}
while(0 == chan_recv(proxy_conn->write_ch, &data)) {
if(data != NULL) {
buf = (kstring_t*)data;
ks_free(buf);
free(buf);
} else {
//mark as end
break;
}
}
proxy_conn_free(priv_conn);
proxy_conn_free(proxy_conn);
}
static void lt_accept_loop(void *arg)
{
proxy_server *srv = (proxy_server*)arg;
lthread_t *lt = NULL;
proxy_conn_t *proxy = NULL;
int ret;
void* msgs[2];
lthread_chan_t* chans[2];
lthread_sel_t *sel = lthread_sel_create();
chans[0] = srv->accepts_ch;
chans[1] = srv->die_ch;
while(!srv->is_die) {
ret = chan_select(sel, chans, msgs, 0, 2, LTHREAD_FOREVER);
switch(ret) {
case 0:
//recv ok
fprintf(stderr, "recv accept channel ok\n");
proxy = (proxy_conn_t*)msgs[0];
if(NULL == proxy && chan_is_closed(msgs[0])) {
ret = -10;
break;
}
lthread_create(<, (void*)lt_request_cli, (void*)proxy);
//yield myself
lthread_sleep(0);
break;
case 1:
//server die
ret = -11;
break;
default:
break;
}
if(ret < 0) {
fprintf(stderr, "%s#%d ret=%d\n", __FUNCTION__, __LINE__, ret);
break;
}
}
lthread_sel_dispose(sel);
}
int main(void)
{
lthread_t *lt = NULL;
proxy_server *srv = &g_srv;
cdns_init();
server_init(srv);
signal(SIGPIPE, SIG_IGN);
/*signal(SIGINT, sig_handler);
signal(SIGQUIT, sig_handler);
signal(SIGUSR1, sig_handler);*/
lthread_create(<, (void*)lt_main, (void*)srv);
//lt = NULL;
//lthread_create(<, (void*)lt_signal, (void*)srv);
lthread_run();
}
int main(int argc, char **argv) {
lthread_t *lt;
if (mysql_library_init(0, NULL, NULL)) {
fprintf(stderr, "failed to initialize mysql library\n");
return 1;
}
/* many lthreads could be spawned, but mysql is very limited
on connections; 100-150 is the default */
printf("running lthread...\n");
if (lthread_create(<, run_query, NULL) == -1) {
fprintf(stderr, "failed to create lthread\n");
exit(1);
}
lthread_run();
printf("lthread scheduler finished\n");
mysql_library_end();
return 0;
}
void lt_main(void *arg)
{
int fd, opt = 1;
proxy_server *srv = (proxy_server*)arg;
lthread_t *lt_accept = NULL;
struct sockaddr cin = {0};
socklen_t addrlen = sizeof(struct sockaddr);
proxy_conn_t *proxy = NULL;
DEFINE_LTHREAD;
lthread_detach();
srv->listen_fd = create_listener("0.0.0.0", 9000);
if(srv->listen_fd < 0) {
exit(1);
}
fprintf(stderr, "listener creating :9000\n");
lthread_create(<_accept, (void*)lt_accept_loop, (void*)srv);
while(!srv->is_die) {
fd = lthread_accept(srv->listen_fd, &cin, &addrlen);
if(fd < 0) {
perror("accept error");
break;
}
if(srv->quiting) {
lthread_close(fd);
break;
}
if(srv->is_die) {
//already die, close and break
lthread_close(fd);
fprintf(stderr, "server already die :9000\n");
break;
}
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int)) == -1) {
perror("failed to set SOREUSEADDR on socket");
break;
}
fprintf(stderr, "accept new client\n");
proxy = proxy_conn_create(fd, 0);
if(0 != chan_send(srv->accepts_ch, proxy)) {
//send failed, free proxy
proxy_conn_free(proxy);
break;
}
//yield myself
lthread_sleep((uint64_t)0);
}
if(-1 != srv->listen_fd) {
close(srv->listen_fd);
srv->listen_fd = -1;
}
if(!srv->is_die) {
srv->is_die = 1;
chan_close(srv->die_ch);
fprintf(stderr, "srv die\n");
}
fprintf(stderr, "lt_accept end\n");
lthread_join(lt_accept, NULL, LTHREAD_FOREVER);
//server release
server_release(srv);
}
