sdk_ret sdk_ipc_init(int module_id) { sdk_ret sret = SDK_EINNER; int ret = -1; if (g_init_flag) return SDK_EBADPARA; g_self_id = module_id; sret = init_mq(); if (SDK_OK != sret) goto err_mq; sret = init_sync(); if (SDK_OK != sret) goto err_sync; sret = init_notify(); if (SDK_OK != sret) goto err_notify; sret = init_socket(); if (SDK_OK != sret) goto err_sock; /* Create IPC main MQ */ g_main_mq = sdk_ipc_mq_create(); if (NULL == g_main_mq) goto err_sock; /* Start IPC recv thread */ g_run_flag = 1; ret = pthread_create(&g_recv_pid, NULL, recv_thread_routine, NULL); if (0 != ret) goto err_sock; /* Init OK */ g_init_flag = 1; return SDK_OK; err_sock: uninit_socket(); err_notify: uninit_notify(); err_sync: uninit_sync(); err_mq: uninit_mq(); return SDK_EINNER; }
int main(int argc, char **argv) { opsoup_t ctx; int round = 1; FILE *f; o = &ctx; memset(o, 0, sizeof (opsoup_t)); if(argc == 2 && strcmp(argv[1], "-v") == 0) o->verbose = 1; if(image_load() != 0) return 1; init_sync(); dis_pass1(); while(dis_pass2(round)) { o->nref = 0; round++; } label_reloc_upgrade(); label_gen_names(); label_sort(); f = fopen(OUTPUT_FILE, "w"); if(f == NULL) { printf("main: couldn't open '" OUTPUT_FILE "' for writing: %s\n", strerror(errno)); return 1; } label_extern_output(f); dis_pass3(f); data_output(f); data_bss_output(f); fclose(f); //label_print_unused(); return 0; }
int main(int argc, char **argv) { int listenfd, port, ret; struct horse *horses; unsigned int horse_num, pperh; pthread_mutex_t mutex, mfinished, mbank, mcur_run, mhb, mnr; pthread_cond_t cond; pthread_barrier_t barrier; struct service service; if (argc != 3) { usage(argv[0]); exit(EXIT_FAILURE); } // parse port port = atoi(argv[1]); listenfd = init_socket(port); _listen(listenfd, LISTENQ); init_sync(&mutex, &cond, &mfinished, &mbank, &mcur_run, &mhb, &mnr); ret = parse_conf_file(argv[2], &horses, &horse_num, &pperh, &mutex, &cond, &barrier, &service); if (ret) goto clean; if (!pperh || pperh > MAX_RACE_NUM) { fprintf(stderr, "races per hour %u should be more than 0 and less than %d\n", pperh, MAX_RACE_NUM + 1); goto clean; } init_signals(); srand(time(NULL)); init_service(&service, &mfinished, &mbank, &mcur_run, &mhb, &mnr, (unsigned int)(60 * 60 / pperh)); server_work(listenfd, &cond, &service, horses, horse_num); clean: // cleaning clean(&mutex, &cond, &mfinished, &mbank, &mcur_run, &mhb, &mnr, horses, listenfd); return EXIT_SUCCESS; }
int main(int argc, char **argv) { char buffer[INSN_MAX * 2], *p, *ep, *q; char outbuf[256]; char *pname = *argv; char *filename = NULL; uint32_t nextsync, synclen, initskip = 0L; int lenread; int32_t lendis; bool autosync = false; int bits = 16, b; bool eof = false; iflag_t prefer; bool rn_error; int64_t offset; FILE *fp; nasm_ctype_init(); nasm_set_verror(ndisasm_verror); iflag_clear_all(&prefer); offset = 0; init_sync(); while (--argc) { char *v, *vv, *p = *++argv; if (*p == '-' && p[1]) { p++; while (*p) switch (nasm_tolower(*p)) { case 'a': /* auto or intelligent sync */ case 'i': autosync = true; p++; break; case 'h': fputs(help, stderr); return 0; case 'r': case 'v': fprintf(stderr, "NDISASM version %s compiled on %s\n", nasm_version, nasm_date); return 0; case 'u': /* -u for -b 32, -uu for -b 64 */ if (bits < 64) bits <<= 1; p++; break; case 'b': /* bits */ v = p[1] ? p + 1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-b' requires an argument\n", pname); return 1; } b = strtoul(v, &ep, 10); if (*ep || !(bits == 16 || bits == 32 || bits == 64)) { fprintf(stderr, "%s: argument to `-b' should" " be 16, 32 or 64\n", pname); } else { bits = b; } p = ""; /* force to next argument */ break; case 'o': /* origin */ v = p[1] ? p + 1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-o' requires an argument\n", pname); return 1; } offset = readnum(v, &rn_error); if (rn_error) { fprintf(stderr, "%s: `-o' requires a numeric argument\n", pname); return 1; } p = ""; /* force to next argument */ break; case 's': /* sync point */ v = p[1] ? p + 1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-s' requires an argument\n", pname); return 1; } add_sync(readnum(v, &rn_error), 0L); if (rn_error) { fprintf(stderr, "%s: `-s' requires a numeric argument\n", pname); return 1; } p = ""; /* force to next argument */ break; case 'e': /* skip a header */ v = p[1] ? p + 1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-e' requires an argument\n", pname); return 1; } initskip = readnum(v, &rn_error); if (rn_error) { fprintf(stderr, "%s: `-e' requires a numeric argument\n", pname); return 1; } p = ""; /* force to next argument */ break; case 'k': /* skip a region */ v = p[1] ? p + 1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-k' requires an argument\n", pname); return 1; } vv = strchr(v, ','); if (!vv) { fprintf(stderr, "%s: `-k' requires two numbers separated" " by a comma\n", pname); return 1; } *vv++ = '\0'; nextsync = readnum(v, &rn_error); if (rn_error) { fprintf(stderr, "%s: `-k' requires numeric arguments\n", pname); return 1; } synclen = readnum(vv, &rn_error); if (rn_error) { fprintf(stderr, "%s: `-k' requires numeric arguments\n", pname); return 1; } add_sync(nextsync, synclen); p = ""; /* force to next argument */ break; case 'p': /* preferred vendor */ v = p[1] ? p + 1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-p' requires an argument\n", pname); return 1; } if (!strcmp(v, "intel")) { iflag_clear_all(&prefer); /* default */ } else if (!strcmp(v, "amd")) { iflag_clear_all(&prefer); iflag_set(&prefer, IF_AMD); iflag_set(&prefer, IF_3DNOW); } else if (!strcmp(v, "cyrix")) { iflag_clear_all(&prefer); iflag_set(&prefer, IF_CYRIX); iflag_set(&prefer, IF_3DNOW); } else if (!strcmp(v, "idt") || !strcmp(v, "centaur") || !strcmp(v, "winchip")) { iflag_clear_all(&prefer); iflag_set(&prefer, IF_3DNOW); } else { fprintf(stderr, "%s: unknown vendor `%s' specified with `-p'\n", pname, v); return 1; } p = ""; /* force to next argument */ break; default: /*bf */ fprintf(stderr, "%s: unrecognised option `-%c'\n", pname, *p); return 1; } } else if (!filename) { filename = p; } else { fprintf(stderr, "%s: more than one filename specified\n", pname); return 1; } } if (!filename) { fprintf(stderr, help, pname); return 0; } if (strcmp(filename, "-")) { fp = fopen(filename, "rb"); if (!fp) { fprintf(stderr, "%s: unable to open `%s': %s\n", pname, filename, strerror(errno)); return 1; } } else fp = stdin; if (initskip > 0) skip(initskip, fp); /* * This main loop is really horrible, and wants rewriting with * an axe. It'll stay the way it is for a while though, until I * find the energy... */ p = q = buffer; nextsync = next_sync(offset, &synclen); do { uint32_t to_read = buffer + sizeof(buffer) - p; if ((nextsync || synclen) && to_read > nextsync - offset - (p - q)) to_read = nextsync - offset - (p - q); if (to_read) { lenread = fread(p, 1, to_read, fp); if (lenread == 0) eof = true; /* help along systems with bad feof */ } else lenread = 0; p += lenread; if ((nextsync || synclen) && (uint32_t)offset == nextsync) { if (synclen) { fprintf(stdout, "%08"PRIX64" skipping 0x%"PRIX32" bytes\n", offset, synclen); offset += synclen; skip(synclen, fp); } p = q = buffer; nextsync = next_sync(offset, &synclen); } while (p > q && (p - q >= INSN_MAX || lenread == 0)) { lendis = disasm((uint8_t *)q, INSN_MAX, outbuf, sizeof(outbuf), bits, offset, autosync, &prefer); if (!lendis || lendis > (p - q) || ((nextsync || synclen) && (uint32_t)lendis > nextsync - offset)) lendis = eatbyte((uint8_t *) q, outbuf, sizeof(outbuf), bits); output_ins(offset, (uint8_t *) q, lendis, outbuf); q += lendis; offset += lendis; } if (q >= buffer + INSN_MAX) { uint8_t *r = (uint8_t *) buffer, *s = (uint8_t *) q; int count = p - q; while (count--) *r++ = *s++; p -= (q - buffer); q = buffer; } } while (lenread > 0 || !(eof || feof(fp))); if (fp != stdin) fclose(fp); return 0; }
int main(int argc, char **argv) { unsigned char buffer[INSN_MAX * 2], *p, *q; char outbuf[256]; char *pname = *argv; char *filename = NULL; unsigned long nextsync, synclen, initskip = 0L; int lenread, lendis; int autosync = FALSE; int bits = 16; int eof = FALSE; int rn_error; long offset; FILE *fp; offset = 0; init_sync(); while (--argc) { char *v, *vv, *p = *++argv; if (*p == '-') { p++; while (*p) switch (tolower(*p)) { case 'a': /* auto or intelligent sync */ case 'i': autosync = TRUE; p++; break; case 'h': fprintf(stderr, help); return 0; case 'r': fprintf(stderr, "NDISASM version " NASM_VER "\n"); return 0; case 'u': /* USE32 */ bits = 32; p++; break; case 'b': /* bits */ v = p[1] ? p+1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-b' requires an argument\n", pname); return 1; } if (!strcmp(v, "16")) bits = 16; else if (!strcmp(v, "32")) bits = 32; else { fprintf(stderr, "%s: argument to `-b' should" " be `16' or `32'\n", pname); } p = ""; /* force to next argument */ break; case 'o': /* origin */ v = p[1] ? p+1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-o' requires an argument\n", pname); return 1; } offset = readnum (v, &rn_error); if (rn_error) { fprintf(stderr, "%s: `-o' requires a numeric argument\n", pname); return 1; } p = ""; /* force to next argument */ break; case 's': /* sync point */ v = p[1] ? p+1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-s' requires an argument\n", pname); return 1; } add_sync (readnum (v, &rn_error), 0L); if (rn_error) { fprintf(stderr, "%s: `-s' requires a numeric argument\n", pname); return 1; } p = ""; /* force to next argument */ break; case 'e': /* skip a header */ v = p[1] ? p+1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-e' requires an argument\n", pname); return 1; } initskip = readnum (v, &rn_error); if (rn_error) { fprintf(stderr, "%s: `-e' requires a numeric argument\n", pname); return 1; } p = ""; /* force to next argument */ break; case 'k': /* skip a region */ v = p[1] ? p+1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-k' requires an argument\n", pname); return 1; } vv = strchr(v, ','); if (!vv) { fprintf(stderr, "%s: `-k' requires two numbers separated" " by a comma\n", pname); return 1; } *vv++ = '\0'; nextsync = readnum (v, &rn_error); if (rn_error) { fprintf(stderr, "%s: `-k' requires numeric arguments\n", pname); return 1; } synclen = readnum (vv, &rn_error); if (rn_error) { fprintf(stderr, "%s: `-k' requires numeric arguments\n", pname); return 1; } add_sync (nextsync, synclen); p = ""; /* force to next argument */ break; } } else if (!filename) { filename = p; } else { fprintf(stderr, "%s: more than one filename specified\n", pname); return 1; } } if (!filename) { fprintf(stderr, help, pname); return 0; } fp = fopen(filename, "rb"); if (!fp) { fprintf(stderr, "%s: unable to open `%s': %s\n", pname, filename, strerror(errno)); return 1; } if (initskip > 0) skip (initskip, fp); /* * This main loop is really horrible, and wants rewriting with * an axe. It'll stay the way it is for a while though, until I * find the energy... */ p = q = buffer; nextsync = next_sync (offset, &synclen); do { unsigned long to_read = buffer+sizeof(buffer)-p; if (to_read > nextsync-offset-(p-q)) to_read = nextsync-offset-(p-q); lenread = fread (p, 1, to_read, fp); if (lenread == 0) eof = TRUE; /* help along systems with bad feof */ p += lenread; if (offset == (long)nextsync) { if (synclen) { printf("%08lX skipping 0x%lX bytes\n", offset, synclen); offset += synclen; skip (synclen, fp); } p = q = buffer; nextsync = next_sync (offset, &synclen); } while (p > q && (p - q >= INSN_MAX || lenread == 0)) { lendis = disasm (q, outbuf, bits, offset, autosync); if (!lendis || lendis > (p - q) || lendis > (int)(nextsync-offset)) lendis = eatbyte (q, outbuf); output_ins (offset, q, lendis, outbuf); q += lendis; offset += lendis; } if (q >= buffer+INSN_MAX) { unsigned char *r = buffer, *s = q; int count = p - q; while (count--) *r++ = *s++; p -= (q - buffer); q = buffer; } } while (lenread > 0 || !(eof || feof(fp))); fclose (fp); return 0; }
int sync_rx_example(struct bladerf *dev) { int status, ret; bool done = false; bool have_tx_data = false; /** [user_buffers] */ /* "User" samples buffers and their associated sizes, in units of samples. * Recall that one sample = two int16_t values. */ int16_t *rx_samples = NULL; int16_t *tx_samples = NULL; const unsigned int samples_len = 10000; /* May be any (reasonable) size */ /* Allocate a buffer to store received samples in */ rx_samples = malloc(samples_len * 2 * 1 * sizeof(int16_t)); if (rx_samples == NULL) { perror("malloc"); return BLADERF_ERR_MEM; } /* Allocate a buffer to prepare transmit data in */ tx_samples = malloc(samples_len * 2 * 1 * sizeof(int16_t)); if (tx_samples == NULL) { perror("malloc"); free(rx_samples); return BLADERF_ERR_MEM; } /** [user_buffers] */ /* Initialize synch interface on RX and TX */ status = init_sync(dev); if (status != 0) { goto out; } /** [enable_modules] */ status = bladerf_enable_module(dev, BLADERF_RX, true); if (status != 0) { fprintf(stderr, "Failed to enable RX: %s\n", bladerf_strerror(status)); goto out; } status = bladerf_enable_module(dev, BLADERF_TX, true); if (status != 0) { fprintf(stderr, "Failed to enable TX: %s\n", bladerf_strerror(status)); goto out; } /** [enable_modules] */ /** [rxtx_loop] */ while (status == 0 && !done) { /* Receive samples */ status = bladerf_sync_rx(dev, rx_samples, samples_len, NULL, 5000); if (status == 0) { /* Process these samples, and potentially produce a response * to transmit */ done = do_work(rx_samples, samples_len, &have_tx_data, tx_samples, samples_len); if (!done && have_tx_data) { /* Transmit a response */ status = bladerf_sync_tx(dev, tx_samples, samples_len, NULL, 5000); if (status != 0) { fprintf(stderr, "Failed to TX samples: %s\n", bladerf_strerror(status)); } } } else { fprintf(stderr, "Failed to RX samples: %s\n", bladerf_strerror(status)); } } if (status == 0) { /* Wait a few seconds for any remaining TX samples to finish * reaching the RF front-end */ usleep(2000000); } /** [rxtx_loop] */ out: ret = status; /** [disable_modules] */ /* Disable RX, shutting down our underlying RX stream */ status = bladerf_enable_module(dev, BLADERF_RX, false); if (status != 0) { fprintf(stderr, "Failed to disable RX: %s\n", bladerf_strerror(status)); } /* Disable TX, shutting down our underlying TX stream */ status = bladerf_enable_module(dev, BLADERF_TX, false); if (status != 0) { fprintf(stderr, "Failed to disable TX: %s\n", bladerf_strerror(status)); } /* Free up our resources */ free(rx_samples); free(tx_samples); /** [disable_modules] */ return ret; }
struct Sync* create_sync(void* shared_memory, struct Arguments* args) { struct Sync* sync = (struct Sync*)shared_memory + args->size; init_sync(sync); return sync; }