void _processFlush() {
int i = 0;
struct so_t* so = NULL;
lock_lock(mGs->mQLock);
i = mGs->mQn;
lock_unlock(mGs->mQLock);
for (;i >0; i--) {
lock_lock(mGs->mQLock);
if (!mGs->mWHead)
so = NULL;
else {
so = mGs->mWHead;
mGs->mWHead = so->next;
if (!mGs->mWHead) {
assert(so == mGs->mWTail);
assert(mGs->mQn == 1);
mGs->mWTail = NULL;
}
--mGs->mQn;
}
lock_unlock(mGs->mQLock);
if (!so)
break;
_lockW(so);
so->mInq = 0;
_flush(so);
_unlockW(so);
}
}
int logger_write(klogger_t* logger, int level, const char* format, ...) {
char buffer[64] = {0};
static const char* logger_level_name[] = { 0, "VERB", "INFO", "WARN", "ERRO", "FATA" };
va_list va_ptr_file;
va_list va_ptr_console;
verify(logger);
verify(format);
if (logger->level > level) {
/* 日志等级不足 */
return error_ok;
}
va_start(va_ptr_file, format);
va_start(va_ptr_console, format);
time_get_string(buffer, sizeof(buffer));
if (logger->mode & logger_mode_file) {
/* 写入日志文件 */
lock_lock(logger->lock);
fprintf(logger->fd, "[%s][%s]", logger_level_name[level], buffer);
vfprintf(logger->fd, format, va_ptr_file);
fprintf(logger->fd, "\n");
if (logger->mode & logger_mode_flush) {
/* 立即写入 */
fflush(logger->fd);
}
lock_unlock(logger->lock);
}
if (logger->mode & logger_mode_console) {
/* 写入stderr */
lock_lock(logger->lock);
if (level == logger_level_verbose) {
set_console_blue();
} else if (level == logger_level_information) {
set_console_white();
} else if (level == logger_level_warning) {
set_console_green();
} else if (level == logger_level_error) {
set_console_red();
} else if (level == logger_level_fatal) {
set_console_yellow();
}
fprintf(stderr, "[%s][%s]", logger_level_name[level], buffer);
vfprintf(stderr, format, va_ptr_console);
fprintf(stderr, "\n");
if (logger->mode & logger_mode_flush) {
/* 立即写入 */
fflush(stderr);
}
lock_unlock(logger->lock);
}
set_console_white();
va_end(va_ptr_file);
va_end(va_ptr_console);
return error_ok;
}
bool nic_free(Packet* packet) {
NIC* nic = nic_find_by_packet(packet);
if(nic == NULL)
return false;
uint8_t* bitmap = (void*)nic + nic->pool.bitmap;
uint32_t count = nic->pool.count;
void* pool = (void*)nic + nic->pool.pool;
uint32_t idx = ((uintptr_t)packet - (uintptr_t)pool) / NIC_CHUNK_SIZE;
if(idx >= count)
return false;
uint8_t req = bitmap[idx];
if(idx + req > count)
return false;
for(uint32_t i = idx + req - 1; i > idx; i--) {
bitmap[i] = 0;
}
bitmap[idx] = 0; // if idx is zero, it for loop will never end
lock_lock(&nic->pool.lock);
nic->pool.used -= req;
lock_unlock(&nic->pool.lock);
return true;
}
/* Handle a DHCPDISCOVER message. */
static uint32_t discover(uint64_t hwaddr, uint32_t *siaddr) {
lock_lock();
/* Figure out a suitable IP address to offer them */
uint32_t offer;
do {
offer = (my_ip & ~0xff) | (uint32_t)next_offer_octet;
next_offer_octet++;
} while ((offer & 0xff) == 0 || offer == my_ip ||
offer == routing_table[0] || offer == routing_table[1] ||
offer == routing_table[2] || offer == routing_table[3]);
lock_unlock();
/* Pass them our IP address so they can pass it back to us when requested
* IP assignment. This thing is in the DHCP spec to allow for multiple DHCP
* servers on the same network.
*/
*siaddr = my_ip;
char pretty_ip[STRLEN_IP];
ip_to_string(offer, pretty_ip);
dprintf("%s: Sending DHCPOFFER of IP %s\n", get_instance_name(), pretty_ip);
return offer;
}
int main(void)
{
const int cpu = procnum();
lock_lock(&lock);
printf("Hello from processor %d\n", procnum());
lock_unlock(&lock);
set_irq_handler(irq_handler);
enable_hw_irq(0);
irq_enable();
soclib_io_set(
base(TIMER),
procnum()*TIMER_SPAN+TIMER_PERIOD,
period[cpu]);
soclib_io_set(
base(TIMER),
procnum()*TIMER_SPAN+TIMER_MODE,
TIMER_RUNNING|TIMER_IRQ_ENABLED);
while (1)
pause();
return 0;
}
enum nss_status internal_function
__nss_cdb_endent(struct nss_cdb *dbp) {
lock_lock(lock);
if (isopen(dbp))
__nss_cdb_doendent(dbp);
lock_unlock(lock);
return NSS_STATUS_SUCCESS;
}
int fileno(FILE *stream)
{
int fd;
lock_lock(&(stream->lock));
fd = stream->fd;
lock_unlock(&(stream->lock));
return fd;
}
void gt_add(uint32_t from, uint32_t ticks, uint32_t session) {
struct ud_t *ud = (struct ud_t*)MALLOC(sizeof(*ud));
ud->from = from;
ud->session = session;
lock_lock(gT->mLock);
timer_add(gT->mTimer, ticks, ud, _cb, 1);
lock_unlock(gT->mLock);
}
int ferror(FILE *stream)
{
int res;
lock_lock(&(stream->lock));
res = ((stream->flags & FILE_FLAG_ERROR) != 0);
lock_unlock(&(stream->lock));
return res;
}
int feof(FILE *stream)
{
int res;
lock_lock(&(stream->lock));
res = ((stream->flags & FILE_FLAG_EOF) != 0);
lock_unlock(&(stream->lock));
return res;
}
off_t ftello(FILE *stream)
{
off_t offset;
lock_lock(&(stream->lock));
offset = unsafely_get_stream_offset(stream);
lock_unlock(&(stream->lock));
return offset;
}
uint32_t window_get_seq_counter(Window* window) {
uint32_t seq_counter;
lock_lock(&window->seq_counter_lock);
seq_counter = ++window->seq_counter;
lock_unlock(&window->seq_counter_lock);
return seq_counter;
}
int logger_write(logger_t* logger, logger_level_e level, const char* format, ...) {
char buffer[64] = {0};
int bytes = 0;
static const char* logger_level_name[] = { 0, "VERB", "INFO", "WARN", "ERRO", "FATA" };
va_list arg_ptr;
assert(logger);
assert(format);
if (logger->level > level) {
/* 日志等级不足 */
return error_ok;
}
va_start(arg_ptr, format);
time_get_string(buffer, sizeof(buffer));
if (logger->mode & logger_mode_file) {
/* 写入日志文件 */
lock_lock(logger->lock);
fprintf(logger->fd, "[%s][%s]", logger_level_name[level], buffer);
bytes = vfprintf(logger->fd, format, arg_ptr);
if (bytes <= 0) {
lock_unlock(logger->lock);
return error_logger_write;
}
fprintf(logger->fd, "\n");
if (logger->mode & logger_mode_flush) {
/* 立即写入 */
fflush(logger->fd);
}
lock_unlock(logger->lock);
}
if (logger->mode & logger_mode_console) {
/* 写入stderr */
lock_lock(logger->lock);
fprintf(stderr, "[%s][%s]", logger_level_name[level], buffer);
vfprintf(stderr, format, arg_ptr);
fprintf(stderr, "\n");
if (logger->mode & logger_mode_flush) {
/* 立即写入 */
fflush(stderr);
}
lock_unlock(logger->lock);
}
va_end(arg_ptr);
return error_ok;
}
void gq_worker_end(struct mq_t *mq) {
mq_lock(mq);
assert(mq->mIsG);
if (!mq_empty(mq)) {
lock_lock(mGq->mLock);
gq_push_mq_raw(mq);
lock_unlock(mGq->mLock);
} else
mq->mIsG = 0;
mq_unlock(mq);
}
int fflush(FILE *stream)
{
if(stream != NULL) {
int res;
lock_lock(&(stream->lock));
res = __uportlibc_unsafely_flush_stream(stream);
lock_unlock(&(stream->lock));
return res;
} else
return __uportlibc_for_each_stream(fflush);
}
enum nss_status internal_function
__nss_cdb_setent(struct nss_cdb *dbp, int stayopen) {
enum nss_status r;
lock_lock(lock);
if (isopen(dbp) || __nss_cdb_dosetent(dbp))
r = NSS_STATUS_SUCCESS, dbp->keepopen |= stayopen;
else
r = NSS_STATUS_UNAVAIL;
lock_unlock(lock);
return r;
}
enum nss_status internal_function
__nss_cdb_getent(struct nss_cdb *dbp,
void *result, char *buf, size_t bufl, int *errnop) {
enum nss_status r;
if (bufl < 30)
return *errnop = ERANGE, NSS_STATUS_TRYAGAIN;
lock_lock(lock);
dbp->keepopen |= 1;
r = __nss_cdb_dogetent(dbp, result, buf, bufl, errnop);
lock_unlock(lock);
return r;
}
void gq_push_msg(struct mq_t *mq, struct msg_t *msg) {
mq_lock(mq);
mq_push_raw(mq, msg);
if (!mq->mIsG) {
assert(!mq->mNext);
lock_lock(mGq->mLock);
gq_push_mq_raw(mq);
lock_unlock(mGq->mLock);
mq->mIsG = 1;
}
mq_unlock(mq);
}
void _pushWQ(struct so_t *so) {
lock_lock(mGs->mQLock);
if (!mGs->mWTail) {
assert(!mGs->mWHead);
mGs->mWHead = mGs->mWTail = so;
mGs->mQn = 1;
} else {
mGs->mWTail->next = so;
mGs->mQn = mGs->mQn + 1;
}
so->next = NULL;
lock_unlock(mGs->mQLock);
}
struct msg_t *mq_pop(struct mq_t *mq) {
struct msg_t *msg = NULL;
lock_lock(mq->mLock);
msg = mq->mHead;
if (msg) {
mq->mHead = msg->next;
if (!mq->mHead) {
assert(mq->mTail == msg);
mq->mTail = NULL;
}
}
lock_unlock(mq->mLock);
return msg;
}
int fseeko(FILE *stream, off_t offset, int whence)
{
int res;
lock_lock(&(stream->lock));
do {
if(unsafely_set_stream_offset(stream, offset, whence) == -1) {
res = -1;
break;
}
memset(&(stream->mb_state), 0, sizeof(mbstate_t));
res = 0;
} while(0);
lock_unlock(&(stream->lock));
return res;
}
int fsetpos(FILE *stream, const fpos_t *pos)
{
int res;
lock_lock(&(stream->lock));
do {
if(unsafely_set_stream_offset(stream, pos->offset, SEEK_SET) == -1) {
res = -1;
break;
}
stream->mb_state = pos->mb_state;
res = 0;
} while(0);
lock_unlock(&(stream->lock));
return res;
}
struct mq_t *gq_pop() {
struct mq_t *mq = NULL;
lock_lock(mGq->mLock);
mq = mGq->mHead;
if (mq) {
mGq->mHead = mq->mNext;
if (!mGq->mHead) {
assert(mGq->mTail == mq);
mGq->mTail = NULL;
}
mq->mNext = NULL;
}
lock_unlock(mGq->mLock);
return mq;
}
int safe_warn(server *srv, const char *format, ...) {
/* displays a warning */
lock_lock (&srv->master->lock_log);
va_list args;
printf ("WARNING ");
va_start (args, format);
vprintf (format, args);
va_end (args);
printf ("\n");
lock_unlock (&srv->master->lock_log);
return 0;
}
int main(void)
{
const int cpu = procnum();
int i;
printf("Cpu %x booted\n", cpu);
for (i=0; i<100; ++i) {
lock_lock(&lock);
printf("Hello from cpu %x\n", cpu);
lock_unlock(&lock);
}
if (atomic_inc(&count) == 4)
exit(0);
while(1);
}
enum nss_status internal_function
__nss_cdb_byname(struct nss_cdb *dbp, const char *name,
void *result, char *buf, size_t bufl, int *errnop) {
enum nss_status r;
if (*name == ':')
return *errnop = ENOENT, NSS_STATUS_NOTFOUND;
lock_lock(lock);
if (!isopen(dbp) && !__nss_cdb_dosetent(dbp))
*errnop = errno, r = NSS_STATUS_UNAVAIL;
else {
r = __nss_cdb_dobyname(dbp, name, strlen(name), result, buf, bufl, errnop);
if (!dbp->keepopen)
__nss_cdb_doendent(dbp);
}
lock_unlock(lock);
return r;
}
enum nss_status internal_function
__nss_cdb_byid(struct nss_cdb *dbp, unsigned long id,
void *result, char *buf, size_t bufl, int *errnop) {
enum nss_status r;
if (bufl < 30)
return *errnop = ERANGE, NSS_STATUS_TRYAGAIN;
lock_lock(lock);
if (!isopen(dbp) && !__nss_cdb_dosetent(dbp))
*errnop = errno, r = NSS_STATUS_UNAVAIL;
else {
r = __nss_cdb_dobyid(dbp, id, result, buf, bufl, errnop);
if (!dbp->keepopen)
__nss_cdb_doendent(dbp);
}
lock_unlock(lock);
return r;
}
int putw(int w, FILE *stream)
{
union word word_union;
size_t i;
int res;
word_union.word = w;
res = 0;
lock_lock(&(stream->lock));
for(i = 0; i < WORD_BIT / 8; i++) {
if(putc_unlocked(word_union.bytes[i], stream) == EOF) {
res = EOF;
break;
}
}
lock_unlock(&(stream->lock));
return res;
}
int fgetpos(FILE *stream, fpos_t *pos)
{
int res;
lock_lock(&(stream->lock));
do {
off_t offset = unsafely_get_stream_offset(stream);
if(offset == -1) {
res = -1;
break;
}
pos->offset = offset;
pos->mb_state = stream->mb_state;
res = 0;
} while(0);
lock_unlock(&(stream->lock));
return res;
}
size_t fread(void *ptr, size_t elem_size, size_t elem_count, FILE *stream)
{
char *buf = (char *) ptr;
size_t count, read_byte_count;
lock_lock(&(stream->lock));
if(__uportlibc_unsafely_prepare_stream_to_read(stream, -1) == EOF) return 0;
count = elem_size * elem_count;
read_byte_count = 0;
while(stream->pushed_c_count > 0 && count > 0) {
stream->pushed_c_count--;
*buf = stream->pushed_cs[stream->pushed_c_count];
buf++;
count--;
read_byte_count++;
}
if(stream->buf_type != _IONBF) {
while(stream->buf_data_cur != stream->buf_data_end && count > 0) {
*buf = *(stream->buf_data_cur);
buf++;
stream->buf_data_cur++;
count--;
read_byte_count++;
}
if(stream->buf_data_cur == stream->buf_data_end) {
stream->buf_data_cur = stream->buf;
stream->buf_data_end = stream->buf;
}
}
while(count > 0) {
size_t tmp_count = (count < SSIZE_MAX ? count : SSIZE_MAX);
ssize_t res = read(stream->fd, buf, tmp_count);
if(res == 0) {
stream->flags |= FILE_FLAG_EOF;
break;
}
if(res == -1) {
stream->flags |= FILE_FLAG_ERROR;
break;
}
buf += res;
count -= res;
read_byte_count += res;
}
lock_unlock(&(stream->lock));
return read_byte_count / elem_size;
}
