void zoom(struct i2c_client *cliente,int value) { struct input_event ev; memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_KEY; ev.code = KEY_LEFTCTRL; ev.value = 1; write(cliente->mfile, &ev, sizeof(struct input_event)); do_sync(cliente,cliente->mfile); memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_REL; ev.code = REL_WHEEL; ev.value = value; write(cliente->mfile, &ev, sizeof(struct input_event)); do_sync(cliente,cliente->mfile); memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_KEY; ev.code = KEY_LEFTCTRL; ev.value = 0; write(cliente->mfile, &ev, sizeof(struct input_event)); do_sync(cliente,cliente->mfile); }
void menu_ctrl(struct i2c_client *cliente) { struct input_event ev; memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_KEY; ev.code = KEY_LEFTCTRL; ev.value = 1; write(cliente->mfile, &ev, sizeof(struct input_event)); do_sync(cliente,cliente->mfile); memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_KEY; ev.code = KEY_COMPOSE; ev.value = 1; write(cliente->mfile, &ev, sizeof(struct input_event)); do_sync(cliente,cliente->mfile); memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_KEY; ev.code = KEY_COMPOSE; ev.value = 0; write(cliente->mfile, &ev, sizeof(struct input_event)); do_sync(cliente,cliente->mfile); memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_KEY; ev.code = KEY_LEFTCTRL; ev.value = 0; write(cliente->mfile, &ev, sizeof(struct input_event)); do_sync(cliente,cliente->mfile); }
/*===========================================================================* * pm_reboot * *===========================================================================*/ PUBLIC void pm_reboot() { /* Perform the VFS side of the reboot call. */ int i; struct fproc *rfp; do_sync(); /* Do exit processing for all leftover processes and servers, * but don't actually exit them (if they were really gone, PM * will tell us about it). */ for (i = 0; i < NR_PROCS; i++) { rfp = &fproc[i]; if (rfp->fp_endpoint == NONE) continue; /* Don't just free the proc right away, but let it finish what it was * doing first */ lock_proc(rfp, 0); free_proc(rfp, 0); unlock_proc(rfp); } do_sync(); unmount_all(); }
static ssize_t write_nbuf (int fd, const char* buf, size_t len, const struct test_spec* sp) { size_t i; ssize_t nwr = -1, ntotal = 0; int err = 0; assert (buf && sp); if (0 == (sp->mode_flags & SEQ_WRITE)) if (-1 == lseek (fd, 0, SEEK_SET)) { err = errno; perror ("lseek"); return -err; } for (i = 0; i < sp->niter; ++i) { nwr = write (fd, buf, len); if (nwr != (ssize_t)len) { err = errno; (void) fprintf (stderr, "%s: wrote %ld bytes out of %ld: err=%d [%s]\n", __func__, (long)nwr, len, err, (err ? strerror(err) : "none")); break; } if (sp->mode_flags & SYNC_TYPE) { do_sync (fd, sp->mode_flags); } ntotal += nwr; } return !err ? ntotal : -err; }
explicit ws_echo_server( std::ostream& log, kind k = kind::sync) : log_(log) , work_(ioc_.get_executor()) , ts_(ioc_) , ws_(ts_) { beast::websocket::permessage_deflate pmd; pmd.server_enable = true; pmd.server_max_window_bits = 9; pmd.compLevel = 1; ws_.set_option(pmd); switch(k) { case kind::sync: t_ = std::thread{[&]{ do_sync(); }}; break; case kind::async: t_ = std::thread{[&]{ ioc_.run(); }}; do_accept(); break; case kind::async_client: t_ = std::thread{[&]{ ioc_.run(); }}; break; } }
/*===========================================================================* * do_fsync * *===========================================================================*/ PUBLIC int do_fsync() { /* Perform the fsync() system call. For now, don't be unnecessarily smart. */ do_sync(); return(OK); }
/*===========================================================================* * pm_reboot * *===========================================================================*/ PUBLIC void pm_reboot() { /* Perform the FS side of the reboot call. */ int i; do_sync(); SANITYCHECK; /* Do exit processing for all leftover processes and servers, * but don't actually exit them (if they were really gone, PM * will tell us about it). */ for (i = 0; i < NR_PROCS; i++) if((m_in.endpt1 = fproc[i].fp_endpoint) != NONE) { /* No FP_EXITING, just free the resources, otherwise * consistency check for fp_endpoint (set to NONE) will * fail if process wants to do something in the (short) * future. */ free_proc(&fproc[i], 0); } SANITYCHECK; unmount_all(); SANITYCHECK; }
/*===========================================================================* * pm_reboot * *===========================================================================*/ void pm_reboot() { /* Perform the VFS side of the reboot call. */ int i; struct fproc *rfp; do_sync(); /* Do exit processing for all leftover processes and servers, but don't * actually exit them (if they were really gone, PM will tell us about it). * Skip processes that handle parts of the file system; we first need to give * them the chance to unmount (which should be possible as all normal * processes have no open files anymore). */ for (i = 0; i < NR_PROCS; i++) { rfp = &fproc[i]; /* Don't just free the proc right away, but let it finish what it was * doing first */ lock_proc(rfp, 0); if (rfp->fp_endpoint != NONE && find_vmnt(rfp->fp_endpoint) == NULL) free_proc(rfp, 0); unlock_proc(rfp); } do_sync(); unmount_all(0 /* Don't force */); /* Try to exit all processes again including File Servers */ for (i = 0; i < NR_PROCS; i++) { rfp = &fproc[i]; /* Don't just free the proc right away, but let it finish what it was * doing first */ lock_proc(rfp, 0); if (rfp->fp_endpoint != NONE) free_proc(rfp, 0); unlock_proc(rfp); } do_sync(); unmount_all(1 /* Force */); }
static ssize_t writev_nbuf (int fd, const char* buf, size_t len, const struct test_spec* sp) { size_t i = 0, j = 0; ssize_t chunk_len = 0, nwr = -1, ntotal = 0, nleft = (ssize_t)len; int err = 0; struct iovec* iov = NULL; const char *p = buf; assert (buf && sp); assert ((sp->num_chunks > 1) && (sp->num_chunks < len)); chunk_len = (ssize_t)(len / sp->num_chunks); assert (chunk_len >= 1); if (0 == (sp->mode_flags & SEQ_WRITE)) if (-1 == lseek (fd, 0, SEEK_SET)) { err = errno; perror ("lseek"); return -err; } iov = calloc (sp->num_chunks, sizeof(iov[0])); if (!iov) { (void) fputs ("calloc for iov failed\n", stderr); return -1; } for (i = 0; (i < sp->num_chunks) && (nleft > 0); ++i) { iov[i].iov_base = (char*)p; iov[i].iov_len = ((i + 1) < sp->num_chunks) ? (size_t)chunk_len : (size_t)nleft; p += iov[i].iov_len; nleft -= iov[i].iov_len; } assert (0 == nleft); for (j = 0; j < sp->niter; ++j) { nwr = writev (fd, iov, sp->num_chunks); if (nwr != (ssize_t)len) { err = errno; (void) fprintf (stderr, "%s: wrote %ld bytes out of %ld: err=%d [%s]\n", __func__, (long)nwr, len, err, (err ? strerror(err) : "none")); break; } if (sp->mode_flags & SYNC_TYPE) { do_sync (fd, sp->mode_flags); } ntotal += nwr; } free (iov); return !err ? ntotal : -err; }
void click_r(struct i2c_client *cliente,int press) { struct input_event ev; memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_KEY; ev.code = BTN_RIGHT; ev.value = press; write(cliente->mfile, &ev, sizeof(struct input_event)); do_sync(cliente,cliente->mfile); }
void scrollh(struct i2c_client *cliente,int value) { struct input_event ev; memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_REL; ev.code = REL_HWHEEL; ev.value = value; write(cliente->mfile, &ev, sizeof(struct input_event)); do_sync(cliente,cliente->mfile); }
static gboolean do_background_flush (gpointer def) { EvaZlibDeflator *zlib_deflator = EVA_ZLIB_DEFLATOR (def); GError *error = NULL; if (!do_sync (zlib_deflator, Z_SYNC_FLUSH, &error)) { eva_io_set_gerror (EVA_IO (zlib_deflator), EVA_IO_ERROR_SYNC, error); } zlib_deflator->flush_source = NULL; return FALSE; }
HttpPoll::HttpPoll(QObject *parent) :ByteStream(parent) { d = new Private(this); d->polltime = 30; d->t = new QTimer(this); d->t->setSingleShot(true); connect(d->t, SIGNAL(timeout()), SLOT(do_sync())); connect(&d->http, SIGNAL(result()), SLOT(http_result())); connect(&d->http, SIGNAL(error(int)), SLOT(http_error(int))); reset(true); }
CassandraStore::ResultCode Store::delete_old_call_fragments_sync(const std::string& impu, const std::vector<CallFragment> fragments, const int64_t cass_timestamp, SAS::TrailId trail) { DeleteOldCallFragments* op = new_delete_old_call_fragments_op(impu, fragments, cass_timestamp); do_sync(op, trail); CassandraStore::ResultCode result = op->get_result_code(); delete op; op = NULL; return result; }
static void check_transfer(rtems_task_priority prio, bool waiter) { rtems_bdbuf_buffer *bd = do_read('I'); if (waiter) { create_waiter(); } activate_purger(prio); do_sync('I', bd); if (waiter) { restore_waiter(); } }
CassandraStore::ResultCode Store::get_call_fragments_sync(const std::string& impu, std::vector<CallFragment>& fragments, SAS::TrailId trail) { GetCallFragments* op = new_get_call_fragments_op(impu); if (do_sync(op, trail)) { op->get_result(fragments); } CassandraStore::ResultCode result = op->get_result_code(); delete op; op = NULL; return result; }
static void process_cmds(void) { char line[VCHANNEL_MAX_LINE]; int size; char *p, *tok1, *tok2, *tok3, *tok4, *tok5, *tok6, *tok7, *tok8; while ((size = g_vchannel_read_fn(line, sizeof(line))) >= 0) { p = unescape(line); tok1 = get_token(&p); tok2 = get_token(&p); tok3 = get_token(&p); tok4 = get_token(&p); tok5 = get_token(&p); tok6 = get_token(&p); tok7 = get_token(&p); tok8 = get_token(&p); if (strcmp(tok1, "SYNC") == 0) do_sync(); else if (strcmp(tok1, "STATE") == 0) do_state(strtoul(tok2, NULL, 0), long_to_hwnd(strtoul(tok3, NULL, 0)), strtol(tok4, NULL, 0)); else if (strcmp(tok1, "POSITION") == 0) do_position(strtoul(tok2, NULL, 0), long_to_hwnd(strtoul(tok3, NULL, 0)), strtol(tok4, NULL, 0), strtol(tok5, NULL, 0), strtol(tok6, NULL, 0), strtol(tok7, NULL, 0)); else if (strcmp(tok1, "ZCHANGE") == 0) do_zchange(strtoul(tok2, NULL, 0), long_to_hwnd(strtoul(tok3, NULL, 0)), long_to_hwnd(strtoul(tok4, NULL, 0))); else if (strcmp(tok1, "FOCUS") == 0) do_focus(strtoul(tok2, NULL, 0), long_to_hwnd(strtoul(tok3, NULL, 0))); else if (strcmp(tok1, "DESTROY") == 0) do_destroy(long_to_hwnd(strtoul(tok3, NULL, 0))); else if (strcmp(tok1, "SPAWN") == 0) do_spawn(strtoul(tok2, NULL, 0), tok3); else if (strcmp(tok1, "PERSISTENT") == 0) do_persistent(strtoul(tok2, NULL, 0), strtol(tok3, NULL, 0)); free(p); } }
static gboolean eva_zlib_deflator_shutdown_write (EvaIO *io, GError **error) { EvaZlibDeflator *zlib_deflator = EVA_ZLIB_DEFLATOR (io); if (!do_sync (EVA_ZLIB_DEFLATOR (io), Z_FINISH, error)) return FALSE; if (zlib_deflator->flush_source != NULL) { eva_source_remove (zlib_deflator->flush_source); zlib_deflator->flush_source = NULL; } if (zlib_deflator->compressed.size == 0) eva_io_notify_read_shutdown (zlib_deflator); else eva_io_mark_idle_notify_read (zlib_deflator); return TRUE; }
CassandraStore::ResultCode Store::write_call_fragment_sync(const std::string& impu, const CallFragment& fragment, const int64_t cass_timestamp, const int32_t ttl, SAS::TrailId trail) { WriteCallFragment* op = new_write_call_fragment_op(impu, fragment, cass_timestamp, ttl); do_sync(op, trail); CassandraStore::ResultCode result = op->get_result_code(); delete op; op = NULL; return result; }
static gboolean gsk_zlib_deflator_shutdown_write (GskIO *io, GError **error) { GskZlibDeflator *zlib_deflator = GSK_ZLIB_DEFLATOR (io); if (!do_sync (GSK_ZLIB_DEFLATOR (io), Z_FINISH, error)) return FALSE; if (zlib_deflator->flush_source != NULL) { gsk_source_remove (zlib_deflator->flush_source); zlib_deflator->flush_source = NULL; } if (zlib_deflator->compressed.size == 0) gsk_io_notify_read_shutdown (zlib_deflator); else gsk_io_mark_idle_notify_read (zlib_deflator); return TRUE; }
static int do_sync_filename(const char *filename) { sync_log_reader_t *slr; int r; if ((filename == NULL) || !strcmp(filename, "-")) slr = sync_log_reader_create_with_fd(0); /* STDIN */ else slr = sync_log_reader_create_with_filename(filename); r = sync_log_reader_begin(slr); if (!r) r = do_sync(slr); sync_log_reader_end(slr); sync_log_reader_free(slr); return r; }
void move_to(struct i2c_client *cliente,int x, int y) { struct input_event ev; memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_ABS; ev.code = ABS_X; ev.value = x; write(cliente->ufile, &ev, sizeof(struct input_event)); memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_ABS; ev.code = ABS_Y; ev.value = y; write(cliente->ufile, &ev, sizeof(struct input_event)); do_sync(cliente,cliente->ufile); }
void init_clocks(void) { /* Kill any active DMAs as they may trigger external memory accesses * in the middle of reprogramming things, and that'll screw us up. * For example, any automatic DMAs left by U-Boot for splash screens. */ size_t i; for (i = 0; i < MAX_DMA_CHANNELS; ++i) { struct dma_register *dma = dma_io_base_addr[i]; dma->cfg = 0; } do_sync(); #ifdef SIC_IWR0 bfin_write_SIC_IWR0(IWR_ENABLE(0)); # ifdef SIC_IWR1 /* BF52x system reset does not properly reset SIC_IWR1 which * will screw up the bootrom as it relies on MDMA0/1 waking it * up from IDLE instructions. See this report for more info: * http://blackfin.uclinux.org/gf/tracker/4323 */ if (ANOMALY_05000435) bfin_write_SIC_IWR1(IWR_ENABLE(10) | IWR_ENABLE(11)); else bfin_write_SIC_IWR1(IWR_DISABLE_ALL); # endif # ifdef SIC_IWR2 bfin_write_SIC_IWR2(IWR_DISABLE_ALL); # endif #else bfin_write_SIC_IWR(IWR_ENABLE(0)); #endif do_sync(); #ifdef EBIU_SDGCTL bfin_write_EBIU_SDGCTL(bfin_read_EBIU_SDGCTL() | SRFS); do_sync(); #endif #ifdef CLKBUFOE bfin_write16(VR_CTL, bfin_read_VR_CTL() | CLKBUFOE); do_sync(); __asm__ __volatile__("IDLE;"); #endif bfin_write_PLL_LOCKCNT(0x300); do_sync(); bfin_write16(PLL_CTL, PLL_CTL_VAL); __asm__ __volatile__("IDLE;"); bfin_write_PLL_DIV(CONFIG_CCLK_ACT_DIV | CONFIG_SCLK_DIV); #ifdef EBIU_SDGCTL bfin_write_EBIU_SDRRC(mem_SDRRC); bfin_write_EBIU_SDGCTL((bfin_read_EBIU_SDGCTL() & SDGCTL_WIDTH) | mem_SDGCTL); #else bfin_write_EBIU_RSTCTL(bfin_read_EBIU_RSTCTL() & ~(SRREQ)); do_sync(); bfin_write_EBIU_RSTCTL(bfin_read_EBIU_RSTCTL() | 0x1); bfin_write_EBIU_DDRCTL0(mem_DDRCTL0); bfin_write_EBIU_DDRCTL1(mem_DDRCTL1); bfin_write_EBIU_DDRCTL2(mem_DDRCTL2); #ifdef CONFIG_MEM_EBIU_DDRQUE bfin_write_EBIU_DDRQUE(CONFIG_MEM_EBIU_DDRQUE); #endif #endif do_sync(); bfin_read16(0); }
void *do_sync_fun(void *) { while (!sync_thr_shutdown) { do_sync(); } return NULL; }
/*===========================================================================* * pm_reboot * *===========================================================================*/ void pm_reboot() { /* Perform the VFS side of the reboot call. This call is performed from the PM * process context. */ message m_out; int i, r; struct fproc *rfp, *pmfp; pmfp = fp; do_sync(); /* Do exit processing for all leftover processes and servers, but don't * actually exit them (if they were really gone, PM will tell us about it). * Skip processes that handle parts of the file system; we first need to give * them the chance to unmount (which should be possible as all normal * processes have no open files anymore). */ /* This is the only place where we allow special modification of "fp". The * reboot procedure should really be implemented as a PM message broadcasted * to all processes, so that each process will be shut down cleanly by a * thread operating on its behalf. Doing everything here is simpler, but it * requires an exception to the strict model of having "fp" be the process * that owns the current worker thread. */ for (i = 0; i < NR_PROCS; i++) { rfp = &fproc[i]; /* Don't just free the proc right away, but let it finish what it was * doing first */ if (rfp != fp) lock_proc(rfp); if (rfp->fp_endpoint != NONE && find_vmnt(rfp->fp_endpoint) == NULL) { worker_set_proc(rfp); /* temporarily fake process context */ free_proc(0); worker_set_proc(pmfp); /* restore original process context */ } if (rfp != fp) unlock_proc(rfp); } do_sync(); unmount_all(0 /* Don't force */); /* Try to exit all processes again including File Servers */ for (i = 0; i < NR_PROCS; i++) { rfp = &fproc[i]; /* Don't just free the proc right away, but let it finish what it was * doing first */ if (rfp != fp) lock_proc(rfp); if (rfp->fp_endpoint != NONE) { worker_set_proc(rfp); /* temporarily fake process context */ free_proc(0); worker_set_proc(pmfp); /* restore original process context */ } if (rfp != fp) unlock_proc(rfp); } do_sync(); unmount_all(1 /* Force */); /* Reply to PM for synchronization */ memset(&m_out, 0, sizeof(m_out)); m_out.m_type = VFS_PM_REBOOT_REPLY; if ((r = ipc_send(PM_PROC_NR, &m_out)) != OK) panic("pm_reboot: ipc_send failed: %d", r); }
void HttpPoll::http_result() { // check for death :) QPointer<QObject> self = this; syncFinished(); if(!self) return; // get id and packet QString id; QString cookie = d->http.getHeader("Set-Cookie"); int n = cookie.indexOf("ID="); if(n == -1) { reset(); error(ErrRead); return; } n += 3; int n2 = cookie.indexOf(';', n); if(n2 != -1) id = cookie.mid(n, n2-n); else id = cookie.mid(n); QByteArray block = d->http.body(); // session error? if(id.right(2) == ":0") { if(id == "0:0" && d->state == 2) { reset(); connectionClosed(); return; } else { reset(); error(ErrRead); return; } } d->ident = id; bool justNowConnected = false; if(d->state == 1) { d->state = 2; justNowConnected = true; } // sync up again soon if(bytesToWrite() > 0 || !d->closing) { d->t->start(d->polltime * 1000); } // connecting if(justNowConnected) { connected(); } else { if(!d->out.isEmpty()) { int x = d->out.size(); d->out.resize(0); takeWrite(x); bytesWritten(x); } } if(!self) return; if(!block.isEmpty()) { appendRead(block); readyRead(); } if(!self) return; if(bytesToWrite() > 0) { do_sync(); } else { if(d->closing) { reset(); delayedCloseFinished(); return; } } }
int HttpPoll::tryWrite() { if(!d->http.isActive()) do_sync(); return 0; }
static int do_daemon_work(const char *channel, const char *sync_shutdown_file, unsigned long timeout, unsigned long min_delta, int *restartp) { int r = 0; time_t session_start; time_t single_start; int delta; struct stat sbuf; sync_log_reader_t *slr; *restartp = RESTART_NONE; slr = sync_log_reader_create_with_channel(channel); session_start = time(NULL); while (1) { single_start = time(NULL); signals_poll(); /* Check for shutdown file */ if (sync_shutdown_file && !stat(sync_shutdown_file, &sbuf)) { unlink(sync_shutdown_file); break; } /* See if its time to RESTART */ if ((timeout > 0) && ((single_start - session_start) > (time_t) timeout)) { *restartp = RESTART_NORMAL; break; } r = sync_log_reader_begin(slr); if (r) { /* including specifically r == IMAP_AGAIN */ if (min_delta > 0) { sleep(min_delta); } else { usleep(100000); /* 1/10th second */ } continue; } /* Process the work log */ if ((r=do_sync(slr))) { syslog(LOG_ERR, "Processing sync log file %s failed: %s", sync_log_reader_get_file_name(slr), error_message(r)); break; } r = sync_log_reader_end(slr); if (r) break; delta = time(NULL) - single_start; if (((unsigned) delta < min_delta) && ((min_delta-delta) > 0)) sleep(min_delta-delta); } sync_log_reader_free(slr); if (*restartp == RESTART_NORMAL) { r = do_restart(); if (r) { syslog(LOG_ERR, "sync_client RESTART failed: %s", error_message(r)); } else { syslog(LOG_INFO, "sync_client RESTART succeeded"); } r = 0; } return(r); }
snmp_err_t snmp_threadsync_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance) { return do_sync(root_oid, root_oid_len, instance, get_next_instance_synced); }
asmlinkage long sys_sync(void) { do_sync(1); return 0; }