int main(void)
{
init_global();
init_gdt();
init_idt();
init_tss();
init_virtual_memory_mapping();
init_process();
init_8259a();
init_clock();
init_keyboard();
init_syscall();
debug_helper();
restart();
}
bool init_pic(void)
{
outb(PIC_MASTER_COMMAND, PIC_ICW1);
outb(PIC_SLAVE_COMMAND, PIC_ICW1);
outb(PIC_MASTER_DATA, IDT_ENTRY_PIC_MASTER);
outb(PIC_SLAVE_DATA, IDT_ENTRY_PIC_SLAVE);
outb(PIC_MASTER_DATA, PIC_MASTER_ICW3);
outb(PIC_SLAVE_DATA, PIC_SLAVE_ICW3);
outb(PIC_MASTER_DATA, PIC_MASTER_ICW4);
outb(PIC_SLAVE_DATA, PIC_SLAVE_ICW4);
outb(PIC_MASTER_IMR, (~PIC_IMR_MASK_IRQ0) & (~PIC_IMR_MASK_IRQ2));
// outb(PIC_MASTER_IMR, PIC_IMR_MASK_ALL);
outb(PIC_SLAVE_IMR, PIC_IMR_MASK_ALL);
bool state = true;
state = init_pit();
if (!state)
{
return false;
}
state = init_tss();
if (!state)
{
return false;
}
return true;
}
int kernel_main() {
init_kernel_stack(KERN_HEAP_OFFSET);
init_device_drivers();
device_open(TTY, 0);
k_printf("entered into main kernel..!\n");
k_printf("and initialized device drivers.\n");
init_gdt();
k_printf("initialized protected mode.\n");
check_physical_mem_size();
k_printf("physical memory size : %d megabytes.\n", physical_mem_size>>20);
init_paging();
k_printf("initialized paging.\n");
init_vfs();
k_printf("initialized file system (fat16).\n");
init_idt();
k_printf("initialized interrupt.\n");
init_tss();
struct fat16_file_kt f;
f = fs_open_fat16("/apps/snake.bin");
create_task(f.buffer, f.information.file_size);
dump_task_queue();
current_task = pop_task_queue();
create_task(init1, 256);
create_task(init2, 256);
create_task(init3, 256);
create_task(init4, 256);
create_task(init5, 256);
dump_task_queue();
/*
do {
struct task_struct_kt *cur = task_head;
do {
k_printf("#%d - stack %x, start %x\n", cur->tid, cur->sp_page, cur->start_entry);
cur = cur->next;
} while (cur != task_head);
} while(0);
*/
//for(;;); // user page가 제대로 동작할때까지 막아둠.
cli();
SCHEDULE();
for(;;);
device_close(TTY, 0);
return 0;
}
int main(int argc, char **argv)
{
int i = 0;
init_tss(&tss1);
init_tss(&tss2);
if (argc < 2 || argv[1] == NULL) {
printf("filename needed\n");
return -1;
}
i = syscall(__NR_mac_file_ctl, 0, argv[1], &tss2);
if (i < 0) {
perror("1get error");
return -1;
} else {
printf("mv %d, iv %d\n", tss2.mlevel.level_value,
tss2.ilevel.level_value);
}
#if 0
tss1.mlevel.level_type = 0;
tss1.mlevel.level_value = 4;
tss1.mlevel.level_catsum = 0;
tss1.mlevel.level_flag = 1;
for (i = 0; i < MAC_CAT_MAX; i++)
tss1.mlevel.level_category[i] = 0;
tss1.ilevel.level_value = 3;
syscall(__NR_mac_file_ctl, 1, argv[1], &tss1);
init_tss(&tss2);
i = syscall(__NR_mac_file_ctl, 0, argv[1], &tss2);
if (i < 0) {
perror("2get error");
return -1;
} else {
printf("mv %d, iv %d\n", tss2.mlevel.level_value,
tss2.ilevel.level_value);
}
#endif
}
void gettaskcon()
{
int i = 0;
init_tss(&tss2);
i = syscall(__NR_mac_task_ctl, 0, 0, &tss2);
if (i < 0) {
perror("gettaskcon error");
exit(-1);
} else
display_tss(&tss2);
}
int settaskcon()
{
int i;
init_tss(&tss1);
tss1.mlevel.level_type = 1;
tss1.mlevel.level_value = 0;
tss1.mlevel.level_catsum = 1;
tss1.mlevel.level_flag = 0;
for (i = 0; i < MAC_CAT_MAX; i++)
tss1.mlevel.level_category[i] = 0;
tss1.mlevel.level_category[4] = 1;
tss1.ilevel.level_value = 8;
i = syscall(__NR_mac_task_ctl, 1, 0, &tss1);
if (i < 0) {
perror("settaskcon error");
return -1;
}
return 0;
}
int main(void)
{
init_pmm();
if (init_mm())
return(1);
vid_init();
vid_set_attr(FG_COLOR, RED);
printf("\naMOS BOSS V.%s %s\n", STRING_VERSION, BUILD_ARCH);
printf("Build %s %s by %s on %s\n\n", COMPILE_DATE, COMPILE_TIME, COMPILE_BY, COMPILE_HOST);
vid_set_attr(FG_COLOR, WHITE);
init_pit();
init_tss();
if (init_intr())
return(1);
init_cpu();
if (init_sched())
return(1);
init_fd();
printf("System memory: %d Mb\n\n", (int)pmm_get_size_mb());
printf("Free kernel mem: %d bytes\nUsed kernel mem: %d bytes\n", (int)get_free_mem(), (int)get_used_mem());
for (;;) {}
return(0);
}
bool thread_pool<Scheduler>::run(boost::unique_lock<boost::mutex>& l,
std::size_t num_threads)
{
HPX_ASSERT(l.owns_lock());
LTM_(info) //-V128
<< "thread_pool::run: " << pool_name_
<< " number of processing units available: " //-V128
<< threads::hardware_concurrency();
LTM_(info) //-V128
<< "thread_pool::run: " << pool_name_
<< " creating " << num_threads << " OS thread(s)"; //-V128
if (0 == num_threads) {
HPX_THROW_EXCEPTION(bad_parameter,
"thread_pool::run", "number of threads is zero");
}
#if defined(HPX_HAVE_THREAD_CUMULATIVE_COUNTS) && \
defined(HPX_HAVE_THREAD_IDLE_RATES)
// scale timestamps to nanoseconds
boost::uint64_t base_timestamp = util::hardware::timestamp();
boost::uint64_t base_time = util::high_resolution_clock::now();
boost::uint64_t curr_timestamp = util::hardware::timestamp();
boost::uint64_t curr_time = util::high_resolution_clock::now();
while ((curr_time - base_time) <= 100000)
{
curr_timestamp = util::hardware::timestamp();
curr_time = util::high_resolution_clock::now();
}
if (curr_timestamp - base_timestamp != 0)
{
timestamp_scale_ = double(curr_time - base_time) /
double(curr_timestamp - base_timestamp);
}
LTM_(info)
<< "thread_pool::run: " << pool_name_
<< " timestamp_scale: " << timestamp_scale_; //-V128
#endif
if (!threads_.empty() || sched_.has_reached_state(state_running))
return true; // do nothing if already running
executed_threads_.resize(num_threads);
executed_thread_phases_.resize(num_threads);
tfunc_times_.resize(num_threads);
exec_times_.resize(num_threads);
try {
HPX_ASSERT(startup_.get() == 0);
startup_.reset(
new boost::barrier(static_cast<unsigned>(num_threads+1))
);
// run threads and wait for initialization to complete
sched_.set_all_states(state_running);
topology const& topology_ = get_topology();
std::size_t thread_num = num_threads;
while (thread_num-- != 0) {
threads::mask_cref_type mask =
sched_.Scheduler::get_pu_mask(topology_, thread_num);
LTM_(info) //-V128
<< "thread_pool::run: " << pool_name_
<< " create OS thread " << thread_num //-V128
<< ": will run on processing units within this mask: "
#if !defined(HPX_WITH_MORE_THAN_64_THREADS) || \
(defined(HPX_HAVE_MAX_CPU_COUNT) && HPX_HAVE_MAX_CPU_COUNT <= 64)
<< std::hex << "0x" << mask;
#else
<< "0b" << mask;
#endif
// create a new thread
threads_.push_back(new boost::thread(
util::bind(&thread_pool::thread_func, this, thread_num,
boost::ref(topology_), boost::ref(*startup_))
));
// set the new threads affinity (on Windows systems)
if (any(mask))
{
error_code ec(lightweight);
topology_.set_thread_affinity_mask(threads_.back(), mask, ec);
if (ec)
{
LTM_(warning) //-V128
<< "thread_pool::run: " << pool_name_
<< " setting thread affinity on OS thread " //-V128
<< thread_num << " failed with: "
<< ec.get_message();
}
}
else
{
LTM_(debug) //-V128
<< "thread_pool::run: " << pool_name_
<< " setting thread affinity on OS thread " //-V128
<< thread_num << " was explicitly disabled.";
}
}
// the main thread needs to have a unique thread_num
init_tss(num_threads);
startup_->wait();
}
void alter_mil(pam_handle_t *pamh, int f)
{
int i = 0;
struct task_security_struct tss1;
struct task_security_struct tss2;
init_tss(&tss1);
init_tss(&tss2);
i = syscall(__NR_mac_task_ctl, 0, 0, &tss2);
if (i < 0) {
pam_syslog(pamh, LOG_INFO, "get task sec1 fail\n");
} else {
pam_syslog(pamh, LOG_INFO, "old task sec tags: mv %d, iv %d\n",
tss2.mlevel.level_value, tss2.ilevel.level_value);
}
if (f == 3) { /* zx,etc 1:1:c4:8 */
tss1.mlevel.level_type = 1;
tss1.mlevel.level_value = 1;
tss1.mlevel.level_catsum = 1;
tss1.mlevel.level_flag = 0;
for (i = 0; i < MAC_CAT_MAX; i++)
tss1.mlevel.level_category[i] = 0;
tss1.mlevel.level_category[4] = 1;
tss1.ilevel.level_value = 8;
}
if (f == 0) { /* root 1:2:c0,c1:8 */
tss1.mlevel.level_type = 1;
tss1.mlevel.level_value = 2;
tss1.mlevel.level_catsum = 2;
tss1.mlevel.level_flag = 0;
for (i = 0; i < MAC_CAT_MAX; i++)
tss1.mlevel.level_category[i] = 0;
tss1.mlevel.level_category[0] = 1;
tss1.mlevel.level_category[1] = 1;
tss1.ilevel.level_value = 8;
}
if (f == 1) { /* secadm 1:2:c0,c2:8 */
tss1.mlevel.level_type = 1;
tss1.mlevel.level_value = 2;
tss1.mlevel.level_catsum = 2;
tss1.mlevel.level_flag = 0;
for (i = 0; i < MAC_CAT_MAX; i++)
tss1.mlevel.level_category[i] = 0;
tss1.mlevel.level_category[0] = 1;
tss1.mlevel.level_category[2] = 1;
tss1.ilevel.level_value = 8;
}
if (f == 2) { /* audadm 1:2:c0,c3:8 */
tss1.mlevel.level_type = 1;
tss1.mlevel.level_value = 2;
tss1.mlevel.level_catsum = 2;
tss1.mlevel.level_flag = 0;
for (i = 0; i < MAC_CAT_MAX; i++)
tss1.mlevel.level_category[i] = 0;
tss1.mlevel.level_category[0] = 1;
tss1.mlevel.level_category[3] = 1;
tss1.ilevel.level_value = 8;
}
syscall(__NR_mac_task_ctl, 1, 0, &tss1);
init_tss(&tss2);
i = syscall(__NR_mac_task_ctl, 0, 0, &tss2);
if (i < 0) {
pam_syslog(pamh, LOG_INFO, "get task sec2 fail\n");
} else {
pam_syslog(pamh, LOG_INFO, "new task sec tags: mv %d, iv %d\n",
tss2.mlevel.level_value, tss2.ilevel.level_value);
}
}
