/*
* Get the Hardware Clock epoch setting from the kernel.
*/
int get_epoch_rtc(unsigned long *epoch_p, int silent)
{
int rtc_fd;
rtc_fd = open_rtc();
if (rtc_fd < 0) {
if (!silent) {
if (errno == ENOENT)
warnx(_
("To manipulate the epoch value in the kernel, we must "
"access the Linux 'rtc' device driver via the device special "
"file %s. This file does not exist on this system."),
rtc_dev_name);
else
warn(_("cannot open %s"), rtc_dev_name);
}
return 1;
}
if (ioctl(rtc_fd, RTC_EPOCH_READ, epoch_p) == -1) {
if (!silent)
warn(_("ioctl(RTC_EPOCH_READ) to %s failed"),
rtc_dev_name);
return 1;
}
if (debug)
printf(_("we have read epoch %ld from %s "
"with RTC_EPOCH_READ ioctl.\n"), *epoch_p,
rtc_dev_name);
return 0;
}
/*
* Set the Hardware Clock epoch in the kernel.
*/
int set_epoch_rtc(const struct hwclock_control *ctl)
{
int rtc_fd;
unsigned long epoch;
epoch = strtoul(ctl->epoch_option, NULL, 10);
/* There were no RTC clocks before 1900. */
if (epoch < 1900 || epoch == ULONG_MAX) {
warnx(_("invalid epoch '%s'."), ctl->epoch_option);
return 1;
}
rtc_fd = open_rtc(ctl);
if (rtc_fd < 0) {
warn(_("cannot open %s"), rtc_dev_name);
return 1;
}
if (ioctl(rtc_fd, RTC_EPOCH_SET, epoch) == -1) {
warn(_("ioctl(%d, RTC_EPOCH_SET, %lu) to %s failed"),
rtc_fd, epoch, rtc_dev_name);
return 1;
}
if (ctl->verbose)
printf(_("ioctl(%d, RTC_EPOCH_SET, %lu) to %s succeeded.\n"),
rtc_fd, epoch, rtc_dev_name);
return 0;
}
int
get_epoch_rtc(unsigned long *epoch_p, int silent) {
/*----------------------------------------------------------------------------
Get the Hardware Clock epoch setting from the kernel.
----------------------------------------------------------------------------*/
int rtc_fd;
rtc_fd = open_rtc();
if (rtc_fd < 0) {
if (!silent) {
if (errno == ENOENT)
fprintf(stderr, _(
"To manipulate the epoch value in the kernel, we must "
"access the Linux 'rtc' device driver via the device special "
"file %s. This file does not exist on this system.\n"),
rtc_dev_name);
else
outsyserr(_("Unable to open %s"), rtc_dev_name);
}
return 1;
}
if (ioctl(rtc_fd, RTC_EPOCH_READ, epoch_p) == -1) {
if (!silent)
outsyserr(_("ioctl(RTC_EPOCH_READ) to %s failed"), rtc_dev_name);
return 1;
}
if (debug)
printf(_("we have read epoch %ld from %s "
"with RTC_EPOCH_READ ioctl.\n"), *epoch_p, rtc_dev_name);
return 0;
}
int set_rtc(const char *path, const char* time) {
fuchsia_hardware_rtc_Time rtc;
int n = sscanf(
time,
"%04hd-%02hhd-%02hhdT%02hhd:%02hhd:%02hhd",
&rtc.year,
&rtc.month,
&rtc.day,
&rtc.hours,
&rtc.minutes,
&rtc.seconds);
if (n != 6) {
printf("Bad time format.\n");
return -1;
}
zx_handle_t handle;
zx_status_t status = open_rtc(path, &handle);
if (status != ZX_OK) {
printf("Can not open RTC device\n");
return status;
}
zx_status_t set_status;
status = fuchsia_hardware_rtc_DeviceSet(handle, &rtc, &set_status);
if (status != ZX_OK) {
return status;
}
return set_status;
}
/* return &rtc if /dev/rtc can be opened, NULL otherwise */
struct clock_ops *probe_for_rtc_clock(const struct hwclock_control *ctl)
{
const int rtc_fd = open_rtc(ctl);
if (rtc_fd < 0)
return NULL;
return &rtc_interface;
}
/* return &rtc if /dev/rtc can be opened, NULL otherwise */
struct clock_ops *probe_for_rtc_clock(void)
{
int rtc_fd = open_rtc();
if (rtc_fd >= 0)
return &rtc;
if (debug)
warn(_("cannot open %s"), rtc_dev_name);
return NULL;
}
/* return &rtc if /dev/rtc can be opened, NULL otherwise */
struct clock_ops *
probe_for_rtc_clock(){
int rtc_fd = open_rtc();
if (rtc_fd >= 0)
return &rtc;
if (debug)
outsyserr(_("Open of %s failed"), rtc_dev_name);
return NULL;
}
static int open_rtc_or_exit(void)
{
int rtc_fd = open_rtc();
if (rtc_fd < 0) {
warn(_("cannot open %s"), rtc_dev_name);
hwclock_exit(EX_OSFILE);
}
return rtc_fd;
}
static int open_rtc_or_exit(const struct hwclock_control *ctl)
{
int rtc_fd = open_rtc(ctl);
if (rtc_fd < 0) {
warn(_("cannot open rtc device"));
hwclock_exit(ctl, EXIT_FAILURE);
}
return rtc_fd;
}
static int
open_rtc_or_exit(void) {
int rtc_fd = open_rtc();
if (rtc_fd < 0) {
outsyserr(_("open() of %s failed"), rtc_dev_name);
hwclock_exit(EX_OSFILE);
}
return rtc_fd;
}
/*
* Same as synchronize_to_clock_tick(), but just for /dev/rtc.
*/
static int synchronize_to_clock_tick_rtc(const struct hwclock_control *ctl)
{
int rtc_fd; /* File descriptor of /dev/rtc */
int ret = 1;
rtc_fd = open_rtc(ctl);
if (rtc_fd == -1) {
warn(_("cannot open rtc device"));
return ret;
} else {
/* Turn on update interrupts (one per second) */
int rc = ioctl(rtc_fd, RTC_UIE_ON, 0);
if (rc != -1) {
/*
* Just reading rtc_fd fails on broken hardware: no
* update interrupt comes and a bootscript with a
* hwclock call hangs
*/
fd_set rfds;
struct timeval tv;
/*
* Wait up to ten seconds for the next update
* interrupt
*/
FD_ZERO(&rfds);
FD_SET(rtc_fd, &rfds);
tv.tv_sec = 10;
tv.tv_usec = 0;
rc = select(rtc_fd + 1, &rfds, NULL, NULL, &tv);
if (0 < rc)
ret = 0;
else if (rc == 0) {
warnx(_("select() to %s to wait for clock tick timed out"),
rtc_dev_name);
} else
warn(_("select() to %s to wait for clock tick failed"),
rtc_dev_name);
/* Turn off update interrupts */
rc = ioctl(rtc_fd, RTC_UIE_OFF, 0);
if (rc == -1)
warn(_("ioctl() to %s to turn off update interrupts failed"),
rtc_dev_name);
} else if (errno == ENOTTY || errno == EINVAL) {
/* rtc ioctl interrupts are unimplemented */
ret = busywait_for_rtc_clock_tick(ctl, rtc_fd);
} else
warn(_("ioctl(%d, RTC_UIE_ON, 0) to %s failed"),
rtc_fd, rtc_dev_name);
}
return ret;
}
/*
* Set the Hardware Clock epoch in the kernel.
*/
int set_epoch_rtc(unsigned long epoch)
{
int rtc_fd;
if (epoch < 1900) {
/* kernel would not accept this epoch value
*
* Bad habit, deciding not to do what the user asks just
* because one believes that the kernel might not like it.
*/
warnx(_("The epoch value may not be less than 1900. "
"You requested %ld"), epoch);
return 1;
}
rtc_fd = open_rtc();
if (rtc_fd < 0) {
if (errno == ENOENT)
warnx(_
("To manipulate the epoch value in the kernel, we must "
"access the Linux 'rtc' device driver via the device special "
"file %s. This file does not exist on this system."),
rtc_dev_name);
else
warn(_("cannot open %s"), rtc_dev_name);
return 1;
}
if (debug)
printf(_("setting epoch to %ld "
"with RTC_EPOCH_SET ioctl to %s.\n"), epoch,
rtc_dev_name);
if (ioctl(rtc_fd, RTC_EPOCH_SET, epoch) == -1) {
if (errno == EINVAL)
warnx(_("The kernel device driver for %s "
"does not have the RTC_EPOCH_SET ioctl."),
rtc_dev_name);
else
warn(_("ioctl(RTC_EPOCH_SET) to %s failed"),
rtc_dev_name);
return 1;
}
return 0;
}
/*
* Get the Hardware Clock epoch setting from the kernel.
*/
int get_epoch_rtc(const struct hwclock_control *ctl, unsigned long *epoch_p)
{
int rtc_fd;
rtc_fd = open_rtc(ctl);
if (rtc_fd < 0) {
warn(_("cannot open %s"), rtc_dev_name);
return 1;
}
if (ioctl(rtc_fd, RTC_EPOCH_READ, epoch_p) == -1) {
warn(_("ioctl(%d, RTC_EPOCH_READ, epoch_p) to %s failed"),
rtc_fd, rtc_dev_name);
return 1;
}
if (ctl->verbose)
printf(_("ioctl(%d, RTC_EPOCH_READ, epoch_p) to %s succeeded.\n"),
rtc_fd, rtc_dev_name);
return 0;
}
int print_rtc(const char *path) {
zx_handle_t handle;
zx_status_t status = open_rtc(path, &handle);
if (status != ZX_OK) {
return -1;
}
fuchsia_hardware_rtc_Time rtc;
status = fuchsia_hardware_rtc_DeviceGet(handle, &rtc);
if (status != ZX_OK) {
return -1;
}
printf(
"%04d-%02d-%02dT%02d:%02d:%02d\n",
rtc.year,
rtc.month,
rtc.day,
rtc.hours,
rtc.minutes,
rtc.seconds);
return 0;
}
/* Check if MAGIC is valid and print the Multiboot information structure
pointed by ADDR. */
void
entry (unsigned long magic, unsigned long addr)
{
multiboot_info_t *mbi;
/* Clear the screen. */
clear();
uint32_t filestart;
/* Am I booted by a Multiboot-compliant boot loader? */
if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
{
printf ("Invalid magic number: 0x%#x\n", (unsigned) magic);
return;
}
/* Set MBI to the address of the Multiboot information structure. */
mbi = (multiboot_info_t *) addr;
/* Print out the flags. */
printf ("flags = 0x%#x\n", (unsigned) mbi->flags);
/* Are mem_* valid? */
if (CHECK_FLAG (mbi->flags, 0))
printf ("mem_lower = %uKB, mem_upper = %uKB\n",
(unsigned) mbi->mem_lower, (unsigned) mbi->mem_upper);
/* Is boot_device valid? */
if (CHECK_FLAG (mbi->flags, 1))
printf ("boot_device = 0x%#x\n", (unsigned) mbi->boot_device);
/* Is the command line passed? */
if (CHECK_FLAG (mbi->flags, 2))
printf ("cmdline = %s\n", (char *) mbi->cmdline);
if (CHECK_FLAG (mbi->flags, 3)) {
int mod_count = 0;
int i;
module_t* mod = (module_t*)mbi->mods_addr;
while(mod_count < mbi->mods_count) {
printf("Module %d loaded at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_start);
filestart = mod->mod_start;
printf("Module %d ends at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_end);
printf("First few bytes of module:\n");
for(i = 0; i<16; i++) {
printf("0x%x ", *((char*)(mod->mod_start+i)));
}
printf("\n");
mod_count++;
}
}
/* Bits 4 and 5 are mutually exclusive! */
if (CHECK_FLAG (mbi->flags, 4) && CHECK_FLAG (mbi->flags, 5))
{
printf ("Both bits 4 and 5 are set.\n");
return;
}
/* Is the section header table of ELF valid? */
if (CHECK_FLAG (mbi->flags, 5))
{
elf_section_header_table_t *elf_sec = &(mbi->elf_sec);
printf ("elf_sec: num = %u, size = 0x%#x,"
" addr = 0x%#x, shndx = 0x%#x\n",
(unsigned) elf_sec->num, (unsigned) elf_sec->size,
(unsigned) elf_sec->addr, (unsigned) elf_sec->shndx);
}
/* Are mmap_* valid? */
if (CHECK_FLAG (mbi->flags, 6))
{
memory_map_t *mmap;
printf ("mmap_addr = 0x%#x, mmap_length = 0x%x\n",
(unsigned) mbi->mmap_addr, (unsigned) mbi->mmap_length);
for (mmap = (memory_map_t *) mbi->mmap_addr;
(unsigned long) mmap < mbi->mmap_addr + mbi->mmap_length;
mmap = (memory_map_t *) ((unsigned long) mmap
+ mmap->size + sizeof (mmap->size)))
printf (" size = 0x%x, base_addr = 0x%#x%#x\n"
" type = 0x%x, length = 0x%#x%#x\n",
(unsigned) mmap->size,
(unsigned) mmap->base_addr_high,
(unsigned) mmap->base_addr_low,
(unsigned) mmap->type,
(unsigned) mmap->length_high,
(unsigned) mmap->length_low);
}
/* Construct an LDT entry in the GDT */
{
seg_desc_t the_ldt_desc;
the_ldt_desc.granularity = 0;
the_ldt_desc.opsize = 1;
the_ldt_desc.reserved = 0;
the_ldt_desc.avail = 0;
the_ldt_desc.present = 1;
the_ldt_desc.dpl = 0x0;
the_ldt_desc.sys = 0;
the_ldt_desc.type = 0x2;
SET_LDT_PARAMS(the_ldt_desc, &ldt, ldt_size);
ldt_desc_ptr = the_ldt_desc;
lldt(KERNEL_LDT);
}
/* Construct a TSS entry in the GDT */
{
seg_desc_t the_tss_desc;
the_tss_desc.granularity = 0;
the_tss_desc.opsize = 0;
the_tss_desc.reserved = 0;
the_tss_desc.avail = 0;
the_tss_desc.seg_lim_19_16 = TSS_SIZE & 0x000F0000;
the_tss_desc.present = 1;
the_tss_desc.dpl = 0x0;
the_tss_desc.sys = 0;
the_tss_desc.type = 0x9;
the_tss_desc.seg_lim_15_00 = TSS_SIZE & 0x0000FFFF;
SET_TSS_PARAMS(the_tss_desc, &tss, tss_size);
tss_desc_ptr = the_tss_desc;
tss.ldt_segment_selector = KERNEL_LDT;
tss.ss0 = KERNEL_DS;
tss.esp0 = 0x800000;
ltr(KERNEL_TSS);
}
//Initialization of IDE
{
printf("Initilization of Idt table...");
set_trap_gate(0,divide_error);
set_trap_gate(1,debug);
set_intr_gate(2,nmi);
set_system_intr_gate(3,int3);
set_system_gate(4,overflow);
set_system_gate(5,bounds);
set_trap_gate(6,invalid_op);
set_trap_gate(7,device_not_available);
set_task_gate(8,31);
set_trap_gate(9,coprocessor_segment_overrun);
set_trap_gate(10,invalid_TSS);
set_trap_gate(11,segment_not_present);
set_trap_gate(12,stack_segment);
set_trap_gate(13,general_protection);
set_trap_gate(14,page_fault);//intr
set_trap_gate(16,coprocessor_error);
set_trap_gate(17,alignment_check);
set_trap_gate(18,machine_check);
set_trap_gate(19,simd_coprocessor_error);
set_system_gate(128,system_call);
set_intr_gate(32,irq0); //intr
set_intr_gate(33,irq1); //intr
set_intr_gate(34,0); //intr
set_intr_gate(40,irq8); //intr
//set_intr_gate(44,irq12); //intr
lidt(idt_desc_ptr);
printf("ok!\n");
}
// Init the PIC
i8259_init();
//Enable interrupts
enable_irq(1);
enable_irq(2);
open_rtc();
enable_irq(8);
enable_irq(12);
uint8_t file =0x00;
//Enable paging
printf("Enabling paging...\n");
paging();
printf("ok!\n");
//Restore interrupts
sti();
//Mounting file system
printf("Mounting filesystem...\n");
open_terminal(&file);
setstart(filestart);
printf("ok!\n");
//clear();
//Executing first program shell
uint8_t cmd[10]={"shell "};
#if debug_by_showing_dentries
test_dentries();
while(1);
#endif
test_system_call((int32_t)cmd, NULL, 0, 2);
asm volatile(".1: hlt; jmp .1;");
}
/*
* Same as synchronize_to_clock_tick(), but just for /dev/rtc.
*/
static int synchronize_to_clock_tick_rtc(void)
{
int rtc_fd; /* File descriptor of /dev/rtc */
int ret;
rtc_fd = open_rtc();
if (rtc_fd == -1) {
warn(_("cannot open %s"), rtc_dev_name);
ret = 1;
} else {
int rc; /* Return code from ioctl */
/* Turn on update interrupts (one per second) */
#if defined(__alpha__) || defined(__sparc__)
/*
* Not all alpha kernels reject RTC_UIE_ON, but probably
* they should.
*/
rc = -1;
errno = EINVAL;
#else
rc = ioctl(rtc_fd, RTC_UIE_ON, 0);
#endif
if (rc == -1 && (errno == ENOTTY || errno == EINVAL)) {
/*
* This rtc device doesn't have interrupt functions.
* This is typical on an Alpha, where the Hardware
* Clock interrupts are used by the kernel for the
* system clock, so aren't at the user's disposal.
*/
if (debug)
printf(_
("%s does not have interrupt functions. "),
rtc_dev_name);
ret = busywait_for_rtc_clock_tick(rtc_fd);
} else if (rc == 0) {
#ifdef Wait_until_update_interrupt
unsigned long dummy;
/* this blocks until the next update interrupt */
rc = read(rtc_fd, &dummy, sizeof(dummy));
ret = 1;
if (rc == -1)
warn(_
("read() to %s to wait for clock tick failed"),
rtc_dev_name);
else
ret = 0;
#else
/*
* Just reading rtc_fd fails on broken hardware: no
* update interrupt comes and a bootscript with a
* hwclock call hangs
*/
fd_set rfds;
struct timeval tv;
/*
* Wait up to ten seconds for the next update
* interrupt
*/
FD_ZERO(&rfds);
FD_SET(rtc_fd, &rfds);
tv.tv_sec = 10;
tv.tv_usec = 0;
rc = select(rtc_fd + 1, &rfds, NULL, NULL, &tv);
ret = 1;
if (rc == -1)
warn(_
("select() to %s to wait for clock tick failed"),
rtc_dev_name);
else if (rc == 0)
warn(_
("select() to %s to wait for clock tick timed out"),
rtc_dev_name);
else
ret = 0;
#endif
/* Turn off update interrupts */
rc = ioctl(rtc_fd, RTC_UIE_OFF, 0);
if (rc == -1)
warn(_
("ioctl() to %s to turn off update interrupts failed"),
rtc_dev_name);
} else {
warn(_
("ioctl() to %s to turn on update interrupts "
"failed unexpectedly"), rtc_dev_name);
ret = 1;
}
}
return ret;
}
