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