void arch_switch_to(struct task_struct *to)
{
if ((to->thread.arch.fs == 0) || (to->mm == NULL))
return;
arch_prctl(to, ARCH_SET_FS, (void __user *) to->thread.arch.fs);
}
static void *thread_pthread_fork(void *arg)
{
pid_t pid;
unsigned long tls = 0;
_threads_survived++;
if (arch_prctl(ARCH_GET_FS, &tls) == -1)
err(1, "arch_prctl()");
if (tls == _tls) {
printf("FAILED\n");
return NULL;
}
_tls = tls;
if ((pid = fork()) == -1)
err(1, "fork()");
if (pid == 0) {
_threads_survived++;
tls = 0;
if (arch_prctl(ARCH_GET_FS, &tls) == -1)
err(1, "arch_prctl()");
if (tls != _tls) {
printf("FAILED\n");
exit(0);
}
if (_threads_survived == 2)
printf("PASSED\n");
exit(0);
} else
wait(NULL);
return NULL;
}
void set_fs()
{
extern int arch_prctl(int code, unsigned long addr);
unsigned long tls_seg;
unsigned long brk, brk_start;
unsigned long cur_fs;
/* This assumes that our TLS segment is in the heap, and the heap is currently
* less than a page big... it could break in awful ways if not...
*
* Our FS segment is normally mapped at the top of the heap, but because the
* binary is modified to place the heap where the executable had it, the FS
* segment gets unmapped when we relocate the stub. Hence we have to relocate
* our TLS segment first.
*/
brk = (unsigned long)sbrk(0);
tls_seg = (unsigned long)xmalloc(PAGE_SIZE);
arch_prctl(ARCH_GET_FS, (long)&cur_fs);
brk_start = brk & ~(PAGE_SIZE-1);
memcpy((void*)tls_seg, (void*)brk_start, brk-brk_start);
arch_prctl(ARCH_SET_FS, tls_seg + (cur_fs - brk_start));
}
static void test_pthread_fork(void)
{
pthread_t pt;
printf("============ test_pthread_fork\n");
_threads_survived = 0;
arch_prctl(ARCH_GET_FS, &_tls);
if (pthread_create(&pt, NULL, thread_pthread_fork, NULL))
err(1, "pthread_create()");
if (pthread_join(pt, NULL))
err(1, "pthread_join()");
}
void *executor_segment_base_get(enum x86_id reg) {
void *base;
int code;
switch(reg) {
case X86_ID_GS_Base: {
code = ARCH_GET_GS;
break;
}
case X86_ID_FS_Base: {
code = ARCH_GET_FS;
break;
}
default: {
code = -1;
break;
}
}
if(arch_prctl(code, (unsigned long*)&base))
return NULL;
return base;
}
long sys_arch_prctl(int code, unsigned long addr)
{
return arch_prctl(current, code, (unsigned long __user *) addr);
}
long arch_ptrace(struct task_struct *child, long request,
unsigned long addr, unsigned long data)
{
int i, ret;
unsigned long __user *p = (void __user *)data;
void __user *vp = p;
switch (request) {
/* read word at location addr. */
case PTRACE_PEEKTEXT:
case PTRACE_PEEKDATA:
ret = generic_ptrace_peekdata(child, addr, data);
break;
/* read the word at location addr in the USER area. */
case PTRACE_PEEKUSR:
ret = peek_user(child, addr, data);
break;
/* write the word at location addr. */
case PTRACE_POKETEXT:
case PTRACE_POKEDATA:
ret = generic_ptrace_pokedata(child, addr, data);
break;
/* write the word at location addr in the USER area */
case PTRACE_POKEUSR:
ret = poke_user(child, addr, data);
break;
case PTRACE_SYSEMU:
case PTRACE_SYSEMU_SINGLESTEP:
ret = -EIO;
break;
#ifdef PTRACE_GETREGS
case PTRACE_GETREGS: { /* Get all gp regs from the child. */
if (!access_ok(VERIFY_WRITE, p, MAX_REG_OFFSET)) {
ret = -EIO;
break;
}
for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
__put_user(getreg(child, i), p);
p++;
}
ret = 0;
break;
}
#endif
#ifdef PTRACE_SETREGS
case PTRACE_SETREGS: { /* Set all gp regs in the child. */
unsigned long tmp = 0;
if (!access_ok(VERIFY_READ, p, MAX_REG_OFFSET)) {
ret = -EIO;
break;
}
for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
__get_user(tmp, p);
putreg(child, i, tmp);
p++;
}
ret = 0;
break;
}
#endif
#ifdef PTRACE_GETFPREGS
case PTRACE_GETFPREGS: /* Get the child FPU state. */
ret = get_fpregs(vp, child);
break;
#endif
#ifdef PTRACE_SETFPREGS
case PTRACE_SETFPREGS: /* Set the child FPU state. */
ret = set_fpregs(vp, child);
break;
#endif
case PTRACE_GET_THREAD_AREA:
ret = ptrace_get_thread_area(child, addr, vp);
break;
case PTRACE_SET_THREAD_AREA:
ret = ptrace_set_thread_area(child, addr, vp);
break;
case PTRACE_FAULTINFO: {
/*
* Take the info from thread->arch->faultinfo,
* but transfer max. sizeof(struct ptrace_faultinfo).
* On i386, ptrace_faultinfo is smaller!
*/
ret = copy_to_user(p, &child->thread.arch.faultinfo,
sizeof(struct ptrace_faultinfo)) ?
-EIO : 0;
break;
}
#ifdef PTRACE_LDT
case PTRACE_LDT: {
struct ptrace_ldt ldt;
if (copy_from_user(&ldt, p, sizeof(ldt))) {
ret = -EIO;
break;
}
/*
* This one is confusing, so just punt and return -EIO for
* now
*/
ret = -EIO;
break;
}
#endif
#ifdef PTRACE_ARCH_PRCTL
case PTRACE_ARCH_PRCTL:
/* XXX Calls ptrace on the host - needs some SMP thinking */
ret = arch_prctl(child, data, (void __user *) addr);
break;
#endif
default:
ret = ptrace_request(child, request, addr, data);
if (ret == -EIO)
ret = subarch_ptrace(child, request, addr, data);
break;
}
return ret;
}
int main(){
struct dirent dent;
struct timespec ts;
ts.tv_sec = 3;
ts.tv_nsec = 0;
printf("nanosleep= %d\n", nanosleep(&ts, NULL));
struct sysinfo asd;
printf("sysinfo= %d\n", sysinfo(&asd));
printf("sysinfo=> freeram=%lld\n", (long long int)asd.freeram);
int dir_fd = open("/home/shashank/Desktop/SGX", O_RDONLY);
char buff[1024];
printf("getdents=%d\n", (int)syscall(SYS_getdents, dir_fd, buff, 1024));
int fd1 = openat(dir_fd, "./glibc/glibc-2.19/ChangeLog", O_RDONLY);
struct stat fileStat;
printf("stat=%d\n", stat("/home/shashank/Desktop/SGX/glibc/glibc-2.19/ChangeLog",&fileStat));
char A[512];
printf("readlink=%d\n", (int)readlink("/lib64/ld-linux-x86-64.so.2", A, 512));
printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!fdatasync=%d\n", fdatasync(fd1));
printf("openat = %d\n", fd1);
close(fd1);
close(dir_fd);
char *d = malloc(1024);
printf("mprotect=%d\n", mprotect(p, 1024, PROT_READ));
//printf("madvise=%d\n", madvise(p, 1024, MADV_NORMAL));
struct rlimit rlim;
printf("getrlimit=%d\n", getrlimit(RLIMIT_AS, &rlim));
printf("rlim_cur=%llu rlim_max=%llu\n", (unsigned long long)rlim.rlim_cur, (unsigned long long)rlim.rlim_max);
cpu_set_t mask;
unsigned int len = sizeof(mask);
CPU_ZERO(&mask);
CPU_SET(0,&mask);
printf("sched_getaffinity=%d\n", sched_getaffinity(getpid(), len, &mask));
printf("sched_setaffinity=%d\n", sched_setaffinity(getpid(), len, &mask));
struct sigaction act;
memset (&act, '\0', sizeof(act));
act.sa_sigaction = &hdl;
sigset_t orig_mask;
act.sa_flags = SA_SIGINFO;
printf("sigaction=%d\n", sigaction(SIGTERM, &act, NULL));
printf("sigprocmask=%d\n", sigprocmask(SIG_SETMASK, &orig_mask, NULL));
static char part2[] = "THIS IS FROM WRITEV : http://www.ccplusplus.com/";
static char part3[] = "]\n";
static char part1[] = "[";
struct iovec iov[3];
iov[0].iov_base = part1;
iov[0].iov_len = strlen(part1);
printf("len= %d\n", (int)iov[0].iov_len);
iov[1].iov_base = part2;
iov[1].iov_len = strlen(part2);
iov[2].iov_base = part3;
iov[2].iov_len = strlen(part3);
printf("RETVal = %d\n",(int)writev(1,iov,3));
DIR *dirp = opendir("/home/shashank");
struct dirent *dp = readdir(dirp);
closedir(dirp);
unsigned long *k = NULL;
printf("arch_prctl=%d\n", arch_prctl(ARCH_GET_FS, k));
printf("arch_prctl=%p\n", k);
pthread_mutex_init(&mutex, NULL);
//mutex = 0;
//g = {1048576, 33554432, 67108864, 134217728, 268435456}
fd = open("stace.c", O_RDWR);
pthread_t thread;
pthread_create(&thread, NULL, f, NULL);
g = 10000;
char arr[10];
printf("fd = %d\n",fd);
//printf("Close!!!!!!!!!!!!!!!=%d\n", close(fd));
do{
//mutex_lock(&mutex);
//printf("before lock %d\n", mutex.__data.__lock);
pthread_mutex_lock(&mutex);
//printf("After lock %d\n", mutex.__data.__lock);
a++;
cnt++;
//printf("RETVal = %d\n",(int)write(1, "HERE\n", 5));
access ("/home", F_OK);
fd = open("stace.c", O_RDWR);
char *map = (char *)mmap(0, 10, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
munmap(map, 10);
close(fd);
//mutex_unlock(&mutex);
//printf("before unlock %d\n", mutex.__data.__lock);
sched_yield();
pthread_mutex_unlock(&mutex);
//printf("after unlock %d\n", mutex.__data.__lock);
}while(g--);
g = 0;
pthread_join(thread, NULL);
pthread_mutex_destroy(&mutex);
printf("cnt=%d, a+b=%d a=%d b=%d\n", cnt, a+b, a, b);
//printf("RETVal = %d\n",(int)read(0, &g, sizeof(g)));
_exit(0);
return 0;
}
