static u32 remove_bp(void *mem) { struct bp_entry *e = p_bpentries; struct bp_entry *f = NULL; if(!e) return 0; if(e->address==mem) { p_bpentries = e->next; f = e; } else { for(; e->next; e=e->next) { if(e->next->address==mem) { f = e->next; e->next = f->next; break; } } } if(!f) return 0; *(f->address) = f->instr; f->instr = 0xffffffff; f->address = NULL; DCStoreRangeNoSync((void*)((u32)mem&~0x1f),32); ICInvalidateRange((void*)((u32)mem&~0x1f),32); _sync(); return 1; }
void game_usermsg(struct service* s, int id, void* msg, int sz) { struct game* self = SERVICE_SELF; struct gate_message* gm = msg; assert(gm->c); UM_CAST(UM_BASE, um, gm->msg); switch (um->msgid) { case IDUM_GAMELOGIN: _login(self, gm->c, um); break; case IDUM_GAMELOGOUT: _logout(self, gm->c, true, true); break; case IDUM_GAMELOADOK: _loadok(self, gm->c); break; case IDUM_GAMESYNC: _sync(self, gm->c, um); break; case IDUM_ROLEPRESS: _role_press(self, gm->c, um); break; case IDUM_USEITEM: _use_item(self, gm->c, um); break; } }
void neam::cr::storage::truncate() { if (mapped_file) mapped_file->clear(); else mapped_file = new std::map<std::string, raw_data>; _sync(); }
pplx::task<void> basic_cloud_page_blob_ostreambuf::commit_blob() { if (m_blob_hash_provider.is_enabled()) { auto this_pointer = std::dynamic_pointer_cast<basic_cloud_page_blob_ostreambuf>(shared_from_this()); return _sync().then([this_pointer] (bool) -> pplx::task<void> { this_pointer->m_blob->properties().set_content_md5(this_pointer->m_blob_hash_provider.hash()); return this_pointer->m_blob->upload_properties_async(this_pointer->m_condition, this_pointer->m_options, this_pointer->m_context); }); } else { return _sync().then([] (bool) { }); } }
bool neam::cr::storage::_write_to_file(const std::string &name, char *memory, size_t size) { if (!mapped_file) mapped_file = new std::map<std::string, raw_data>; mapped_file->erase(name); mapped_file->emplace(name, (raw_data(size, reinterpret_cast<int8_t *>(memory), neam::force_duplicate))); _sync(); return true; }
uint16_t i_alloc(uint16_t devno) { staticfast fsptr dev; staticfast blkno_t blk; struct dinode *buf; staticfast uint16_t j; uint16_t k; unsigned ino; if(baddev(dev = getdev(devno))) goto corrupt; tryagain: if(dev->s_ninode) { if(!(dev->s_tinode)) goto corrupt; ino = dev->s_inode[--dev->s_ninode]; if(ino < 2 || ino >=(dev->s_isize-2)*8) goto corrupt; --dev->s_tinode; return(ino); } /* We must scan the inodes, and fill up the table */ _sync(); /* Make on-disk inodes consistent */ k = 0; for(blk = 2; blk < dev->s_isize; blk++) { buf = (struct dinode *)bread(devno, blk, 0); for(j=0; j < 8; j++) { if(!(buf[j].i_mode || buf[j].i_nlink)) dev->s_inode[k++] = 8*(blk-2) + j; if(k==FILESYS_TABSIZE) { brelse(buf); goto done; } } brelse(buf); } done: if(!k) { if(dev->s_tinode) goto corrupt; udata.u_error = ENOSPC; return(0); } dev->s_ninode = k; goto tryagain; corrupt: kputs("i_alloc: corrupt superblock\n"); dev->s_mounted = 1; udata.u_error = ENOSPC; return(0); }
//this method is called from client thread!!! (not from eibhandler thread) void CEIBHandler::Write(const CCemi_L_Data_Frame& data, BlockingMode mode, JTCMonitor* optional_mon) { do { //put the frame (that about the be sent) in the Handler queue and wake him up //note: writing to the queue is synced JTCSynchronized _sync(*this); KnxElementQueue elem; elem._frame = data; elem._mode = mode; elem._optional_mon = optional_mon; _buffer.Write(elem); this->notify(); }while(0); if((mode == WAIT_FOR_CONFRM || mode == WAIT_FOR_ACK) && optional_mon != NULL){ //block the client thread till we got proper response from the KnxNet/IP device JTCSynchronized sync(*optional_mon); optional_mon->wait(); } }
static int _update_remove(unsigned code, gcoap_resp_handler_t handle) { coap_pkt_t pkt; if (_rd_loc[0] == 0) { return RDCLI_NORD; } /* build CoAP request packet */ int res = gcoap_req_init(&pkt, buf, sizeof(buf), code, _rd_loc); if (res < 0) { return RDCLI_ERR; } coap_hdr_set_type(pkt.hdr, COAP_TYPE_CON); ssize_t pkt_len = gcoap_finish(&pkt, 0, COAP_FORMAT_NONE); /* send request */ gcoap_req_send2(buf, pkt_len, &_rd_remote, handle); /* synchronize response */ return _sync(); }
void CEIBHandler::RunEIBWriter() { KnxElementQueue msg2write; CEIBInterface& iface = CEIBServer::GetInstance().GetEIBInterface(); JTCSynchronized sync(_wait_mon); //sync the reading from the queue JTCSynchronized _sync(*this); while (!_stop) { START_TRY //if we have a packet waiting in the queue then forward it to the KNXNet/IP device if(_buffer.Read(msg2write)) { iface.Write(msg2write); } if(_pause) { LOG_DEBUG("EIB Writer suspended."); _wait_mon.wait(); LOG_DEBUG("EIB Writer resumed."); } //release the lock untill the buffer will be filled up or 1 sec passed (to give change to the pause feature) this->wait(1500); END_TRY_START_CATCH_JTC(e) LOG_ERROR("JTC Error: %s",e.getMessage()); END_TRY_START_CATCH(ex) LOG_ERROR("Exception at EIB Writer handler: %s",ex.what()); END_TRY_START_CATCH_ANY LOG_ERROR("Unknown Exception at EIB Writer handler"); END_CATCH } }
static int _discover_internal(const sock_udp_ep_t *remote, char *regif, size_t maxlen) { coap_pkt_t pkt; /* save pointer to result buffer */ _regif_buf = regif; _regif_buf_len = maxlen; /* do URI discovery for the registration interface */ int res = gcoap_req_init(&pkt, buf, sizeof(buf), COAP_METHOD_GET, "/.well-known/core"); if (res < 0) { return RDCLI_ERR; } coap_hdr_set_type(pkt.hdr, COAP_TYPE_CON); gcoap_add_qstring(&pkt, "rt", "core.rd"); size_t pkt_len = gcoap_finish(&pkt, 0, COAP_FORMAT_NONE); res = gcoap_req_send2(buf, pkt_len, remote, _on_discover); if (res < 0) { return RDCLI_ERR; } return _sync(); }
static u32 insert_bp(void *mem) { u32 i; struct bp_entry *p; for(i=0; i<GEKKO_MAX_BP; i++) { if(bp_entries[i].address == NULL) break; } if(i==GEKKO_MAX_BP) return 0; p = &bp_entries[i]; p->next = p_bpentries; p->address = mem; p_bpentries = p; p->instr = *(p->address); *(p->address) = BPCODE; DCStoreRangeNoSync((void*)((u32)mem&~0x1f),32); ICInvalidateRange((void*)((u32)mem&~0x1f),32); _sync(); return 1; }
int rdcli_register(const sock_udp_ep_t *remote, const char *regif) { assert(remote); int res; ssize_t pkt_len; int retval; coap_pkt_t pkt; _lock(); /* if no registration interface is given, we will need to trigger a URI * discovery for it first (see section 5.2) */ if (regif == NULL) { retval = _discover_internal(remote, _rd_regif, sizeof(_rd_regif)); if (retval != RDCLI_OK) { goto end; } } else { if (strlen(_rd_regif) >= sizeof(_rd_regif)) { retval = RDCLI_OVERFLOW; goto end; } strncpy(_rd_regif, regif, sizeof(_rd_regif)); } /* build and send CoAP POST request to the RD's registration interface */ res = gcoap_req_init(&pkt, buf, sizeof(buf), COAP_METHOD_POST, _rd_regif); if (res < 0) { retval = RDCLI_ERR; goto end; } /* set some packet options and write query string */ coap_hdr_set_type(pkt.hdr, COAP_TYPE_CON); rdcli_common_add_qstring(&pkt); /* add the resource description as payload */ res = gcoap_get_resource_list(pkt.payload, pkt.payload_len, COAP_FORMAT_LINK); if (res < 0) { retval = RDCLI_ERR; goto end; } /* finish up the packet */ pkt_len = gcoap_finish(&pkt, res, COAP_FORMAT_LINK); /* send out the request */ res = gcoap_req_send2(buf, pkt_len, remote, _on_register); if (res < 0) { retval = RDCLI_ERR; goto end; } retval = _sync(); end: /* if we encountered any error, we mark the client as not connected */ if (retval != RDCLI_OK) { _rd_loc[0] = '\0'; } #ifdef MODULE_RDCLI_STANDALONE else { rdcli_standalone_signal(true); } #endif mutex_unlock(&_mutex); return retval; }
void doexit(int16_t val, int16_t val2) { int16_t j; ptptr p; irqflags_t irq; #ifdef DEBUG kprintf("process %d exiting\n", udata.u_ptab->p_pid); kprintf ("udata.u_page %u, udata.u_ptab %x, udata.u_ptab->p_page %u\n", udata.u_page, udata.u_ptab, udata.u_ptab->p_page); #endif if (udata.u_ptab->p_pid == 1) panic("killed init"); _sync(); /* Not necessary, but a good idea. */ irq = di(); /* Discard our memory before we blow away and reuse the memory */ pagemap_free(udata.u_ptab); for (j = 0; j < UFTSIZE; ++j) { if (udata.u_files[j] != NO_FILE) doclose(j); } udata.u_ptab->p_exitval = (val << 8) | (val2 & 0xff); i_deref(udata.u_cwd); i_deref(udata.u_root); /* Stash away child's execution tick counts in process table, * overlaying some no longer necessary stuff. * * Pedantically POSIX says we should do this at the point of wait() */ udata.u_utime += udata.u_cutime; udata.u_stime += udata.u_cstime; memcpy(&(udata.u_ptab->p_priority), &udata.u_utime, 2 * sizeof(clock_t)); for (p = ptab; p < ptab_end; ++p) { if (p->p_status == P_EMPTY || p == udata.u_ptab) continue; /* Set any child's parents to our parent */ if (p->p_pptr == udata.u_ptab) p->p_pptr = udata.u_ptab->p_pptr; /* Send SIGHUP to any pgrp members and remove them from our pgrp */ if (p->p_pgrp == udata.u_ptab->p_pid) { p->p_pgrp = 0; ssig(p, SIGHUP); } } tty_exit(); irqrestore(irq); #ifdef DEBUG kprintf ("udata.u_page %u, udata.u_ptab %x, udata.u_ptab->p_page %u\n", udata.u_page, udata.u_ptab, udata.u_ptab->p_page); #endif #ifdef CONFIG_ACCT acctexit(p); #endif udata.u_page = 0xFFFFU; udata.u_page2 = 0xFFFFU; /* FIXME: send SIGCLD here */ /* FIXME: POSIX.1 says that SIG_IGN for SIGCLD means don't go zombie, just clean up as we go */ /* Wake up a waiting parent, if any. */ wakeup((char *) udata.u_ptab->p_pptr); udata.u_ptab->p_status = P_ZOMBIE; nready--; nproc--; switchin(getproc()); panic("doexit: won't exit"); }
neam::cr::storage::~storage() { _sync(); if (mapped_file) delete mapped_file; }
int sync(void) {return(_sync());}