int privsep_recv(struct io *io, struct msg *msg, struct msgbuf *msgbuf) { char *tmpbuf; if (msgbuf != NULL) { msgbuf->buf = NULL; msgbuf->len = 0; } if (io_wait(io, sizeof *msg, INFTIM, NULL) != 0) return (-1); if (io_read2(io, msg, sizeof *msg) != 0) return (-1); if (msg->size == 0) return (0); if (io_wait(io, msg->size, INFTIM, NULL) != 0) return (-1); if (msgbuf == NULL) { if ((tmpbuf = io_read(io, msg->size)) == NULL) return (-1); xfree(tmpbuf); } else { if ((msgbuf->buf = io_read(io, msg->size)) == NULL) return (-1); msgbuf->len = msg->size; } return (0); }
static void remap_pic(void) { u8 mask[2]; mask[0] = inb(0x21); mask[1] = inb(0xa1); outb(0x20, 0x11); outb(0xa0, 0x11); io_wait(); outb(0x21, 0x20); // map to interrupt range 0x20-0x27 outb(0xa1, 0x28); // map to interrupt range 0x28-0x2f io_wait(); outb(0x21, 4); // have slave at IRQ2 outb(0xa1, 2); // ping master through IRQ2 io_wait(); outb(0x21, 1); // 8086 mode outb(0xa1, 1); // ditto io_wait(); outb(0x21, mask[0]); outb(0xa1, mask[1]); io_wait(); }
void irq_handler(const interrupt_info_t info) { if (info.id >= INTERRUPT_IRQ_CMOS_CLOCK) { io_write_ui8(PIC_SLAVE_COMMAND, PIC_OCW2_EOI); io_wait(); } io_write_ui8(PIC_MASTER_COMMAND, PIC_OCW2_EOI); io_wait(); // Just handle stuff in the ISR handler. isr_handler(info); }
void pic_remap(int offset1, int offset2) { unsigned char a1, a2; a1 = inb(PIC1_DATA); // save masks a2 = inb(PIC2_DATA); outb(PIC1_COMMAND, ICW1_INIT+ICW1_ICW4); // starts the initialization sequence (in cascade mode) io_wait(); outb(PIC2_COMMAND, ICW1_INIT+ICW1_ICW4); io_wait(); outb(PIC1_DATA, offset1); // ICW2: Master PIC vector offset io_wait(); outb(PIC2_DATA, offset2); // ICW2: Slave PIC vector offset io_wait(); outb(PIC1_DATA, 4); // ICW3: tell Master PIC that there is a slave PIC at IRQ2 (0000 0100) io_wait(); outb(PIC2_DATA, 2); // ICW3: tell Slave PIC its cascade identity (0000 0010) io_wait(); outb(PIC1_DATA, ICW4_8086); io_wait(); outb(PIC2_DATA, ICW4_8086); io_wait(); outb(PIC1_DATA, a1); // restore saved masks. outb(PIC2_DATA, a2); }
void pic_remap(int offset1, int offset2) { unsigned char a1, a2; /* Save masks */ a1 = inportb(PIC1_DATA); a2 = inportb(PIC2_DATA); /* Start the init sequence in cascade mode */ outportb(PIC1_COMMAND, ICW1_INIT+ICW1_ICW4); io_wait(); outportb(PIC2_COMMAND, ICW1_INIT+ICW1_ICW4); io_wait(); /* ICW2: Master/Slave vector offsets */ outportb(PIC1_DATA, offset1); io_wait(); outportb(PIC2_DATA, offset2); io_wait(); /* ICW3: Inform Master of slave at IRQ2 */ outportb(PIC1_DATA, 4); io_wait(); /* ICW3: Tell slave its cascade identity */ outportb(PIC2_DATA, 2); io_wait(); outportb(PIC1_DATA, ICW4_8086); io_wait(); outportb(PIC2_DATA, ICW4_8086); io_wait(); /* Restore saved masks */ outportb(PIC1_DATA, a1); outportb(PIC2_DATA, a2); }
void PIC_remap(uint8_t offset1,uint8_t offset2){ unsigned char a1, a2; a1 = inb(PIC_MASTER_DATA_PORT); // save masks a2 = inb(PIC_SLAVE_DATA_PORT); outb(PIC_MASTER_CONTROL_PORT, ICW1_INIT+ICW1_ICW4); // starts the initialization sequence (in cascade mode) io_wait(); outb(PIC_SLAVE_CONTROL_PORT, ICW1_INIT+ICW1_ICW4); io_wait(); outb(PIC_MASTER_DATA_PORT, offset1); // ICW2: Master PIC vector offset io_wait(); outb(PIC_SLAVE_DATA_PORT, offset2); // ICW2: Slave PIC vector offset io_wait(); outb(PIC_MASTER_DATA_PORT, 4); // ICW3: tell Master PIC that there is a slave PIC at IRQ2 (0000 0100) io_wait(); outb(PIC_SLAVE_DATA_PORT, 2); // ICW3: tell Slave PIC its cascade identity (0000 0010) io_wait(); outb(PIC_MASTER_DATA_PORT, ICW4_8086); io_wait(); outb(PIC_SLAVE_DATA_PORT, ICW4_8086); io_wait(); outb(PIC_MASTER_DATA_PORT, a1); // restore saved masks. outb(PIC_SLAVE_DATA_PORT, a2); }
/* * arguments: * offset1 - vector offset for master PIC * vectors on the master become offset1...offset1+7 * offset2 - same for slave PIC: offset2...offset2+7 */ void PIC_remap(uint8_t master_offset, uint8_t slave_offset) { uint8_t master_mask; uint8_t slave_mask; master_mask = inb(PIC_MASTER_DATA);/* If no command was send the Data Port can be use to get the interrupt masks */ slave_mask = inb(PIC_SLAVE_DATA); outb(PIC_MASTER_COMMAND, ICW1_INIT+ICW1_ICW4); /* starts the initialization sequence (in cascade mode) */ io_wait(); outb(PIC_SLAVE_COMMAND, ICW1_INIT+ICW1_ICW4); io_wait(); outb(PIC_MASTER_DATA, master_offset); /* Set the offset of the master PIC */ io_wait(); outb(PIC_SLAVE_DATA, slave_offset); /* The same for the slave */ io_wait(); outb(PIC_MASTER_DATA, 4); /* Tell master PIC that there is a slave PIC at IQ2 (0000 0100) */ io_wait(); outb(PIC_SLAVE_DATA, 2); /* Tell slave PIC it's cascade identity (0000 0010) */ io_wait(); outb(PIC_MASTER_DATA, ICW4_8086); io_wait(); outb(PIC_SLAVE_DATA, ICW4_8086); io_wait(); outb(PIC_MASTER_DATA, master_mask); /* Restore the saved masks */ outb(PIC_SLAVE_DATA, slave_mask ); }
void pic_remap_irq_vector (int offset1, int offset2) { unsigned char a1, a2; a1 = inportb (PIC1_DATA); // save masks a2 = inportb (PIC2_DATA); outportb (PIC1_COMMAND, ICW1_INIT + ICW1_ICW4); io_wait (); outportb (PIC2_COMMAND, ICW1_INIT + ICW1_ICW4); io_wait (); outportb (PIC1_DATA, offset1); io_wait (); outportb (PIC2_DATA, offset2); io_wait (); outportb (PIC1_DATA, 4); io_wait (); outportb (PIC2_DATA, 2); io_wait (); outportb (PIC1_DATA, ICW4_8086); io_wait (); outportb (PIC2_DATA, ICW4_8086); io_wait (); /* Mask all irqs */ outportb (PIC1_DATA, 0xff); outportb (PIC2_DATA, 0xff); outportb (PIC1_DATA, a1); // restore saved masks. outportb (PIC2_DATA, a2); }
void pic_init() { u8 a1, a2; a1 = inb(0x21); // Save masks a2 = inb(0xa1); outb(0x20, 0x11); // Start the initialization sequence io_wait(); outb(0xa0, 0x11); io_wait(); outb(0x21, 0x20); // IRQ 0..7 -> INTR 0x20..0x27 io_wait(); outb(0xa1, 0x28); // IRG 8..15 -> INTR 0x28..0x2f io_wait(); outb(0x21, 4); io_wait(); outb(0xa1, 2); io_wait(); outb(0x21, 1); io_wait(); outb(0xa1, 1); io_wait(); outb(0x21, a1); // Restore masks outb(0x21, a2); }
void pit_init(unsigned int freq) { unsigned int divisor = 1193180 / freq; set_interrupt_handler(0x20, irq0); outb(0x43, 0x36); // repeat mode io_wait(); outb(0x40, divisor & 255); io_wait(); outb(0x40, divisor >> 8); io_wait(); }
static PyObject* read_fields(drizzle_con_st *con, drizzle_result_st *result) { int status = 1; size_t offset = 0, size = 0, total = 0; drizzle_return_t ret; drizzle_field_t field; while(status){ field = drizzle_field_read(result, &offset, &size, &total, &ret); if (ret == DRIZZLE_RETURN_ROW_END) { break; } status = io_wait(con, ret); if (status == -1){ goto error; } } if (field == NULL) { Py_RETURN_NONE; } else if (offset > 0) { } else { } if (field) { drizzle_field_free(field); } Py_RETURN_NONE; error: return NULL; }
int main(int argc, char **argv) { io_poller poller; // clear poller_type because init_poller uses it to see if the poller has been initialized. poller.poller_type = IO_POLLER_NONE; // Process the command line arguments // This causes an appropriate poller to be created, mock tests to be installed, etc. process_args(&poller, argc, argv); if(poller.poller_type == IO_POLLER_NONE) { // poller was not initialized probably because no arguments were specified. fprintf(stderr, "You must specify --client, --server or --mock.\n"); exit(1); } // Run the main event loop. for(;;) { if(io_wait(&poller, INT_MAX) < 0) { perror("io_wait"); } io_dispatch(&poller); } io_poller_dispose(&poller); return 0; }
int main() { int64 r; if (!io_fd(0)) return 111; if (!io_fd(1)) return 111; for (;;) { if (flageof && writepos >= readpos) return 0; if (!flageof && readpos < sizeof buf) io_wantread(0); if (writepos < readpos) io_wantwrite(1); io_wait(); if (!flageof && readpos < sizeof buf) io_dontwantread(0); if (writepos < readpos) io_dontwantwrite(1); if (!flageof && readpos < sizeof buf) { r = io_tryread(0,buf + readpos,sizeof buf - readpos); if (r <= -2) return 111; /* read error other than EAGAIN */ if (r == 0) flageof = 1; if (r > 0) readpos += r; } if (writepos < readpos) { r = io_trywrite(1,buf + writepos,readpos - writepos); if (r <= -2) return 111; /* write error other than EAGAIN */ if (r > 0) { writepos += r; if (writepos == readpos) readpos = writepos = 0; /* if writepos is big, might want to left-shift buffer here */ } } } }
static struct io_plan *r_done(struct io_conn *conn, struct data *d) { d->state++; if (d->state == 3) return io_close(conn); return io_wait(conn, NULL, io_never, NULL); }
static PyObject* ConnectionObject_autocommit(ConnectionObject *self, PyObject *args) { int flag, status = 1; char query[256]; drizzle_return_t ret; drizzle_result_st result; if (!PyArg_ParseTuple(args, "i", &flag)) { return NULL; } DEBUG("autocommit %d", flag); snprintf(query, 256, "SET AUTOCOMMIT=%d;", flag); BDEBUG("query %s", query); while(status){ (void)drizzle_query(self->con, &result, query, 256, &ret); status = io_wait(self->con, ret); if (status == -1){ goto error; } } drizzle_result_free(&result); Py_RETURN_NONE; error: drizzle_result_free(&result); PyErr_SetString(PyExc_IOError, drizzle_error(drizzle)); return NULL; }
static PyObject* get_desc(result_t *r, drizzle_con_st *con, drizzle_result_st *result) { int status = 1, desclen = 0; uint16_t size = 0; drizzle_return_t ret; drizzle_column_st column; drizzle_column_st *c; PyObject *c_info = NULL; PyObject *desc = NULL; drizzle_column_type_t *types = NULL; size = drizzle_result_column_count(result); DEBUG("column count:%d" , size); r->column_count = size; types = PyMem_Malloc(sizeof(drizzle_column_type_t) * size); if (types == NULL) { return NULL; } r->types = types; desc = PyTuple_New(size); if (desc == NULL) { return NULL; } while (1) { c = drizzle_column_read(result, &column, &ret); status = io_wait(con, ret); if (status == -1) { goto error; } if (c == NULL) { break; } else { c_info = get_column_desc(desclen, types, &column); if (c_info == NULL) { goto error; } PyTuple_SetItem(desc, desclen, c_info); c_info = NULL; drizzle_column_free(c); desclen++; } } return desc; error: if (c) { drizzle_column_free(c); } if (c_info) { Py_DECREF(c_info); } if (desc) { Py_DECREF(desc); } return NULL; }
int main(int argc, char **argv) { int sd; struct sockaddr_in sin; io_init(); printf("Opening listening socket...\n"); if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { perror("socket"); exit(1); } if(set_nonblock(sd) < 0) { perror("setnonblocking"); close(sd); exit(1); } memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_port = htons(PORT); sin.sin_addr.s_addr = htonl(INADDR_ANY); if(bind(sd, (struct sockaddr*)&sin, sizeof(sin)) < 0) { perror("bind"); close(sd); exit(1); } if (listen(sd, STD_LISTEN_SIZE) == -1) { perror("listen"); close(sd); exit(1); } g_accepter.fd = sd; g_accepter.proc = accept_proc; if(io_add(&g_accepter, IO_READ) < 0) { perror("io_add_main"); close(sd); exit(1); } printf("Listening on port %d, fd %d.\n", PORT, g_accepter.fd); for(;;) { io_wait(MAXINT); } io_exit(); return 0; }
static struct io_plan *read_json(struct io_conn *conn, struct json_connection *jcon) { jsmntok_t *toks; bool valid; log_io(jcon->log, true, jcon->buffer + jcon->used, jcon->len_read); /* Resize larger if we're full. */ jcon->used += jcon->len_read; if (jcon->used == tal_count(jcon->buffer)) tal_resize(&jcon->buffer, jcon->used * 2); again: toks = json_parse_input(jcon->buffer, jcon->used, &valid); if (!toks) { if (!valid) { log_unusual(jcon->dstate->base_log, "Invalid token in json input: '%.*s'", (int)jcon->used, jcon->buffer); return io_close(conn); } /* We need more. */ goto read_more; } /* Empty buffer? (eg. just whitespace). */ if (tal_count(toks) == 1) { jcon->used = 0; goto read_more; } parse_request(jcon, toks); /* Remove first {}. */ memmove(jcon->buffer, jcon->buffer + toks[0].end, tal_count(jcon->buffer) - toks[0].end); jcon->used -= toks[0].end; tal_free(toks); /* Need to wait for command to finish? */ if (jcon->current) { jcon->len_read = 0; return io_wait(conn, jcon, read_json, jcon); } /* See if we can parse the rest. */ goto again; read_more: tal_free(toks); return io_read_partial(conn, jcon->buffer + jcon->used, tal_count(jcon->buffer) - jcon->used, &jcon->len_read, read_json, jcon); }
//------------------------------------------------------------------------------------------------------------------------------- // // 读取硬盘分区信息函数 // //------------------------------------------------------------------------------------------------------------------------------- int ReadPartition(void) { int i = 0; int sector, head, cylinder; unsigned char buffer[512]; struct partition* p; #ifndef HD_BOOT_SECTOR #define HD_BOOT_SECTOR 0 #endif ConsolePrintf("Check the hard disk partition\n"); sector = HD_BOOT_SECTOR &0xff; cylinder = (HD_BOOT_SECTOR &0xffff00)>>8; head = (HD_BOOT_SECTOR &0xf000000)>>24; while(inb(HD_STATUS) & 0x80); io_wait(); outb(0,HD_CMD); outb(1,0x1f2); ///////////读写的扇区数.这个端口应该是:0X1F2,下面开始增加一 outb(HD_BOOT_SECTOR,0x1f3); ////////开始扇区 outb(cylinder,0x1f4); ///////开始柱面 outb(cylinder>>8,0x1f5); ///////开始柱面高位 outb(0xE0|(0 <<4)|head,0x1f6); /////主磁盘 outb(0x20,0x1F7); ////read命令 while(inb(HD_STATUS) & 0x80); insw(0x1F0, buffer, 256); if (buffer[510] != (unsigned char) 0x55 || buffer[511] != (unsigned char) 0xAA){ ConsolePrintFault(); ConsoleWarning(" read_partition(): Can't Read Harddisk(IDE) partition data\n"); return -1; } ConsolePrintOK(); for (i=1;i<5;i++) { p = (struct partition*)&buffer[0x1be + (i-1)*0x10]; //partition table offset after 446 byte. hd[i].start_sect = p->start_sec; // 从0算起的绝对扇区(分区表的起始扇区,不是FAT表的) hd[i].start_head=p->start_head; hd[i].start_cyl=p->start_cyl; hd[i].nr_sects = p->size; // 分区扇区总数 hd[i].flag = p->type; hd[i].lowsec = p->lowsec; hd[i].type = GetPartitionName( p->type); hd[i].name = 0x42+i; FindActivePartition(p, i); } ReadIDEInfo(); return 0; }
void irq_clear_mask(uint8_t irq){ uint16_t port; if(irq < 8){ port = MPIC_DAT_ADDR; } else { port = SPIC_DAT_ADDR; irq -= 8; } uint8_t value = inb(port) & ~(1 << irq); outb(port, value); io_wait(); }
bool Keyboard::waitForBuffer(uint8_t buffer, bool state) { int counter = 0; uint8_t status = 0x00; do { status = inb(0x64); io_wait(); counter++; if(counter > 16) return false; } while((status & buffer) != (state ? buffer : 0)); return true; }
void init_PIC() { //PIC1 Command: 0x20 data: 0x21 //PIC2 Command: 0xA0 data: 0xA1 //Send a 0x20 to the Command Port for EOI // //0x11 = initialize command // makes PIC wait for 3 more words // fist: vector offset // second: how it is wired to slave/master // third: environment info //Save the PIC masks unsigned char mask1, mask2; mask1 = inportb(PIC1_DATA); mask2 = inportb(PIC2_DATA); //initialize the PICs outportb(PIC1_COMMAND, PIC_INIT); io_wait(); outportb(PIC2_COMMAND, PIC_INIT); io_wait(); //set vector table offset!! outportb(PIC1_DATA, 32); io_wait(); outportb(PIC2_DATA, 40); io_wait(); //tell master there is a slave at irq2 outportb(PIC1_DATA, 4); io_wait(); //tell slave its cascade identity?? outportb(PIC2_DATA, 2); io_wait(); //put PICs into 8086 mode outportb(PIC1_DATA, 0x01); io_wait(); outportb(PIC2_DATA, 0x01); io_wait(); //restore the saved masks outportb(PIC1_DATA, mask1); outportb(PIC2_DATA, mask2); }
/* rimappa i PIC (programmable input controller) * offset_1: offset riferito alla IDT delle interruzioni per il primo PIC * offset_2: offset riferito alla IDT delle interruzioni per il PIC slave */ void irq_remap(unsigned int offset_1, unsigned int offset_2) { /* * PIC_P e' il PIC primario o "master" * PIC_S e' il PIC secondario o "slave" * * Quando si manifesta un IRQ che riguarda il PIC secondario, * il PIC primario riceve IRQ 2 * * ICW = initialization command word * OCW = operation command word */ /* Inizializzazione */ /* 0x10 significa che si sta' inizializzando */ /* 0x01 significa che si deve arrivare fino a ICW4 */ sendICW(0x11, 0x11, 0); io_wait(); /* ICW2: PIC_P a partire da "offset_1" */ /* PIC_S a partire da "offset_2" */ sendICW(offset_1, offset_2, 1); io_wait(); /* ICW3: PIC_P: IRQ2 per pilotare PIC_S */ /* PIC_S: pilotato con IRQ2 da PIC_P */ sendICW(0x04, 0x02, 1); io_wait(); /* ICW4: si precisa la modalita' del microprocessore; 0x01 = 8086 */ sendICW(0x01, 0x01, 1); io_wait(); /* OCW1: azzera la maschera in modo da abilitare tutti i numeri IRQ */ sendICW(0x00, 0x00, 1); io_wait(); }
static void init_conn(int fd, struct data *d) { int fd2; ok1(d->state == 0); d->state++; idler = io_new_conn(fd, io_wait(d, read_buf, d)); io_set_finish(idler, finish_idle, d); /* This will wake us up, as read will fail. */ fd2 = open("/dev/null", O_RDONLY); ok1(fd2 >= 0); io_set_finish(io_new_conn(fd2, io_read(idler, 1, never, NULL)), finish_waker, d); }
static struct io_plan *init_idle(struct io_conn *conn, struct data *d) { int fd2; ok1(d->state == 0); d->state++; idler = conn; io_set_finish(conn, finish_idle, d); /* This will wake us up, as read will fail. */ fd2 = open("/dev/null", O_RDONLY); ok1(fd2 >= 0); io_set_finish(io_new_conn(NULL, fd2, init_waker, d), finish_waker, d); return io_wait(conn, d, read_buf, d); }
/** * Main event loop for OpenVPN in client mode, where only one VPN tunnel * is active. * @ingroup eventloop * * @param c - The context structure of the single active VPN tunnel. */ static void tunnel_point_to_point(struct context *c) { context_clear_2(c); /* set point-to-point mode */ c->mode = CM_P2P; /* initialize tunnel instance */ init_instance_handle_signals(c, c->es, CC_HARD_USR1_TO_HUP); if (IS_SIG(c)) { return; } /* main event loop */ while (true) { perf_push(PERF_EVENT_LOOP); /* process timers, TLS, etc. */ pre_select(c); P2P_CHECK_SIG(); /* set up and do the I/O wait */ io_wait(c, p2p_iow_flags(c)); P2P_CHECK_SIG(); /* timeout? */ if (c->c2.event_set_status == ES_TIMEOUT) { perf_pop(); continue; } /* process the I/O which triggered select */ process_io(c); P2P_CHECK_SIG(); perf_pop(); } uninit_management_callback(); /* tear down tunnel instance (unless --persist-tun) */ close_instance(c); }
//------------------------------------------------------------------------------------------------------------------------------- // // 硬盘读写处理函数 // //------------------------------------------------------------------------------------------------------------------------------- void HardDiskRW(int RW, unsigned long sectors, void* buffer) { unsigned __eflag; int sector, head, cylinder; save_eflags(&__eflag); sector = sectors &0xff; cylinder = (sectors &0xffff00)>>8; head = (sectors &0xf000000)>>24; while(inb(HD_STATUS) & 0x80); io_wait(); outb(0,HD_CMD); outb(1,0x1f2); ///////////读写的扇区数.这个端口应该是:0X1F2,下面开始增加一 outb(sector,0x1f3); ////////开始扇区 outb(cylinder,0x1f4); ///////开始柱面 outb(cylinder>>8,0x1f5); ///////开始柱面高位 outb(0xE0|(0 <<4)|head,0x1f6); /////主磁盘 if (RW == READ) { ////read命令 outb(0x20,0x1F7); while(inb(HD_STATUS) & 0x80); insw(0x1F0, buffer, 256); } else if (RW == WRITE) { ////write命令 if (inb(HD_STATUS & 0x01)) { ConsoleWarning(" issue write_command command error !\n"); return; } outb(0x30,0x1F7); while((inb(HD_STATUS) & 0x08) == 0); //DRQ outsw(0x1F0, buffer, 256); } else { ConsoleWarning(" Panic:bad command:you only can read or write on harddisk!"); } restore_eflags(__eflag); return; }
static struct io_plan do_send_tx(struct io_conn *conn, struct generator *gen) { struct pending_update *u; assert(conn == gen->update); u = list_top(&gen->updates, struct pending_update, list); if (u) { log_debug(gen->log, "Sending transaction update shard %u off %u", u->update.shard, u->update.txoff); return io_write(&u->update, sizeof(u->update), tx_sent, gen); } log_debug(gen->log, "Sending transactions going idle %p", gen); return io_wait(gen, do_send_tx, gen); }
ATADEV_TYPE DISK::detect_device_type() { soft_reset(); if (m_master) outportb(m_bus + ATA_REG_HDDEVSEL, 0xA0); else outportb(m_bus + ATA_REG_HDDEVSEL, 0xB0); io_wait(); unsigned char cl = inportb(m_bus + ATA_REG_LBA1); /* CYL_LO */ unsigned char ch = inportb(m_bus + ATA_REG_LBA2); /* CYL_HI */ printf("ATA device type %02X%02X\n",ch,cl); /* differentiate ATA, ATAPI, SATA and SATAPI */ if (cl == 0x14 && ch == 0xEB) return ATADEV_PATAPI; if (cl == 0x69 && ch == 0x96) return ATADEV_SATAPI; if (cl == 0 && ch == 0) return ATADEV_PATA; if (cl == 0x3c && ch == 0xc3) return ATADEV_SATA; return ATADEV_UNKNOWN; }
static void server_mainloop( ) { static time_t ot_last_clean_time; time_t next_timeout_check = g_now + OT_CLIENT_TIMEOUT_CHECKINTERVAL; struct iovec *iovector; int iovec_entries; for( ; ; ) { int64 i; io_wait(); while( ( i = io_canread( ) ) != -1 ) { const void *cookie = io_getcookie( i ); if( cookie == FLAG_TCP ) handle_accept( i ); else if( cookie == FLAG_UDP ) handle_udp4( i ); else handle_read( i ); } while( ( i = mutex_workqueue_popresult( &iovec_entries, &iovector ) ) != -1 ) http_sendiovecdata( i, iovec_entries, iovector ); while( ( i = io_canwrite( ) ) != -1 ) handle_write( i ); if( g_now > next_timeout_check ) { while( ( i = io_timeouted() ) != -1 ) handle_dead( i ); next_timeout_check = g_now + OT_CLIENT_TIMEOUT_CHECKINTERVAL; } /* See if we need to move our pools */ if( NOW != ot_last_clean_time ) { ot_last_clean_time = NOW; clean_all_torrents(); } /* Enforce setting the clock */ signal_handler( SIGALRM ); } }