void AsyncIO::initializeContext() {
if (!ctxSet_.load(std::memory_order_acquire)) {
std::lock_guard<std::mutex> lock(initMutex_);
if (!ctxSet_.load(std::memory_order_relaxed)) {
int rc = io_queue_init(capacity_, &ctx_);
// returns negative errno
if (rc == -EAGAIN) {
long aio_nr, aio_max;
std::unique_ptr<FILE, int(*)(FILE*)>
fp(fopen("/proc/sys/fs/aio-nr", "r"), fclose);
PCHECK(fp);
CHECK_EQ(fscanf(fp.get(), "%ld", &aio_nr), 1);
std::unique_ptr<FILE, int(*)(FILE*)>
aio_max_fp(fopen("/proc/sys/fs/aio-max-nr", "r"), fclose);
PCHECK(aio_max_fp);
CHECK_EQ(fscanf(aio_max_fp.get(), "%ld", &aio_max), 1);
LOG(ERROR) << "No resources for requested capacity of " << capacity_;
LOG(ERROR) << "aio_nr " << aio_nr << ", aio_max_nr " << aio_max;
}
checkKernelError(rc, "AsyncIO: io_queue_init failed");
DCHECK(ctx_);
ctxSet_.store(true, std::memory_order_release);
}
}
}
// create stages initaliztion
int pipe_create(pipe_t *pipe, int stages)
{
int pipe_index;
stage_t **link = &pipe->head, *new_stage, *stage;
//init
PCHECK(pthread_mutex_init(&pipe->mutex, NULL));
pipe->stages = stages;
pipe->active = 0;
for (pipe_index = 0; pipe_index <= stages; ++pipe_index) {
EV_TEST(NULL, new_stage, (stage_t*)malloc(sizeof(stage_t)));
PCHECK(pthread_mutex_init(&new_stage->mutex, NULL));
PCHECK(pthread_cond_init(&new_stage->avail, NULL));
PCHECK(pthread_cond_init(&new_stage->ready, NULL));
new_stage->data_ready = 0;
*link = new_stage;
link = &new_stage->next;
}
*link = (stage_t*)NULL;
pipe->tail = new_stage;
for (stage = pipe->head; stage->next != NULL; stage = stage->next) {
PCHECK(pthread_create(&stage->thread, NULL, pipe_stage, (void*)stage));
}
return 0;
}
int main(int argc, const char* argv[])
{
threadpool thpool;
struct __workq WorkQ;
int i;
begin:
srand(time(NULL));
WorkQ.cnt = 0;
PCHECK(pthread_mutex_init(&WorkQ.lock, NULL));
PCHECK(pthread_cond_init(&WorkQ.got_consumer_cond, NULL));
PCHECK(pthread_cond_init(&WorkQ.got_producer_cond, NULL));
TAILQ_INIT(&WorkQ.head);
if (!(thpool = thpool_init(PRODUCER_THREAD_NUM + CONSUMER_THREAD_NUM))) {
errx(EXIT_FAILURE, "thpool_init() error.\n");
}
/* 消费者线程 */
for (i = 0; i < CONSUMER_THREAD_NUM; i++) {
thpool_add_work(thpool, consumer, &WorkQ);
}
sleep(2);
/* 生产者线程 */
for (i = 0; i < PRODUCER_THREAD_NUM; i++) {
thpool_add_work(thpool, producer, &WorkQ);
}
end:
thpool_wait(thpool);
thpool_destroy(thpool);
exit(EXIT_SUCCESS);
}
void MsgModule::ModuleInit()
{
ConfigModule* conf_module = FindModule<ConfigModule>(app_);
// ZMQ初始化
zmq_ctx_ = zmq_init(1);
PCHECK(zmq_ctx_ != NULL)
<< "zmq_init error!";
connsvr_zmq_sock_ = zmq_socket(zmq_ctx_, ZMQ_PAIR);
PCHECK(connsvr_zmq_sock_ != NULL)
<< "zmq_socket error!";
PCHECK(zmq_bind(connsvr_zmq_sock_, conf_module->GetConnsvrZmqAddr()) == 0)
<< "zmq_bind error!";
datasvr_zmq_sock_ = zmq_socket(zmq_ctx_, ZMQ_PAIR);
PCHECK(datasvr_zmq_sock_ != NULL)
<< "zmq_socket error!";
PCHECK(zmq_connect(datasvr_zmq_sock_, conf_module->GetDatasvrZmqAddr()) == 0)
<< "zmq_connect error!";
// 注册消息处理函数
REGISTER_MSG_BEGIN(MsgModule, ProtoCs::Msg)
REGISTER_MSG(this, ProtoCs::Msg::kQuickRegReqFieldNumber, &MsgModule::OnClientQuickRegReq)
REGISTER_MSG(this, ProtoCs::Msg::kNormalRegReqFieldNumber, &MsgModule::OnClientNormalRegReq)
REGISTER_MSG(this, ProtoCs::Msg::kLoginReqFieldNumber, &MsgModule::OnClientLoginReq)
REGISTER_MSG_END;
REGISTER_MSG_BEGIN(MsgModule, ProtoSs::Msg)
REGISTER_MSG(this, ProtoSs::Msg::kAccountRegResFieldNumber, &MsgModule::OnDatasvrAccountRegRes)
REGISTER_MSG(this, ProtoSs::Msg::kAccountVerifyResFieldNumber, &MsgModule::OnDatasvrAccountVerifyRes)
REGISTER_MSG(this, ProtoSs::Msg::kGetPlayerDataResFieldNumber, &MsgModule::OnDatasvrGetPlayerDataRes)
REGISTER_MSG(this, ProtoSs::Msg::kSetPlayerDataResFieldNumber, &MsgModule::OnDatasvrSetPlayerDataRes)
REGISTER_MSG_END;
LOG(INFO) << ModuleName() << " init ok!";
}
static void queue_remove(struct __workq* pworkq)
{
PCHECK(pthread_mutex_lock(&pworkq->lock));
while (pworkq->cnt == 0) { /* 队列已空 */
printf("---------------------------->empty.\n");
/* 那么消费者休眠，等待生产者生产之后的通知 */
PCHECK(pthread_cond_wait(&pworkq->got_producer_cond, &pworkq->lock));
}
struct _Data* pdata = TAILQ_FIRST(&pworkq->head);
TAILQ_REMOVE(&pworkq->head, pdata, entry);
--pworkq->cnt;
printf("['%lu' Consume %d] current cnt (%d)\n", pthread_self(), pdata->value, pworkq->cnt);
#if 0
if (pworkq->cnt == (QUEUE_MAX_NUM - 1)) {
PCHECK(pthread_cond_broadcast(&pworkq->got_consumer_cond)); /* 通知生产者可以继续生产 */
}
#endif
PCHECK(pthread_mutex_unlock(&pworkq->lock));
PCHECK(pthread_cond_broadcast(&pworkq->got_consumer_cond)); /* 通知生产者可以继续生产 */
free(pdata);
}
static void queue_add(struct __workq* pworkq)
{
PCHECK(pthread_mutex_lock(&pworkq->lock));
while (pworkq->cnt == QUEUE_MAX_NUM) { /* 队列已满 */
printf("---------------------------->full.\n");
/* 那么生产者休眠，等待消费者消费之后的通知 */
PCHECK(pthread_cond_wait(&pworkq->got_consumer_cond, &pworkq->lock));
}
struct _Data* pdata = (struct _Data*)calloc(1, sizeof(struct _Data));
pdata->value = rand() % 1000 + 1;
TAILQ_INSERT_HEAD(&pworkq->head, pdata, entry);
++pworkq->cnt;
printf("['%lu' Produce %d] current cnt (%d)\n", pthread_self(), pdata->value, pworkq->cnt);
#if 0
if (pworkq->cnt == 1) {
PCHECK(pthread_cond_broadcast(
&pworkq->got_producer_cond)); /* 通知消费者可以继续消费了 */
}
#endif
PCHECK(pthread_mutex_unlock(&pworkq->lock));
PCHECK(pthread_cond_broadcast(
&pworkq->got_producer_cond)); /* 通知消费者可以继续消费了 */
}
int
main(int argc, char *argv[])
{
int s;
int i;
int num_live, count;
if(argc == 1)
{
fprintf(stderr, "Need at least one sleep time arg\n");
exit(1);
}
count = argc - 1;
workers = calloc(count, sizeof(*workers));
if(workers == NULL)
{
perror("calloc");
exit(1);
}
for(i = 0; i < count; ++i)
{
workers[i].idx = i;
workers[i].sleep = strtol(argv[i + 1], NULL, 10);
workers[i].state = WORKING;
s = pthread_create(&(workers[i].id), NULL, &thread_fn, &(workers[i].idx));
PCHECK(s);
printf("created %d\n", i);
}
num_live = count;
while(num_live > 0)
{
int idx;
s = pthread_mutex_lock(&mtx);
PCHECK(s);
while(num_done == 0)
{
s = pthread_cond_wait(&cond, &mtx);
PCHECK(s);
}
for(i = 0; i < count; ++i)
{
if(workers[i].state == DONE)
{
s = pthread_join(workers[i].id, NULL);
PCHECK(s);
workers[i].state = JOINED;
num_done--;
num_live--;
printf("joined %d\n", i);
}
}
s = pthread_mutex_unlock(&mtx);
PCHECK(s);
}
return EXIT_SUCCESS;
}
void CaptureFD::release() {
if (oldFDCopy_ != fd_) {
readIncremental(); // Feed chunkCob_
PCHECK(dup2(oldFDCopy_, fd_) != -1) << "Could not restore old FD "
<< oldFDCopy_ << " into " << fd_;
PCHECK(close(oldFDCopy_) != -1) << "Could not close " << oldFDCopy_;
oldFDCopy_ = fd_; // Make this call idempotent
}
}
int
pipe_start(pipe_t *pipe, int value) {
PCHECK(pthread_mutex_lock(&pipe->mutex));
pipe->active++;
PCHECK(pthread_mutex_unlock(&pipe->mutex));
//诛仙乘首先进来
pipe_send(pipe->head, value);
return 0;
}
CaptureFD::CaptureFD(int fd, ChunkCob chunk_cob)
: chunkCob_(std::move(chunk_cob)), fd_(fd), readOffset_(0) {
oldFDCopy_ = dup(fd_);
PCHECK(oldFDCopy_ != -1) << "Could not copy FD " << fd_;
int file_fd = open(file_.path().string().c_str(), O_WRONLY|O_CREAT, 0600);
PCHECK(dup2(file_fd, fd_) != -1) << "Could not replace FD " << fd_
<< " with " << file_fd;
PCHECK(close(file_fd) != -1) << "Could not close " << file_fd;
}
/// 2个线程同时写一个共享数据，使用RWL保护
void* lock_add(void *arg)
{
for (int i=0; i< COUNT; ++i) {
PCHECK(pthread_rwlock_wrlock(&rwl));
++lock_sum;
PCHECK(pthread_rwlock_unlock(&rwl));
}
printf("thread:%lu lock_sum:%d\n", (unsigned long)pthread_self(), lock_sum);
return 0;
}
Sock(int fd_in, int fd_out)
: iostream_(fd_in, fd_out)
, us_addr_len_(sizeof us_addr_)
, them_addr_len_(sizeof them_addr_)
, us_addr_str_{ '\0' }
, them_addr_str_{ '\0' }
{
// Get our local IP address as "us".
if (-1 != getsockname(fd_in, reinterpret_cast<struct sockaddr*>(&us_addr_),
&us_addr_len_)) {
switch (us_addr_len_) {
case sizeof(sockaddr_in) :
PCHECK(inet_ntop(AF_INET, &(reinterpret_cast<struct sockaddr_in*>(
&us_addr_)->sin_addr),
us_addr_str_, sizeof us_addr_str_) != nullptr);
break;
case sizeof(sockaddr_in6) :
PCHECK(inet_ntop(AF_INET6, &(reinterpret_cast<struct sockaddr_in6*>(
&us_addr_)->sin6_addr),
us_addr_str_, sizeof us_addr_str_) != nullptr);
break;
default:
LOG(ERROR) << "bogus address length (" << us_addr_len_
<< ") returned from getsockname";
}
} else {
CHECK_EQ(ENOTSOCK, errno); // only acceptable error from getsockname
}
// Get the remote IP address as "them".
if (-1 != getpeername(fd_out,
reinterpret_cast<struct sockaddr*>(&them_addr_),
&them_addr_len_)) {
switch (them_addr_len_) {
case sizeof(sockaddr_in) :
PCHECK(inet_ntop(AF_INET, &(reinterpret_cast<struct sockaddr_in*>(
&them_addr_)->sin_addr),
them_addr_str_, sizeof them_addr_str_) != nullptr);
break;
case sizeof(sockaddr_in6) :
PCHECK(inet_ntop(AF_INET6, &(reinterpret_cast<struct sockaddr_in6*>(
&them_addr_)->sin6_addr),
them_addr_str_, sizeof them_addr_str_) != nullptr);
break;
default:
LOG(ERROR) << "bogus address length (" << them_addr_len_
<< ") returned from getpeername";
}
} else {
// Ignore ENOTSOCK errors from getpeername, useful for testing.
PLOG_IF(WARNING, ENOTSOCK != errno) << "getpeername failed";
}
}
void MemoryMapping::init(File file,
off_t offset, off_t length,
int prot,
bool grow) {
off_t pageSize = sysconf(_SC_PAGESIZE);
CHECK_GE(offset, 0);
// Round down the start of the mapped region
size_t skipStart = offset % pageSize;
offset -= skipStart;
file_ = std::move(file);
mapLength_ = length;
if (mapLength_ != -1) {
mapLength_ += skipStart;
// Round up the end of the mapped region
mapLength_ = (mapLength_ + pageSize - 1) / pageSize * pageSize;
}
// stat the file
struct stat st;
CHECK_ERR(fstat(file_.fd(), &st));
off_t remaining = st.st_size - offset;
if (mapLength_ == -1) {
length = mapLength_ = remaining;
} else {
if (length > remaining) {
if (grow) {
PCHECK(0 == ftruncate(file_.fd(), offset + length))
<< "ftructate() failed, couldn't grow file";
remaining = length;
} else {
length = remaining;
}
}
if (mapLength_ > remaining) mapLength_ = remaining;
}
if (length == 0) {
mapLength_ = 0;
mapStart_ = nullptr;
} else {
unsigned char* start = static_cast<unsigned char*>(
mmap(nullptr, mapLength_, prot, MAP_SHARED, file_.fd(), offset));
PCHECK(start != MAP_FAILED)
<< " offset=" << offset
<< " length=" << mapLength_;
mapStart_ = start;
data_.reset(start + skipStart, length);
}
}
int main() {
pthread_t thread_id = 0 ;
void *thread_result = NULL;
PCHECK(pthread_create(&thread_id, NULL, thread_routine, NULL));
PCHECK(pthread_join(thread_id, &thread_result));
if (thread_result == (void*)NULL) {
printf("thread return nULL\n") ;
return 0 ;
}
else
return 1 ;
}
int lpc_open(const char* cpszLpcPath, const char* cpszRdWr, unsigned char bCreate, LPC* pLPC)
{
CHECK_NOTNULL(cpszLpcPath);
CHECK_NOTNULL(cpszRdWr);
CHECK_NOTNULL(pLPC);
if(bCreate)
{
remove(cpszLpcPath);
PCHECK(0 == mkfifo(cpszLpcPath, 0777)) << "mkfifo " << cpszLpcPath << " failed with " << strerror(errno);
}
int iOpenFlags = 0;
if('w' == cpszRdWr[0])
{
iOpenFlags = O_WRONLY;
}
else if('r' == cpszRdWr[0])
{
iOpenFlags = O_RDONLY;
}
else
{
LOG(FATAL) << "cpszRdWr [" << cpszRdWr << "]is invalid";
return LPC_RET_INVALID_PARAM_IN;;
}
iOpenFlags = O_RDWR | O_NONBLOCK;
int fd;
FILE* fp;
PCHECK((fd = open(cpszLpcPath, iOpenFlags)) > 0)
<< "open " << cpszLpcPath << " failed with :" << strerror(errno);
PCHECK((fp = fdopen(fd, cpszRdWr)) != NULL)
<< "fdopen " << fd << " failed with : " << strerror(errno);
LPC lpc;
PCHECK((lpc = (LPC)calloc(1, sizeof(LPCInfo))) != NULL)
<< "calloc failed";
lpc->fd = fd;
lpc->fp = fp;
*pLPC = lpc;
return LPC_RET_OK;
}
int main(void)
{
PCHECK(pthread_rwlock_init(&rwl, NULL));
pthread_t ptid[2];
PCHECK(pthread_create(&ptid[0], NULL, lock_add, NULL));
PCHECK(pthread_create(&ptid[1], NULL, lock_add, NULL));
for (int i=0; i<2; ++i)
pthread_join(ptid[i], NULL/*not care thread return code */);
printf("lock_sum:%d\n", lock_sum);
return EXIT_SUCCESS;
} /* ---------- end of function main ---------- */
void WorkerThread::setup() {
sigset_t ss;
// Ignore some signals
sigemptyset(&ss);
sigaddset(&ss, SIGHUP);
sigaddset(&ss, SIGINT);
sigaddset(&ss, SIGQUIT);
sigaddset(&ss, SIGUSR1);
sigaddset(&ss, SIGUSR2);
sigaddset(&ss, SIGPIPE);
sigaddset(&ss, SIGALRM);
sigaddset(&ss, SIGTERM);
sigaddset(&ss, SIGCHLD);
sigaddset(&ss, SIGIO);
PCHECK(pthread_sigmask(SIG_BLOCK, &ss, nullptr) == 0);
// Update the currentWorker_ thread-local pointer
CHECK(nullptr == currentWorker_);
currentWorker_ = this;
// Update the manager with the event base this worker runs on
if (eventBaseManager_) {
eventBaseManager_->setEventBase(&eventBase_, false);
}
}
/* Provide output */
prng_error_status
prngOutput(PRNG *p, BYTE *outbuf,UINT outbuflen)
{
UINT i;
GEN_CTX *ctx = &p->outstate;
CHECKSTATE(p);
GENCHECK(p);
PCHECK(outbuf);
chASSERT(BACKTRACKLIMIT > 0);
for(i=0;i<outbuflen;i++,ctx->index++,ctx->numout++)
{
/* Check backtracklimit */
if(ctx->numout > BACKTRACKLIMIT)
{
prng_do_SHA1(ctx);
prng_make_new_state(ctx, ctx->out);
}
/* Check position in IV */
if(ctx->index>=20)
{
prng_do_SHA1(ctx);
}
/* Output data */
outbuf[i] = (ctx->out)[ctx->index];
}
return PRNG_SUCCESS;
}
int defaultPageProgram(FlashChipBase *base, FlashPageProgramMode mode, uint32_t waddr, const uint8_t *wdata, uint32_t size)
{
PCHECK(base);
INSTRUCT_ZCREATE(cmd, addr, dummy, data);
if (size > base->mPageSize)
return -1;
if (!(mode & base->mPageProgramSupport)) {
FLASH_NOTSUPPORT();
return HAL_INVALID;
}
if (((waddr + size) > base->mSize) || (size > base->mPageSize))
return -1;
if (mode == FLASH_PAGEPROGRAM)
{
cmd.data = FLASH_INSTRUCTION_PP;
data.line = 1;
}
else if (mode == FLASH_QUAD_PAGEPROGRAM)
{
cmd.data = FLASH_INSTRUCTION_QPP;
data.line = 4;
}
else
FLASH_NOWAY();
addr.data = waddr;
addr.line = 1;
data.pdata = (uint8_t *)wdata;
data.len = size;
return base->driverWrite(base, &cmd, &addr, NULL, &data);
}
static FlashChipBase *EN25QHXXA_FlashCtor(uint32_t arg)
{
EN25QHXXA_Flash *impl = malloc(sizeof(EN25QHXXA_Flash));
uint32_t jedec = arg;
uint32_t size;
PCHECK(impl);
HAL_Memset(impl, 0, sizeof(EN25QHXXA_Flash));
if (jedec == EN25QH64A_JEDEC) {
size = 128 * 16 * 0x1000;
}
else {
return NULL;
}
impl->base.mJedec = jedec;
impl->base.mPageSize = 256;
impl->base.mSize = size;
impl->base.mMaxFreq = 104 * 1000 * 1000;
impl->base.mMaxReadFreq = 83 * 1000 * 1000;
impl->base.mEraseSizeSupport = FLASH_ERASE_64KB | FLASH_ERASE_32KB | FLASH_ERASE_4KB | FLASH_ERASE_CHIP;
impl->base.mPageProgramSupport = FLASH_PAGEPROGRAM | FLASH_QUAD_PAGEPROGRAM;
impl->base.mReadStausSupport = FLASH_STATUS1 | FLASH_STATUS2 | FLASH_STATUS3;
impl->base.mWriteStatusSupport = FLASH_STATUS1 | FLASH_STATUS3;//
impl->base.mReadSupport = FLASH_READ_NORMAL_MODE | FLASH_READ_FAST_MODE | FLASH_READ_DUAL_O_MODE
| FLASH_READ_DUAL_IO_MODE | FLASH_READ_QUAD_O_MODE | FLASH_READ_QUAD_IO_MODE;
impl->base.mFlashStatus = 0;
impl->base.mDummyCount = 1;
return &impl->base;
}
int EN25QHXXA_ReadStatus(FlashChipBase *base, FlashStatus reg, uint8_t *status)
{
PCHECK(base);
INSTRUCT_ZCREATE(cmd, addr, dummy, data);
if (!(reg & base->mReadStausSupport)) {
FLASH_NOTSUPPORT();
return -1;
}
if (reg == FLASH_STATUS1)
{
cmd.data = FLASH_INSTRUCTION_RDSR;
}
else if (reg == FLASH_STATUS2)
{
cmd.data = FLASH_INSTRUCTION_RDSR2;
}
else if (reg == FLASH_STATUS3)
{
cmd.data = FLASH_INSTRUCTION_RDSR3;
}
else
FLASH_NOWAY();
data.pdata = (uint8_t *)status;
data.len = 1;
data.line = 1;
return base->driverRead(base, &cmd, NULL, NULL, &data);
}
int defaultSetFreq(FlashChipBase *base, uint32_t freq)
{
PCHECK(base);
INSTRUCT_ZCREATE(cmd, addr, dummy, data);
return base->mDriver->setFreq(base->mDriver, freq);
}
int defaultSwitchReadMode(FlashChipBase *base, FlashReadMode mode)
{
PCHECK(base);
uint8_t status;
int ret;
if (!(mode & base->mReadSupport)) {
FLASH_NOTSUPPORT();
return HAL_INVALID;
}
if (!((base->mReadStausSupport & FLASH_STATUS2) && (base->mWriteStatusSupport & FLASH_STATUS2))) {
//do not need switch
return 0;
}
if (mode == FLASH_READ_QUAD_O_MODE || mode == FLASH_READ_QUAD_IO_MODE || mode == FLASH_READ_QPI_MODE)
{
ret = base->readStatus(base, FLASH_STATUS2, &status);
if (ret < 0)
return -1;
status |= 1 << 1;
ret = base->writeStatus(base, FLASH_STATUS2, &status);
}
else
{
ret = base->readStatus(base, FLASH_STATUS2, &status);
if (ret < 0)
return -1;
status &= ~(1 << 1);
ret = base->writeStatus(base, FLASH_STATUS2, &status);
}
return ret;
}
static FlashChipBase *DefaultFlashCtor(void)
{
DefaultFlash *impl = malloc(sizeof(DefaultFlash));
PCHECK(impl);
memset(impl, 0, sizeof(DefaultFlash));
FLASH_DEBUG("create default chip");
impl->base.mPageSize = 256;
impl->base.mSize = -1;
impl->base.mMaxFreq = -1;
impl->base.mMaxReadFreq = -1;
/*
impl->base.mEraseSizeSupport = FLASH_ERASE_64KB | FLASH_ERASE_CHIP;
impl->base.mPageProgramSupport = FLASH_PAGEPROGRAM;
impl->base.mReadStausSupport = FLASH_STATUS1;
impl->base.mWriteStatusSupport = FLASH_STATUS1;
impl->base.mReadSupport = FLASH_READ_NORMAL_MODE | FLASH_READ_FAST_MODE;
*/
impl->base.mEraseSizeSupport = FLASH_ERASE_4KB | FLASH_ERASE_32KB | FLASH_ERASE_64KB | FLASH_ERASE_CHIP;
impl->base.mPageProgramSupport = FLASH_PAGEPROGRAM;
impl->base.mReadStausSupport = FLASH_STATUS1;
impl->base.mWriteStatusSupport = FLASH_STATUS1;
impl->base.mReadSupport = FLASH_READ_NORMAL_MODE | FLASH_READ_FAST_MODE | FLASH_READ_DUAL_O_MODE;
return &impl->base;
}
unsigned char* borrow(size_t size) {
std::lock_guard<folly::SpinLock> lg(lock_);
assert(storage_);
auto as = allocSize(size);
if (as != allocSize_ || freeList_.empty()) {
return nullptr;
}
auto p = freeList_.back().first;
if (!freeList_.back().second) {
PCHECK(0 == ::mprotect(p, pagesize(), PROT_NONE));
}
freeList_.pop_back();
/* We allocate minimum number of pages required, plus a guard page.
Since we use this for stack storage, requested allocation is aligned
at the top of the allocated pages, while the guard page is at the bottom.
-- increasing addresses -->
Guard page Normal pages
|xxxxxxxxxx|..........|..........|
<- allocSize_ ------------------->
p -^ <- size -------->
limit -^
*/
auto limit = p + allocSize_ - size;
assert(limit >= p + pagesize());
return limit;
}
TemporaryDirectory::TemporaryDirectory(const char* dirnamePrefix) {
static const char* mkdtempSuffix = ".XXXXXX";
boost::filesystem::path tmpDir = boost::filesystem::temp_directory_path();
// add one for "/" and one for string null terminator
int tmpDirLen = tmpDir.string().size() + strlen(dirnamePrefix) +
strlen(mkdtempSuffix) + 2;
// this actually needs to be a char * (not a const char * and not a
// std::string) to pass to mkdtemp, because mkdtemp mutates the template
// string to create a randomized location
char templateDirName[tmpDirLen];
snprintf(
templateDirName,
tmpDirLen,
"%s/%s%s",
tmpDir.string().c_str(),
dirnamePrefix,
mkdtempSuffix);
// mkdtemp does magic where it overwrites templateDirName with the finalized
// value and then also returns it (thus dn) if it succeeds or null if failure
char* dn = mkdtemp(templateDirName);
dirname_ = templateDirName;
PCHECK(dn != nullptr) << "mkdtemp(" << dirname_ << ")";
}
int defaultPowerDown(FlashChipBase *base)
{
PCHECK(base);
INSTRUCT_ZCREATE(cmd, addr, dummy, data);
cmd.data = FLASH_INSTRUCTION_PWDN;
return base->driverWrite(base, &cmd, NULL, NULL, NULL);
}
int defaultResumeErasePageprogram(FlashChipBase *base)
{
PCHECK(base);
INSTRUCT_ZCREATE(cmd, addr, dummy, data);
cmd.data = FLASH_INSTRUCTION_EPRS;
return base->driverWrite(base, &cmd, NULL, NULL, NULL);
}
void EventModule::ModuleInit()
{
// TCP 初始化
listen_fd_ = socket(AF_INET, SOCK_STREAM, 0);
PCHECK(listen_fd_ > 0)
<< "socket error!";
Epoller::SetNonBlock(listen_fd_);
Epoller::SetSocketOpt(listen_fd_);
ConfigModule* conf_module = FindModule<ConfigModule>(app_);
int32_t listen_port = conf_module->config().listen_port();
struct sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = 0;
sin.sin_port = htons(listen_port);
CHECK(bind(listen_fd_, (struct sockaddr*)&sin, sizeof(sin)) == 0)
<< "bind error!";
CHECK(listen(listen_fd_, 32) == 0)
<< "listen error!";
// ZMQ初始化
zmq_ctx_ = zmq_init(1);
PCHECK(zmq_ctx_ != NULL)
<< "zmq_init error!";
zmq_sock_ = zmq_socket(zmq_ctx_, ZMQ_PAIR);
PCHECK(zmq_sock_ != NULL)
<< "zmq_socket error!";
PCHECK(zmq_connect(zmq_sock_, conf_module->config().gamesvr_zmq_addr().c_str()) == 0)
<< "zmq_connect error!";
// 初始化 Epoller
int32_t conn_pool_size = conf_module->config().conn_pool_size();
epoller_ = new Epoller();
epoller_->Init(conn_pool_size);
// 增加tcp accept事件
int ret = epoller_->AddEvent(listen_fd_, EVENT_READ, EventModule::DoTcpAccept, (void*)epoller_);
CHECK(ret == 0)
<< "epoller_.AddEvent error.";
LOG(INFO) << ModuleName() << " init ok!";
}
static int EN25QHXXA_FlashDeinit(FlashChipBase * base)
{
PCHECK(base);
EN25QHXXA_Flash *impl = __containerof(base, EN25QHXXA_Flash, base);
free(impl);
return 0;
}
