int loop(int fd, int *error)
{
char buffer[BUFFER_SIZE];
char out[BUFFER_OUT];
fd_set readfds;
t_client cli;
init_data(&cli, buffer, out, fd);
while (1)
{
init_select(&readfds, &cli, fd);
if (select(select_max_fd(&cli, fd), &readfds, 0, 0, 0) != -1)
{
if (FD_ISSET(STDIN_FILENO, &readfds))
handle_user_input(&cli, error, buffer, out);
else if (FD_ISSET(cli.sock, &readfds))
handle_recv_reply(&cli, error, buffer);
else if (IS_ACTIVE(cli.data) && FD_ISSET(cli.data, &readfds))
handle_accept_data(&cli, error);
else if (IS_ACTIVE(cli.control) && FD_ISSET(cli.control, &readfds))
handle_recv_data(&cli, error, buffer);
if (*error)
return (exiting(*error));
}
else
return (fprintf(stderr, "select error: %s\n", strerror(errno)));
}
}
int main(int argc, char *argv[]) {
int i;
init(); /* Init some variables (like malloc timestamp string, encrypt text string, etc.) */
check_par(argc, argv); /* Check command arguments number */
open_config(argv); /* Open config file and check if it failed */
open_log(argv); /* Open log file and check if it failed */
get_ipaddr(); /* Get server IP address */
create_socket(); /* Create a socket */
bind_socket(); /* Bind the socket */
listen_socket(); /* Listen at the socket */
print_server_info(); /* Print server information */
while (TRUE) { /* Read until the end of file */
if (read_flag) {
if (fscanf(fcfg, "%s", enc_txt) == EOF) {
finish_flag = 1;
break;
} else {
fscanf(fcfg, "%s", dec_txt);
}
}
read_flag = 0;
init_select(); /* Select function */
if (select_func() == -1) break;
for (i = 0; i < max_fds + 1; i++) {
if (FD_ISSET(i, &rfds)) {
if (i == sockfd) { /* If have a new client connect */
if (accept_new_cli() == -1) break; /* Try to accept new client */
if (check_connect() == -1) break; /* Check connect message from client */
if (print_client_info() == -1) break; /* Print the information of client side */
store_client_ip(); /* Store the client ip address */
break;
} else { /* If have new message from client side */
client_ip = get_host_by_sockfd(i); /* Get the client ip address by socket */
recv_socket_msg(i, recv_mark); /* Get the message from socket */
handle_client_msg(i); /* Handle client message (SUCCESS_MSG, FAILURE_MSG, DISPATCH_MSG, etc.) */
break;
}
}
if (main_flag == EXIT_FAILURE) break;
}
if (main_flag == EXIT_FAILURE) break;
}
remained_cli = ask_clients_quit(); /* Ask clients quit and count the remain clients number */
wait_clients_quit(); /* Wait for all clients quit */
quit_server(); /* Clean up and quit server, also print the message to log */
return main_flag;
}
int main(int argc, char **argv)
{
t_env e;
if (argc == 1)
exit(0);
((t_stat *)get_instance())->env = &e;
if (init_args(argv, &e, argc) == -1)
return (make_error(&e, "Error initializing arguments\n"));
if (init_termios(&e) == -1)
return (make_error(&e, "Error initializing terminal\n"));
if (init_select(&e) == -1)
return (make_error(&e, "Configuration error\n"));
}
int loop_server(t_server *server)
{
fd_set rfds;
fd_set wfds;
fd_set efds;
int fdmax;
while (server->alive)
{
fdmax = init_select(server, &rfds, &wfds, &efds);
if (server->alive)
{
if (select(fdmax + 1, &rfds, &wfds, &efds, (struct timeval*)0) == -1)
{
return (derror("select:"));
}
}
if (server->alive)
{
post_select(server, &rfds, &wfds);
}
}
return (0);
}
/*===========================================================================*
* sef_cb_init_fresh *
*===========================================================================*/
static int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *info)
{
/* Initialize the virtual file server. */
int s, i;
struct fproc *rfp;
message mess;
struct rprocpub rprocpub[NR_BOOT_PROCS];
force_sync = 0;
receive_from = ANY;
self = NULL;
verbose = 0;
/* Initialize proc endpoints to NONE */
for (rfp = &fproc[0]; rfp < &fproc[NR_PROCS]; rfp++) {
rfp->fp_endpoint = NONE;
rfp->fp_pid = PID_FREE;
}
/* Initialize the process table with help of the process manager messages.
* Expect one message for each system process with its slot number and pid.
* When no more processes follow, the magic process number NONE is sent.
* Then, stop and synchronize with the PM.
*/
do {
if ((s = sef_receive(PM_PROC_NR, &mess)) != OK)
panic("VFS: couldn't receive from PM: %d", s);
if (mess.m_type != PM_INIT)
panic("unexpected message from PM: %d", mess.m_type);
if (NONE == mess.PM_PROC) break;
rfp = &fproc[mess.PM_SLOT];
rfp->fp_flags = FP_NOFLAGS;
rfp->fp_pid = mess.PM_PID;
rfp->fp_endpoint = mess.PM_PROC;
rfp->fp_grant = GRANT_INVALID;
rfp->fp_blocked_on = FP_BLOCKED_ON_NONE;
rfp->fp_realuid = (uid_t) SYS_UID;
rfp->fp_effuid = (uid_t) SYS_UID;
rfp->fp_realgid = (gid_t) SYS_GID;
rfp->fp_effgid = (gid_t) SYS_GID;
rfp->fp_umask = ~0;
} while (TRUE); /* continue until process NONE */
mess.m_type = OK; /* tell PM that we succeeded */
s = send(PM_PROC_NR, &mess); /* send synchronization message */
/* All process table entries have been set. Continue with initialization. */
fp = &fproc[_ENDPOINT_P(VFS_PROC_NR)];/* During init all communication with
* FSes is on behalf of myself */
init_dmap(); /* Initialize device table. */
system_hz = sys_hz();
/* Map all the services in the boot image. */
if ((s = sys_safecopyfrom(RS_PROC_NR, info->rproctab_gid, 0,
(vir_bytes) rprocpub, sizeof(rprocpub), S)) != OK){
panic("sys_safecopyfrom failed: %d", s);
}
for (i = 0; i < NR_BOOT_PROCS; i++) {
if (rprocpub[i].in_use) {
if ((s = map_service(&rprocpub[i])) != OK) {
panic("VFS: unable to map service: %d", s);
}
}
}
/* Subscribe to block and character driver events. */
s = ds_subscribe("drv\\.[bc]..\\..*", DSF_INITIAL | DSF_OVERWRITE);
if (s != OK) panic("VFS: can't subscribe to driver events (%d)", s);
/* Initialize worker threads */
for (i = 0; i < NR_WTHREADS; i++) {
worker_init(&workers[i]);
}
worker_init(&sys_worker); /* exclusive system worker thread */
worker_init(&dl_worker); /* exclusive worker thread to resolve deadlocks */
/* Initialize global locks */
if (mthread_mutex_init(&pm_lock, NULL) != 0)
panic("VFS: couldn't initialize pm lock mutex");
if (mthread_mutex_init(&exec_lock, NULL) != 0)
panic("VFS: couldn't initialize exec lock");
if (mthread_mutex_init(&bsf_lock, NULL) != 0)
panic("VFS: couldn't initialize block special file lock");
/* Initialize event resources for boot procs and locks for all procs */
for (rfp = &fproc[0]; rfp < &fproc[NR_PROCS]; rfp++) {
if (mutex_init(&rfp->fp_lock, NULL) != 0)
panic("unable to initialize fproc lock");
#if LOCK_DEBUG
rfp->fp_vp_rdlocks = 0;
rfp->fp_vmnt_rdlocks = 0;
#endif
}
init_vnodes(); /* init vnodes */
init_vmnts(); /* init vmnt structures */
init_select(); /* init select() structures */
init_filps(); /* Init filp structures */
mount_pfs(); /* mount Pipe File Server */
worker_start(do_init_root); /* mount initial ramdisk as file system root */
yield(); /* force do_init_root to start */
self = NULL;
return(OK);
}
/*===========================================================================*
* sef_cb_init_fresh *
*===========================================================================*/
PRIVATE int sef_cb_init_fresh(int type, sef_init_info_t *info)
{
/* Initialize the virtual file server. */
int s, i;
register struct fproc *rfp;
struct vmnt *vmp;
struct vnode *root_vp;
message mess;
struct rprocpub rprocpub[NR_BOOT_PROCS];
/* Clear endpoint field */
last_login_fs_e = NONE;
mount_m_in.m1_p3 = (char *) NONE;
/* Initialize the process table with help of the process manager messages.
* Expect one message for each system process with its slot number and pid.
* When no more processes follow, the magic process number NONE is sent.
* Then, stop and synchronize with the PM.
*/
do {
if (OK != (s=sef_receive(PM_PROC_NR, &mess)))
panic("FS couldn't receive from PM: %d", s);
if (mess.m_type != PM_INIT)
panic("unexpected message from PM: %d", mess.m_type);
if (NONE == mess.PM_PROC) break;
rfp = &fproc[mess.PM_SLOT];
rfp->fp_pid = mess.PM_PID;
rfp->fp_endpoint = mess.PM_PROC;
rfp->fp_openfd = 0;
rfp->fp_realuid = (uid_t) SYS_UID;
rfp->fp_effuid = (uid_t) SYS_UID;
rfp->fp_realgid = (gid_t) SYS_GID;
rfp->fp_effgid = (gid_t) SYS_GID;
rfp->fp_umask = ~0;
rfp->fp_grant = GRANT_INVALID;
rfp->fp_blocked_on = FP_BLOCKED_ON_NONE;
rfp->fp_revived = NOT_REVIVING;
rfp->fp_fsizelim.rlim_cur = RLIM_FSIZE_DEFAULT;
rfp->fp_fsizelim.rlim_max = RLIM_FSIZE_DEFAULT;
rfp->fp_nofilelim.rlim_cur = RLIM_NOFILE_DEFAULT;
rfp->fp_nofilelim.rlim_max = RLIM_NOFILE_DEFAULT;
} while (TRUE); /* continue until process NONE */
mess.m_type = OK; /* tell PM that we succeeded */
s = send(PM_PROC_NR, &mess); /* send synchronization message */
/* All process table entries have been set. Continue with initialization. */
/* The following initializations are needed to let dev_opcl succeed .*/
fp = (struct fproc *) NULL;
who_e = who_p = VFS_PROC_NR;
/* Initialize device table. */
build_dmap();
/* Map all the services in the boot image. */
if((s = sys_safecopyfrom(RS_PROC_NR, info->rproctab_gid, 0,
(vir_bytes) rprocpub, sizeof(rprocpub), S)) != OK) {
panic("sys_safecopyfrom failed: %d", s);
}
for(i=0;i < NR_BOOT_PROCS;i++) {
if(rprocpub[i].in_use) {
if((s = map_service(&rprocpub[i])) != OK) {
panic("unable to map service: %d", s);
}
}
}
init_root(); /* init root device and load super block */
init_select(); /* init select() structures */
vmp = &vmnt[0]; /* Should be the root filesystem */
if (vmp->m_dev == NO_DEV)
panic("vfs: no root filesystem");
root_vp= vmp->m_root_node;
/* The root device can now be accessed; set process directories. */
for (rfp=&fproc[0]; rfp < &fproc[NR_PROCS]; rfp++) {
FD_ZERO(&(rfp->fp_filp_inuse));
if (rfp->fp_pid != PID_FREE) {
dup_vnode(root_vp);
rfp->fp_rd = root_vp;
dup_vnode(root_vp);
rfp->fp_wd = root_vp;
} else rfp->fp_endpoint = NONE;
}
system_hz = sys_hz();
/* Subscribe to driver events for VFS drivers. */
s = ds_subscribe("drv\\.vfs\\..*", DSF_INITIAL | DSF_OVERWRITE);
if(s != OK) {
panic("vfs: can't subscribe to driver events");
}
SANITYCHECK;
#if DO_SANITYCHECKS
FIXME("VFS: DO_SANITYCHECKS is on");
#endif
return(OK);
}
int main(void)
{
/* Local scalars */
char job, job_i;
char eigsrc, eigsrc_i;
char initv, initv_i;
lapack_int n, n_i;
lapack_int ldh, ldh_i;
lapack_int ldh_r;
lapack_int ldvl, ldvl_i;
lapack_int ldvl_r;
lapack_int ldvr, ldvr_i;
lapack_int ldvr_r;
lapack_int mm, mm_i;
lapack_int m, m_i;
lapack_int info, info_i;
lapack_int i;
int failed;
/* Local arrays */
lapack_int *select = NULL, *select_i = NULL;
lapack_complex_double *h = NULL, *h_i = NULL;
lapack_complex_double *w = NULL, *w_i = NULL;
lapack_complex_double *vl = NULL, *vl_i = NULL;
lapack_complex_double *vr = NULL, *vr_i = NULL;
lapack_complex_double *work = NULL, *work_i = NULL;
double *rwork = NULL, *rwork_i = NULL;
lapack_int *ifaill = NULL, *ifaill_i = NULL;
lapack_int *ifailr = NULL, *ifailr_i = NULL;
lapack_complex_double *w_save = NULL;
lapack_complex_double *vl_save = NULL;
lapack_complex_double *vr_save = NULL;
lapack_int *ifaill_save = NULL;
lapack_int *ifailr_save = NULL;
lapack_complex_double *h_r = NULL;
lapack_complex_double *vl_r = NULL;
lapack_complex_double *vr_r = NULL;
/* Iniitialize the scalar parameters */
init_scalars_zhsein( &job, &eigsrc, &initv, &n, &ldh, &ldvl, &ldvr, &mm );
ldh_r = n+2;
ldvl_r = mm+2;
ldvr_r = mm+2;
job_i = job;
eigsrc_i = eigsrc;
initv_i = initv;
n_i = n;
ldh_i = ldh;
ldvl_i = ldvl;
ldvr_i = ldvr;
mm_i = mm;
/* Allocate memory for the LAPACK routine arrays */
select = (lapack_int *)LAPACKE_malloc( n * sizeof(lapack_int) );
h = (lapack_complex_double *)
LAPACKE_malloc( ldh*n * sizeof(lapack_complex_double) );
w = (lapack_complex_double *)
LAPACKE_malloc( n * sizeof(lapack_complex_double) );
vl = (lapack_complex_double *)
LAPACKE_malloc( ldvl*mm * sizeof(lapack_complex_double) );
vr = (lapack_complex_double *)
LAPACKE_malloc( ldvr*mm * sizeof(lapack_complex_double) );
work = (lapack_complex_double *)
LAPACKE_malloc( n*n * sizeof(lapack_complex_double) );
rwork = (double *)LAPACKE_malloc( n * sizeof(double) );
ifaill = (lapack_int *)LAPACKE_malloc( mm * sizeof(lapack_int) );
ifailr = (lapack_int *)LAPACKE_malloc( mm * sizeof(lapack_int) );
/* Allocate memory for the C interface function arrays */
select_i = (lapack_int *)LAPACKE_malloc( n * sizeof(lapack_int) );
h_i = (lapack_complex_double *)
LAPACKE_malloc( ldh*n * sizeof(lapack_complex_double) );
w_i = (lapack_complex_double *)
LAPACKE_malloc( n * sizeof(lapack_complex_double) );
vl_i = (lapack_complex_double *)
LAPACKE_malloc( ldvl*mm * sizeof(lapack_complex_double) );
vr_i = (lapack_complex_double *)
LAPACKE_malloc( ldvr*mm * sizeof(lapack_complex_double) );
work_i = (lapack_complex_double *)
LAPACKE_malloc( n*n * sizeof(lapack_complex_double) );
rwork_i = (double *)LAPACKE_malloc( n * sizeof(double) );
ifaill_i = (lapack_int *)LAPACKE_malloc( mm * sizeof(lapack_int) );
ifailr_i = (lapack_int *)LAPACKE_malloc( mm * sizeof(lapack_int) );
/* Allocate memory for the backup arrays */
w_save = (lapack_complex_double *)
LAPACKE_malloc( n * sizeof(lapack_complex_double) );
vl_save = (lapack_complex_double *)
LAPACKE_malloc( ldvl*mm * sizeof(lapack_complex_double) );
vr_save = (lapack_complex_double *)
LAPACKE_malloc( ldvr*mm * sizeof(lapack_complex_double) );
ifaill_save = (lapack_int *)LAPACKE_malloc( mm * sizeof(lapack_int) );
ifailr_save = (lapack_int *)LAPACKE_malloc( mm * sizeof(lapack_int) );
/* Allocate memory for the row-major arrays */
h_r = (lapack_complex_double *)
LAPACKE_malloc( n*(n+2) * sizeof(lapack_complex_double) );
vl_r = (lapack_complex_double *)
LAPACKE_malloc( n*(mm+2) * sizeof(lapack_complex_double) );
vr_r = (lapack_complex_double *)
LAPACKE_malloc( n*(mm+2) * sizeof(lapack_complex_double) );
/* Initialize input arrays */
init_select( n, select );
init_h( ldh*n, h );
init_w( n, w );
init_vl( ldvl*mm, vl );
init_vr( ldvr*mm, vr );
init_work( n*n, work );
init_rwork( n, rwork );
init_ifaill( mm, ifaill );
init_ifailr( mm, ifailr );
/* Backup the ouptut arrays */
for( i = 0; i < n; i++ ) {
w_save[i] = w[i];
}
for( i = 0; i < ldvl*mm; i++ ) {
vl_save[i] = vl[i];
}
for( i = 0; i < ldvr*mm; i++ ) {
vr_save[i] = vr[i];
}
for( i = 0; i < mm; i++ ) {
ifaill_save[i] = ifaill[i];
}
for( i = 0; i < mm; i++ ) {
ifailr_save[i] = ifailr[i];
}
/* Call the LAPACK routine */
zhsein_( &job, &eigsrc, &initv, select, &n, h, &ldh, w, vl, &ldvl, vr,
&ldvr, &mm, &m, work, rwork, ifaill, ifailr, &info );
/* Initialize input data, call the column-major middle-level
* interface to LAPACK routine and check the results */
for( i = 0; i < n; i++ ) {
select_i[i] = select[i];
}
for( i = 0; i < ldh*n; i++ ) {
h_i[i] = h[i];
}
for( i = 0; i < n; i++ ) {
w_i[i] = w_save[i];
}
for( i = 0; i < ldvl*mm; i++ ) {
vl_i[i] = vl_save[i];
}
for( i = 0; i < ldvr*mm; i++ ) {
vr_i[i] = vr_save[i];
}
for( i = 0; i < n*n; i++ ) {
work_i[i] = work[i];
}
for( i = 0; i < n; i++ ) {
rwork_i[i] = rwork[i];
}
for( i = 0; i < mm; i++ ) {
ifaill_i[i] = ifaill_save[i];
}
for( i = 0; i < mm; i++ ) {
ifailr_i[i] = ifailr_save[i];
}
info_i = LAPACKE_zhsein_work( LAPACK_COL_MAJOR, job_i, eigsrc_i, initv_i,
select_i, n_i, h_i, ldh_i, w_i, vl_i, ldvl_i,
vr_i, ldvr_i, mm_i, &m_i, work_i, rwork_i,
ifaill_i, ifailr_i );
failed = compare_zhsein( w, w_i, vl, vl_i, vr, vr_i, m, m_i, ifaill,
ifaill_i, ifailr, ifailr_i, info, info_i, job,
ldvl, ldvr, mm, n );
if( failed == 0 ) {
printf( "PASSED: column-major middle-level interface to zhsein\n" );
} else {
printf( "FAILED: column-major middle-level interface to zhsein\n" );
}
/* Initialize input data, call the column-major high-level
* interface to LAPACK routine and check the results */
for( i = 0; i < n; i++ ) {
select_i[i] = select[i];
}
for( i = 0; i < ldh*n; i++ ) {
h_i[i] = h[i];
}
for( i = 0; i < n; i++ ) {
w_i[i] = w_save[i];
}
for( i = 0; i < ldvl*mm; i++ ) {
vl_i[i] = vl_save[i];
}
for( i = 0; i < ldvr*mm; i++ ) {
vr_i[i] = vr_save[i];
}
for( i = 0; i < n*n; i++ ) {
work_i[i] = work[i];
}
for( i = 0; i < n; i++ ) {
rwork_i[i] = rwork[i];
}
for( i = 0; i < mm; i++ ) {
ifaill_i[i] = ifaill_save[i];
}
for( i = 0; i < mm; i++ ) {
ifailr_i[i] = ifailr_save[i];
}
info_i = LAPACKE_zhsein( LAPACK_COL_MAJOR, job_i, eigsrc_i, initv_i,
select_i, n_i, h_i, ldh_i, w_i, vl_i, ldvl_i, vr_i,
ldvr_i, mm_i, &m_i, ifaill_i, ifailr_i );
failed = compare_zhsein( w, w_i, vl, vl_i, vr, vr_i, m, m_i, ifaill,
ifaill_i, ifailr, ifailr_i, info, info_i, job,
ldvl, ldvr, mm, n );
if( failed == 0 ) {
printf( "PASSED: column-major high-level interface to zhsein\n" );
} else {
printf( "FAILED: column-major high-level interface to zhsein\n" );
}
/* Initialize input data, call the row-major middle-level
* interface to LAPACK routine and check the results */
for( i = 0; i < n; i++ ) {
select_i[i] = select[i];
}
for( i = 0; i < ldh*n; i++ ) {
h_i[i] = h[i];
}
for( i = 0; i < n; i++ ) {
w_i[i] = w_save[i];
}
for( i = 0; i < ldvl*mm; i++ ) {
vl_i[i] = vl_save[i];
}
for( i = 0; i < ldvr*mm; i++ ) {
vr_i[i] = vr_save[i];
}
for( i = 0; i < n*n; i++ ) {
work_i[i] = work[i];
}
for( i = 0; i < n; i++ ) {
rwork_i[i] = rwork[i];
}
for( i = 0; i < mm; i++ ) {
ifaill_i[i] = ifaill_save[i];
}
for( i = 0; i < mm; i++ ) {
ifailr_i[i] = ifailr_save[i];
}
LAPACKE_zge_trans( LAPACK_COL_MAJOR, n, n, h_i, ldh, h_r, n+2 );
if( LAPACKE_lsame( job, 'b' ) || LAPACKE_lsame( job, 'l' ) ) {
LAPACKE_zge_trans( LAPACK_COL_MAJOR, n, mm, vl_i, ldvl, vl_r, mm+2 );
}
if( LAPACKE_lsame( job, 'b' ) || LAPACKE_lsame( job, 'r' ) ) {
LAPACKE_zge_trans( LAPACK_COL_MAJOR, n, mm, vr_i, ldvr, vr_r, mm+2 );
}
info_i = LAPACKE_zhsein_work( LAPACK_ROW_MAJOR, job_i, eigsrc_i, initv_i,
select_i, n_i, h_r, ldh_r, w_i, vl_r, ldvl_r,
vr_r, ldvr_r, mm_i, &m_i, work_i, rwork_i,
ifaill_i, ifailr_i );
if( LAPACKE_lsame( job, 'b' ) || LAPACKE_lsame( job, 'l' ) ) {
LAPACKE_zge_trans( LAPACK_ROW_MAJOR, n, mm, vl_r, mm+2, vl_i, ldvl );
}
if( LAPACKE_lsame( job, 'b' ) || LAPACKE_lsame( job, 'r' ) ) {
LAPACKE_zge_trans( LAPACK_ROW_MAJOR, n, mm, vr_r, mm+2, vr_i, ldvr );
}
failed = compare_zhsein( w, w_i, vl, vl_i, vr, vr_i, m, m_i, ifaill,
ifaill_i, ifailr, ifailr_i, info, info_i, job,
ldvl, ldvr, mm, n );
if( failed == 0 ) {
printf( "PASSED: row-major middle-level interface to zhsein\n" );
} else {
printf( "FAILED: row-major middle-level interface to zhsein\n" );
}
/* Initialize input data, call the row-major high-level
* interface to LAPACK routine and check the results */
for( i = 0; i < n; i++ ) {
select_i[i] = select[i];
}
for( i = 0; i < ldh*n; i++ ) {
h_i[i] = h[i];
}
for( i = 0; i < n; i++ ) {
w_i[i] = w_save[i];
}
for( i = 0; i < ldvl*mm; i++ ) {
vl_i[i] = vl_save[i];
}
for( i = 0; i < ldvr*mm; i++ ) {
vr_i[i] = vr_save[i];
}
for( i = 0; i < n*n; i++ ) {
work_i[i] = work[i];
}
for( i = 0; i < n; i++ ) {
rwork_i[i] = rwork[i];
}
for( i = 0; i < mm; i++ ) {
ifaill_i[i] = ifaill_save[i];
}
for( i = 0; i < mm; i++ ) {
ifailr_i[i] = ifailr_save[i];
}
/* Init row_major arrays */
LAPACKE_zge_trans( LAPACK_COL_MAJOR, n, n, h_i, ldh, h_r, n+2 );
if( LAPACKE_lsame( job, 'b' ) || LAPACKE_lsame( job, 'l' ) ) {
LAPACKE_zge_trans( LAPACK_COL_MAJOR, n, mm, vl_i, ldvl, vl_r, mm+2 );
}
if( LAPACKE_lsame( job, 'b' ) || LAPACKE_lsame( job, 'r' ) ) {
LAPACKE_zge_trans( LAPACK_COL_MAJOR, n, mm, vr_i, ldvr, vr_r, mm+2 );
}
info_i = LAPACKE_zhsein( LAPACK_ROW_MAJOR, job_i, eigsrc_i, initv_i,
select_i, n_i, h_r, ldh_r, w_i, vl_r, ldvl_r, vr_r,
ldvr_r, mm_i, &m_i, ifaill_i, ifailr_i );
if( LAPACKE_lsame( job, 'b' ) || LAPACKE_lsame( job, 'l' ) ) {
LAPACKE_zge_trans( LAPACK_ROW_MAJOR, n, mm, vl_r, mm+2, vl_i, ldvl );
}
if( LAPACKE_lsame( job, 'b' ) || LAPACKE_lsame( job, 'r' ) ) {
LAPACKE_zge_trans( LAPACK_ROW_MAJOR, n, mm, vr_r, mm+2, vr_i, ldvr );
}
failed = compare_zhsein( w, w_i, vl, vl_i, vr, vr_i, m, m_i, ifaill,
ifaill_i, ifailr, ifailr_i, info, info_i, job,
ldvl, ldvr, mm, n );
if( failed == 0 ) {
printf( "PASSED: row-major high-level interface to zhsein\n" );
} else {
printf( "FAILED: row-major high-level interface to zhsein\n" );
}
/* Release memory */
if( select != NULL ) {
LAPACKE_free( select );
}
if( select_i != NULL ) {
LAPACKE_free( select_i );
}
if( h != NULL ) {
LAPACKE_free( h );
}
if( h_i != NULL ) {
LAPACKE_free( h_i );
}
if( h_r != NULL ) {
LAPACKE_free( h_r );
}
if( w != NULL ) {
LAPACKE_free( w );
}
if( w_i != NULL ) {
LAPACKE_free( w_i );
}
if( w_save != NULL ) {
LAPACKE_free( w_save );
}
if( vl != NULL ) {
LAPACKE_free( vl );
}
if( vl_i != NULL ) {
LAPACKE_free( vl_i );
}
if( vl_r != NULL ) {
LAPACKE_free( vl_r );
}
if( vl_save != NULL ) {
LAPACKE_free( vl_save );
}
if( vr != NULL ) {
LAPACKE_free( vr );
}
if( vr_i != NULL ) {
LAPACKE_free( vr_i );
}
if( vr_r != NULL ) {
LAPACKE_free( vr_r );
}
if( vr_save != NULL ) {
LAPACKE_free( vr_save );
}
if( work != NULL ) {
LAPACKE_free( work );
}
if( work_i != NULL ) {
LAPACKE_free( work_i );
}
if( rwork != NULL ) {
LAPACKE_free( rwork );
}
if( rwork_i != NULL ) {
LAPACKE_free( rwork_i );
}
if( ifaill != NULL ) {
LAPACKE_free( ifaill );
}
if( ifaill_i != NULL ) {
LAPACKE_free( ifaill_i );
}
if( ifaill_save != NULL ) {
LAPACKE_free( ifaill_save );
}
if( ifailr != NULL ) {
LAPACKE_free( ifailr );
}
if( ifailr_i != NULL ) {
LAPACKE_free( ifailr_i );
}
if( ifailr_save != NULL ) {
LAPACKE_free( ifailr_save );
}
return 0;
}
void select_glDrawElements(const pointer_state_t* vtx, GLenum mode, GLuint count, GLenum type, GLvoid * indices) {
if (count == 0) return;
if (vtx->pointer == NULL) return;
GLushort *ind = (GLushort*)indices;
GLsizei min, max;
getminmax_indices(indices, &max, &min, count);
max++;
GLfloat *vert = copy_gl_array(vtx->pointer, vtx->type,
vtx->size, vtx->stride,
GL_FLOAT, 3, 0, max);
GLfloat tmp[3];
init_select();
GLfloat zmin=1.0f, zmax=0.0f;
for (int i=min; i<max; i++) {
select_transform(vert+i*3);
if (vert[i*3+2]<zmin) zmin=vert[i*3+2];
if (vert[i*3+2]>zmax) zmax=vert[i*3+2];
}
if (zmin<0.0f) zmin = 0.0f;
if (zmax>1.0f) zmax = 1.0f;
#define FOUND() { \
if (zmin<state.selectbuf.zmin) state.selectbuf.zmin=zmin; \
if (zmax>state.selectbuf.zmax) state.selectbuf.zmax=zmax; \
state.selectbuf.hit = 1; \
free(vert); \
return; \
}
for (int i=0; i<count; i++) {
switch (mode) {
case GL_POINTS:
if (select_point_in_viewscreen(vert+ind[i]*3))
FOUND();
break;
case GL_LINES:
if (i%2==1) {
if (select_segment_in_viewscreen(vert+ind[(i-1)]*3, vert+ind[i]*3))
FOUND();
}
break;
case GL_LINE_STRIP:
case GL_LINE_LOOP: //FIXME: the last "loop" segment is missing here
if (i>0) {
if (select_segment_in_viewscreen(vert+ind[(i-1)]*3, vert+ind[i]*3))
FOUND();
}
break;
case GL_TRIANGLES:
if (i%3==2) {
if (select_triangle_in_viewscreen(vert+ind[(i-2)]*3, vert+ind[(i-1)]*3, vert+ind[i]*3))
FOUND();
}
break;
case GL_TRIANGLE_STRIP:
if (i>1) {
if (select_triangle_in_viewscreen(vert+ind[(i-2)]*3, vert+ind[(i-1)]*3, vert+ind[i]*3))
FOUND();
}
break;
case GL_TRIANGLE_FAN:
if (i>1) {
if (select_triangle_in_viewscreen(vert+ind[0]*3, vert+ind[(i-1)]*3, vert+ind[i]*3))
FOUND();
}
break;
default:
return; // Should never go there!
}
}
free(vert);
#undef FOUND
}
void select_glDrawArrays(const pointer_state_t* vtx, GLenum mode, GLuint first, GLuint count) {
if (count == 0) return;
if (vtx->pointer == NULL) return;
if (state.selectbuf.buffer == NULL) return;
GLfloat *vert = copy_gl_array(vtx->pointer, vtx->type,
vtx->size, vtx->stride,
GL_FLOAT, 3, 0, count+first);
GLfloat tmp[3];
GLfloat zmin=1.0f, zmax=0.0f;
init_select();
#define FOUND() { \
if (zmin<state.selectbuf.zmin) state.selectbuf.zmin=zmin; \
if (zmax>state.selectbuf.zmax) state.selectbuf.zmax=zmax; \
state.selectbuf.hit = 1; \
free(vert); \
return; \
}
// transform the points
for (int i=first; i<count+first; i++) {
select_transform(vert+i*3);
if (vert[i*3+2]<zmin) zmin=vert[i*3+2];
if (vert[i*3+2]>zmax) zmax=vert[i*3+2];
}
// intersect with screen now
GLfloat *vert2 = vert + first*3;
for (int i=0; i<count; i++) {
switch (mode) {
case GL_POINTS:
if (select_point_in_viewscreen(vert2+i*3))
FOUND();
break;
case GL_LINES:
if (i%2==1) {
if (select_segment_in_viewscreen(vert2+(i-1)*3, vert2+i*3))
FOUND();
}
break;
case GL_LINE_STRIP:
case GL_LINE_LOOP: //FIXME: the last "loop" segment is missing here
if (i>0) {
if (select_segment_in_viewscreen(vert2+(i-1)*3, vert2+i*3))
FOUND();
}
break;
case GL_TRIANGLES:
if (i%3==2) {
if (select_triangle_in_viewscreen(vert2+(i-2)*3, vert2+(i-1)*3, vert2+i*3))
FOUND();
}
break;
case GL_TRIANGLE_STRIP:
if (i>1) {
if (select_triangle_in_viewscreen(vert2+(i-2)*3, vert2+(i-1)*3, vert2+i*3))
FOUND();
}
break;
case GL_TRIANGLE_FAN:
if (i>1) {
if (select_triangle_in_viewscreen(vert2, vert2+(i-1)*3, vert2+i*3))
FOUND();
}
break;
default:
return; // Should never go there!
}
}
free(vert);
#undef FOUND
}
/*===========================================================================*
* sef_cb_init_fresh *
*===========================================================================*/
static int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *info)
{
/* Initialize the virtual file server. */
int s, i;
struct fproc *rfp;
message mess;
struct rprocpub rprocpub[NR_BOOT_PROCS];
self = NULL;
verbose = 0;
/* Initialize proc endpoints to NONE */
for (rfp = &fproc[0]; rfp < &fproc[NR_PROCS]; rfp++) {
rfp->fp_endpoint = NONE;
rfp->fp_pid = PID_FREE;
}
/* Initialize the process table with help of the process manager messages.
* Expect one message for each system process with its slot number and pid.
* When no more processes follow, the magic process number NONE is sent.
* Then, stop and synchronize with the PM.
*/
do {
if ((s = sef_receive(PM_PROC_NR, &mess)) != OK)
panic("VFS: couldn't receive from PM: %d", s);
if (mess.m_type != VFS_PM_INIT)
panic("unexpected message from PM: %d", mess.m_type);
if (NONE == mess.VFS_PM_ENDPT) break;
rfp = &fproc[mess.VFS_PM_SLOT];
rfp->fp_flags = FP_NOFLAGS;
rfp->fp_pid = mess.VFS_PM_PID;
rfp->fp_endpoint = mess.VFS_PM_ENDPT;
rfp->fp_grant = GRANT_INVALID;
rfp->fp_blocked_on = FP_BLOCKED_ON_NONE;
rfp->fp_realuid = (uid_t) SYS_UID;
rfp->fp_effuid = (uid_t) SYS_UID;
rfp->fp_realgid = (gid_t) SYS_GID;
rfp->fp_effgid = (gid_t) SYS_GID;
rfp->fp_umask = ~0;
} while (TRUE); /* continue until process NONE */
mess.m_type = OK; /* tell PM that we succeeded */
s = ipc_send(PM_PROC_NR, &mess); /* send synchronization message */
system_hz = sys_hz();
/* Subscribe to block and character driver events. */
s = ds_subscribe("drv\\.[bc]..\\..*", DSF_INITIAL | DSF_OVERWRITE);
if (s != OK) panic("VFS: can't subscribe to driver events (%d)", s);
/* Initialize worker threads */
worker_init();
/* Initialize global locks */
if (mthread_mutex_init(&bsf_lock, NULL) != 0)
panic("VFS: couldn't initialize block special file lock");
init_dmap(); /* Initialize device table. */
/* Map all the services in the boot image. */
if ((s = sys_safecopyfrom(RS_PROC_NR, info->rproctab_gid, 0,
(vir_bytes) rprocpub, sizeof(rprocpub))) != OK){
panic("sys_safecopyfrom failed: %d", s);
}
for (i = 0; i < NR_BOOT_PROCS; i++) {
if (rprocpub[i].in_use) {
if ((s = map_service(&rprocpub[i])) != OK) {
panic("VFS: unable to map service: %d", s);
}
}
}
/* Initialize locks and initial values for all processes. */
for (rfp = &fproc[0]; rfp < &fproc[NR_PROCS]; rfp++) {
if (mutex_init(&rfp->fp_lock, NULL) != 0)
panic("unable to initialize fproc lock");
rfp->fp_worker = NULL;
#if LOCK_DEBUG
rfp->fp_vp_rdlocks = 0;
rfp->fp_vmnt_rdlocks = 0;
#endif
/* Initialize process directories. mount_fs will set them to the
* correct values.
*/
for (i = 0; i < OPEN_MAX; i++)
rfp->fp_filp[i] = NULL;
rfp->fp_rd = NULL;
rfp->fp_wd = NULL;
}
init_vnodes(); /* init vnodes */
init_vmnts(); /* init vmnt structures */
init_select(); /* init select() structures */
init_filps(); /* Init filp structures */
/* Mount PFS and initial file system root. */
worker_start(fproc_addr(VFS_PROC_NR), do_init_root, &mess /*unused*/,
FALSE /*use_spare*/);
return(OK);
}
void select_glDrawElements(const pointer_state_t* vtx, GLenum mode, GLuint count, GLenum type, GLvoid * indices) {
if (count == 0) return;
if (vtx->pointer == NULL) return;
GLushort *ind = (GLushort*)indices;
GLsizei min, max;
getminmax_indices(indices, &max, &min, count);
max++;
GLfloat *vert = copy_gl_array(vtx->pointer, vtx->type,
vtx->size, vtx->stride,
GL_FLOAT, 4, 0, max);
init_select();
GLfloat zmin=1e10f, zmax=-10e6f;
int found = 0;
for (int i=min; i<max; i++) {
select_transform(vert+i*4);
ZMinMax(&glstate->selectbuf.zminoverall, &glstate->selectbuf.zmaxoverall, vert+i*4);
}
#define FOUND() { \
found = 1; \
glstate->selectbuf.hit = 1; \
}
for (int i=0; i<count; i++) {
switch (mode) {
case GL_POINTS:
if (select_point_in_viewscreen(vert+ind[i]*4)) {
ZMinMax(&zmin, &zmax, vert+ind[i]*4);
FOUND();
}
break;
case GL_LINES:
if (i%2==1) {
if (select_segment_in_viewscreen(vert+ind[(i-1)]*4, vert+ind[i]*4)) {
ZMinMax(&zmin, &zmax, vert+ind[i-1]*4);
ZMinMax(&zmin, &zmax, vert+ind[i]*4);
FOUND();
}
}
break;
case GL_LINE_STRIP:
case GL_LINE_LOOP: //FIXME: the last "loop" segment is missing here
if (i>0) {
if (select_segment_in_viewscreen(vert+ind[(i-1)]*4, vert+ind[i]*4)) {
ZMinMax(&zmin, &zmax, vert+ind[i-1]*4);
ZMinMax(&zmin, &zmax, vert+ind[i]*4);
FOUND();
}
}
break;
case GL_TRIANGLES:
if (i%3==2) {
if (select_triangle_in_viewscreen(vert+ind[(i-2)]*4, vert+ind[(i-1)]*4, vert+ind[i]*4)) {
ZMinMax(&zmin, &zmax, vert+ind[i-2]*4);
ZMinMax(&zmin, &zmax, vert+ind[i-1]*4);
ZMinMax(&zmin, &zmax, vert+ind[i]*4);
FOUND();
}
}
break;
case GL_TRIANGLE_STRIP:
if (i>1) {
if (select_triangle_in_viewscreen(vert+ind[(i-2)]*4, vert+ind[(i-1)]*4, vert+ind[i]*4)) {
ZMinMax(&zmin, &zmax, vert+ind[i-2]*4);
ZMinMax(&zmin, &zmax, vert+ind[i-1]*4);
ZMinMax(&zmin, &zmax, vert+ind[i]*4);
FOUND();
}
}
break;
case GL_TRIANGLE_FAN:
if (i>1) {
if (select_triangle_in_viewscreen(vert+ind[0]*4, vert+ind[(i-1)]*4, vert+ind[i]*4))
ZMinMax(&zmin, &zmax, vert+ind[0]*4);
ZMinMax(&zmin, &zmax, vert+ind[i-1]*4);
ZMinMax(&zmin, &zmax, vert+ind[i]*4);
FOUND();
}
break;
default:
return; // Should never go there!
}
}
free(vert);
if(found) {
if (zmin<glstate->selectbuf.zmin) glstate->selectbuf.zmin=zmin;
if (zmax>glstate->selectbuf.zmax) glstate->selectbuf.zmax=zmax;
}
#undef FOUND
}
void select_glDrawArrays(const pointer_state_t* vtx, GLenum mode, GLuint first, GLuint count) {
if (count == 0) return;
if (vtx->pointer == NULL) return;
if (glstate->selectbuf.buffer == NULL) return;
GLfloat *vert = copy_gl_array(vtx->pointer, vtx->type,
vtx->size, vtx->stride,
GL_FLOAT, 4, 0, count+first);
GLfloat zmin=1e10f, zmax=-1e10f;
init_select();
int found = 0;
#define FOUND() { \
found = 1; \
glstate->selectbuf.hit = 1; \
}
// transform the points
for (int i=first; i<count+first; i++) {
select_transform(vert+i*4);
ZMinMax(&glstate->selectbuf.zminoverall, &glstate->selectbuf.zmaxoverall, vert+i*4);
}
// intersect with screen now
GLfloat *vert2 = vert + first*4;
for (int i=0; i<count; i++) {
switch (mode) {
case GL_POINTS:
if (select_point_in_viewscreen(vert2+i*4)) {
ZMinMax(&zmin, &zmax, vert+i*4);
FOUND();
}
break;
case GL_LINES:
if (i%2==1) {
if (select_segment_in_viewscreen(vert2+(i-1)*4, vert2+i*4)) {
ZMinMax(&zmin, &zmax, vert+(i-1)*4);
ZMinMax(&zmin, &zmax, vert+i*4);
FOUND();
}
}
break;
case GL_LINE_STRIP:
case GL_LINE_LOOP: //FIXME: the last "loop" segment is missing here
if (i>0) {
if (select_segment_in_viewscreen(vert2+(i-1)*4, vert2+i*4)) {
ZMinMax(&zmin, &zmax, vert+(i-1)*4);
ZMinMax(&zmin, &zmax, vert+i*4);
FOUND();
}
}
break;
case GL_TRIANGLES:
if (i%3==2) {
if (select_triangle_in_viewscreen(vert2+(i-2)*4, vert2+(i-1)*4, vert2+i*4)) {
ZMinMax(&zmin, &zmax, vert+(i-2)*4);
ZMinMax(&zmin, &zmax, vert+(i-1)*4);
ZMinMax(&zmin, &zmax, vert+i*4);
FOUND();
}
}
break;
case GL_TRIANGLE_STRIP:
if (i>1) {
if (select_triangle_in_viewscreen(vert2+(i-2)*4, vert2+(i-1)*4, vert2+i*4)) {
ZMinMax(&zmin, &zmax, vert+(i-2)*4);
ZMinMax(&zmin, &zmax, vert+(i-1)*4);
ZMinMax(&zmin, &zmax, vert+i*4);
FOUND();
}
}
break;
case GL_TRIANGLE_FAN:
if (i>1) {
if (select_triangle_in_viewscreen(vert2, vert2+(i-1)*4, vert2+i*4)) {
ZMinMax(&zmin, &zmax, vert);
ZMinMax(&zmin, &zmax, vert+(i-1)*4);
ZMinMax(&zmin, &zmax, vert+i*4);
FOUND();
}
}
break;
default:
return; // Should never go there!
}
}
free(vert);
if(found) {
if (zmin<glstate->selectbuf.zmin) glstate->selectbuf.zmin=zmin;
if (zmax>glstate->selectbuf.zmax) glstate->selectbuf.zmax=zmax;
}
#undef FOUND
}
/*!
* \brief initializes the static vars/arrays
* \param h - pointer to the io_wait_h that will be initialized
* \param max_fd - maximum allowed fd number
* \param poll_method - poll method (0 for automatic best fit)
*/
int init_io_wait(io_wait_h* h, char *name, int max_fd,
enum poll_types poll_method, int max_prio)
{
char * poll_err;
memset(h, 0, sizeof(*h));
h->name = name;
h->max_prio = max_prio;
h->max_fd_no=max_fd;
#ifdef HAVE_EPOLL
h->epfd=-1;
#endif
#ifdef HAVE_KQUEUE
h->kq_fd=-1;
#endif
#ifdef HAVE_DEVPOLL
h->dpoll_fd=-1;
#endif
poll_err=check_poll_method(poll_method);
/* set an appropiate poll method */
if (poll_err || (poll_method==0)){
poll_method=choose_poll_method();
if (poll_err){
LM_ERR("%s, using %s instead\n",
poll_err, poll_method_str[poll_method]);
}else{
LM_INFO("using %s as the io watch method"
" (auto detected)\n", poll_method_str[poll_method]);
}
}
h->poll_method=poll_method;
/* common stuff, everybody has fd_hash */
h->fd_hash=local_malloc(sizeof(*(h->fd_hash))*h->max_fd_no);
if (h->fd_hash==0){
LM_CRIT("could not alloc fd hashtable (%ld bytes)\n",
(long)sizeof(*(h->fd_hash))*h->max_fd_no );
goto error;
}
memset((void*)h->fd_hash, 0, sizeof(*(h->fd_hash))*h->max_fd_no);
/* init the fd array as needed for priority ordering */
h->fd_array=local_malloc(sizeof(*(h->fd_array))*h->max_fd_no);
if (h->fd_array==0){
LM_CRIT("could not alloc fd array (%ld bytes)\n",
(long)sizeof(*(h->fd_hash))*h->max_fd_no);
goto error;
}
memset((void*)h->fd_array, 0, sizeof(*(h->fd_array))*h->max_fd_no);
/* array with indexes in fd_array where the priority changes */
h->prio_idx=local_malloc(sizeof(*(h->prio_idx))*h->max_prio);
if (h->prio_idx==0){
LM_CRIT("could not alloc fd array (%ld bytes)\n",
(long)sizeof(*(h->prio_idx))*h->max_prio);
goto error;
}
memset((void*)h->prio_idx, 0, sizeof(*(h->prio_idx))*h->max_prio);
switch(poll_method){
case POLL_POLL:
break;
#ifdef HAVE_SELECT
case POLL_SELECT:
if ((poll_method==POLL_SELECT) && (init_select(h)<0)){
LM_CRIT("select init failed\n");
goto error;
}
break;
#endif
#ifdef HAVE_DEVPOLL
case POLL_DEVPOLL:
if ((poll_method==POLL_DEVPOLL) && (init_devpoll(h)<0)){
LM_CRIT("/dev/poll init failed\n");
goto error;
}
h->dp_changes=local_malloc(sizeof(*(h->dp_changes))*h->max_fd_no);
if (h->dp_changes==0){
LM_CRIT("could not alloc db changes array (%ld bytes)\n",
(long)sizeof(*(h->dp_changes))*h->max_fd_no);
goto error;
}
memset((void*)h->dp_changes, 0,
sizeof(*(h->dp_changes))*h->max_fd_no);
break;
#endif
#ifdef HAVE_SIGIO_RT
case POLL_SIGIO_RT:
if ((poll_method==POLL_SIGIO_RT) && (init_sigio(h, 0)<0)){
LM_CRIT("sigio init failed\n");
goto error;
}
break;
#endif
#ifdef HAVE_EPOLL
case POLL_EPOLL_LT:
case POLL_EPOLL_ET:
h->ep_array=local_malloc(sizeof(*(h->ep_array))*h->max_fd_no);
if (h->ep_array==0){
LM_CRIT("could not alloc epoll array\n");
goto error;
}
memset((void*)h->ep_array, 0, sizeof(*(h->ep_array))*h->max_fd_no);
if (init_epoll(h)<0){
LM_CRIT("epoll init failed\n");
goto error;
}
break;
#endif
#ifdef HAVE_KQUEUE
case POLL_KQUEUE:
h->kq_array=local_malloc(sizeof(*(h->kq_array))*h->max_fd_no);
if (h->kq_array==0){
LM_CRIT("could not alloc kqueue event array\n");
goto error;
}
h->kq_changes_size=KQ_CHANGES_ARRAY_SIZE;
h->kq_changes=local_malloc(sizeof(*(h->kq_changes))*
h->kq_changes_size);
if (h->kq_changes==0){
LM_CRIT("could not alloc kqueue changes array\n");
goto error;
}
h->kq_nchanges=0;
memset((void*)h->kq_array, 0, sizeof(*(h->kq_array))*h->max_fd_no);
memset((void*)h->kq_changes, 0,
sizeof(*(h->kq_changes))* h->kq_changes_size);
if (init_kqueue(h)<0){
LM_CRIT("kqueue init failed\n");
goto error;
}
break;
#endif
default:
LM_CRIT("unknown/unsupported poll method %s (%d)\n",
poll_method_str[poll_method], poll_method);
goto error;
}
return 0;
error:
return -1;
}
/*!
* \brief initializes the static vars/arrays
* \param h - pointer to the io_wait_h that will be initialized
* \param max_fd - maximum allowed fd number
* \param poll_method - poll method (0 for automatic best fit)
*/
int init_io_wait(io_wait_h* h, char *name, int max_fd,
enum poll_types poll_method, int async)
{
char * poll_err;
memset(h, 0, sizeof(*h));
h->name = name;
h->max_fd_no=max_fd;
#ifdef HAVE_EPOLL
h->epfd=-1;
#endif
#ifdef HAVE_KQUEUE
h->kq_fd=-1;
#endif
#ifdef HAVE_DEVPOLL
h->dpoll_fd=-1;
#endif
poll_err=check_poll_method(poll_method);
/* set an appropiate poll method */
if (poll_err || (poll_method==0)){
poll_method=choose_poll_method();
if (poll_err){
LM_ERR("%s, using %s instead\n",
poll_err, poll_method_str[poll_method]);
}else{
LM_INFO("using %s as the io watch method"
" (auto detected)\n", poll_method_str[poll_method]);
}
}
h->poll_method=poll_method;
if (h->poll_method != POLL_POLL && h->poll_method != POLL_EPOLL_LT &&
h->poll_method != POLL_EPOLL_ET) {
if (async)
LM_WARN("Tried to enable async polling but current poll method is %d."
" Currently we only support POLL and EPOLL \n",h->poll_method);
async=0;
}
/* common stuff, everybody has fd_hash */
h->fd_hash=local_malloc(sizeof(*(h->fd_hash))*h->max_fd_no);
if (h->fd_hash==0){
LM_CRIT("could not alloc fd hashtable (%ld bytes)\n",
(long)sizeof(*(h->fd_hash))*h->max_fd_no );
goto error;
}
memset((void*)h->fd_hash, 0, sizeof(*(h->fd_hash))*h->max_fd_no);
switch(poll_method){
case POLL_POLL:
#ifdef HAVE_SELECT
case POLL_SELECT:
#endif
#ifdef HAVE_SIGIO_RT
case POLL_SIGIO_RT:
#endif
#ifdef HAVE_DEVPOLL
case POLL_DEVPOLL:
#endif
h->fd_array=local_malloc(sizeof(*(h->fd_array))*h->max_fd_no);
if (h->fd_array==0){
LM_CRIT("could not alloc fd array (%ld bytes)\n",
(long)sizeof(*(h->fd_hash))*h->max_fd_no);
goto error;
}
memset((void*)h->fd_array, 0, sizeof(*(h->fd_array))*h->max_fd_no);
#ifdef HAVE_SIGIO_RT
if ((poll_method==POLL_SIGIO_RT) && (init_sigio(h, 0)<0)){
LM_CRIT("sigio init failed\n");
goto error;
}
#endif
#ifdef HAVE_DEVPOLL
if ((poll_method==POLL_DEVPOLL) && (init_devpoll(h)<0)){
LM_CRIT("/dev/poll init failed\n");
goto error;
}
#endif
#ifdef HAVE_SELECT
if ((poll_method==POLL_SELECT) && (init_select(h)<0)){
LM_CRIT("select init failed\n");
goto error;
}
#endif
break;
#ifdef HAVE_EPOLL
case POLL_EPOLL_LT:
case POLL_EPOLL_ET:
h->ep_array=local_malloc(sizeof(*(h->ep_array))*h->max_fd_no);
if (h->ep_array==0){
LM_CRIT("could not alloc epoll array\n");
goto error;
}
memset((void*)h->ep_array, 0, sizeof(*(h->ep_array))*h->max_fd_no);
if (init_epoll(h)<0){
LM_CRIT("epoll init failed\n");
goto error;
}
break;
#endif
#ifdef HAVE_KQUEUE
case POLL_KQUEUE:
h->kq_array=local_malloc(sizeof(*(h->kq_array))*h->max_fd_no);
if (h->kq_array==0){
LM_CRIT("could not alloc kqueue event array\n");
goto error;
}
h->kq_changes_size=KQ_CHANGES_ARRAY_SIZE;
h->kq_changes=local_malloc(sizeof(*(h->kq_changes))*
h->kq_changes_size);
if (h->kq_changes==0){
LM_CRIT("could not alloc kqueue changes array\n");
goto error;
}
h->kq_nchanges=0;
memset((void*)h->kq_array, 0, sizeof(*(h->kq_array))*h->max_fd_no);
memset((void*)h->kq_changes, 0,
sizeof(*(h->kq_changes))* h->kq_changes_size);
if (init_kqueue(h)<0){
LM_CRIT("kqueue init failed\n");
goto error;
}
break;
#endif
default:
LM_CRIT("unknown/unsupported poll method %s (%d)\n",
poll_method_str[poll_method], poll_method);
goto error;
}
return 0;
error:
return -1;
}
/* initializes the static vars/arrays
* params: h - pointer to the io_wait_h that will be initialized
* max_fd - maximum allowed fd number
* poll_m - poll method (0 for automatic best fit)
*/
int init_io_wait(io_wait_h* h, int max_fd, enum poll_types poll_method)
{
char * poll_err;
if (_os_ver==0) _os_ver=get_sys_version(0,0,0);
memset(h, 0, sizeof(*h));
h->max_fd_no=max_fd;
#ifdef HAVE_EPOLL
h->epfd=-1;
#endif
#ifdef HAVE_KQUEUE
h->kq_fd=-1;
#endif
#ifdef HAVE_DEVPOLL
h->dpoll_fd=-1;
#endif
poll_err=check_poll_method(poll_method);
/* set an appropiate poll method */
if (poll_err || (poll_method==0)){
poll_method=choose_poll_method();
if (poll_err){
LOG(L_ERR, "ERROR: init_io_wait: %s, using %s instead\n",
poll_err, poll_method_str[poll_method]);
}else{
LOG(L_INFO, "init_io_wait: using %s as the io watch method"
" (auto detected)\n", poll_method_str[poll_method]);
}
}
h->poll_method=poll_method;
/* common stuff, everybody has fd_hash */
h->fd_hash=local_malloc(sizeof(*(h->fd_hash))*h->max_fd_no);
if (h->fd_hash==0){
LOG(L_CRIT, "ERROR: init_io_wait: could not alloc"
" fd hashtable (%ld bytes)\n",
(long)sizeof(*(h->fd_hash))*h->max_fd_no );
goto error;
}
memset((void*)h->fd_hash, 0, sizeof(*(h->fd_hash))*h->max_fd_no);
switch(poll_method){
case POLL_POLL:
#ifdef HAVE_SELECT
case POLL_SELECT:
#endif
#ifdef HAVE_SIGIO_RT
case POLL_SIGIO_RT:
#endif
#ifdef HAVE_DEVPOLL
case POLL_DEVPOLL:
#endif
h->fd_array=local_malloc(sizeof(*(h->fd_array))*h->max_fd_no);
if (h->fd_array==0){
LOG(L_CRIT, "ERROR: init_io_wait: could not"
" alloc fd array (%ld bytes)\n",
(long)sizeof(*(h->fd_hash))*h->max_fd_no);
goto error;
}
memset((void*)h->fd_array, 0, sizeof(*(h->fd_array))*h->max_fd_no);
#ifdef HAVE_SIGIO_RT
if ((poll_method==POLL_SIGIO_RT) && (init_sigio(h, 0)<0)){
LOG(L_CRIT, "ERROR: init_io_wait: sigio init failed\n");
goto error;
}
#endif
#ifdef HAVE_DEVPOLL
if ((poll_method==POLL_DEVPOLL) && (init_devpoll(h)<0)){
LOG(L_CRIT, "ERROR: init_io_wait: /dev/poll init failed\n");
goto error;
}
#endif
#ifdef HAVE_SELECT
if ((poll_method==POLL_SELECT) && (init_select(h)<0)){
LOG(L_CRIT, "ERROR: init_io_wait: select init failed\n");
goto error;
}
#endif
break;
#ifdef HAVE_EPOLL
case POLL_EPOLL_LT:
case POLL_EPOLL_ET:
h->ep_array=local_malloc(sizeof(*(h->ep_array))*h->max_fd_no);
if (h->ep_array==0){
LOG(L_CRIT, "ERROR: init_io_wait: could not alloc"
" epoll array\n");
goto error;
}
memset((void*)h->ep_array, 0, sizeof(*(h->ep_array))*h->max_fd_no);
if (init_epoll(h)<0){
LOG(L_CRIT, "ERROR: init_io_wait: epoll init failed\n");
goto error;
}
break;
#endif
#ifdef HAVE_KQUEUE
case POLL_KQUEUE:
h->kq_array=local_malloc(sizeof(*(h->kq_array))*h->max_fd_no);
if (h->kq_array==0){
LOG(L_CRIT, "ERROR: init_io_wait: could not alloc"
" kqueue event array\n");
goto error;
}
h->kq_changes_size=KQ_CHANGES_ARRAY_SIZE;
h->kq_changes=local_malloc(sizeof(*(h->kq_changes))*
h->kq_changes_size);
if (h->kq_changes==0){
LOG(L_CRIT, "ERROR: init_io_wait: could not alloc"
" kqueue changes array\n");
goto error;
}
h->kq_nchanges=0;
memset((void*)h->kq_array, 0, sizeof(*(h->kq_array))*h->max_fd_no);
memset((void*)h->kq_changes, 0,
sizeof(*(h->kq_changes))* h->kq_changes_size);
if (init_kqueue(h)<0){
LOG(L_CRIT, "ERROR: init_io_wait: kqueue init failed\n");
goto error;
}
break;
#endif
default:
LOG(L_CRIT, "BUG: init_io_wait: unknown/unsupported poll"
" method %s (%d)\n",
poll_method_str[poll_method], poll_method);
goto error;
}
return 0;
error:
return -1;
}
