/* 565RLE image format: [count(2 bytes), rle(2 bytes)] */
int load_565rle_image(char *filename, bool bf_supported)
{
struct fb_info *info;
int fd, count, err = 0;
unsigned max;
unsigned short *data, *ptr ;
uint32_t *bits;
unsigned int out;
info = registered_fb[0];
if (!info) {
printk(KERN_WARNING "%s: Can not access framebuffer\n",
__func__);
return -ENODEV;
}
fd = sys_open(filename, O_RDONLY, 0);
if (fd < 0) {
printk(KERN_WARNING "%s: Can not open %s\n",
__func__, filename);
return -ENOENT;
}
count = sys_lseek(fd, (off_t)0, 2);
if (count <= 0) {
err = -EIO;
goto err_logo_close_file;
}
sys_lseek(fd, (off_t)0, 0);
data = kmalloc(count, GFP_KERNEL);
if (!data) {
printk(KERN_WARNING "%s: Can not alloc data\n", __func__);
err = -ENOMEM;
goto err_logo_close_file;
}
if (sys_read(fd, (char *)data, count) != count) {
err = -EIO;
goto err_logo_free_data;
}
max = fb_width(info) * fb_height(info);
ptr = data;
if (bf_supported && (info->node == 1 || info->node == 2)) {
err = -EPERM;
pr_err("%s:%d no info->creen_base on fb%d!\n",
__func__, __LINE__, info->node);
goto err_logo_free_data;
}
bits = (uint32_t*)(info->screen_base);
while (count > 3) {
unsigned n = ptr[0];
if (n > max)
break;
out = rgb32(ptr[1]);
memset32(bits, out, n << 2);
bits += n;
max -= n;
ptr += 2;
count -= 4;
}
err_logo_free_data:
kfree(data);
err_logo_close_file:
sys_close(fd);
return err;
}
static void __init handle_initrd(void)
{
int error;
int pid;
real_root_dev = new_encode_dev(ROOT_DEV);
create_dev("/dev/root.old", Root_RAM0);
/* mount initrd on rootfs' /root */
mount_block_root("/dev/root.old", root_mountflags & ~MS_RDONLY);
sys_mkdir("/old", 0700);
root_fd = sys_open("/", 0, 0);
old_fd = sys_open("/old", 0, 0);
/* move initrd over / and chdir/chroot in initrd root */
sys_chdir("/root");
sys_mount(".", "/", NULL, MS_MOVE, NULL);
sys_chroot(".");
/*
* In case that a resume from disk is carried out by linuxrc or one of
* its children, we need to tell the freezer not to wait for us.
*/
current->flags |= PF_FREEZER_SKIP;
pid = kernel_thread(do_linuxrc, "/linuxrc", SIGCHLD);
if (pid > 0)
while (pid != sys_wait4(-1, NULL, 0, NULL))
yield();
current->flags &= ~PF_FREEZER_SKIP;
/* move initrd to rootfs' /old */
sys_fchdir(old_fd);
sys_mount("/", ".", NULL, MS_MOVE, NULL);
/* switch root and cwd back to / of rootfs */
sys_fchdir(root_fd);
sys_chroot(".");
sys_close(old_fd);
sys_close(root_fd);
if (new_decode_dev(real_root_dev) == Root_RAM0) {
sys_chdir("/old");
return;
}
ROOT_DEV = new_decode_dev(real_root_dev);
mount_root();
printk(KERN_NOTICE "Trying to move old root to /initrd ... ");
error = sys_mount("/old", "/root/initrd", NULL, MS_MOVE, NULL);
if (!error)
printk("okay\n");
else {
int fd = sys_open("/dev/root.old", O_RDWR, 0);
if (error == -ENOENT)
printk("/initrd does not exist. Ignored.\n");
else
printk("failed\n");
printk(KERN_NOTICE "Unmounting old root\n");
sys_umount("/old", MNT_DETACH);
printk(KERN_NOTICE "Trying to free ramdisk memory ... ");
if (fd < 0) {
error = fd;
} else {
error = sys_ioctl(fd, BLKFLSBUF, 0);
sys_close(fd);
}
printk(!error ? "okay\n" : "failed\n");
}
}
void
mips_syscall(struct trapframe *tf)
{
int callno;
int32_t retval;
int err;
assert(curspl==0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
#if OPT_A2
case SYS_open:
err = sys_open((char *)tf->tf_a0, tf->tf_a1, tf->tf_a2);
if (err > 0)
{
retval = err;
err = 0;
}
break;
case SYS_close:
err = sys_close(tf->tf_a0);
break;
case SYS_read:
err = sys_read(tf->tf_a0, (void *)tf->tf_a1, tf->tf_a2);
if (err > 0)
{
retval = err;
err = 0;
}
break;
case SYS_write:
err = sys_write(tf->tf_a0, (void *)tf->tf_a1, tf->tf_a2);
if (err > 0)
{
retval = err;
err = 0;
}
break;
case SYS_fork:
err = sys_fork(tf);
if (err >= 0)
{
retval = err;
err = 0;
}
break;
case SYS_getpid:
err = sys_getpid();
if (err > 0)
{
retval = err;
err = 0;
}
break;
case SYS_waitpid:
err = sys_waitpid(tf->tf_a0, (int *)tf->tf_a1, (int)tf->tf_a2);
break;
case SYS__exit:
sys__exit(0);
break;
case SYS_execv:
err = sys_execv((char *)tf->tf_a0, (char **)tf->tf_a1);
break;
#endif
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
if (err < 0) {
/*
* Return the error code. This gets converted at
* userlevel to a return value of -1 and the error
* code in errno.
*/
tf->tf_v0 = (-1)*(err);
tf->tf_a3 = 1; /* signal an error */
}
else {
/* Success. */
tf->tf_v0 = retval;
tf->tf_a3 = 0; /* signal no error */
}
/*
* Now, advance the program counter, to avoid restarting
* the syscall over and over again.
*/
tf->tf_epc += 4;
/* Make sure the syscall code didn't forget to lower spl */
assert(curspl==0);
}
/*
* System call dispatcher.
*
* A pointer to the trapframe created during exception entry (in
* exception-*.S) is passed in.
*
* The calling conventions for syscalls are as follows: Like ordinary
* function calls, the first 4 32-bit arguments are passed in the 4
* argument registers a0-a3. 64-bit arguments are passed in *aligned*
* pairs of registers, that is, either a0/a1 or a2/a3. This means that
* if the first argument is 32-bit and the second is 64-bit, a1 is
* unused.
*
* This much is the same as the calling conventions for ordinary
* function calls. In addition, the system call number is passed in
* the v0 register.
*
* On successful return, the return value is passed back in the v0
* register, or v0 and v1 if 64-bit. This is also like an ordinary
* function call, and additionally the a3 register is also set to 0 to
* indicate success.
*
* On an error return, the error code is passed back in the v0
* register, and the a3 register is set to 1 to indicate failure.
* (Userlevel code takes care of storing the error code in errno and
* returning the value -1 from the actual userlevel syscall function.
* See src/user/lib/libc/arch/mips/syscalls-mips.S and related files.)
*
* Upon syscall return the program counter stored in the trapframe
* must be incremented by one instruction; otherwise the exception
* return code will restart the "syscall" instruction and the system
* call will repeat forever.
*
* If you run out of registers (which happens quickly with 64-bit
* values) further arguments must be fetched from the user-level
* stack, starting at sp+16 to skip over the slots for the
* registerized values, with copyin().
*/
void
syscall(struct trapframe *tf)
{
int callno;
int32_t retval;
int err;
KASSERT(curthread != NULL);
KASSERT(curthread->t_curspl == 0);
KASSERT(curthread->t_iplhigh_count == 0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
int whence = 0;
off_t position = 0;
int32_t retval2 = 0;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
case SYS___time:
err = sys___time((userptr_t)tf->tf_a0,
(userptr_t)tf->tf_a1);
break;
/* Add stuff here */
case SYS_write:
err = sys_write((int)tf->tf_a0,(const void *)tf->tf_a1,(size_t)tf->tf_a2, &retval);
break;
case SYS_read:
err = sys_read(tf->tf_a0, (void *) tf->tf_a1, (size_t) tf->tf_a2, &retval);
break;
case SYS_open:
err = sys_open((char *)tf->tf_a0, tf->tf_a1, (mode_t)tf->tf_a2, &retval);
break;
case SYS_close:
err = sys_close(tf->tf_a0);
break;
case SYS_dup2:
err = sys_dup2(tf->tf_a0, tf->tf_a1, &retval);
break;
case SYS_lseek:
position |= (off_t)tf->tf_a2;
position <<= 32;
position |= (off_t)tf->tf_a3;
err = copyin((const userptr_t)tf->tf_sp+16, &whence, sizeof(whence));
if (err)
break;
err = sys_lseek((int)tf->tf_a0, position, (int)whence, &retval, &retval2);
if(!err)
tf->tf_v1 = retval2;
break;
case SYS_fork:
err = sys_fork(tf,&retval);
break;
case SYS_getpid:
err = sys_getpid((pid_t *)&retval);
break;
case SYS_waitpid:
err = sys_waitpid((pid_t)tf->tf_a0, (userptr_t)tf->tf_a1, (int)tf->tf_a2, (pid_t *)&retval);
break;
case SYS__exit:
sys__exit((int)tf->tf_a0);
err = -1;
//will never come here as it doesnt return
break;
case SYS_execv:
err=sys_execv((const char *)tf->tf_a0,(char **)tf->tf_a1);
break;
case SYS_sbrk:
err=(int)sys_sbrk((intptr_t)tf->tf_a0, (vaddr_t *)&retval);
break;
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
if (err) {
/*
* Return the error code. This gets converted at
* userlevel to a return value of -1 and the error
* code in errno.
*/
tf->tf_v0 = err;
tf->tf_a3 = 1; /* signal an error */
}
else {
/* Success. */
tf->tf_v0 = retval;
tf->tf_a3 = 0; /* signal no error */
}
/*
* Now, advance the program counter, to avoid restarting
* the syscall over and over again.
*/
tf->tf_epc += 4;
/* Make sure the syscall code didn't forget to lower spl */
KASSERT(curthread->t_curspl == 0);
/* ...or leak any spinlocks */
KASSERT(curthread->t_iplhigh_count == 0);
}
/*
* For backward compatibility? Maybe this should be moved
* into arch/i386 instead?
*/
SYSCALL_DEFINE2(creat, const char __user *, pathname, umode_t, mode)
{
return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
}
s32 bbe16_stress_test_start(void)
{
u32 readlen = 0;
unsigned int handle;
mm_segment_t oldfs;
u32 buffer[0x10];
long ret;
#ifdef BSP_DSP_BBE16
set_hi_crg_ctrl15_tensi_dps0_srst_req(0);
set_hi_crg_ctrl15_tensi_bbe16_srst_req(0);
#else
set_hi_crg_srstdis2_tensi_dps0_pd_srst_dis(1);
set_hi_crg_srstdis2_tensi_dsp0_core_srst_dis(1);
#endif
bbe16_tcm_addr = (u32)ioremap_nocache(BBE_TCM_ADDR, BBE_TCM_SIZE);
if (NULL == (void*)bbe16_tcm_addr)
{
printk(KERN_ERR"fail to io remap\n");
return -ENOMEM;
}
#if 0
/* BBE16 DMEM1 Æ«ÒÆ0x40000(256KB) */
writel(DDR_TLPHY_IMAGE_ADDR, bbe16_tcm_addr + 0x40000);
writel(1024/4, bbe16_tcm_addr+0x40004);
writel(AXI_MEM_64_SRC_FOR_BBE16_PHY, bbe16_tcm_addr+0x40008);
writel(AXI_MEM_FOR_MEMCPY_SIZE*2/4, bbe16_tcm_addr+0x4000C);
writel(AXI_MEM_FOR_BBE16_SRC_ADDR_PHY, bbe16_tcm_addr+0x40010);
writel(AXI_MEM_FOR_MEMCPY_SIZE*2/4, bbe16_tcm_addr+0x40014);
writel(0, bbe16_tcm_addr+0x4001C);
#endif
oldfs = get_fs();
set_fs(KERNEL_DS);
handle = (unsigned int)sys_open("/data/bbe16", O_RDONLY, 0);
if (IS_ERR((const void*)handle))
{
printk(KERN_ERR"fail to open file '/data/bbe16'\n");
return -1;
}
do
{
ret = sys_read(handle, (char*)buffer, sizeof(buffer));
memcpy((void*)(bbe16_tcm_addr+0x40080+readlen), (void*)buffer, sizeof(buffer));
readlen += ret;
}while(ret == sizeof(buffer));
sys_close(handle);
set_fs(oldfs);
#ifdef BSP_DSP_BBE16
set_hi_sc_ctrl13_bbe16_runstall(0);
#else
set_hi_sc_ctrl13_dsp0_runstall(0);
#endif
printk(KERN_INFO"OK, image length: %d\n", readlen);
return 0;
}
/* 565RLE image format: [count(2 bytes), rle(2 bytes)] */
int load_565rle_image(char *filename)
{
struct fb_info *info;
int fd, count, err = 0;
unsigned max;
#ifdef CONFIG_PANTECH_FB_24BPP_RGB888
IBUF_TYPE *data, *bits, *ptr;
#else
unsigned short *data, *bits, *ptr;
#endif
info = registered_fb[0];
if (!info) {
printk(KERN_WARNING "%s: Can not access framebuffer\n",
__func__);
return -ENODEV;
}
fd = sys_open(filename, O_RDONLY, 0);
if (fd < 0) {
printk(KERN_WARNING "%s: Can not open %s\n",
__func__, filename);
return -ENOENT;
}
count = sys_lseek(fd, (off_t)0, 2);
if (count <= 0) {
err = -EIO;
goto err_logo_close_file;
}
sys_lseek(fd, (off_t)0, 0);
data = kmalloc(count, GFP_KERNEL);
if (!data) {
printk(KERN_WARNING "%s: Can not alloc data\n", __func__);
err = -ENOMEM;
goto err_logo_close_file;
}
if (sys_read(fd, (char *)data, count) != count) {
err = -EIO;
goto err_logo_free_data;
}
max = fb_width(info) * fb_height(info);
ptr = data;
#ifdef CONFIG_PANTECH_FB_24BPP_RGB888
bits = (IBUF_TYPE *)(info->screen_base);
#else
bits = (unsigned short *)(info->screen_base);
#endif
while (count > 3) {
unsigned n = ptr[0];
if (n > max)
break;
#ifdef CONFIG_PANTECH_FB_24BPP_RGB888
memset32((unsigned int *)bits, ptr[1], n << 2);
#else
memset16(bits, ptr[1], n << 1);
#endif
bits += n;
max -= n;
ptr += 2;
count -= 4;
}
err_logo_free_data:
kfree(data);
err_logo_close_file:
sys_close(fd);
return err;
}
/*
* The main routine to restore task via sigreturn.
* This one is very special, we never return there
* but use sigreturn facility to restore core registers
* and jump execution to some predefined ip read from
* core file.
*/
long __export_restore_task(struct task_restore_core_args *args)
{
long ret = -1;
VmaEntry *vma_entry;
u64 va;
unsigned long premmapped_end = args->premmapped_addr + args->premmapped_len;
struct rt_sigframe *rt_sigframe;
unsigned long new_sp;
pid_t my_pid = sys_getpid();
rt_sigaction_t act;
task_entries = args->task_entries;
ksigfillset(&act.rt_sa_mask);
act.rt_sa_handler = sigchld_handler;
act.rt_sa_flags = SA_SIGINFO | SA_RESTORER | SA_RESTART;
act.rt_sa_restorer = cr_restore_rt;
sys_sigaction(SIGCHLD, &act, NULL, sizeof(k_rtsigset_t));
log_set_fd(args->logfd);
log_set_loglevel(args->loglevel);
cap_last_cap = args->cap_last_cap;
pr_info("Switched to the restorer %d\n", my_pid);
for (vma_entry = args->self_vmas; vma_entry->start != 0; vma_entry++) {
unsigned long addr = vma_entry->start;
unsigned long len;
if (!vma_entry_is(vma_entry, VMA_AREA_REGULAR))
continue;
pr_debug("Examine %"PRIx64"-%"PRIx64"\n", vma_entry->start, vma_entry->end);
if (addr < args->premmapped_addr) {
if (vma_entry->end >= args->premmapped_addr)
len = args->premmapped_addr - addr;
else
len = vma_entry->end - vma_entry->start;
if (sys_munmap((void *) addr, len)) {
pr_err("munmap fail for %lx - %lx\n", addr, addr + len);
goto core_restore_end;
}
}
if (vma_entry->end >= TASK_SIZE)
continue;
if (vma_entry->end > premmapped_end) {
if (vma_entry->start < premmapped_end)
addr = premmapped_end;
len = vma_entry->end - addr;
if (sys_munmap((void *) addr, len)) {
pr_err("munmap fail for %lx - %lx\n", addr, addr + len);
goto core_restore_end;
}
}
}
sys_munmap(args->self_vmas,
((void *)(vma_entry + 1) - ((void *)args->self_vmas)));
/* Shift private vma-s to the left */
for (vma_entry = args->tgt_vmas; vma_entry->start != 0; vma_entry++) {
if (!vma_entry_is(vma_entry, VMA_AREA_REGULAR))
continue;
if (!vma_priv(vma_entry))
continue;
if (vma_entry->end >= TASK_SIZE)
continue;
if (vma_entry->start > vma_entry->shmid)
break;
if (vma_remap(vma_premmaped_start(vma_entry),
vma_entry->start, vma_entry_len(vma_entry)))
goto core_restore_end;
}
/* Shift private vma-s to the right */
for (vma_entry = args->tgt_vmas + args->nr_vmas -1;
vma_entry >= args->tgt_vmas; vma_entry--) {
if (!vma_entry_is(vma_entry, VMA_AREA_REGULAR))
continue;
if (!vma_priv(vma_entry))
continue;
if (vma_entry->start > TASK_SIZE)
continue;
if (vma_entry->start < vma_entry->shmid)
break;
if (vma_remap(vma_premmaped_start(vma_entry),
vma_entry->start, vma_entry_len(vma_entry)))
goto core_restore_end;
}
/*
* OK, lets try to map new one.
*/
for (vma_entry = args->tgt_vmas; vma_entry->start != 0; vma_entry++) {
if (!vma_entry_is(vma_entry, VMA_AREA_REGULAR))
continue;
if (vma_priv(vma_entry))
continue;
va = restore_mapping(vma_entry);
if (va != vma_entry->start) {
pr_err("Can't restore %"PRIx64" mapping with %"PRIx64"\n", vma_entry->start, va);
goto core_restore_end;
}
}
/*
* Walk though all VMAs again to drop PROT_WRITE
* if it was not there.
*/
for (vma_entry = args->tgt_vmas; vma_entry->start != 0; vma_entry++) {
if (!(vma_entry_is(vma_entry, VMA_AREA_REGULAR)))
continue;
if (vma_entry_is(vma_entry, VMA_ANON_SHARED)) {
struct shmem_info *entry;
entry = find_shmem(args->shmems,
vma_entry->shmid);
if (entry && entry->pid == my_pid &&
entry->start == vma_entry->start)
futex_set_and_wake(&entry->lock, 1);
}
if (vma_entry->prot & PROT_WRITE)
continue;
sys_mprotect(decode_pointer(vma_entry->start),
vma_entry_len(vma_entry),
vma_entry->prot);
}
/*
* Finally restore madivse() bits
*/
for (vma_entry = args->tgt_vmas; vma_entry->start != 0; vma_entry++) {
unsigned long i;
if (!vma_entry->has_madv || !vma_entry->madv)
continue;
for (i = 0; i < sizeof(vma_entry->madv) * 8; i++) {
if (vma_entry->madv & (1ul << i)) {
ret = sys_madvise(vma_entry->start,
vma_entry_len(vma_entry),
i);
if (ret) {
pr_err("madvise(%"PRIx64", %"PRIu64", %ld) "
"failed with %ld\n",
vma_entry->start,
vma_entry_len(vma_entry),
i, ret);
goto core_restore_end;
}
}
}
}
sys_munmap(args->tgt_vmas,
((void *)(vma_entry + 1) - ((void *)args->tgt_vmas)));
ret = sys_munmap(args->shmems, SHMEMS_SIZE);
if (ret < 0) {
pr_err("Can't unmap shmem %ld\n", ret);
goto core_restore_end;
}
/*
* Tune up the task fields.
*/
ret |= sys_prctl_safe(PR_SET_NAME, (long)args->comm, 0, 0);
ret |= sys_prctl_safe(PR_SET_MM, PR_SET_MM_START_CODE, (long)args->mm.mm_start_code, 0);
ret |= sys_prctl_safe(PR_SET_MM, PR_SET_MM_END_CODE, (long)args->mm.mm_end_code, 0);
ret |= sys_prctl_safe(PR_SET_MM, PR_SET_MM_START_DATA, (long)args->mm.mm_start_data, 0);
ret |= sys_prctl_safe(PR_SET_MM, PR_SET_MM_END_DATA, (long)args->mm.mm_end_data, 0);
ret |= sys_prctl_safe(PR_SET_MM, PR_SET_MM_START_STACK, (long)args->mm.mm_start_stack, 0);
ret |= sys_prctl_safe(PR_SET_MM, PR_SET_MM_START_BRK, (long)args->mm.mm_start_brk, 0);
ret |= sys_prctl_safe(PR_SET_MM, PR_SET_MM_BRK, (long)args->mm.mm_brk, 0);
ret |= sys_prctl_safe(PR_SET_MM, PR_SET_MM_ARG_START, (long)args->mm.mm_arg_start, 0);
ret |= sys_prctl_safe(PR_SET_MM, PR_SET_MM_ARG_END, (long)args->mm.mm_arg_end, 0);
ret |= sys_prctl_safe(PR_SET_MM, PR_SET_MM_ENV_START, (long)args->mm.mm_env_start, 0);
ret |= sys_prctl_safe(PR_SET_MM, PR_SET_MM_ENV_END, (long)args->mm.mm_env_end, 0);
ret |= sys_prctl_safe(PR_SET_MM, PR_SET_MM_AUXV, (long)args->mm_saved_auxv, args->mm_saved_auxv_size);
if (ret)
goto core_restore_end;
/*
* Because of requirements applied from kernel side
* we need to restore /proc/pid/exe symlink late,
* after old existing VMAs are superseded with
* new ones from image file.
*/
ret = restore_self_exe_late(args);
if (ret)
goto core_restore_end;
/*
* We need to prepare a valid sigframe here, so
* after sigreturn the kernel will pick up the
* registers from the frame, set them up and
* finally pass execution to the new IP.
*/
rt_sigframe = (void *)args->t->mem_zone.rt_sigframe + 8;
if (restore_thread_common(rt_sigframe, args->t))
goto core_restore_end;
/*
* Threads restoration. This requires some more comments. This
* restorer routine and thread restorer routine has the following
* memory map, prepared by a caller code.
*
* | <-- low addresses high addresses --> |
* +-------------------------------------------------------+-----------------------+
* | this proc body | own stack | heap | rt_sigframe space | thread restore zone |
* +-------------------------------------------------------+-----------------------+
*
* where each thread restore zone is the following
*
* | <-- low addresses high addresses --> |
* +--------------------------------------------------------------------------+
* | thread restore proc | thread1 stack | thread1 heap | thread1 rt_sigframe |
* +--------------------------------------------------------------------------+
*/
if (args->nr_threads > 1) {
struct thread_restore_args *thread_args = args->thread_args;
long clone_flags = CLONE_VM | CLONE_FILES | CLONE_SIGHAND |
CLONE_THREAD | CLONE_SYSVSEM;
long last_pid_len;
long parent_tid;
int i, fd;
fd = sys_open(LAST_PID_PATH, O_RDWR, LAST_PID_PERM);
if (fd < 0) {
pr_err("Can't open last_pid %d\n", fd);
goto core_restore_end;
}
ret = sys_flock(fd, LOCK_EX);
if (ret) {
pr_err("Can't lock last_pid %d\n", fd);
goto core_restore_end;
}
for (i = 0; i < args->nr_threads; i++) {
char last_pid_buf[16], *s;
/* skip self */
if (thread_args[i].pid == args->t->pid)
continue;
mutex_lock(&args->rst_lock);
new_sp =
RESTORE_ALIGN_STACK((long)thread_args[i].mem_zone.stack,
sizeof(thread_args[i].mem_zone.stack));
last_pid_len = vprint_num(last_pid_buf, sizeof(last_pid_buf), thread_args[i].pid - 1, &s);
ret = sys_write(fd, s, last_pid_len);
if (ret < 0) {
pr_err("Can't set last_pid %ld/%s\n", ret, last_pid_buf);
goto core_restore_end;
}
/*
* To achieve functionality like libc's clone()
* we need a pure assembly here, because clone()'ed
* thread will run with own stack and we must not
* have any additional instructions... oh, dear...
*/
RUN_CLONE_RESTORE_FN(ret, clone_flags, new_sp, parent_tid, thread_args, args->clone_restore_fn);
}
ret = sys_flock(fd, LOCK_UN);
if (ret) {
pr_err("Can't unlock last_pid %ld\n", ret);
goto core_restore_end;
}
sys_close(fd);
}
restore_rlims(args);
pr_info("%ld: Restored\n", sys_getpid());
futex_set(&zombies_inprogress, args->nr_zombies);
restore_finish_stage(CR_STATE_RESTORE);
futex_wait_while_gt(&zombies_inprogress, 0);
sys_sigaction(SIGCHLD, &args->sigchld_act, NULL, sizeof(k_rtsigset_t));
ret = restore_signals(args->siginfo, args->siginfo_nr, true);
if (ret)
goto core_restore_end;
ret = restore_signals(args->t->siginfo, args->t->siginfo_nr, false);
if (ret)
goto core_restore_end;
restore_finish_stage(CR_STATE_RESTORE_SIGCHLD);
if (args->siginfo_size) {
ret = sys_munmap(args->siginfo, args->siginfo_size);
if (ret < 0) {
pr_err("Can't unmap signals %ld\n", ret);
goto core_restore_failed;
}
}
rst_tcp_socks_all(args->rst_tcp_socks, args->rst_tcp_socks_size);
/*
* Writing to last-pid is CAP_SYS_ADMIN protected,
* turning off TCP repair is CAP_SYS_NED_ADMIN protected,
* thus restore* creds _after_ all of the above.
*/
ret = restore_creds(&args->creds);
futex_set_and_wake(&thread_inprogress, args->nr_threads);
restore_finish_stage(CR_STATE_RESTORE_CREDS);
if (ret)
BUG();
/* Wait until children stop to use args->task_entries */
futex_wait_while_gt(&thread_inprogress, 1);
log_set_fd(-1);
/*
* The code that prepared the itimers makes shure the
* code below doesn't fail due to bad timing values.
*/
#define itimer_armed(args, i) \
(args->itimers[i].it_interval.tv_sec || \
args->itimers[i].it_interval.tv_usec)
if (itimer_armed(args, 0))
sys_setitimer(ITIMER_REAL, &args->itimers[0], NULL);
if (itimer_armed(args, 1))
sys_setitimer(ITIMER_VIRTUAL, &args->itimers[1], NULL);
if (itimer_armed(args, 2))
sys_setitimer(ITIMER_PROF, &args->itimers[2], NULL);
ret = sys_munmap(args->task_entries, TASK_ENTRIES_SIZE);
if (ret < 0) {
ret = ((long)__LINE__ << 16) | ((-ret) & 0xffff);
goto core_restore_failed;
}
/*
* Sigframe stack.
*/
new_sp = (long)rt_sigframe + SIGFRAME_OFFSET;
/*
* Prepare the stack and call for sigreturn,
* pure assembly since we don't need any additional
* code insns from gcc.
*/
ARCH_RT_SIGRETURN(new_sp);
core_restore_end:
futex_abort_and_wake(&task_entries->nr_in_progress);
pr_err("Restorer fail %ld\n", sys_getpid());
sys_exit_group(1);
return -1;
core_restore_failed:
ARCH_FAIL_CORE_RESTORE;
return ret;
}
static int my_open(const char *file, int oflag) {
int result = sys_open(file, oflag, 0);
if (result < 0)
fail(file, "Cannot open ELF file! ", "errno", my_errno, NULL, 0);
return result;
}
/* create a pid file in the pid directory. open it and leave it locked */
void pidfile_create(const char *program_name)
{
int fd;
char buf[20];
const char *short_configfile;
char *name;
pid_t pid;
/* Add a suffix to the program name if this is a process with a
* none default configuration file name. */
if (strcmp( CONFIGFILE, get_dyn_CONFIGFILE()) == 0) {
name = SMB_STRDUP(program_name);
} else {
short_configfile = strrchr( get_dyn_CONFIGFILE(), '/');
if (short_configfile == NULL) {
/* conf file in current directory */
short_configfile = get_dyn_CONFIGFILE();
} else {
/* full/relative path provided */
short_configfile++;
}
if (asprintf(&name, "%s-%s", program_name,
short_configfile) == -1) {
smb_panic("asprintf failed");
}
}
if (asprintf(&pidFile_name, "%s/%s.pid", lp_piddir(), name) == -1) {
smb_panic("asprintf failed");
}
pid = pidfile_pid(name);
if (pid != 0) {
DEBUG(0,("ERROR: %s is already running. File %s exists and process id %d is running.\n",
name, pidFile_name, (int)pid));
exit(1);
}
fd = sys_open(pidFile_name, O_NONBLOCK | O_CREAT | O_WRONLY | O_EXCL,
0644);
if (fd == -1) {
DEBUG(0,("ERROR: can't open %s: Error was %s\n", pidFile_name,
strerror(errno)));
exit(1);
}
if (fcntl_lock(fd,SMB_F_SETLK,0,1,F_WRLCK)==False) {
DEBUG(0,("ERROR: %s : fcntl lock of file %s failed. Error was %s\n",
name, pidFile_name, strerror(errno)));
exit(1);
}
memset(buf, 0, sizeof(buf));
slprintf(buf, sizeof(buf) - 1, "%u\n", (unsigned int) sys_getpid());
if (write(fd, buf, strlen(buf)) != (ssize_t)strlen(buf)) {
DEBUG(0,("ERROR: can't write to file %s: %s\n",
pidFile_name, strerror(errno)));
exit(1);
}
/* Leave pid file open & locked for the duration... */
SAFE_FREE(name);
}
int wsys_open(const smb_ucs2_t *wfname, int oflag, mode_t mode)
{
pstring fname;
return sys_open(unicode_to_unix(fname,wfname,sizeof(fname)), oflag, mode);
}
static int rda_wifi_init_uart(char *dev)
{
int errno;
struct termios ti;
struct serial_struct ss;
int fd;
fd = sys_open(dev, O_RDWR | O_NOCTTY, 0);
if (fd < 0) {
printk("Can't open serial port");
return -1;
}
sys_ioctl(fd, TCFLSH, TCIOFLUSH);
/* Clear the cust flag */
if((errno = sys_ioctl(fd, TIOCGSERIAL, &ss))<0){
printk("BAUD: error to get the serial_struct info:%s\n", errno);
goto err;
}
if (ss.flags & ASYNC_SPD_CUST) {
printk("clear ASYNC_SPD_CUST\r\n");
ss.flags &= ~ASYNC_SPD_CUST;
}
if((errno = sys_ioctl(fd, TIOCSSERIAL, &ss))<0){
printk("BAUD: error to set serial_struct:%s\n", errno);
goto err;
}
if ((errno = sys_ioctl(fd, TCGETS, (long)&ti)) < 0) {
printk("unable to get UART port setting");
printk("Can't get port settings");
goto err;
}
cfmakeraw(&ti);
ti.c_cflag |= CLOCAL;
ti.c_cflag &= ~CRTSCTS;
ti.c_lflag = 0;
ti.c_cc[VTIME] = 5; /* 0.5 sec */
ti.c_cc[VMIN] = 0;
/* Set initial baudrate */
cfsetospeed(&ti, B115200);
cfsetispeed(&ti, B115200);
if ((errno = sys_ioctl(fd, TCSETS, (long)&ti)) < 0) {
printk("unable to set UART port setting");
printk("Can't set port settings");
goto err;
}
errno = sys_ioctl(fd, TCFLSH, TCIOFLUSH);
if(errno < 0)
goto err;
return fd;
err:
if(fd > 0)
sys_close(fd);
return -1;
}
/* 565RLE image format: [count(2 bytes), rle(2 bytes)] */
int load_565rle_image(char *filename)
{
struct fb_info *info;
int fd, err = 0;
unsigned count, max;
char *data, *bits, *ptr;
printk("LUYA!!!!1 load_565rle_image\n");
info = registered_fb[0];
if (!info) {
printk(KERN_WARNING "%s: Can not access framebuffer\n",
__func__);
return -ENODEV;
}
printk("LUYA!!!!2 load_565rle_image\n");
fd = sys_open(filename, O_RDONLY, 0);
if (fd < 0) {
printk(KERN_WARNING "%s: Can not open %s\n",
__func__, filename);
return -ENOENT;
}
max = fb_width(info) * fb_height(info)*4;
printk("LUYA!!!!max=%d\n",max);
count = (unsigned)sys_lseek(fd, (off_t)0, 2);
printk("LUYA!!!!count=%d\n",count);
if (count == 0) {
sys_close(fd);
err = -EIO;
goto err_logo_close_file;
}
sys_lseek(fd, (off_t)0, 0);
data = kmalloc(count, GFP_KERNEL);
if (!data) {
printk(KERN_WARNING "%s: Can not alloc data\n", __func__);
err = -ENOMEM;
goto err_logo_close_file;
}
if ((unsigned)sys_read(fd, (char *)data, count) != count) {
err = -EIO;
goto err_logo_free_data;
}
ptr = data+54;
bits = (char *)(info->screen_base);
//memcpy((void *)info->screen_base,(void *)(data+27),480*800*4);
while (max > 0) {
// unsigned n = ptr[0];
// if (n > max)
// break;
//memset16(bits, ptr[0], 1 << 1);
//memset16(bits+1, ptr[3], 1 << 1);
//memset16(bits+2, ptr[2], 1 << 1);
//memset16(bits+3, ptr[1], 1 << 1);
bits[0] = ptr[2];
bits[1] = ptr[1];
bits[2] = ptr[0];
bits[3] = ptr[3];
bits += 4;
max -= 4;
ptr += 4;
// count -= 1;
}
err_logo_free_data:
kfree(data);
err_logo_close_file:
sys_close(fd);
return err;
}
/*
* Main program
*/
void lab_cmd_nanddump(int argc, const char **argv)
{
unsigned char readbuf[512];
unsigned char oobbuf[16];
unsigned long ofs;
struct mtd_info* mtd = NULL;
int i, ofd, bs, start_addr, end_addr, pretty_print;
struct mtd_oob_buf oob = {0, 16, oobbuf};
unsigned char pretty_buf[120];
int retlen;
/* Make sure enough arguments were passed */
if (argc < 3 || argv[1][1] != '\0') {
lab_printf("usage: %s <mtd number> <dumpname> [start addr] [length]\r\n", argv[0]);
return;
}
/* Open MTD device */
if ((mtd = get_mtd_device(NULL, argv[1][0]-'0')) == NULL) {
lab_puts("Couldn't open flash\r\n");
return;
}
if (mtd->type != MTD_NANDFLASH) {
lab_puts("This MTD is not NAND flash. I can't dump this - sorry.\r\n");
put_mtd_device(mtd);
return;
}
/* Make sure device page sizes are valid */
if (!(mtd->oobsize == 16 && mtd->oobblock == 512) &&
!(mtd->oobsize == 8 && mtd->oobblock == 256)) {
lab_puts("Unknown flash (not normal NAND)\r\n");
put_mtd_device(mtd);
return;
}
/* Open output file for writing */
if ((ofd = sys_open(argv[2], O_WRONLY | O_CREAT, 0644)) == -1) {
lab_puts("Couldn't open outfile\r\n");
put_mtd_device(mtd);
return;
}
/* Initialize start/end addresses and block size */
start_addr = 0;
end_addr = mtd->size;
bs = mtd->oobblock;
/* See if start address and length were specified */
if (argc == 4) {
start_addr = simple_strtoul(argv[3], NULL, 0) & ~(bs - 1);
end_addr = mtd->size;
} else if (argc == 5) {
start_addr = simple_strtoul(argv[3], NULL, 0) & ~(bs - 1);
end_addr = (simple_strtoul(argv[3], NULL, 0) + simple_strtoul(argv[4], NULL, 0)) & ~(bs - 1);
}
/* Ask user if they would like pretty output */
lab_puts("Would you like formatted output? ");
if (tolower(pretty_buf[0] = lab_getc_seconds(NULL, 0)) != 'y')
pretty_print = 0;
else
pretty_print = 1;
lab_putc(pretty_buf[0]);
/* Print informative message */
lab_printf("\r\nDumping data starting at 0x%08x and ending at 0x%08x...\r\n",
start_addr, end_addr);
lab_printf("OOB size: %d. OOB block: %d\r\n",
mtd->oobsize, mtd->oobblock);
/* Dump the flash contents */
for (ofs = start_addr; ofs < end_addr ; ofs+=bs) {
struct nand_oobinfo oobsel;
oobsel.useecc = 0;
/* Read page data and exit on failure */
// if (MTD_READECC(mtd, ofs, bs, &retlen, readbuf, NULL, &oobsel)) {
if (MTD_READECC(mtd, ofs, bs, &retlen, readbuf, &oobbuf, NULL)) {
lab_puts("Error in mtdread\r\n");
// put_mtd_device(mtd);
// sys_close(ofd);
// return;
}
/* Write out page data */
if (pretty_print) {
for (i = 0; i < bs; i += 16) {
sprintf(pretty_buf,
"0x%08x: %02x %02x %02x %02x %02x %02x %02x "
"%02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
(unsigned int) (ofs + i), readbuf[i],
readbuf[i+1], readbuf[i+2],
readbuf[i+3], readbuf[i+4],
readbuf[i+5], readbuf[i+6],
readbuf[i+7], readbuf[i+8],
readbuf[i+9], readbuf[i+10],
readbuf[i+11], readbuf[i+12],
readbuf[i+13], readbuf[i+14],
readbuf[i+15]);
sys_write(ofd, pretty_buf, 60);
}
} else
sys_write(ofd, readbuf, bs);
/* Read OOB data and exit on failure */
oob.start = ofs;
if ((ofs & 0xFFFF) == 0x0)
lab_printf("Dumping %lx\r", ofs);
#if 0
if (MTD_READOOB(mtd, ofs, mtd->oobsize, &retlen, oobbuf)) {
lab_puts("ioctl(MEMREADOOB) failed\r\n");
put_mtd_device(mtd);
sys_close(ofd);
return;
}
#endif
/* Write out OOB data */
if (pretty_print) {
if (mtd->oobsize == 16) {
sprintf(pretty_buf, " OOB Data: %02x %02x %02x %02x %02x %02x "
"%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
oobbuf[0], oobbuf[1], oobbuf[2],
oobbuf[3], oobbuf[4], oobbuf[5],
oobbuf[6], oobbuf[7], oobbuf[8],
oobbuf[9], oobbuf[10], oobbuf[11],
oobbuf[12], oobbuf[13], oobbuf[14],
oobbuf[15]);
sys_write(ofd, pretty_buf, 60);
} else {
sprintf(pretty_buf, " OOB Data: %02x %02x %02x %02x %02x %02x "
"%02x %02x\n",
oobbuf[0], oobbuf[1], oobbuf[2],
oobbuf[3], oobbuf[4], oobbuf[5],
oobbuf[6], oobbuf[7]);
sys_write(ofd, pretty_buf, 48);
}
} else
sys_write(ofd, oobbuf, mtd->oobsize);
}
/* Close the output file and MTD device */
put_mtd_device(mtd);
sys_close(ofd);
lab_puts("\n");
/* Exit happy */
return;
}
static int __init mount_nfs_root(void)
{
char *root_dev, *root_data;
unsigned int timeout;
int try, err;
err = nfs_root_data(&root_dev, &root_data);
if (err != 0)
return 0;
/*
* The server or network may not be ready, so try several
* times. Stop after a few tries in case the client wants
* to fall back to other boot methods.
*/
timeout = NFSROOT_TIMEOUT_MIN;
for (try = 1; ; try++) {
err = do_mount_root(root_dev, "nfs",
root_mountflags, root_data);
if (err == 0)
return 1;
if (try > NFSROOT_RETRY_MAX)
break;
/* Wait, in case the server refused us immediately */
ssleep(timeout);
timeout <<= 1;
if (timeout > NFSROOT_TIMEOUT_MAX)
timeout = NFSROOT_TIMEOUT_MAX;
}
return 0;
}
#endif
#if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD)
void __init change_floppy(char *fmt, ...)
{
struct termios termios;
char buf[80];
char c;
int fd;
va_list args;
va_start(args, fmt);
vsprintf(buf, fmt, args);
va_end(args);
fd = sys_open("/dev/root", O_RDWR | O_NDELAY, 0);
if (fd >= 0) {
sys_ioctl(fd, FDEJECT, 0);
sys_close(fd);
}
printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf);
fd = sys_open("/dev/console", O_RDWR, 0);
if (fd >= 0) {
sys_ioctl(fd, TCGETS, (long)&termios);
termios.c_lflag &= ~ICANON;
sys_ioctl(fd, TCSETSF, (long)&termios);
sys_read(fd, &c, 1);
termios.c_lflag |= ICANON;
sys_ioctl(fd, TCSETSF, (long)&termios);
sys_close(fd);
}
}
#endif
void __init mount_root(void)
{
#ifdef CONFIG_ROOT_NFS
if (ROOT_DEV == Root_NFS) {
if (mount_nfs_root())
return;
printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n");
ROOT_DEV = Root_FD0;
}
#endif
#ifdef CONFIG_BLK_DEV_FD
if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) {
/* rd_doload is 2 for a dual initrd/ramload setup */
if (rd_doload==2) {
if (rd_load_disk(1)) {
ROOT_DEV = Root_RAM1;
root_device_name = NULL;
}
} else
change_floppy("root floppy");
}
#endif
#ifdef CONFIG_BLOCK
create_dev("/dev/root", ROOT_DEV);
mount_block_root("/dev/root", root_mountflags);
#endif
}
/*
* Prepare the namespace - decide what/where to mount, load ramdisks, etc.
*/
void __init prepare_namespace(void)
{
int is_floppy;
if (root_delay) {
printk(KERN_INFO "Waiting %dsec before mounting root device...\n",
root_delay);
ssleep(root_delay);
}
/*
* wait for the known devices to complete their probing
*
* Note: this is a potential source of long boot delays.
* For example, it is not atypical to wait 5 seconds here
* for the touchpad of a laptop to initialize.
*/
wait_for_device_probe();
md_run_setup();
if (saved_root_name[0]) {
root_device_name = saved_root_name;
if (!strncmp(root_device_name, "mtd", 3) ||
!strncmp(root_device_name, "ubi", 3)) {
mount_block_root(root_device_name, root_mountflags);
goto out;
}
ROOT_DEV = name_to_dev_t(root_device_name);
if (strncmp(root_device_name, "/dev/", 5) == 0)
root_device_name += 5;
}
if (initrd_load())
goto out;
/* wait for any asynchronous scanning to complete */
if ((ROOT_DEV == 0) && root_wait) {
printk(KERN_INFO "Waiting for root device %s...\n",
saved_root_name);
while (driver_probe_done() != 0 ||
(ROOT_DEV = name_to_dev_t(saved_root_name)) == 0)
msleep(100);
async_synchronize_full();
}
is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
if (is_floppy && rd_doload && rd_load_disk(0))
ROOT_DEV = Root_RAM0;
check_resume_attempted();
mount_root();
out:
devtmpfs_mount("dev");
sys_mount(".", "/", NULL, MS_MOVE, NULL);
sys_chroot((const char __user __force *)".");
}
/*
* This is the main page dumping routine, it's executed
* inside a victim process space.
*/
static int dump_pages(struct parasite_dump_pages_args *args)
{
unsigned long nrpages, pfn, length;
unsigned long prot_old, prot_new;
u64 *map, off;
int ret = -1, fd;
args->nrpages_dumped = 0;
args->nrpages_skipped = 0;
prot_old = prot_new = 0;
pfn = args->vma_entry.start / PAGE_SIZE;
nrpages = (args->vma_entry.end - args->vma_entry.start) / PAGE_SIZE;
args->nrpages_total = nrpages;
length = nrpages * sizeof(*map);
/*
* Up to 10M of pagemap will handle 5G mapping.
*/
map = brk_alloc(length);
if (!map) {
ret = -ENOMEM;
goto err;
}
fd = sys_open("/proc/self/pagemap", O_RDONLY, 0);
if (fd < 0) {
sys_write_msg("Can't open self pagemap");
ret = fd;
goto err_free;
}
off = pfn * sizeof(*map);
off = sys_lseek(fd, off, SEEK_SET);
if (off != pfn * sizeof(*map)) {
sys_write_msg("Can't seek pagemap");
ret = off;
goto err_close;
}
ret = sys_read(fd, map, length);
if (ret != length) {
sys_write_msg("Can't read self pagemap");
goto err_free;
}
sys_close(fd);
fd = fd_pages;
/*
* Try to change page protection if needed so we would
* be able to dump contents.
*/
if (!(args->vma_entry.prot & PROT_READ)) {
prot_old = (unsigned long)args->vma_entry.prot;
prot_new = prot_old | PROT_READ;
ret = sys_mprotect((void *)args->vma_entry.start,
(unsigned long)vma_entry_len(&args->vma_entry),
prot_new);
if (ret) {
sys_write_msg("sys_mprotect failed\n");
goto err_free;
}
}
ret = 0;
for (pfn = 0; pfn < nrpages; pfn++) {
size_t vaddr;
if (should_dump_page(&args->vma_entry, map[pfn])) {
/*
* That's the optimized write of
* page_entry structure, see image.h
*/
vaddr = (size_t)args->vma_entry.start + pfn * PAGE_SIZE;
ret = sys_write_safe(fd, &vaddr, sizeof(vaddr));
if (ret)
return ret;
ret = sys_write_safe(fd, (void *)vaddr, PAGE_SIZE);
if (ret)
return ret;
args->nrpages_dumped++;
} else if (map[pfn] & PME_PRESENT)
args->nrpages_skipped++;
}
/*
* Don't left pages readable if they were not.
*/
if (prot_old != prot_new) {
ret = sys_mprotect((void *)args->vma_entry.start,
(unsigned long)vma_entry_len(&args->vma_entry),
prot_old);
if (ret) {
sys_write_msg("PANIC: Ouch! sys_mprotect failed on restore\n");
goto err_free;
}
}
ret = 0;
err_free:
brk_free(length);
err:
return ret;
err_close:
sys_close(fd);
goto err_free;
}
int bsp_om_append_file(char *filename, void * address, u32 length, u32 max_size)
{
int ret = BSP_OK;
int fd;
int bytes;
int len;
mm_segment_t old_fs;
old_fs = get_fs();
set_fs(KERNEL_DS);
ret = om_create_dir(OM_ROOT_PATH);
if(BSP_OK != ret)
{
om_error("<bsp_om_append_file>, create dir failed! ret = %d\n", ret);
goto out;
}
/* open file */
ret = sys_access(filename, 0);
if(BSP_OK != ret)
{
/*create file */
fd = sys_open(filename, O_CREAT|O_RDWR, 0755);
if(fd < 0)
{
om_error("<bsp_om_append_file>, open failed while mode is create, ret = %d\n", fd);
goto out;
}
}
else
{
fd = sys_open(filename, O_APPEND|O_RDWR, 0755);
if(fd < 0)
{
om_error("<bsp_om_append_file>, open failed while mode is append, ret = %d\n", fd);
goto out;
}
}
len = sys_lseek(fd, 0, SEEK_END);
if(ERROR == len)
{
om_error("<bsp_om_append_file>, seek failed! ret = %d\n", len);
(void)sys_close(fd);
goto out;
}
if (len >= max_size)
{
sys_close(fd);
ret = sys_unlink(filename);
if (OK != ret)
{
om_error("<bsp_om_append_file>, remove failed! ret = %d\n", ret);
goto out;
}
/*重新建立reset文件*/
fd = sys_open(filename, O_CREAT|O_RDWR, 0755);
if(fd < 0)
{
om_error("<bsp_om_append_file>, create failed! ret = %d\n", fd);
goto out;
}
}
bytes = sys_write(fd, address, length);
if(bytes != length)
{
om_error("<bsp_om_append_file>, write data failed! ret = %d\n", bytes);
ret = BSP_ERROR;
(void)sys_close(fd);
goto out;
}
ret = sys_close(fd);
if(0 != ret)
{
om_error("<bsp_om_append_file>, close failed! ret = %d\n", ret);
ret = BSP_ERROR;
goto out;
}
ret = BSP_OK;
out:
set_fs(old_fs);
return ret;
}
}
void creat_lseek_read_write_open_close_file_test(void)
{
int count = 0;
char buff_in[100] = "Hello world!\nI'm writing a small OS.\nThanks.";
char buff_out[100] = {0};
char filename[50] = {0};
unsigned short oldfs;
/* 已创建了内核默认的最多磁盘存储文件数，则停止 */
while((++count) < NR_D_INODE) {
_k_printf("This is the content will be written: \n%s\n\n", buff_in);
sprintf(filename, "/hello--%d.txt", count);
_k_printf("%s\n", filename);
/* 创建文件并写入 */
oldfs = set_fs_kernel();
FILEDESC desc = sys_creat(filename, FILE_FILE | FILE_RW);
set_fs(oldfs);
if(-1 == desc) {
k_printf("creat_lseek_...: Create file failed!");
return;
}
d_printf("Create file return.\n");
if(-1 == sys_lseek(desc, 995920, SEEK_SET)) {
k_printf("creat_lseek_...: Lseek file failed!");
return;
}
d_printf("Lseek file return.\n");
oldfs = set_fs_kernel();
if(-1 == sys_write(desc, buff_in, 1 + strlen(buff_in))) {
set_fs(oldfs);
k_printf("creat_lseek_...: Write file failed!");
return;
}
set_fs(oldfs);
d_printf("Write file return.\n");
if(-1 == sys_close(desc)) {
k_printf("creat_lseek_...: Close file failed!");
return;
}
d_printf("Close file return.\n");
/* 打印根目录含有的文件 */
print_dir("/");
/* 打开之前创建的文件，读取 */
oldfs = set_fs_kernel();
if(-1 == (desc = sys_open(filename, O_RW))) {
set_fs(oldfs);
k_printf("creat_lseek_...: Open file failed!");
return;
}
set_fs(oldfs);
d_printf("Open file return.\n");
if(-1 == sys_lseek(desc, 995920, SEEK_SET)) {
k_printf("creat_lseek_...: Lseek file failed!");
return;
}
d_printf("Lseek file return.\n");
oldfs = set_fs_kernel();
if(-1 == sys_read(desc, buff_out, 1 + strlen(buff_in))) {
set_fs(oldfs);
k_printf("creat_lseek_...: Read file failed!");
return;
}
set_fs(oldfs);
d_printf("Read file return.\n");
if(-1 == sys_close(desc)) {
k_printf("creat_lseek_...: Close file failed!");
return;
}
d_printf("Close file return.\n");
_k_printf("This is the content of READ file: \n%s\n\n", buff_out);
s32 hifi2_stress_test_start(void)
{
u32 readlen = 0;
unsigned int handle;
mm_segment_t oldfs;
u32 buffer[0x10];
long ret = 0;
int error = 0;
error |= bsp_hifi_pll_enable();
error |= bsp_hifi_power_on();
error |= bsp_hifi_clock_enable();
error |= bsp_hifi_unreset();
hifi2_tcm_addr = (u32)ioremap_nocache(HIFI_TCM_ADDR, HIFI_TCM_SIZE);
if (NULL == (void*)hifi2_tcm_addr)
{
printk(KERN_ERR"fail to io remap\n");
return -ENOMEM;
}
oldfs = get_fs();
set_fs(KERNEL_DS);
handle = (unsigned int)sys_open("/data/hifi2", O_RDONLY, 0);
if (IS_ERR((const void*)handle))
{
printk(KERN_ERR"fail to open file '/data/hifi2'\n");
return -1;
}
#ifdef BSP_DSP_BBE16
do
{
ret = sys_read(handle, (char*)buffer, sizeof(buffer));
memcpy((void*)(hifi2_tcm_addr+0x4080+readlen), (void*)buffer, sizeof(buffer));
readlen += ret;
}while(ret == sizeof(buffer));
#else
do
{
ret = sys_read(handle, (char*)buffer, sizeof(buffer));
memcpy((void*)(hifi2_tcm_addr+readlen), (void*)buffer, sizeof(buffer));
readlen += ret;
}while(ret == sizeof(buffer));
#endif
sys_close(handle);
set_fs(oldfs);
#if 0
#ifdef BSP_DSP_BBE16
/* HiFi2 DMEM1Æ«ÒÆ0x4000(16KB) */
writel(DDR_TLPHY_IMAGE_ADDR, hifi2_tcm_addr+0x4000);
writel(1024/4, hifi2_tcm_addr+0x4004);
writel(AXI_MEM_64_SRC_FOR_HIFI_PHY, hifi2_tcm_addr+0x4008);
writel(AXI_MEM_64_FOR_MEMCPY_SIZE*2/4, hifi2_tcm_addr+0x400C);
writel(AXI_MEM_FOR_HIFI_SRC_ADDR_PHY, hifi2_tcm_addr+0x4010);
writel(AXI_MEM_FOR_MEMCPY_SIZE*2/4, hifi2_tcm_addr+0x4014);
writel(0, hifi2_tcm_addr+0x401C);
#else
/* HiFi2 DMEM1Æ«ÒÆ0x8000(32KB) */
writel(DDR_TLPHY_IMAGE_ADDR, hifi2_tcm_addr+0x8000);
writel(1024/4, hifi2_tcm_addr+0x8004);
writel(AXI_MEM_64_SRC_FOR_HIFI_PHY, hifi2_tcm_addr+0x8008);
writel(AXI_MEM_64_FOR_MEMCPY_SIZE*2/4, hifi2_tcm_addr+0x800C);
writel(AXI_MEM_FOR_HIFI_SRC_ADDR_PHY, hifi2_tcm_addr+0x8010);
writel(AXI_MEM_FOR_MEMCPY_SIZE*2/4, hifi2_tcm_addr+0x8014);
writel(0, hifi2_tcm_addr+0x801C);
set_hi_sc_ctrl12_hifi_runstall(0);
#endif
#endif
/* HiFi2 DMEM1Æ«ÒÆ0x8000(32KB) */
writel(SHD_DDR_V2P(HIFI_DDR_BASEADDR), hifi2_tcm_addr+0x8000);
writel(HIFI_DDR_SIZE/4, hifi2_tcm_addr+0x8004);
writel(AXI_MEM_64_SRC_FOR_HIFI_PHY, hifi2_tcm_addr+0x8008);
writel(AXI_MEM_FOR_MEMCPY_SIZE*2/4, hifi2_tcm_addr+0x800C);
writel(AXI_MEM_FOR_HIFI_SRC_ADDR_PHY, hifi2_tcm_addr+0x8010);
writel(AXI_MEM_FOR_MEMCPY_SIZE*2/4, hifi2_tcm_addr+0x8014);
writel(0, hifi2_tcm_addr+0x801C);
error |= bsp_hifi_run();
printk(KERN_INFO"OK, image length: %d\n", readlen);
return error;
}
/* 565RLE image format: [count(2 bytes), rle(2 bytes)] */
int load_565rle_image(char *filename, bool bf_supported)
{
struct fb_info *info;
int fd, count, err = 0;
unsigned max;
unsigned short *data, *bits, *ptr;
struct module *owner;
int pad;
info = registered_fb[0];
if (!info) {
printk(KERN_WARNING "%s: Can not access framebuffer\n",
__func__);
return -ENODEV;
}
owner = info->fbops->owner;
if (!try_module_get(owner))
return -ENODEV;
if (info->fbops->fb_open && info->fbops->fb_open(info, 0)) {
module_put(owner);
return -ENODEV;
}
fd = sys_open(filename, O_RDONLY, 0);
if (fd < 0) {
printk(KERN_WARNING "%s: Can not open %s\n",
__func__, filename);
return -ENOENT;
}
count = sys_lseek(fd, (off_t)0, 2);
if (count <= 0) {
err = -EIO;
goto err_logo_close_file;
}
sys_lseek(fd, (off_t)0, 0);
data = kmalloc(count, GFP_KERNEL);
if (!data) {
printk(KERN_WARNING "%s: Can not alloc data\n", __func__);
err = -ENOMEM;
goto err_logo_close_file;
}
if (sys_read(fd, (char *)data, count) != count) {
err = -EIO;
goto err_logo_free_data;
}
max = fb_width(info) * fb_height(info);
ptr = data;
if (bf_supported && (info->node == 1 || info->node == 2)) {
err = -EPERM;
pr_err("%s:%d no info->creen_base on fb%d!\n",
__func__, __LINE__, info->node);
goto err_logo_free_data;
}
if (info->screen_base) {
bits = (unsigned short *)(info->screen_base);
while (count > 3) {
unsigned n = ptr[0];
if (n > max)
break;
pad = memset16_rgb8888(bits, ptr[1], n << 1, info);
bits += n << 1;
bits += pad;
max -= n;
ptr += 2;
count -= 4;
}
}
flush_cache_all();
outer_flush_all();
err_logo_free_data:
kfree(data);
err_logo_close_file:
sys_close(fd);
return err;
}
/*
* System call dispatcher.
*
* A pointer to the trapframe created during exception entry (in
* exception.S) is passed in.
*
* The calling conventions for syscalls are as follows: Like ordinary
* function calls, the first 4 32-bit arguments are passed in the 4
* argument registers a0-a3. 64-bit arguments are passed in *aligned*
* pairs of registers, that is, either a0/a1 or a2/a3. This means that
* if the first argument is 32-bit and the second is 64-bit, a1 is
* unused.
*
* This much is the same as the calling conventions for ordinary
* function calls. In addition, the system call number is passed in
* the v0 register.
*
* On successful return, the return value is passed back in the v0
* register, or v0 and v1 if 64-bit. This is also like an ordinary
* function call, and additionally the a3 register is also set to 0 to
* indicate success.
*
* On an error return, the error code is passed back in the v0
* register, and the a3 register is set to 1 to indicate failure.
* (Userlevel code takes care of storing the error code in errno and
* returning the value -1 from the actual userlevel syscall function.
* See src/user/lib/libc/arch/mips/syscalls-mips.S and related files.)
*
* Upon syscall return the program counter stored in the trapframe
* must be incremented by one instruction; otherwise the exception
* return code will restart the "syscall" instruction and the system
* call will repeat forever.
*
* If you run out of registers (which happens quickly with 64-bit
* values) further arguments must be fetched from the user-level
* stack, starting at sp+16 to skip over the slots for the
* registerized values, with copyin().
*/
void
syscall(struct trapframe *tf)
{
int callno;
int32_t retval;
int err = 0;
KASSERT(curthread != NULL);
KASSERT(curthread->t_curspl == 0);
KASSERT(curthread->t_iplhigh_count == 0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
case SYS___time:
err = sys___time((userptr_t)tf->tf_a0,
(userptr_t)tf->tf_a1);
break;
/* Add stuff here */
case SYS_read:
err = sys_read((int)tf->tf_a0, // filehandle
(void*)tf->tf_a1, // buffer
(size_t)tf->tf_a2, // size
&retval); // return value
break;
case SYS_write:
err = sys_write((int)tf->tf_a0, // filehandle
(const void*)tf->tf_a1, // buffer
(size_t)tf->tf_a2, // size
&retval); // return value
break;
case SYS_open:
err = sys_open((const char*)tf->tf_a0, // filename
(int)tf->tf_a1, // flags
&retval); // return value
break;
case SYS_close:
err = sys_close((int)tf->tf_a0); // filehandle
break;
case SYS_dup2:
err = sys_dup2((int)tf->tf_a0, // old_filehandle
(int)tf->tf_a1, // new_filehandle
&retval); // return value
break;
case SYS__exit:
sys_exit((int)tf->tf_a0); // exitcode
break;
case SYS_getpid:
retval = sys_getpid(); // exitcode
break;
case SYS_waitpid:
err = sys_waitpid((pid_t)tf->tf_a0, (int*)tf->tf_a1, tf->tf_a2, &retval);
break;
case SYS_fork:
err = sys_fork(tf, &retval);
break;
case SYS_execv:
err = sys_execv((userptr_t)tf->tf_a0, (userptr_t)tf->tf_a1);
break;
case SYS_sbrk:
err = sys_sbrk((intptr_t)tf->tf_a0, &retval);
break;
case SYS_lseek: {
off_t offset = tf->tf_a2;
offset = offset<<32;
offset = offset|tf->tf_a3;
int whence;
int err_copyin = copyin((userptr_t)tf->tf_sp+16,&whence,sizeof(whence));
if (err_copyin) {
break;
}
off_t retoffset;
err = sys_lseek((int)tf->tf_a0, // filehandle
offset, // desired offset
whence,
&retoffset); // return value
if (!err) {
retval = retoffset>>32;
tf->tf_v1 = retoffset;
}
break;
} break;
case SYS___getcwd:
err = sys___getcwd((char*)tf->tf_a0, // buffer
(size_t)tf->tf_a1, // size
&retval); // return value
break;
case SYS_chdir:
err = sys_chdir((char*)tf->tf_a0); // path
break;
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
/* 565RLE image format: [count(2 bytes), rle(2 bytes)] */
int load_565rle_image(char *filename)
{
struct fb_info *info;
int fd, count, err = 0;
unsigned max;
unsigned short *data, *ptr;
char *bits;
pixel_set_t pixel_set;
info = registered_fb[0];
if (!info) {
printk(KERN_WARNING "%s: Can not access framebuffer\n",
__func__);
return -ENODEV;
}
switch (info->var.bits_per_pixel) {
case 16:
pixel_set = memset16;
break;
case 32:
pixel_set = pixel_set_rgba;
break;
default:
printk(KERN_WARNING "%s: Can not find pixel_set operation\n",
__func__);
return -EDOM;
}
fd = sys_open(filename, O_RDONLY, 0);
if (fd < 0) {
printk(KERN_WARNING "%s: Can not open %s\n",
__func__, filename);
return -ENOENT;
}
count = sys_lseek(fd, (off_t)0, 2);
if (count <= 0) {
err = -EIO;
goto err_logo_close_file;
}
sys_lseek(fd, (off_t)0, 0);
data = kmalloc(count, GFP_KERNEL);
if (!data) {
printk(KERN_WARNING "%s: Can not alloc data\n", __func__);
err = -ENOMEM;
goto err_logo_close_file;
}
if (sys_read(fd, (char *)data, count) != count) {
err = -EIO;
goto err_logo_free_data;
}
max = fb_width(info) * fb_height(info);
ptr = data;
bits = info->screen_base;
while (count > 3) {
unsigned n = ptr[0];
if (n > max)
break;
bits += pixel_set(bits, ptr[1], n);
max -= n;
ptr += 2;
count -= 4;
}
err_logo_free_data:
kfree(data);
err_logo_close_file:
sys_close(fd);
return err;
}
/*
* For backward compatibility? Maybe this should be moved
* into arch/i386 instead?
*/
asmlinkage long sys_creat(const char __user * pathname, int mode)
{
return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
}
static void SN_get(struct work_struct *work)
{
char *pbuf = (char *)kzalloc(512, GFP_KERNEL);;
char SN[31] = {0};
char bd_addr[6] = {0};
int i = 0;
// unsigned short *pSnLen = NULL;
long fd = 0;
char buf_tmp[15] = {0};
char mac_tmp[30] = {0};
DBG(1,"%s........enter\n",__FUNCTION__);
GetSNSectorInfo(pbuf);
unsigned short *pSnLen = (unsigned short *)pbuf;
memcpy(SN,pbuf+2,*pSnLen);
//memcpy(sn_buf,pbuf+2,*pSnLen);
//printk("%s..psnlen=%d...SN=%s\n",__FUNCTION__,*pSnLen,SN);
fd = sys_open(SN_FILE,O_CREAT | O_RDWR,S_IRWXU|S_IRGRP|S_IROTH);
if(fd < 0)
{
printk("%s SN_get: open file /data/sn failed\n",__FILE__);
return;
}
sys_write(fd, (const char __user *)SN, *pSnLen);
sys_close(fd);
fd = sys_open(BLUE_MAC,O_CREAT | O_RDWR,S_IRWXU|S_IRGRP|S_IROTH);
if(fd < 0)
{
printk("%s SN_get: open file /data/blue_mac failed\n",__FILE__);
return;
}
for(i=499; i<=504; i++)
{
//printk("%s....*(pbuf+%d)=%x\n",__FUNCTION__,i,*(pbuf+i));
bd_addr[504-i] = *(pbuf+i);
//sprintf(mac_tmp+i-499+4,"%02x:",*(pbuf+i));
// printk("%s.....bd_addr[504-i] =%x\n",__FUNCTION__,bd_addr[504-i]);
}
sprintf(mac_tmp,"%02x:%02x:%02x:%02x:%02x:%02x",bd_addr[5],bd_addr[4],bd_addr[3],bd_addr[2],bd_addr[1],bd_addr[0]);
//printk("%s....msc_tmp=%s\n",__FUNCTION__,mac_tmp);
sys_write(fd, (const char __user *)mac_tmp,strlen(mac_tmp));
sys_close(fd);
kfree(pbuf);
/*
fd = sys_open(BLUE_MAC,O_CREAT | O_RDWR,S_IRWXU|S_IRGRP|S_IROTH);
sys_read(fd,buf_tmp,15);
for (i=0;i<15;i++)
printk("buf_tmp[i]=%4x",buf_tmp[i]);
printk("mac over\n");
sys_close(fd);
*/
DBG(1,"%s.......blue over.\n",__FUNCTION__);
}
static void
syscall_handler (struct intr_frame *f)
{
/* Check to see that we can read supplied user memory pointer, using the
check_mem_ptr helper() function, in get_word_from_stack(). If the
check fails, the process is terminated. */
int syscall_number = (int)get_word_on_stack(f, 0);
switch(syscall_number) {
case SYS_HALT:
{
sys_halt();
break;
}
case SYS_EXIT:
{
int status = (int)get_word_on_stack(f, 1);
sys_exit(status);
/* Returns exit status to the kernel. */
f->eax = status;
break;
}
case SYS_EXEC:
{
const char *cmd_line = (const char *)get_word_on_stack(f, 1);
pid_t pid = sys_exec(cmd_line);
/* Returns new processes pid. */
f->eax = pid;
break;
}
case SYS_WAIT:
{
pid_t pid = (pid_t)get_word_on_stack(f, 1);
/* Returns child's exit status (pid argument is pid of this child). */
f->eax = sys_wait(pid);
break;
}
case SYS_CREATE:
{
const char *filename = (const char *)get_word_on_stack(f, 1);
unsigned initial_size = (unsigned)get_word_on_stack(f, 2);
/* Returns true to the kernel if creation is successful. */
f->eax = (int)sys_create(filename, initial_size);
break;
}
case SYS_REMOVE:
{
const char *filename = (const char *)get_word_on_stack(f, 1);
/* Returns true if successful, and false otherwise. */
f->eax = sys_remove(filename);
break;
}
case SYS_OPEN:
{
const char *filename = (const char *)get_word_on_stack(f, 1);
/* Returns file descriptor of opened file, or -1 if it could not
be opened. */
f->eax = sys_open(filename);
break;
}
case SYS_FILESIZE:
{
int fd = (int)get_word_on_stack(f, 1);
/* Returns size of file in bytes. */
f->eax = sys_filesize(fd);
break;
}
case SYS_READ:
{
int fd = (int)get_word_on_stack(f, 1);
void *buffer = (void *)get_word_on_stack(f, 2);
unsigned size = (unsigned)get_word_on_stack(f, 3);
/* Returns number of bytes actually read, or -1 if it could not
be read. */
f->eax = sys_read(fd, buffer, size, f);
break;
}
case SYS_WRITE:
{
int fd = (int)get_word_on_stack(f, 1);
void *buffer = (void *)get_word_on_stack(f, 2);
unsigned size = (unsigned)get_word_on_stack(f, 3);
/* Returns number of bytes written. */
f->eax = sys_write(fd, buffer, size);
break;
}
case SYS_SEEK:
{
int fd = (int)get_word_on_stack(f, 1);
unsigned position = (int)get_word_on_stack(f, 2);
sys_seek(fd, position);
break;
}
case SYS_TELL:
{
int fd = (int)get_word_on_stack(f, 1);
/* Returns the position of the next byte to be read or written in open
file 'fd' (in bytes, from start of file). */
f->eax = sys_tell(fd);
break;
}
case SYS_CLOSE:
{
int fd = (int)get_word_on_stack(f, 1);
sys_close(fd);
break;
}
case SYS_MMAP:
{
int fd = (int)get_word_on_stack(f, 1);
void *addr = (void *)get_word_on_stack(f, 2);
f->eax = sys_mmap(fd, addr);
break;
}
case SYS_MUNMAP:
{
mapid_t mapping = (mapid_t)get_word_on_stack(f, 1);
sys_munmap(mapping);
break;
}
default:
{
NOT_REACHED();
}
}
}
/*
* System call dispatcher.
*
* A pointer to the trapframe created during exception entry (in
* exception.S) is passed in.
*
* The calling conventions for syscalls are as follows: Like ordinary
* function calls, the first 4 32-bit arguments are passed in the 4
* argument registers a0-a3. 64-bit arguments are passed in *aligned*
* pairs of registers, that is, either a0/a1 or a2/a3. This means that
* if the first argument is 32-bit and the second is 64-bit, a1 is
* unused.
*
* This much is the same as the calling conventions for ordinary
* function calls. In addition, the system call number is passed in
* the v0 register.
*
* On successful return, the return value is passed back in the v0
* register, or v0 and v1 if 64-bit. This is also like an ordinary
* function call, and additionally the a3 register is also set to 0 to
* indicate success.
*
* On an error return, the error code is passed back in the v0
* register, and the a3 register is set to 1 to indicate failure.
* (Userlevel code takes care of storing the error code in errno and
* returning the value -1 from the actual userlevel syscall function.
* See src/user/lib/libc/arch/mips/syscalls-mips.S and related files.)
*
* Upon syscall return the program counter stored in the trapframe
* must be incremented by one instruction; otherwise the exception
* return code will restart the "syscall" instruction and the system
* call will repeat forever.
*
* If you run out of registers (which happens quickly with 64-bit
* values) further arguments must be fetched from the user-level
* stack, starting at sp+16 to skip over the slots for the
* registerized values, with copyin().
*/
void
syscall(struct trapframe *tf)
{
int callno;
int32_t retval;
int err;
KASSERT(curthread != NULL);
KASSERT(curthread->t_curspl == 0);
KASSERT(curthread->t_iplhigh_count == 0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
case SYS___time:
err = sys___time((userptr_t)tf->tf_a0,
(userptr_t)tf->tf_a1);
break;
#ifdef UW
case SYS_write:
err = sys_write((int)tf->tf_a0,
(userptr_t)tf->tf_a1,
(int)tf->tf_a2,
(int *)(&retval));
break;
#if OPT_A2
case SYS_open:
err = sys_open((const char*)tf->tf_a0,
(int)tf->tf_a1,
(int *)(&retval));
break;
case SYS_read:
err = sys_read((int)tf->tf_a0,
(userptr_t)tf->tf_a1,
(int)tf->tf_a2,
(int *)(&retval));
break;
case SYS_close:
err = sys_close((int)tf->tf_a0);
break;
#endif
case SYS__exit:
sys__exit((int)tf->tf_a0);
/* sys__exit does not return, execution should not get here */
panic("unexpected return from sys__exit");
break;
#endif // UW
/* Add stuff here */
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
if (err) {
/*
* Return the error code. This gets converted at
* userlevel to a return value of -1 and the error
* code in errno.
*/
tf->tf_v0 = err;
tf->tf_a3 = 1; /* signal an error */
}
else {
/* Success. */
tf->tf_v0 = retval;
tf->tf_a3 = 0; /* signal no error */
}
/*
* Now, advance the program counter, to avoid restarting
* the syscall over and over again.
*/
tf->tf_epc += 4;
/* Make sure the syscall code didn't forget to lower spl */
KASSERT(curthread->t_curspl == 0);
/* ...or leak any spinlocks */
KASSERT(curthread->t_iplhigh_count == 0);
}
static int init(void * unused)
{
lock_kernel();
/*
* init can run on any cpu.
*/
set_cpus_allowed(current, CPU_MASK_ALL);
/*
* Tell the world that we're going to be the grim
* reaper of innocent orphaned children.
*
* We don't want people to have to make incorrect
* assumptions about where in the task array this
* can be found.
*/
child_reaper = current;
cad_pid = task_pid(current);
smp_prepare_cpus(max_cpus);
do_pre_smp_initcalls();
smp_init();
sched_init_smp();
cpuset_init_smp();
/*
* Do this before initcalls, because some drivers want to access
* firmware files.
*/
populate_rootfs();
do_basic_setup();
/*
* check if there is an early userspace init. If yes, let it do all
* the work
*/
if (!ramdisk_execute_command)
ramdisk_execute_command = "/init";
if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
ramdisk_execute_command = NULL;
prepare_namespace();
}
/*
* Ok, we have completed the initial bootup, and
* we're essentially up and running. Get rid of the
* initmem segments and start the user-mode stuff..
*/
free_initmem();
unlock_kernel();
mark_rodata_ro();
system_state = SYSTEM_RUNNING;
numa_default_policy();
if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
printk(KERN_WARNING "Warning: unable to open an initial console.\n");
(void) sys_dup(0);
(void) sys_dup(0);
if (ramdisk_execute_command) {
run_init_process(ramdisk_execute_command);
printk(KERN_WARNING "Failed to execute %s\n",
ramdisk_execute_command);
}
/*
* We try each of these until one succeeds.
*
* The Bourne shell can be used instead of init if we are
* trying to recover a really broken machine.
*/
if (execute_command) {
run_init_process(execute_command);
printk(KERN_WARNING "Failed to execute %s. Attempting "
"defaults...\n", execute_command);
}
run_init_process("/sbin/init");
run_init_process("/etc/init");
run_init_process("/bin/init");
run_init_process("/bin/sh");
panic("No init found. Try passing init= option to kernel.");
}
static int get_sys_cpu_usage_info_ex_procstat(void)
{
int fd;
int nReadSize;
char szTempBuf[256];
char buf[256];
char *pbuf;
int nCoreIndex = 0, i;
oldfs = get_fs();
set_fs(KERNEL_DS);
fd = sys_open("/proc/stat", O_RDONLY, 0);
if (fd < 0)
{
THRML_LOG("[get_sys_cpu_usage_info] open fail fd:%d \n", fd);
set_fs(oldfs);
return -1;
}
nReadSize = sys_read(fd, buf, sizeof(buf) - 1);
buf[254] = '\n';
buf[255] = 0x0;
set_fs(oldfs);
sys_close(fd);
pbuf = buf;
SEEK_BUFF(pbuf, '\n');
THRML_LOG("[Read Buff]:%s \n", buf);
for (nCoreIndex = 0; nCoreIndex < NUMBER_OF_CORE; nCoreIndex++)
{
int ret = 0;
sprintf(szTempBuf, "cpu%01d %%lu %%lu %%lu %%lu %%lu %%lu %%lu", nCoreIndex);
/* Get CPU Info */
if (strncmp(pbuf, "cpu", 3) == 0)
{
ret = sscanf(pbuf, szTempBuf, &cpu_index_list[nCoreIndex].u[CPU_USAGE_CURRENT_FIELD], &cpu_index_list[nCoreIndex].n[CPU_USAGE_CURRENT_FIELD],
&cpu_index_list[nCoreIndex].s[CPU_USAGE_CURRENT_FIELD], &cpu_index_list[nCoreIndex].i[CPU_USAGE_CURRENT_FIELD],
&cpu_index_list[nCoreIndex].w[CPU_USAGE_CURRENT_FIELD], &cpu_index_list[nCoreIndex].q[CPU_USAGE_CURRENT_FIELD],
&cpu_index_list[nCoreIndex].sq[CPU_USAGE_CURRENT_FIELD]);
SEEK_BUFF(pbuf, '\n');
THRML_LOG("sscanf = %d, buf = %0x, pbuf = %0x\n", ret, (int) &buf[0], (int) pbuf);
}
/* Frame */
cpu_index_list[nCoreIndex].u[CPU_USAGE_FRAME_FIELD] = cpu_index_list[nCoreIndex].u[CPU_USAGE_CURRENT_FIELD] -
cpu_index_list[nCoreIndex].u[CPU_USAGE_SAVE_FIELD];
cpu_index_list[nCoreIndex].n[CPU_USAGE_FRAME_FIELD] = cpu_index_list[nCoreIndex].n[CPU_USAGE_CURRENT_FIELD] -
cpu_index_list[nCoreIndex].n[CPU_USAGE_SAVE_FIELD];
cpu_index_list[nCoreIndex].s[CPU_USAGE_FRAME_FIELD] = cpu_index_list[nCoreIndex].s[CPU_USAGE_CURRENT_FIELD] -
cpu_index_list[nCoreIndex].s[CPU_USAGE_SAVE_FIELD];
cpu_index_list[nCoreIndex].i[CPU_USAGE_FRAME_FIELD] = TRIMz_ex(cpu_index_list[nCoreIndex].tz,
(cpu_index_list[nCoreIndex].i[CPU_USAGE_CURRENT_FIELD] -
cpu_index_list[nCoreIndex].i[CPU_USAGE_SAVE_FIELD])) ;
cpu_index_list[nCoreIndex].w[CPU_USAGE_FRAME_FIELD] = cpu_index_list[nCoreIndex].w[CPU_USAGE_CURRENT_FIELD] -
cpu_index_list[nCoreIndex].w[CPU_USAGE_SAVE_FIELD];
cpu_index_list[nCoreIndex].q[CPU_USAGE_FRAME_FIELD] = cpu_index_list[nCoreIndex].q[CPU_USAGE_CURRENT_FIELD] -
cpu_index_list[nCoreIndex].q[CPU_USAGE_SAVE_FIELD] ;
cpu_index_list[nCoreIndex].sq[CPU_USAGE_FRAME_FIELD] = cpu_index_list[nCoreIndex].sq[CPU_USAGE_CURRENT_FIELD] -
cpu_index_list[nCoreIndex].sq[CPU_USAGE_SAVE_FIELD];
/* Total Frame */
cpu_index_list[nCoreIndex].tot_frme = cpu_index_list[nCoreIndex].u[CPU_USAGE_FRAME_FIELD] +
cpu_index_list[nCoreIndex].n[CPU_USAGE_FRAME_FIELD] +
cpu_index_list[nCoreIndex].s[CPU_USAGE_FRAME_FIELD] +
cpu_index_list[nCoreIndex].i[CPU_USAGE_FRAME_FIELD] +
cpu_index_list[nCoreIndex].w[CPU_USAGE_FRAME_FIELD] +
cpu_index_list[nCoreIndex].q[CPU_USAGE_FRAME_FIELD] +
cpu_index_list[nCoreIndex].sq[CPU_USAGE_FRAME_FIELD];
/* CPU Usage */
if(cpu_index_list[nCoreIndex].tot_frme > 0)
{
cpuloadings[nCoreIndex] = (100-(((int)cpu_index_list[nCoreIndex].i[CPU_USAGE_FRAME_FIELD]*100)/(int)cpu_index_list[nCoreIndex].tot_frme));
}else
{
/* CPU unplug case */
cpuloadings[nCoreIndex] = 0;
}
cpu_index_list[nCoreIndex].u[CPU_USAGE_SAVE_FIELD] = cpu_index_list[nCoreIndex].u[CPU_USAGE_CURRENT_FIELD];
cpu_index_list[nCoreIndex].n[CPU_USAGE_SAVE_FIELD] = cpu_index_list[nCoreIndex].n[CPU_USAGE_CURRENT_FIELD];
cpu_index_list[nCoreIndex].s[CPU_USAGE_SAVE_FIELD] = cpu_index_list[nCoreIndex].s[CPU_USAGE_CURRENT_FIELD];
cpu_index_list[nCoreIndex].i[CPU_USAGE_SAVE_FIELD] = cpu_index_list[nCoreIndex].i[CPU_USAGE_CURRENT_FIELD];
cpu_index_list[nCoreIndex].w[CPU_USAGE_SAVE_FIELD] = cpu_index_list[nCoreIndex].w[CPU_USAGE_CURRENT_FIELD];
cpu_index_list[nCoreIndex].q[CPU_USAGE_SAVE_FIELD] = cpu_index_list[nCoreIndex].q[CPU_USAGE_CURRENT_FIELD];
cpu_index_list[nCoreIndex].sq[CPU_USAGE_SAVE_FIELD] = cpu_index_list[nCoreIndex].sq[CPU_USAGE_CURRENT_FIELD];
THRML_LOG("CPU%d Frame:%d USAGE:%d \n", nCoreIndex, cpu_index_list[nCoreIndex].tot_frme, cpuloadings[nCoreIndex]);
for(i=0 ; i<3 ; i++)
{
THRML_LOG("Index [u:%d] [n:%d] [s:%d] [i:%d] [w:%d] [q:%d] [sq:%d] \n", i, cpu_index_list[nCoreIndex].u[i],
cpu_index_list[nCoreIndex].n[i],
cpu_index_list[nCoreIndex].s[i],
cpu_index_list[nCoreIndex].i[i],
cpu_index_list[nCoreIndex].w[i],
cpu_index_list[nCoreIndex].q[i],
cpu_index_list[nCoreIndex].sq[i]);
}
}//for
return 0;
}
static int syscall_dispatch(uint32_t sysnum, uint32_t args, regs_t *regs)
{
switch (sysnum) {
case SYS_waitpid:
return sys_waitpid((waitpid_args_t *)args);
case SYS_exit:
do_exit((int)args);
panic("exit failed!\n");
return 0;
case SYS_thr_exit:
kthread_exit((void *)args);
panic("thr_exit failed!\n");
return 0;
case SYS_thr_yield:
sched_make_runnable(curthr);
sched_switch();
return 0;
case SYS_fork:
return sys_fork(regs);
case SYS_getpid:
return curproc->p_pid;
case SYS_sync:
sys_sync();
return 0;
#ifdef __MOUNTING__
case SYS_mount:
return sys_mount((mount_args_t *) args);
case SYS_umount:
return sys_umount((argstr_t *) args);
#endif
case SYS_mmap:
return (int) sys_mmap((mmap_args_t *) args);
case SYS_munmap:
return sys_munmap((munmap_args_t *) args);
case SYS_open:
return sys_open((open_args_t *) args);
case SYS_close:
return sys_close((int)args);
case SYS_read:
return sys_read((read_args_t *)args);
case SYS_write:
return sys_write((write_args_t *)args);
case SYS_dup:
return sys_dup((int)args);
case SYS_dup2:
return sys_dup2((dup2_args_t *)args);
case SYS_mkdir:
return sys_mkdir((mkdir_args_t *)args);
case SYS_rmdir:
return sys_rmdir((argstr_t *)args);
case SYS_unlink:
return sys_unlink((argstr_t *)args);
case SYS_link:
return sys_link((link_args_t *)args);
case SYS_rename:
return sys_rename((rename_args_t *)args);
case SYS_chdir:
return sys_chdir((argstr_t *)args);
case SYS_getdents:
return sys_getdents((getdents_args_t *)args);
case SYS_brk:
return (int) sys_brk((void *)args);
case SYS_lseek:
return sys_lseek((lseek_args_t *)args);
case SYS_halt:
sys_halt();
return -1;
case SYS_set_errno:
curthr->kt_errno = (int)args;
return 0;
case SYS_errno:
return curthr->kt_errno;
case SYS_execve:
return sys_execve((execve_args_t *)args, regs);
case SYS_stat:
return sys_stat((stat_args_t *)args);
case SYS_pipe:
return sys_pipe((int *)args);
case SYS_uname:
return sys_uname((struct utsname *)args);
case SYS_debug:
return sys_debug((argstr_t *)args);
case SYS_kshell:
return sys_kshell((int)args);
default:
dbg(DBG_ERROR, "ERROR: unknown system call: %d (args: %#08x)\n", sysnum, args);
curthr->kt_errno = ENOSYS;
return -1;
}
}
static int findpty(char **slave)
{
int master = -1;
char *line = NULL;
SMB_STRUCT_DIR *dirp = NULL;
const char *dpname;
*slave = NULL;
#if defined(HAVE_GRANTPT)
/* Try to open /dev/ptmx. If that fails, fall through to old method. */
if ((master = sys_open("/dev/ptmx", O_RDWR, 0)) >= 0) {
grantpt(master);
unlockpt(master);
line = (char *)ptsname(master);
if (line) {
*slave = SMB_STRDUP(line);
}
if (*slave == NULL) {
DEBUG(0,
("findpty: Unable to create master/slave pty pair.\n"));
/* Stop fd leak on error. */
close(master);
return -1;
} else {
DEBUG(10,
("findpty: Allocated slave pty %s\n", *slave));
return (master);
}
}
#endif /* HAVE_GRANTPT */
line = SMB_STRDUP("/dev/ptyXX");
if (!line) {
return (-1);
}
dirp = sys_opendir("/dev");
if (!dirp) {
SAFE_FREE(line);
return (-1);
}
while ((dpname = readdirname(dirp)) != NULL) {
if (strncmp(dpname, "pty", 3) == 0 && strlen(dpname) == 5) {
DEBUG(3,
("pty: try to open %s, line was %s\n", dpname,
line));
line[8] = dpname[3];
line[9] = dpname[4];
if ((master = sys_open(line, O_RDWR, 0)) >= 0) {
DEBUG(3, ("pty: opened %s\n", line));
line[5] = 't';
*slave = line;
sys_closedir(dirp);
return (master);
}
}
}
sys_closedir(dirp);
SAFE_FREE(line);
return (-1);
}