Channel TIDELog::writeCHAN(const std::string& name, const std::string& type, const std::string& source, const Array& source_spec, const Array& fmt_spec) { // argument checking check_bounds("name", 256, name.length()); check_bounds("type", 10, type.length()); check_bounds("source", 256, source.length()); check_bounds("source_spec", 256, source_spec.length); check_bounds("fmt_spec", UINT_MAX, fmt_spec.length); // header HEADER hdr(TAG_CHAN, 4 + 1 + name.length() + type.length() + 4 + source.length() + 4 + source_spec.length + 4 + fmt_spec.length + 4); write_checked<HEADER,HDR_SIZE>(hdr); // ID const uint32_t id = ++num_chans; check_io(1, fwrite(&id, sizeof(id), 1, logfile), "id"); // name write_checked(SArray(name.c_str(), name.length()), "name"); // type write_checked(Array(type.c_str(), type.length()), "type"); // human-readable source description write_checked(Array(source.c_str(), source.length()), "source"); // source string write_checked(source_spec, "spec"); // format spec write_checked(fmt_spec, "format"); fflush(logfile); return Channel(id, name, type, source, source_spec, fmt_spec); }
void clr(char** empty) { //fprintf(stdout,"HELLO!\n"); //empty character array pid_t pid; int status; strcpy(empty[0],"clear"); //printf("%s",empty[0]); switch(pid=fork()){ case -1: //syserr("fork"); case 0: //syserr("exec"); //fprintf(stdout,"arrives at exec: %s\n", empty[0]); //checks IO redirect check_io(); if(execvp(empty[0],empty)==-1) //executes file and tests for failure { fprintf(stdout,"Command not found\n"); _exit(-1); } default: if(!dont_wait) { //fprintf(stdout,"%d",pid); waitpid(pid,&status,WUNTRACED);} } }
void help() { fprintf(stdout,"\n"); pid_t pid; int status; char *fstr= (char*) malloc(sizeof(char)*40); strcpy(fstr,getenv("SHELL")); strcat(fstr,"/help.txt"); //printf("%s",fstr); char *help[]={"more",fstr,(char *) 0}; switch(pid=fork()){ case -1: //syserr("fork"); case 0: //syserr("exec"); //checks IO redirect check_io(); if(execvp(help[0],help)==-1) { fprintf(stdout,"Command not found\n"); _exit(-1); } //syserr("exec"); default: if(!dont_wait) { //fprintf(stdout,"%d",pid); waitpid(pid,&status,WUNTRACED);} } }
/************************ * Other command function handler * ************************/ void other(char** command) { pid_t pid; int status; //First Instance of the Switch case used for creating a forked process. //Giving it PID as a switch case, it can determine if the child process or the parent process //simply by checking for zero. switch(pid=fork()){ case -1: //syserr("fork"); case 0: //syserr("exec"); //checks IO redirect check_io(); //execute to "unknown" command if(execvp(command[0],command)==-1) { fprintf(stdout,"Command not found\n"); _exit(-1); } default: if(!dont_wait) { //fprintf(stdout,"%d",pid); waitpid(pid,&status,WUNTRACED);} } }
static int work_fn(void *arg) { uint64_t tsc_end = rte_get_timer_cycles() + g_time_in_sec * g_tsc_rate; struct worker_thread *worker = (struct worker_thread *)arg; struct ns_worker_ctx *ns_ctx = NULL; printf("Starting thread on core %u\n", worker->lcore); if (spdk_nvme_register_io_thread() != 0) { fprintf(stderr, "spdk_nvme_register_io_thread() failed on core %u\n", worker->lcore); return -1; } /* Submit initial I/O for each namespace. */ ns_ctx = worker->ns_ctx; while (ns_ctx != NULL) { submit_io(ns_ctx, g_queue_depth); ns_ctx = ns_ctx->next; } while (1) { /* * Check for completed I/O for each controller. A new * I/O will be submitted in the io_complete callback * to replace each I/O that is completed. */ ns_ctx = worker->ns_ctx; while (ns_ctx != NULL) { check_io(ns_ctx); ns_ctx = ns_ctx->next; } if (((tsc_end - rte_get_timer_cycles()) / g_tsc_rate) > (uint64_t)g_time_in_sec / 5 && ((tsc_end - rte_get_timer_cycles()) / g_tsc_rate) < (uint64_t)(g_time_in_sec / 5 + 10)) { ns_ctx = worker->ns_ctx; while (ns_ctx != NULL) { if (spdk_nvme_ctrlr_reset(ns_ctx->ctr_entry->ctrlr) < 0) { fprintf(stderr, "nvme reset failed.\n"); return -1; } ns_ctx = ns_ctx->next; } } if (rte_get_timer_cycles() > tsc_end) { break; } } ns_ctx = worker->ns_ctx; while (ns_ctx != NULL) { drain_io(ns_ctx); ns_ctx = ns_ctx->next; } spdk_nvme_unregister_io_thread(); return 0; }
/** * Returns the original file descriptor * Usage: * io:getfd ( ) * * [+1, -0, e] */ static int io_getfd(lua_State *L) { ev_io* io = check_io(L, 1); lua_pushinteger ( L , io->fd ); return 1; }
int mcast_poll(char *data, int size) { int ret; unsigned int len; struct sockaddr_in6 addr; len = sizeof(addr); ret = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr *)&addr, &len); if (ret < 0) { perror("socket"); exit(1); } if (memcmp(MSG_IO, buf, sizeof(MSG_IO)) == 0) { dbg("recv: io", &addr); return check_io(buf, ret, data, size); } else { dbg("recv: UNKNOWN", &addr); } return -EAGAIN; }
/* * Paste text file to console/serial line. Avoid ascii-xfer problem of * swallowing up status messages returned via the serial line. * This is especially useful for Embedded Microprocessor Development Kits * that use raw file transfer mode (no protocols) to download text encoded * executable files (eg., in S-Record or Intel Hex formats) * * TC Wan <*****@*****.**> 2003-10-18 */ int paste_file(void) { FILE *fp; char line[1024]; char *s; const int dotrans = 0; const int ldelay = 1; /* hardcoded 1 ms */ char buf[128] = ""; char *ptr; int bytes_read; unsigned long bdone = 0; int x; if ((s = filedir(1, 0)) == NULL) return 0; if ((fp = fopen(s, "r")) == NULL) { perror(s); return -1; } while (fgets(line, sizeof(line), fp)) { /* Check for I/O or timer. */ x = check_io(portfd_connected, 0, 1000, buf, sizeof(buf), &bytes_read); /* Send data from the modem to the screen. */ if ((x & 1)) { ptr = buf; while (bytes_read-- > 0) { if (P_PARITY[0] == 'M' || P_PARITY[0] == 'S') *ptr &= 0x7f; vt_out(*ptr++); } mc_wflush(); } if (dotrans && (s = strrchr(line, '\n')) != NULL) { if (s > line && *(s - 1) == '\r') s--; *s = 0; s = line; for (s = line; *s; s++) vt_send(*s); vt_send('\r'); vt_send('\n'); bdone += strlen(line) + 2; } else { for (s = line; *s; s++) vt_send(*s); bdone += strlen(s); } if (ldelay) { #ifdef HAVE_USLEEP usleep(ldelay * 1000); #endif } } fclose(fp); return 0; }
static void drain_io(struct ns_entry *entry) { entry->is_draining = true; while (entry->current_queue_depth > 0) { check_io(entry); } }
static void drain_io(struct ns_worker_ctx *ns_ctx) { ns_ctx->is_draining = true; while (ns_ctx->current_queue_depth > 0) { check_io(ns_ctx); } }
static void drain_io(void) { g_ns->is_draining = true; while (g_ns->current_queue_depth > 0) { check_io(); } }
void IOOUTCALL cpu_out_d(UINT port, UINT32 data) { if (CPU_STAT_PM && (CPU_STAT_VM86 || (CPU_STAT_CPL > CPU_STAT_IOPL))) { check_io(port, 4); } iocore_out32(port, data); }
void IOOUTCALL cpu_out_w(UINT port, UINT16 data) { if (CPU_STAT_PM && (CPU_STAT_VM86 || (CPU_STAT_CPL > CPU_STAT_IOPL))) { check_io(port, 2); } iocore_out16(port, data); }
UINT16 IOINPCALL cpu_in_w(UINT port) { if (CPU_STAT_PM && (CPU_STAT_VM86 || (CPU_STAT_CPL > CPU_STAT_IOPL))) { check_io(port, 2); } return iocore_inp16(port); }
UINT32 IOINPCALL cpu_in_d(UINT port) { if (CPU_STAT_PM && (CPU_STAT_VM86 || (CPU_STAT_CPL > CPU_STAT_IOPL))) { check_io(port, 4); } return iocore_inp32(port); }
void IOOUTCALL cpu_out(UINT port, UINT8 data) { if (CPU_STAT_PM && (CPU_STAT_VM86 || (CPU_STAT_CPL > CPU_STAT_IOPL))) { check_io(port, 1); } iocore_out8(port, data); }
/** * Stops the io so it won't be called by the specified event loop. * * Usage: * io:stop(loop) * * [+0, -0, e] */ static int io_stop(lua_State *L) { ev_io* io = check_io(L, 1); struct ev_loop* loop = *check_loop_and_init(L, 2); loop_stop_watcher(L, 2, 1); ev_io_stop(loop, io); return 0; }
UINT8 IOINPCALL cpu_in(UINT port) { if (CPU_STAT_PM && (CPU_STAT_VM86 || (CPU_STAT_CPL > CPU_STAT_IOPL))) { check_io(port, 1); } return iocore_inp8(port); }
void TIDELog::writeTIDE() { const off_t pos = ftello(logfile); fseeko(logfile, 0, SEEK_SET); HEADER hdr(TAG_TIDE, pos); write_checked<HEADER,HDR_SIZE>(hdr, "TIDE header"); write_checked<TIDE,TIDE_SIZE>(TIDE(1, 0, num_chans, num_chunks), "TIDE block"); check_io(0, fflush(logfile), "flush"); }
/** * Starts the io so it won't be called by the specified event loop. * * Usage: * io:start(loop [, is_daemon]) * * [+0, -0, e] */ static int io_start(lua_State *L) { ev_io* io = check_io(L, 1); struct ev_loop* loop = *check_loop_and_init(L, 2); int is_daemon = lua_toboolean(L, 3); ev_io_start(loop, io); loop_start_watcher(L, 2, 1, is_daemon); return 0; }
static int work_fn(void *arg) { uint64_t tsc_end; struct worker_thread *worker = (struct worker_thread *)arg; struct ns_worker_ctx *ns_ctx = NULL; printf("Starting thread on core %u\n", worker->lcore); /* Allocate a queue pair for each namespace. */ ns_ctx = worker->ns_ctx; while (ns_ctx != NULL) { if (init_ns_worker_ctx(ns_ctx) != 0) { printf("ERROR: init_ns_worker_ctx() failed\n"); return 1; } ns_ctx = ns_ctx->next; } tsc_end = rte_get_timer_cycles() + g_time_in_sec * g_tsc_rate; /* Submit initial I/O for each namespace. */ ns_ctx = worker->ns_ctx; while (ns_ctx != NULL) { submit_io(ns_ctx, g_queue_depth); ns_ctx = ns_ctx->next; } while (1) { /* * Check for completed I/O for each controller. A new * I/O will be submitted in the io_complete callback * to replace each I/O that is completed. */ ns_ctx = worker->ns_ctx; while (ns_ctx != NULL) { check_io(ns_ctx); ns_ctx = ns_ctx->next; } if (rte_get_timer_cycles() > tsc_end) { break; } } ns_ctx = worker->ns_ctx; while (ns_ctx != NULL) { drain_io(ns_ctx); cleanup_ns_worker_ctx(ns_ctx); ns_ctx = ns_ctx->next; } return 0; }
static int work_fn(void *arg) { uint64_t tsc_end = rte_get_timer_cycles() + g_time_in_sec * g_tsc_rate; struct worker_thread *worker = (struct worker_thread *)arg; struct ns_entry *entry = NULL; printf("Starting thread on core %u\n", worker->lcore); nvme_register_io_thread(); /* Submit initial I/O for each namespace. */ entry = worker->namespaces; while (entry != NULL) { submit_io(entry, g_queue_depth); entry = entry->next; } while (1) { /* * Check for completed I/O for each controller. A new * I/O will be submitted in the io_complete callback * to replace each I/O that is completed. */ entry = worker->namespaces; while (entry != NULL) { check_io(entry); entry = entry->next; } if (rte_get_timer_cycles() > tsc_end) { break; } } entry = worker->namespaces; while (entry != NULL) { drain_io(entry); entry = entry->next; } nvme_unregister_io_thread(); return 0; }
/************************ * Environment function * Purpose: Displays all environment data that is pointed to by * external environment pointer. ************************/ void envi(){ //checks IO redirect check_io(); //prints out file fprintf(stdout,"%s",getenv("PWD")); int f=0; while(*environ!=NULL) { fprintf(stdout,"%s\n",*environ); environ++; f++; } for(;f>0;f--) { environ--; } }
/************************ *Directory function implementation ************************/ void dir(char** directory,int dircount) { int status; //add ls -al to our arguments //add only one and overwrite dir directory[dircount+1]=(char*) malloc(sizeof(directory[dircount])); //malloc a new array location to //fprintf(stdout,"%d",dircount); //shift all array data to the right 1 strcpy(directory[0],"-al"); while(dircount>=0) { directory[dircount+1]=directory[dircount]; dircount--; } directory[0]="ls"; //fprintf(stdout,"%s",directory[0]); pid_t pid; switch(pid=fork()){ case -1: //syserr("fork"); case 0: //fprintf(stdout,"Executing: %s",directory[0]); //checks IO redirect check_io(); if(execvp(directory[0],directory)==-1) //executes file and tests for failure { fprintf(stdout,"Command not found\n"); _exit(-1); } //syserr("exec"); default: if(!dont_wait) { //fprintf(stdout,"%d",pid); waitpid(pid,&status,WUNTRACED);} } }
void echoarg(char** echoarg,int echocount) { int i; int j; //checks IO redirect check_io(); for(j=1;j<echocount;j++) { for(i=0;i<strlen(echoarg[j]);i++) { if(echoarg[j][i]!='"') { fprintf(stdout,"%c",echoarg[j][i]); } } fprintf(stdout," "); } fprintf(stdout,"\n"); //clears line to throw }
static int work_fn(void) { uint64_t tsc_end; printf("Starting work_fn on core %u\n", rte_lcore_id()); /* Allocate a queue pair for each namespace. */ if (init_ns_worker_ctx() != 0) { printf("ERROR: init_ns_worker_ctx() failed\n"); return 1; } tsc_end = spdk_get_ticks() + g_time_in_sec * g_tsc_rate; /* Submit initial I/O for each namespace. */ submit_single_io(); g_complete_tsc_start = spdk_get_ticks(); while (1) { /* * Check for completed I/O for each controller. A new * I/O will be submitted in the io_complete callback * to replace each I/O that is completed. */ check_io(); if (spdk_get_ticks() > tsc_end) { break; } } drain_io(); cleanup_ns_worker_ctx(); return 0; }
int main(int argc, char *argv[]) { mrp_mainloop_t *ml; mrp_clear(&cfg); parse_cmdline(&cfg, argc, argv); mrp_log_set_mask(cfg.log_mask); mrp_log_set_target(cfg.log_target); ml = mainloop_create(&cfg); if (ml == NULL) fatal("failed to create main loop."); dbus_test.ml = ml; setup_dbus_tests(ml); ml = dbus_test.ml; setup_timers(ml); setup_io(ml); setup_signals(ml); MRP_UNUSED(setup_deferred); /* XXX TODO: add deferred tests... */ #ifdef GLIB_ENABLED if (cfg.mainloop_type != MAINLOOP_GLIB && cfg.mainloop_type != MAINLOOP_QT) { if (cfg.ngio > 0 || cfg.ngtimer > 0) glib_pump_setup(ml); } setup_glib_io(); setup_glib_timers(); #endif if (mrp_add_timer(ml, 1000, check_quit, NULL) == NULL) fatal("failed to create quit-check timer"); setup_wakeup(ml); mainloop_run(&cfg); check_io(); check_timers(); check_signals(); #ifdef GLIB_ENABLED check_glib_io(); check_glib_timers(); #endif if (dbus_test.client != 0) close(dbus_test.pipe[1]); /* let the client continue */ check_dbus(); #ifdef GLIB_ENABLED if (cfg.mainloop_type != MAINLOOP_GLIB) { if (cfg.ngio > 0 || cfg.ngtimer > 0) glib_pump_cleanup(); } #endif cleanup_wakeup(); mainloop_cleanup(&cfg); }
void TIDELog::write_checked<timeval>(const timeval& tv, const char* name) { uint64_t timestamp = ((uint64_t) tv.tv_sec * 10e6) + (uint64_t) tv.tv_usec; assert(sizeof(uint64_t) == 8); check_io(1, fwrite(×tamp, sizeof (timestamp), 1, logfile), "timeval"); }
static int eat(const char *filename) { #define fail_if(cond) \ while (cond) \ { \ show_error(filename); \ if (fd != -1) \ close(fd); \ return -1; \ } #define check_io(i, j) \ while ((size_t) (i) != (size_t) (j)) \ { \ if ((i) >= 0) \ errno = EIO; \ fail_if(1); \ } const int fd = open(filename, O_RDWR); fail_if(fd == -1); const off_t file_size = lseek(fd, 0, SEEK_END); fail_if(file_size == -1); int rc; off_t offset; ssize_t r_bytes, w_bytes; offset = lseek(fd, 0, SEEK_SET); fail_if(offset == -1); if (block_size == 0) { struct statvfs st; rc = fstatvfs(fd, &st); fail_if(rc == -1); if (st.f_bsize == 0 || st.f_bsize >= block_size_limit) { errno = ERANGE; fail_if(1); } block_size = st.f_bsize; } const off_t n_blocks = (file_size + block_size - 1) / block_size; const size_t tail_size = (size_t) (1 + (file_size - 1) % block_size); switch (n_blocks) { case 2: r_bytes = read(fd, buffer, block_size); check_io(r_bytes, block_size); w_bytes = write(STDOUT_FILENO, buffer, block_size); check_io(w_bytes, block_size); case 1: r_bytes = read(fd, buffer, tail_size); check_io(r_bytes, tail_size); w_bytes = write(STDOUT_FILENO, buffer, (size_t) r_bytes); check_io(w_bytes, r_bytes); case 0: goto done; default: break; } struct stat stat; rc = fstat(fd, &stat); fail_if(rc == -1); if (stat.st_nlink > 1 && !opt_force) { errno = EMLINK; fail_if(1); } for (off_t i = 0; i < n_blocks / 2; i++) { r_bytes = read(fd, buffer, block_size); check_io(r_bytes, block_size); w_bytes = write(STDOUT_FILENO, buffer, block_size); check_io(w_bytes, block_size); if (i == 0 && opt_punch) { #if HAVE_FALLOC_FL_PUNCH_HOLE rc = fallocate(fd, FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE, offset, block_size); if (rc == 0) { offset = 0; while (1) { r_bytes = read(fd, buffer, block_size); if (r_bytes == 0) break; offset += r_bytes; fail_if(r_bytes == -1); w_bytes = write(STDOUT_FILENO, buffer, (size_t) r_bytes); check_io(w_bytes, r_bytes); rc = fallocate(fd, FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE, 0, offset); fail_if(rc != 0); } goto done; } else #else errno = ENOTSUP; #endif { show_error(filename); if (opt_punch > 1) { fprintf(stderr, "hungrycat: %s: fallocate() failed\n", filename); close(fd); return 1; } else fprintf(stderr, "hungrycat: %s: fallocate() failed; falling back to ftruncate()\n", filename); } } offset = (n_blocks - i - 1) * block_size; r_bytes = pread(fd, buffer, block_size, offset); check_io(r_bytes, (i == 0 ? tail_size : block_size)); w_bytes = pwrite(fd, buffer, (size_t) r_bytes, i * block_size); check_io(r_bytes, w_bytes); rc = ftruncate(fd, offset); fail_if(rc == -1); } if ((n_blocks & 1) == 1) { r_bytes = read(fd, buffer, block_size); check_io(r_bytes, block_size); w_bytes = write(STDOUT_FILENO, buffer, block_size); check_io(w_bytes, block_size); rc = ftruncate(fd, (n_blocks / 2) * block_size); fail_if(rc == -1); } for (off_t i = (n_blocks / 2) - 1; i > 0; i--) { r_bytes = pread(fd, buffer, block_size, i * block_size); check_io(r_bytes, block_size); w_bytes = write(STDOUT_FILENO, buffer, block_size); check_io(w_bytes, block_size); rc = ftruncate(fd, i * block_size); fail_if(rc == -1); } assert(n_blocks > 0); r_bytes = pread(fd, buffer, tail_size, 0); check_io(r_bytes, tail_size); w_bytes = write(STDOUT_FILENO, buffer, (size_t) r_bytes); check_io(w_bytes, r_bytes); done: rc = unlink(filename); fail_if(rc == -1); rc = close(fd); { const int fd = -1; fail_if(rc == -1); } return 0; #undef fail_if }
/* * The main terminal loop: * - If there are characters received send them * to the screen via the appropriate translate function. */ int do_terminal(void) { char buf[128]; int buf_offset = 0; int c; int x; int blen; int zauto = 0; static const char zsig[] = "**\030B00"; int zpos = 0; const char *s; dirflush = 0; WIN *error_on_open_window = NULL; dirty_goto: /* Show off or online time */ update_status_time(); /* If the status line was shown temporarily, delete it again. */ if (tempst) { tempst = 0; mc_wclose(st, 1); st = NULL; } /* Auto Zmodem? */ if (P_PAUTO[0] >= 'A' && P_PAUTO[0] <= 'Z') zauto = P_PAUTO[0]; /* Set the terminal modes */ setcbreak(2); /* Raw, no echo */ keyboard(KSTART, 0); /* Main loop */ while (1) { /* See if window size changed */ if (size_changed) { size_changed = 0; wrapln = us->wrap; /* I got the resize code going again! Yeah! */ mc_wclose(us, 0); us = NULL; if (st) mc_wclose(st, 0); st = NULL; mc_wclose(stdwin, 0); if (win_init(tfcolor, tbcolor, XA_NORMAL) < 0) leave(_("Could not re-initialize window system.")); /* Set the terminal modes */ setcbreak(2); /* Raw, no echo */ init_emul(terminal, 0); } /* Update the timer. */ timer_update(); /* check if device is ok, if not, try to open it */ if (!get_device_status(portfd_connected)) { /* Ok, it's gone, most probably someone unplugged the USB-serial, we * need to free the FD so that a replug can get the same device * filename, open it again and be back */ int reopen = portfd == -1; close(portfd); lockfile_remove(); portfd = -1; if (open_term(reopen, reopen, 1) < 0) { if (!error_on_open_window) error_on_open_window = mc_tell(_("Cannot open %s!"), dial_tty); } else { if (error_on_open_window) { mc_wclose(error_on_open_window, 1); error_on_open_window = NULL; } } } /* Check for I/O or timer. */ x = check_io(portfd_connected, 0, 1000, buf + buf_offset, sizeof(buf) - buf_offset, &blen); blen += buf_offset; buf_offset = 0; /* Data from the modem to the screen. */ if ((x & 1) == 1) { char obuf[sizeof(buf)]; char *ptr; if (using_iconv()) { char *otmp = obuf; size_t output_len = sizeof(obuf); size_t input_len = blen; ptr = buf; do_iconv(&ptr, &input_len, &otmp, &output_len); // something happened at all? if (output_len < sizeof(obuf)) { if (input_len) { // something remained, we need to adapt buf accordingly memmove(buf, ptr, input_len); buf_offset = input_len; } blen = sizeof(obuf) - output_len; ptr = obuf; } else ptr = buf; } else { ptr = buf; } while (blen-- > 0) { /* Auto zmodem detect */ if (zauto) { if (zsig[zpos] == *ptr) zpos++; else zpos = 0; } if (P_PARITY[0] == 'M' || P_PARITY[0] == 'S') *ptr &= 0x7f; if (display_hex) { unsigned char c = *ptr++; unsigned char u = c >> 4; c &= 0xf; vt_out(u > 9 ? 'a' + (u - 10) : '0' + u); vt_out(c > 9 ? 'a' + (c - 10) : '0' + c); vt_out(' '); } else vt_out(*ptr++); if (zauto && zsig[zpos] == 0) { dirflush = 1; keyboard(KSTOP, 0); updown('D', zauto - 'A'); dirflush = 0; zpos = 0; blen = 0; goto dirty_goto; } } mc_wflush(); }