/* * 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; }