From 9394c9fa54f750ce50a8ea01ce5b0a3a2b4cf17e Mon Sep 17 00:00:00 2001 From: Balazs Gerofi Date: Sat, 19 May 2012 16:54:14 +0900 Subject: [PATCH] stat(), get_sched_affinity(), gettimeofday() and some detailed debug msgs --- kernel/include/affinity.h | 149 ++++++++++++++++++++++++++++++++++++++ kernel/include/time.h | 39 ++++++++++ kernel/syscall.c | 55 +++++++++++++- 3 files changed, 240 insertions(+), 3 deletions(-) create mode 100644 kernel/include/affinity.h create mode 100644 kernel/include/time.h diff --git a/kernel/include/affinity.h b/kernel/include/affinity.h new file mode 100644 index 00000000..f12fbddf --- /dev/null +++ b/kernel/include/affinity.h @@ -0,0 +1,149 @@ +/* + * Adapted from Linux sched.h + * + * Modified to omit __GNUC_PREREQ checks and use + * the naive implementations. + * + */ + +#if !defined __cpu_set_t_defined +# define __cpu_set_t_defined +/* Size definition for CPU sets. */ +# define __CPU_SETSIZE 1024 +# define __NCPUBITS (8 * sizeof (__cpu_mask)) + +/* Type for array elements in 'cpu_set_t'. */ +typedef unsigned long int __cpu_mask; + +/* Basic access functions. */ +# define __CPUELT(cpu) ((cpu) / __NCPUBITS) +# define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS)) + +/* Data structure to describe CPU mask. */ +typedef struct +{ + __cpu_mask __bits[__CPU_SETSIZE / __NCPUBITS]; +} cpu_set_t; + +/* Access functions for CPU masks. */ +# define __CPU_ZERO_S(setsize, cpusetp) \ + do { \ + size_t __i; \ + size_t __imax = (setsize) / sizeof (__cpu_mask); \ + __cpu_mask *__bits = (cpusetp)->__bits; \ + for (__i = 0; __i < __imax; ++__i) \ + __bits[__i] = 0; \ + } while (0) +# define __CPU_SET_S(cpu, setsize, cpusetp) \ + (__extension__ \ + ({ size_t __cpu = (cpu); \ + __cpu < 8 * (setsize) \ + ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] \ + |= __CPUMASK (__cpu)) \ + : 0; })) +# define __CPU_CLR_S(cpu, setsize, cpusetp) \ + (__extension__ \ + ({ size_t __cpu = (cpu); \ + __cpu < 8 * (setsize) \ + ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] \ + &= ~__CPUMASK (__cpu)) \ + : 0; })) +# define __CPU_ISSET_S(cpu, setsize, cpusetp) \ + (__extension__ \ + ({ size_t __cpu = (cpu); \ + __cpu < 8 * (setsize) \ + ? ((((__const __cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] \ + & __CPUMASK (__cpu))) != 0 \ + : 0; })) + +# define __CPU_COUNT_S(setsize, cpusetp) \ + __sched_cpucount (setsize, cpusetp) + +# define __CPU_EQUAL_S(setsize, cpusetp1, cpusetp2) \ + (__extension__ \ + ({ __const __cpu_mask *__arr1 = (cpusetp1)->__bits; \ + __const __cpu_mask *__arr2 = (cpusetp2)->__bits; \ + size_t __imax = (setsize) / sizeof (__cpu_mask); \ + size_t __i; \ + for (__i = 0; __i < __imax; ++__i) \ + if (__bits[__i] != __bits[__i]) \ + break; \ + __i == __imax; })) + +# define __CPU_OP_S(setsize, destset, srcset1, srcset2, op) \ + (__extension__ \ + ({ cpu_set_t *__dest = (destset); \ + __const __cpu_mask *__arr1 = (srcset1)->__bits; \ + __const __cpu_mask *__arr2 = (srcset2)->__bits; \ + size_t __imax = (setsize) / sizeof (__cpu_mask); \ + size_t __i; \ + for (__i = 0; __i < __imax; ++__i) \ + ((__cpu_mask *) __dest->__bits)[__i] = __arr1[__i] op __arr2[__i]; \ + __dest; })) + +# define __CPU_ALLOC_SIZE(count) \ + ((((count) + __NCPUBITS - 1) / __NCPUBITS) * sizeof (__cpu_mask)) +# define __CPU_ALLOC(count) __sched_cpualloc (count) +# define __CPU_FREE(cpuset) __sched_cpufree (cpuset) + +#if 0 +__BEGIN_DECLS + +extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) + __THROW; +extern cpu_set_t *__sched_cpualloc (size_t __count) __THROW __wur; +extern void __sched_cpufree (cpu_set_t *__set) __THROW; + +__END_DECLS +#endif + +#endif + +/* Access macros for `cpu_set'. */ +# define CPU_SETSIZE __CPU_SETSIZE +# define CPU_SET(cpu, cpusetp) __CPU_SET_S (cpu, sizeof (cpu_set_t), cpusetp) +# define CPU_CLR(cpu, cpusetp) __CPU_CLR_S (cpu, sizeof (cpu_set_t), cpusetp) +# define CPU_ISSET(cpu, cpusetp) __CPU_ISSET_S (cpu, sizeof (cpu_set_t), \ + cpusetp) +# define CPU_ZERO(cpusetp) __CPU_ZERO_S (sizeof (cpu_set_t), cpusetp) +# define CPU_COUNT(cpusetp) __CPU_COUNT_S (sizeof (cpu_set_t), cpusetp) + +# define CPU_SET_S(cpu, setsize, cpusetp) __CPU_SET_S (cpu, setsize, cpusetp) +# define CPU_CLR_S(cpu, setsize, cpusetp) __CPU_CLR_S (cpu, setsize, cpusetp) +# define CPU_ISSET_S(cpu, setsize, cpusetp) __CPU_ISSET_S (cpu, setsize, \ + cpusetp) +# define CPU_ZERO_S(setsize, cpusetp) __CPU_ZERO_S (setsize, cpusetp) +# define CPU_COUNT_S(setsize, cpusetp) __CPU_COUNT_S (setsize, cpusetp) + +# define CPU_EQUAL(cpusetp1, cpusetp2) \ + __CPU_EQUAL_S (sizeof (cpu_set_t), cpusetp1, cpusetp2) +# define CPU_EQUAL_S(setsize, cpusetp1, cpusetp2) \ + __CPU_EQUAL_S (setsize, cpusetp1, cpusetp2) + +# define CPU_AND(destset, srcset1, srcset2) \ + __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, &) +# define CPU_OR(destset, srcset1, srcset2) \ + __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, |) +# define CPU_XOR(destset, srcset1, srcset2) \ + __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, ^) +# define CPU_AND_S(setsize, destset, srcset1, srcset2) \ + __CPU_OP_S (setsize, destset, srcset1, srcset2, &) +# define CPU_OR_S(setsize, destset, srcset1, srcset2) \ + __CPU_OP_S (setsize, destset, srcset1, srcset2, |) +# define CPU_XOR_S(setsize, destset, srcset1, srcset2) \ + __CPU_OP_S (setsize, destset, srcset1, srcset2, ^) + +# define CPU_ALLOC_SIZE(count) __CPU_ALLOC_SIZE (count) +# define CPU_ALLOC(count) __CPU_ALLOC (count) +# define CPU_FREE(cpuset) __CPU_FREE (cpuset) + +#if 0 +/* Set the CPU affinity for a task */ +extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, + __const cpu_set_t *__cpuset) __THROW; + +/* Get the CPU affinity for a task */ +extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, + cpu_set_t *__cpuset) __THROW; +#endif + diff --git a/kernel/include/time.h b/kernel/include/time.h new file mode 100644 index 00000000..c009e112 --- /dev/null +++ b/kernel/include/time.h @@ -0,0 +1,39 @@ +/* + * time.h: + * + * excerpted from the cross-compiler's header folder + */ + +#ifndef __TIME_H +#define __TIME_H + +typedef long int __time_t; + +/* POSIX.1b structure for a time value. This is like a `struct timeval' but + has nanoseconds instead of microseconds. */ +struct timespec + { + __time_t tv_sec; /* Seconds. */ + long int tv_nsec; /* Nanoseconds. */ + }; + + +/* A time value that is accurate to the nearest + microsecond but also has a range of years. */ +struct timeval + { + __time_t tv_sec; /* Seconds. */ + long tv_usec; /* Microseconds. */ + }; + + +/* Structure crudely representing a timezone. + This is obsolete and should never be used. */ +struct timezone + { + int tz_minuteswest; /* Minutes west of GMT. */ + int tz_dsttime; /* Nonzero if DST is ever in effect. */ + }; + +#endif // __TIME_H + diff --git a/kernel/syscall.c b/kernel/syscall.c index 11b9d738..f23a6bb3 100644 --- a/kernel/syscall.c +++ b/kernel/syscall.c @@ -15,6 +15,8 @@ #include #include #include +#include +#include /* Headers taken from kitten LWK */ #include @@ -72,6 +74,10 @@ static int do_syscall(struct syscall_request *req, aal_mc_user_context_t *ctx) { struct syscall_response *res = cpu_local_var(scp).response_va; + dkprintf("SC(%d)[%3d] sending syscall\n", + aal_mc_get_processor_id(), + req->number); + send_syscall(req); dkprintf("SC(%d)[%3d] waiting for host.. \n", @@ -98,6 +104,7 @@ long sys_brk(int n, aal_mc_user_context_t *ctx) extend_process_region(cpu_local_var(current), region->brk_start, region->brk_end, address); + return region->brk_end; } @@ -153,11 +160,31 @@ static int stop(void) SYSCALL_DECLARE(open) { + SYSCALL_HEADER; + dkprintf("open: %s\n", (char*)aal_mc_syscall_arg0(ctx)); SYSCALL_ARGS_3(MI, D, D); SYSCALL_FOOTER; } +SYSCALL_DECLARE(stat) +{ + SYSCALL_HEADER; + dkprintf("stat(\"%s\");\n", (char*)aal_mc_syscall_arg0(ctx)); + SYSCALL_ARGS_2(D, D); + SYSCALL_FOOTER; +} + + +SYSCALL_DECLARE(gettimeofday) +{ + SYSCALL_HEADER; + dkprintf("gettimeofday() \n"); + SYSCALL_ARGS_1(MO); + SYSCALL_FOOTER; +} + + static DECLARE_WAITQ(my_waitq); SYSCALL_DECLARE(ioctl) @@ -254,7 +281,7 @@ SYSCALL_DECLARE(pwrite) SYSCALL_DECLARE(close) { - kprintf("[%d] close() \n", aal_mc_get_processor_id()); + dkprintf("[%d] close() \n", aal_mc_get_processor_id()); return -EBADF; /* @@ -614,7 +641,7 @@ SYSCALL_DECLARE(getrlimit) case RLIMIT_STACK: dkprintf("[%d] getrlimit() RLIMIT_STACK\n", aal_mc_get_processor_id()); - rlm->rlim_cur = (128*4096); /* Linux provides 8MB */ + rlm->rlim_cur = (512*4096); /* Linux provides 8MB */ rlm->rlim_max = (1024*1024*1024); ret = 0; break; @@ -627,6 +654,23 @@ SYSCALL_DECLARE(getrlimit) return ret; } +SYSCALL_DECLARE(sched_getaffinity) +{ + //int pid = (int)aal_mc_syscall_arg0(ctx); + //int size = (int)aal_mc_syscall_arg1(ctx); + int cpu_id; + cpu_set_t *mask = (cpu_set_t *)aal_mc_syscall_arg2(ctx); + + CPU_ZERO(mask); + for (cpu_id = 0; cpu_id < 120; ++cpu_id) + CPU_SET(cpu_id, mask); + + dkprintf("sched_getaffinity returns full mask\n"); + + return 0; +} + + SYSCALL_DECLARE(noop) { kprintf("noop() \n"); @@ -638,6 +682,7 @@ static long (*syscall_table[])(int, aal_mc_user_context_t *) = { [1] = sys_write, [2] = sys_open, [3] = sys_close, + [4] = sys_stat, [5] = sys_fstat, [8] = sys_lseek, [9] = sys_mmap, @@ -654,6 +699,7 @@ static long (*syscall_table[])(int, aal_mc_user_context_t *) = { [56] = sys_clone, [60] = sys_exit, [63] = sys_uname, + [96] = sys_gettimeofday, [97] = sys_getrlimit, [102] = sys_getxid, [104] = sys_getxid, @@ -663,6 +709,7 @@ static long (*syscall_table[])(int, aal_mc_user_context_t *) = { [111] = sys_getxid, [158] = sys_arch_prctl, [202] = sys_futex, + [204] = sys_sched_getaffinity, [218] = sys_set_tid_address, [231] = sys_exit_group, [273] = sys_set_robust_list, @@ -698,7 +745,9 @@ long syscall(int num, aal_mc_user_context_t *ctx) if (syscall_table[num]) { l = syscall_table[num](num, ctx); - dkprintf(" %lx\n", l); + + dkprintf("SC(%d)[%3d] ret: %d\n", + aal_mc_get_processor_id(), num, l); } else { dkprintf("USC[%3d](%lx, %lx, %lx, %lx, %lx) @ %lx | %lx\n", num, aal_mc_syscall_arg0(ctx), aal_mc_syscall_arg1(ctx),