void dump_state()
{
disable_progress_bar();
printf("Queue and cache status dump\n");
printf("===========================\n");
printf("file buffer read queue (main thread -> reader thread)\n");
dump_queue(to_reader);
printf("file buffer decompress queue (reader thread -> inflate"
" thread(s))\n");
dump_queue(to_inflate);
printf("file buffer write queue (main thread -> writer thread)\n");
dump_queue(to_writer);
printf("\nbuffer cache (uncompressed blocks and compressed blocks "
"'in flight')\n");
dump_cache(data_cache);
printf("fragment buffer cache (uncompressed frags and compressed"
" frags 'in flight')\n");
dump_cache(fragment_cache);
enable_progress_bar();
}
void *iOS(void *t){
for(;;){
if( SYS_STATUS == OS_QUEUE_FAIL){ pthread_exit(NULL); }
pthread_mutex_lock(&count_mutex);
if( update_queue_time_out(&qptr,SYS_TIME) != QUEUE_OK ||
sort_queue_by_time_out(&qptr) != QUEUE_OK ){ printf("%s",encode(OS_QUEUE_EMPTY)); }
else{
if(check_queue_time_out(&qptr,&emgcy_qptr)!= QUEUE_OK ||
mv_queue_to_queue(&qptr,&emgcy_qptr) != QUEUE_OK ){ printf("%s,%s","iOS->",encode(OS_EQUEUE_FAIL));
SYS_STATUS = OS_QUEUE_FAIL;
pthread_exit(NULL); }
// emergency queue list exist
if(is_queue_empty(&emgcy_qptr)!= QUEUE_OK){
if( sort_queue_by_priority(&emgcy_qptr) != QUEUE_OK ||
get_queue_head(&emgcy_qptr,&pop_qptr) != QUEUE_OK ){ printf("%s,%s","iOS->",encode(OS_EQUEUE_FAIL));
SYS_STATUS = OS_QUEUE_FAIL;
pthread_exit(NULL); }
printf("\t%s,%d\n","@iOS work on emergency queue -> id @",pop_qptr->id);
update_queue_work_time(&pop_qptr,SYS_TIME);
if( check_queue_work_time(&pop_qptr) == QUEUE_OK ){
pop_queue_head(&emgcy_qptr,&pop_qptr);
}
printf("@NORMAL queue\n");
dump_queue(qptr);
printf("@EMERGENCY queue\n");
dump_queue(emgcy_qptr);
// normal queue list
}else {
if( sort_queue_by_priority(&qptr) != QUEUE_OK ||
get_queue_head(&qptr,&pop_qptr) != QUEUE_OK ){ printf("%s,%s","iOS->",encode(OS_QUEUE_FAIL));
SYS_STATUS = OS_QUEUE_FAIL;
pthread_exit(NULL); }
printf("\t%s,%d\n","@iOS work on normal queue -> id @",pop_qptr->id);
update_queue_work_time(&pop_qptr,SYS_TIME);
if( check_queue_work_time(&pop_qptr) == QUEUE_OK ){
pop_queue_head(&qptr,&pop_qptr);
}
printf("@NORMAL queue\n");
dump_queue(qptr);
printf("@EMERGENCY queue\n");
dump_queue(emgcy_qptr);
}
}
pthread_mutex_unlock(&count_mutex);
sleep(SYS_TIME);
}
}
//struct thread_pool* tp_init_thread_pool(struct thread_pool* pool, int numthr, void*(func)(void*), char* name )
struct thread_pool *tp_create_thread_pool(int numthr, void *(func) (void *), char *name)
{
struct thread_pool *pool;
int i;
if (numthr > MAX_THREAD_NUM) {
printf("Error!! numthr %d > MAX-THREAD-NUM\n", numthr);
return NULL;
}
/// alloc a thread-pool
pool = (struct thread_pool *) malloc(sizeof(struct thread_pool));
if (!pool) {
printf("Fail to create thrpool %s\n", name);
return NULL;
}
memset(pool, 0, sizeof(struct thread_pool));
// set thread-pool name
strncpy(pool->name, name, 15);
pool->name[15] = 0;
pool->num_threads = numthr;
// work-queue associated with thread-pool
pool->queue = create_queue("RR-queue");
if (pool->queue == NULL) {
error("Fail to create queue\n");
goto err_out_1;
}
dump_queue(pool->queue);
/// the mutex and bitmap is not necessary now...
pthread_mutex_init(&pool->mutex, NULL);
/// now bitmap is no longer needed in a thread-pool, replaced by a work-queue
bmp_init(&pool->bitmap, numthr, 1); // initially all bits are "1": free
//bmp_dump( &pool->bitmap);
/// create the thread-pool
for (i = 0; i < numthr; i++) {
//sem_init( &pool->sem[i], 0, 0); // init the sem-count to be 0
//pool->arg1[i] = 0;
//pool->arg2[i] = 0;
if (pthread_create(&pool->thread[i], NULL, func, (void *) pool) != 0) {
error("Error creating thread %d in pool %s\n", i, name);
}
}
//dbg("tpool %s: init bitmap= %s\n", pool->name, int_to_binary(pool->bitmap) );
printf("Have created tpool %s: thr-num = %d\n", pool->name, pool->num_threads);
return pool;
err_out_1:
tp_destroy_thread_pool(pool);
return NULL;
}
int main(int argc, char **argv)
{
int msg, pid, err;
struct msgque_data msgque;
msgque.key = ftok(argv[0], 822155650);
if (msgque.key == -1) {
printf("Can't make key\n");
return -errno;
}
msgque.msq_id = msgget(msgque.key, IPC_CREAT | IPC_EXCL | 0666);
if (msgque.msq_id == -1) {
err = -errno;
printf("Can't create queue\n");
goto err_out;
}
err = fill_msgque(&msgque);
if (err) {
printf("Failed to fill queue\n");
goto err_destroy;
}
err = dump_queue(&msgque);
if (err) {
printf("Failed to dump queue\n");
goto err_destroy;
}
err = check_and_destroy_queue(&msgque);
if (err) {
printf("Failed to check and destroy queue\n");
goto err_out;
}
err = restore_queue(&msgque);
if (err) {
printf("Failed to restore queue\n");
goto err_destroy;
}
err = check_and_destroy_queue(&msgque);
if (err) {
printf("Failed to test queue\n");
goto err_out;
}
return 0;
err_destroy:
if (msgctl(msgque.msq_id, IPC_RMID, 0)) {
printf("Failed to destroy queue: %d\n", -errno);
return -errno;
}
err_out:
return err;
}
static void cleanup(void) {
rmsckif();
if(haskey(& rc, "unix") && getpid() == ppid)
unlink(value(& rc, "unix"));
empty(& data);
empty(& rc);
empty(& track);
freelist(& playlist);
if(current_station) {
free(current_station);
current_station = NULL;
}
if(subfork)
waitpid(subfork, NULL, 0);
dump_queue();
/* Clean cache. */
if(!access(rcpath("cache"), R_OK | W_OK | X_OK)) {
const char * cache = rcpath("cache");
DIR * directory = opendir(cache);
if(directory != NULL) {
time_t expiry = 24 * 60 * 60; /* Expiration after 24h. */
struct dirent * entry;
struct stat status;
char path[PATH_MAX];
if(haskey(& rc, "expiry"))
expiry = atoi(value(& rc, "expiry"));
while((entry = readdir(directory)) != NULL) {
snprintf(path, sizeof(path), "%s/%s", cache, entry->d_name);
if(!stat(path, & status)) {
if(status.st_mtime < (time(NULL) - expiry)) {
unlink(path);
}
}
}
closedir(directory);
}
}
if(playfork)
kill(playfork, SIGUSR1);
}
int skge_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs)
{
const u32 *r = (const u32 *) regs->data;
int dual = !(regs->data[0x11a] & 1);
dump_pci(regs->data + 0x380);
dump_control(regs->data);
printf("\nBus Management Unit\n");
printf("-------------------\n");
printf("CSR Receive Queue 1 0x%08X\n", r[24]);
printf("CSR Sync Queue 1 0x%08X\n", r[26]);
printf("CSR Async Queue 1 0x%08X\n", r[27]);
if (dual) {
printf("CSR Receive Queue 2 0x%08X\n", r[25]);
printf("CSR Async Queue 2 0x%08X\n", r[29]);
printf("CSR Sync Queue 2 0x%08X\n", r[28]);
}
dump_mac(regs->data);
dump_gmac("GMAC 1", regs->data + 0x2800);
dump_timer("Timer", regs->data + 0x130);
dump_timer("Blink Source", regs->data +0x170);
dump_queue("Receive Queue 1", regs->data +0x400, 1);
dump_queue("Sync Transmit Queue 1", regs->data +0x600, 0);
dump_queue("Async Transmit Queue 1", regs->data +0x680, 0);
dump_ram("Receive RAMbuffer 1", regs->data+0x800);
dump_ram("Sync Transmit RAMbuffer 1", regs->data+0xa00);
dump_ram("Async Transmit RAMbuffer 1", regs->data+0xa80);
dump_fifo("Receive MAC FIFO 1", regs->data+0xc00);
dump_fifo("Transmit MAC FIFO 1", regs->data+0xd00);
if (dual) {
dump_gmac("GMAC 1", regs->data + 0x2800);
dump_queue("Receive Queue 2", regs->data +0x480, 1);
dump_queue("Async Transmit Queue 2", regs->data +0x780, 0);
dump_queue("Sync Transmit Queue 2", regs->data +0x700, 0);
dump_ram("Receive RAMbuffer 2", regs->data+0x880);
dump_ram("Sync Transmit RAMbuffer 2", regs->data+0xb00);
dump_ram("Async Transmit RAMbuffer 21", regs->data+0xb80);
dump_fifo("Receive MAC FIFO 2", regs->data+0xc80);
dump_fifo("Transmit MAC FIFO 2", regs->data+0xd80);
}
dump_timer("Descriptor Poll", regs->data+0xe00);
return 0;
}
void dump_queue(const FacadeReadInterface & facade, size_t limit,
FILE * stream)
{
dump_queue(facade.GetAlgorithm(), facade.GetGrid().get(), limit, stream);
}
int sky2_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs)
{
const u16 *r16 = (const u16 *) regs->data;
const u32 *r32 = (const u32 *) regs->data;
int dual;
dump_pci(regs->data + 0x1c00);
dump_control(regs->data);
printf("\nBus Management Unit\n");
printf("-------------------\n");
printf("CSR Receive Queue 1 0x%08X\n", r32[24]);
printf("CSR Sync Queue 1 0x%08X\n", r32[26]);
printf("CSR Async Queue 1 0x%08X\n", r32[27]);
dual = (regs->data[0x11e] & 2) != 0;
if (dual) {
printf("CSR Receive Queue 2 0x%08X\n", r32[25]);
printf("CSR Async Queue 2 0x%08X\n", r32[29]);
printf("CSR Sync Queue 2 0x%08X\n", r32[28]);
}
dump_mac(regs->data);
dump_prefetch("Status", regs->data + 0xe80);
dump_prefetch("Receive 1", regs->data + 0x450);
dump_prefetch("Transmit 1", regs->data + 0x450 + 0x280);
if (dual) {
dump_prefetch("Receive 2", regs->data + 0x450 + 0x80);
dump_prefetch("Transmit 2", regs->data + 0x450 + 0x380);
}
printf("\nStatus FIFO\n");
printf("\tWrite Pointer 0x%02X\n", regs->data[0xea0]);
printf("\tRead Pointer 0x%02X\n", regs->data[0xea4]);
printf("\tLevel 0x%02X\n", regs->data[0xea8]);
printf("\tWatermark 0x%02X\n", regs->data[0xeac]);
printf("\tISR Watermark 0x%02X\n", regs->data[0xead]);
dump_timer("Status level", regs->data + 0xeb0);
dump_timer("TX status", regs->data + 0xec0);
dump_timer("ISR", regs->data + 0xed0);
printf("\nGMAC control 0x%04X\n", r32[0xf00 >> 2]);
printf("GPHY control 0x%04X\n", r32[0xf04 >> 2]);
printf("LINK control 0x%02hX\n", r16[0xf10 >> 1]);
dump_gmac("GMAC 1", regs->data + 0x2800);
dump_gmac_fifo("Rx GMAC 1", regs->data + 0xc40);
dump_gmac_fifo("Tx GMAC 1", regs->data + 0xd40);
dump_queue2("Receive Queue 1", regs->data +0x400, 1);
dump_queue("Sync Transmit Queue 1", regs->data +0x600, 0);
dump_queue2("Async Transmit Queue 1", regs->data +0x680, 0);
dump_ram("Receive RAMbuffer 1", regs->data+0x800);
dump_ram("Sync Transmit RAMbuffer 1", regs->data+0xa00);
dump_ram("Async Transmit RAMbuffer 1", regs->data+0xa80);
if (dual) {
dump_ram("Receive RAMbuffer 2", regs->data+0x880);
dump_ram("Sync Transmit RAMbuffer 2", regs->data+0xb00);
dump_ram("Async Transmit RAMbuffer 21", regs->data+0xb80);
dump_gmac("GMAC 2", regs->data + 0x3800);
dump_gmac_fifo("Rx GMAC 2", regs->data + 0xc40 + 128);
dump_gmac_fifo("Tx GMAC 2", regs->data + 0xd40 + 128);
}
return 0;
}
