Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 3feb88562d149f078319e5a1b2f7acaa10251a5c

Authored by Paolo 'Blaisorblade' Giarrusso 2006-03-31 18:30:25 +0800

Committed by Linus Torvalds 2006-04-01 04:18:52 +0800

Exists in master and in 7 other branches

[PATCH] uml: check for differences in host support

If running on a host not supporting TLS (for instance 2.4) we should report
that cleanly to the user, instead of printing not comprehensible "error 5" for
that.

Additionally, i386 and x86_64 support different ranges for
user_desc->entry_number, and we must account for that; we couldn't pass
ourselves -1 because we need to override previously existing TLS descriptors
which glibc has possibly set, so test at startup the range to use.

x86 and x86_64 existing ranges are hardcoded.

Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Acked-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

Showing 8 changed files with 102 additions and 6 deletions Inline Diff

arch/um/include/os.h
arch/um/include/sysdep-i386/tls.h
arch/um/include/user_util.h
arch/um/os-Linux/sys-i386/Makefile
arch/um/os-Linux/sys-i386/tls.c
arch/um/os-Linux/tls.c
arch/um/sys-i386/tls.c
include/asm-um/segment.h

arch/um/include/os.h

Diff comments View file @ 3feb885

 /*
  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
 #ifndef __OS_H__
 #define __OS_H__
 #include "uml-config.h"
 #include "asm/types.h"
 #include "../os/include/file.h"
 #include "sysdep/ptrace.h"
 #include "kern_util.h"
 #include "skas/mm_id.h"
 #include "irq_user.h"
 #include "sysdep/tls.h"
 #define OS_TYPE_FILE 1
 #define OS_TYPE_DIR 2
 #define OS_TYPE_SYMLINK 3
 #define OS_TYPE_CHARDEV 4
 #define OS_TYPE_BLOCKDEV 5
 #define OS_TYPE_FIFO 6
 #define OS_TYPE_SOCK 7
 /* os_access() flags */
 #define OS_ACC_F_OK    0       /* Test for existence.  */
 #define OS_ACC_X_OK    1       /* Test for execute permission.  */
 #define OS_ACC_W_OK    2       /* Test for write permission.  */
 #define OS_ACC_R_OK    4       /* Test for read permission.  */
 #define OS_ACC_RW_OK   (OS_ACC_W_OK | OS_ACC_R_OK) /* Test for RW permission */
 /*
  * types taken from stat_file() in hostfs_user.c
  * (if they are wrong here, they are wrong there...).
  */
 struct uml_stat {
 	int                ust_dev;        /* device */
 	unsigned long long ust_ino;        /* inode */
 	int                ust_mode;       /* protection */
 	int                ust_nlink;      /* number of hard links */
 	int                ust_uid;        /* user ID of owner */
 	int                ust_gid;        /* group ID of owner */
 	unsigned long long ust_size;       /* total size, in bytes */
 	int                ust_blksize;    /* blocksize for filesystem I/O */
 	unsigned long long ust_blocks;     /* number of blocks allocated */
 	unsigned long      ust_atime;      /* time of last access */
 	unsigned long      ust_mtime;      /* time of last modification */
 	unsigned long      ust_ctime;      /* time of last change */
 };
 struct openflags {
 	unsigned int r : 1;
 	unsigned int w : 1;
 	unsigned int s : 1;	/* O_SYNC */
 	unsigned int c : 1;	/* O_CREAT */
 	unsigned int t : 1;	/* O_TRUNC */
 	unsigned int a : 1;	/* O_APPEND */
 	unsigned int e : 1;	/* O_EXCL */
 	unsigned int cl : 1;    /* FD_CLOEXEC */
 };
 #define OPENFLAGS() ((struct openflags) { .r = 0, .w = 0, .s = 0, .c = 0, \
  					  .t = 0, .a = 0, .e = 0, .cl = 0 })
 static inline struct openflags of_read(struct openflags flags)
 {
 	flags.r = 1;
 	return(flags);
 }
 static inline struct openflags of_write(struct openflags flags)
 {
 	flags.w = 1;
 	return(flags);
 }
 static inline struct openflags of_rdwr(struct openflags flags)
 {
 	return(of_read(of_write(flags)));
 }
 static inline struct openflags of_set_rw(struct openflags flags, int r, int w)
 {
 	flags.r = r;
 	flags.w = w;
 	return(flags);
 }
 static inline struct openflags of_sync(struct openflags flags)
 {
 	flags.s = 1;
 	return(flags);
 }
 static inline struct openflags of_create(struct openflags flags)
 {
 	flags.c = 1;
 	return(flags);
 }
 static inline struct openflags of_trunc(struct openflags flags)
 {
 	flags.t = 1;
 	return(flags);
 }
 static inline struct openflags of_append(struct openflags flags)
 {
 	flags.a = 1;
 	return(flags);
 }
 static inline struct openflags of_excl(struct openflags flags)
 {
 	flags.e = 1;
 	return(flags);
 }
 static inline struct openflags of_cloexec(struct openflags flags)
 {
 	flags.cl = 1;
 	return(flags);
 }
 /* file.c */
 extern int os_stat_file(const char *file_name, struct uml_stat *buf);
 extern int os_stat_fd(const int fd, struct uml_stat *buf);
 extern int os_access(const char *file, int mode);
 extern void os_print_error(int error, const char* str);
 extern int os_get_exec_close(int fd, int *close_on_exec);
 extern int os_set_exec_close(int fd, int close_on_exec);
 extern int os_ioctl_generic(int fd, unsigned int cmd, unsigned long arg);
 extern int os_window_size(int fd, int *rows, int *cols);
 extern int os_new_tty_pgrp(int fd, int pid);
 extern int os_get_ifname(int fd, char *namebuf);
 extern int os_set_slip(int fd);
 extern int os_set_owner(int fd, int pid);
 extern int os_sigio_async(int master, int slave);
 extern int os_mode_fd(int fd, int mode);
 extern int os_seek_file(int fd, __u64 offset);
 extern int os_open_file(char *file, struct openflags flags, int mode);
 extern int os_read_file(int fd, void *buf, int len);
 extern int os_write_file(int fd, const void *buf, int count);
 extern int os_file_size(char *file, unsigned long long *size_out);
 extern int os_file_modtime(char *file, unsigned long *modtime);
 extern int os_pipe(int *fd, int stream, int close_on_exec);
 extern int os_set_fd_async(int fd, int owner);
 extern int os_clear_fd_async(int fd);
 extern int os_set_fd_block(int fd, int blocking);
 extern int os_accept_connection(int fd);
 extern int os_create_unix_socket(char *file, int len, int close_on_exec);
 extern int os_shutdown_socket(int fd, int r, int w);
 extern void os_close_file(int fd);
 extern int os_rcv_fd(int fd, int *helper_pid_out);
 extern int create_unix_socket(char *file, int len, int close_on_exec);
 extern int os_connect_socket(char *name);
 extern int os_file_type(char *file);
 extern int os_file_mode(char *file, struct openflags *mode_out);
 extern int os_lock_file(int fd, int excl);
 extern void os_flush_stdout(void);
 extern int os_stat_filesystem(char *path, long *bsize_out,
 			      long long *blocks_out, long long *bfree_out,
 			      long long *bavail_out, long long *files_out,
 			      long long *ffree_out, void *fsid_out,
 			      int fsid_size, long *namelen_out,
 			      long *spare_out);
 extern int os_change_dir(char *dir);
 extern int os_fchange_dir(int fd);
 /* start_up.c */
 extern void os_early_checks(void);
 extern int can_do_skas(void);
 extern void os_check_bugs(void);
+extern void check_host_supports_tls(int *supports_tls, int *tls_min);
 /* Make sure they are clear when running in TT mode. Required by
  * SEGV_MAYBE_FIXABLE */
 #ifdef UML_CONFIG_MODE_SKAS
 #define clear_can_do_skas() do { ptrace_faultinfo = proc_mm = 0; } while (0)
 #else
 #define clear_can_do_skas() do {} while (0)
 #endif
 /* mem.c */
 extern int create_mem_file(unsigned long long len);
 /* process.c */
 extern unsigned long os_process_pc(int pid);
 extern int os_process_parent(int pid);
 extern void os_stop_process(int pid);
 extern void os_kill_process(int pid, int reap_child);
 extern void os_kill_ptraced_process(int pid, int reap_child);
 extern void os_usr1_process(int pid);
 extern long os_ptrace_ldt(long pid, long addr, long data);
 extern int os_getpid(void);
 extern int os_getpgrp(void);
 extern void init_new_thread_stack(void *sig_stack, void (*usr1_handler)(int));
 extern void init_new_thread_signals(int altstack);
 extern int run_kernel_thread(int (*fn)(void *), void *arg, void **jmp_ptr);
 extern int os_map_memory(void *virt, int fd, unsigned long long off,
 			 unsigned long len, int r, int w, int x);
 extern int os_protect_memory(void *addr, unsigned long len,
 			     int r, int w, int x);
 extern int os_unmap_memory(void *addr, int len);
 extern int os_drop_memory(void *addr, int length);
 extern int can_drop_memory(void);
 extern void os_flush_stdout(void);
 /* tt.c
  * for tt mode only (will be deleted in future...)
  */
 extern void forward_ipi(int fd, int pid);
 extern void kill_child_dead(int pid);
 extern void stop(void);
 extern int wait_for_stop(int pid, int sig, int cont_type, void *relay);
 extern int protect_memory(unsigned long addr, unsigned long len,
 			  int r, int w, int x, int must_succeed);
 extern void forward_pending_sigio(int target);
 extern int start_fork_tramp(void *arg, unsigned long temp_stack,
 			    int clone_flags, int (*tramp)(void *));
 /* uaccess.c */
 extern unsigned long __do_user_copy(void *to, const void *from, int n,
 				    void **fault_addr, void **fault_catcher,
 				    void (*op)(void *to, const void *from,
 					       int n), int *faulted_out);
 /* helper.c */
 extern int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv,
 		      unsigned long *stack_out);
 extern int run_helper_thread(int (*proc)(void *), void *arg,
 			     unsigned int flags, unsigned long *stack_out,
 			     int stack_order);
 extern int helper_wait(int pid);
 /* tls.c */
 extern int os_set_thread_area(user_desc_t *info, int pid);
 extern int os_get_thread_area(user_desc_t *info, int pid);
 /* umid.c */
 extern int umid_file_name(char *name, char *buf, int len);
 extern int set_umid(char *name);
 extern char *get_umid(void);
 /* signal.c */
 extern void set_sigstack(void *sig_stack, int size);
 extern void remove_sigstack(void);
 extern void set_handler(int sig, void (*handler)(int), int flags, ...);
 extern int change_sig(int signal, int on);
 extern void block_signals(void);
 extern void unblock_signals(void);
 extern int get_signals(void);
 extern int set_signals(int enable);
 extern void os_usr1_signal(int on);
 /* trap.c */
 extern void os_fill_handlinfo(struct kern_handlers h);
 extern void do_longjmp(void *p, int val);
 /* util.c */
 extern void stack_protections(unsigned long address);
 extern void task_protections(unsigned long address);
 extern int raw(int fd);
 extern void setup_machinename(char *machine_out);
 extern void setup_hostinfo(void);
 extern int setjmp_wrapper(void (*proc)(void *, void *), ...);
 /* time.c */
 #define BILLION (1000 * 1000 * 1000)
 extern void switch_timers(int to_real);
 extern void idle_sleep(int secs);
 extern void enable_timer(void);
 extern void disable_timer(void);
 extern void user_time_init(void);
 extern void uml_idle_timer(void);
 extern unsigned long long os_nsecs(void);
 /* skas/mem.c */
 extern long run_syscall_stub(struct mm_id * mm_idp,
 			     int syscall, unsigned long *args, long expected,
 			     void **addr, int done);
 extern long syscall_stub_data(struct mm_id * mm_idp,
 			      unsigned long *data, int data_count,
 			      void **addr, void **stub_addr);
 extern int map(struct mm_id * mm_idp, unsigned long virt,
 	       unsigned long len, int r, int w, int x, int phys_fd,
 	       unsigned long long offset, int done, void **data);
 extern int unmap(struct mm_id * mm_idp, void *addr, unsigned long len,
 		 int done, void **data);
 extern int protect(struct mm_id * mm_idp, unsigned long addr,
 		   unsigned long len, int r, int w, int x, int done,
 		   void **data);
 /* skas/process.c */
 extern int is_skas_winch(int pid, int fd, void *data);
 extern int start_userspace(unsigned long stub_stack);
 extern int copy_context_skas0(unsigned long stack, int pid);
 extern void userspace(union uml_pt_regs *regs);
 extern void map_stub_pages(int fd, unsigned long code,
 			   unsigned long data, unsigned long stack);
 extern void new_thread(void *stack, void **switch_buf_ptr,
 			 void **fork_buf_ptr, void (*handler)(int));
 extern void thread_wait(void *sw, void *fb);
 extern void switch_threads(void *me, void *next);
 extern int start_idle_thread(void *stack, void *switch_buf_ptr,
 			     void **fork_buf_ptr);
 extern void initial_thread_cb_skas(void (*proc)(void *),
 				 void *arg);
 extern void halt_skas(void);
 extern void reboot_skas(void);
 /* irq.c */
 extern int os_waiting_for_events(struct irq_fd *active_fds);
 extern int os_isatty(int fd);
 extern int os_create_pollfd(int fd, int events, void *tmp_pfd, int size_tmpfds);
 extern void os_free_irq_by_cb(int (*test)(struct irq_fd *, void *), void *arg,
 		struct irq_fd *active_fds, struct irq_fd ***last_irq_ptr2);
 extern void os_free_irq_later(struct irq_fd *active_fds,
 		int irq, void *dev_id);
 extern int os_get_pollfd(int i);
 extern void os_set_pollfd(int i, int fd);
 extern void os_set_ioignore(void);
 extern void init_irq_signals(int on_sigstack);
 /* sigio.c */
 extern void write_sigio_workaround(void);
 extern int add_sigio_fd(int fd, int read);
 extern int ignore_sigio_fd(int fd);
 /* skas/trap */
 extern void sig_handler_common_skas(int sig, void *sc_ptr);
 extern void user_signal(int sig, union uml_pt_regs *regs, int pid);
 #endif

arch/um/include/sysdep-i386/tls.h

Diff comments View file @ 3feb885

 #ifndef _SYSDEP_TLS_H
 #define _SYSDEP_TLS_H
 # ifndef __KERNEL__
 /* Change name to avoid conflicts with the original one from <asm/ldt.h>, which
  * may be named user_desc (but in 2.4 and in header matching its API was named
  * modify_ldt_ldt_s). */
 typedef struct um_dup_user_desc {
 	unsigned int  entry_number;
 	unsigned int  base_addr;
 	unsigned int  limit;
 	unsigned int  seg_32bit:1;
 	unsigned int  contents:2;
 	unsigned int  read_exec_only:1;
 	unsigned int  limit_in_pages:1;
 	unsigned int  seg_not_present:1;
 	unsigned int  useable:1;
 } user_desc_t;
 # else /* __KERNEL__ */
 #  include <asm/ldt.h>
 typedef struct user_desc user_desc_t;
 # endif /* __KERNEL__ */
+#define GDT_ENTRY_TLS_MIN_I386 6
+#define GDT_ENTRY_TLS_MIN_X86_64 12
 #endif /* _SYSDEP_TLS_H */

arch/um/include/user_util.h

Diff comments View file @ 3feb885

 /*
  * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
 #ifndef __USER_UTIL_H__
 #define __USER_UTIL_H__
 #include "sysdep/ptrace.h"
+/* Copied from kernel.h */
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 #define CATCH_EINTR(expr) while ((errno = 0, ((expr) < 0)) && (errno == EINTR))
 extern int mode_tt;
 extern int grantpt(int __fd);
 extern int unlockpt(int __fd);
 extern char *ptsname(int __fd);
 struct cpu_task {
 	int pid;
 	void *task;
 };
 extern struct cpu_task cpu_tasks[];
 extern void (*sig_info[])(int, union uml_pt_regs *);
 extern unsigned long low_physmem;
 extern unsigned long high_physmem;
 extern unsigned long uml_physmem;
 extern unsigned long uml_reserved;
 extern unsigned long end_vm;
 extern unsigned long start_vm;
 extern unsigned long long highmem;
 extern char host_info[];
 extern char saved_command_line[];
 extern unsigned long _stext, _etext, _sdata, _edata, __bss_start, _end;
 extern unsigned long _unprotected_end;
 extern unsigned long brk_start;
 extern int pty_output_sigio;
 extern int pty_close_sigio;
 extern void *add_signal_handler(int sig, void (*handler)(int));
 extern int linux_main(int argc, char **argv);
 extern void set_cmdline(char *cmd);
 extern void input_cb(void (*proc)(void *), void *arg, int arg_len);
 extern int get_pty(void);
 extern void *um_kmalloc(int size);
 extern int switcheroo(int fd, int prot, void *from, void *to, int size);
 extern void do_exec(int old_pid, int new_pid);
 extern void tracer_panic(char *msg, ...);
 extern int detach(int pid, int sig);
 extern int attach(int pid);
 extern void kill_child_dead(int pid);
 extern int cont(int pid);
 extern void check_sigio(void);
 extern void arch_check_bugs(void);
 extern int cpu_feature(char *what, char *buf, int len);
 extern int arch_handle_signal(int sig, union uml_pt_regs *regs);
 extern int arch_fixup(unsigned long address, void *sc_ptr);
 extern void arch_init_thread(void);
 extern int raw(int fd);
 #endif

arch/um/os-Linux/sys-i386/Makefile

Diff comments View file @ 3feb885

1	#	1	#
2	# Copyright (C) 2000 Jeff Dike (jdike@karaya.com)	2	# Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
3	# Licensed under the GPL	3	# Licensed under the GPL
4	#	4	#
5		5
6	obj-$(CONFIG_MODE_SKAS) = registers.o	6	obj-$(CONFIG_MODE_SKAS) = registers.o tls.o
7		7
8	USER_OBJS := $(obj-y)	8	USER_OBJS := $(obj-y)
9		9
10	include arch/um/scripts/Makefile.rules	10	include arch/um/scripts/Makefile.rules
11		11

arch/um/os-Linux/sys-i386/tls.c

Diff comments View file @ 3feb885

File was created	1	#include <linux/unistd.h>
	2	#include "sysdep/tls.h"
	3	#include "user_util.h"
	4
	5	static _syscall1(int, get_thread_area, user_desc_t *, u_info);
	6
	7	/* Checks whether host supports TLS, and sets *tls_min according to the value
	8	* valid on the host.
	9	* i386 host have it == 6; x86_64 host have it == 12, for i386 emulation. */
	10	void check_host_supports_tls(int supports_tls, int tls_min) {
	11	/* Values for x86 and x86_64.*/
	12	int val[] = {GDT_ENTRY_TLS_MIN_I386, GDT_ENTRY_TLS_MIN_X86_64};
	13	int i;
	14
	15	for (i = 0; i < ARRAY_SIZE(val); i++) {
	16	user_desc_t info;
	17	info.entry_number = val[i];
	18
	19	if (get_thread_area(&info) == 0) {
	20	*tls_min = val[i];
	21	*supports_tls = 1;
	22	return;
	23	} else {
	24	if (errno == EINVAL)
	25	continue;
	26	else if (errno == ENOSYS)
	27	*supports_tls = 0;
	28	return;
	29	}
	30	}
	31
	32	*supports_tls = 0;
	33	}
	34

arch/um/os-Linux/tls.c

Diff comments View file @ 3feb885

1	#include <errno.h>	1	#include <errno.h>
2	#include <sys/ptrace.h>	2	#include <sys/ptrace.h>
3	#include <asm/ldt.h>	3	#include <asm/ldt.h>
4	#include "sysdep/tls.h"	4	#include "sysdep/tls.h"
5	#include "uml-config.h"	5	#include "uml-config.h"
6		6
7	/* TLS support - we basically rely on the host's one.*/	7	/* TLS support - we basically rely on the host's one.*/
8		8
9	/* In TT mode, this should be called only by the tracing thread, and makes sense	9	/* In TT mode, this should be called only by the tracing thread, and makes sense
10	* only for PTRACE_SET_THREAD_AREA. In SKAS mode, it's used normally.	10	* only for PTRACE_SET_THREAD_AREA. In SKAS mode, it's used normally.
11	*	11	*
12	*/	12	*/
13		13
14	#ifndef PTRACE_GET_THREAD_AREA	14	#ifndef PTRACE_GET_THREAD_AREA
15	#define PTRACE_GET_THREAD_AREA 25	15	#define PTRACE_GET_THREAD_AREA 25
16	#endif	16	#endif
17		17
18	#ifndef PTRACE_SET_THREAD_AREA	18	#ifndef PTRACE_SET_THREAD_AREA
19	#define PTRACE_SET_THREAD_AREA 26	19	#define PTRACE_SET_THREAD_AREA 26
20	#endif	20	#endif
21		21
22	int os_set_thread_area(user_desc_t *info, int pid)	22	int os_set_thread_area(user_desc_t *info, int pid)
23	{	23	{
24	int ret;	24	int ret;
25		25
26	ret = ptrace(PTRACE_SET_THREAD_AREA, pid, info->entry_number,	26	ret = ptrace(PTRACE_SET_THREAD_AREA, pid, info->entry_number,
27	(unsigned long) info);	27	(unsigned long) info);
28	if (ret < 0)	28	if (ret < 0)
29	ret = -errno;	29	ret = -errno;
30	return ret;	30	return ret;
31	}	31	}
32		32
33	#ifdef UML_CONFIG_MODE_SKAS	33	#ifdef UML_CONFIG_MODE_SKAS
34		34
35	int os_get_thread_area(user_desc_t *info, int pid)	35	int os_get_thread_area(user_desc_t *info, int pid)
36	{	36	{
37	int ret;	37	int ret;
38		38
39	ret = ptrace(PTRACE_GET_THREAD_AREA, pid, info->entry_number,	39	ret = ptrace(PTRACE_GET_THREAD_AREA, pid, info->entry_number,
40	(unsigned long) info);	40	(unsigned long) info);
41	if (ret < 0)	41	if (ret < 0)
42	ret = -errno;	42	ret = -errno;
43	return ret;	43	return ret;
44	}	44	}
45		45
46	#endif	46	#endif
47		47
48	#ifdef UML_CONFIG_MODE_TT	48	#ifdef UML_CONFIG_MODE_TT
49	#include "linux/unistd.h"	49	#include "linux/unistd.h"
50		50
51	_syscall1(int, get_thread_area, user_desc_t *, u_info);	51	static _syscall1(int, get_thread_area, user_desc_t *, u_info);
52	_syscall1(int, set_thread_area, user_desc_t *, u_info);	52	static _syscall1(int, set_thread_area, user_desc_t *, u_info);
53		53
54	int do_set_thread_area_tt(user_desc_t *info)	54	int do_set_thread_area_tt(user_desc_t *info)
55	{	55	{
56	int ret;	56	int ret;
57		57
58	ret = set_thread_area(info);	58	ret = set_thread_area(info);
59	if (ret < 0) {	59	if (ret < 0) {
60	ret = -errno;	60	ret = -errno;
61	}	61	}
62	return ret;	62	return ret;
63	}	63	}
64		64
65	int do_get_thread_area_tt(user_desc_t *info)	65	int do_get_thread_area_tt(user_desc_t *info)
66	{	66	{
67	int ret;	67	int ret;
68		68
69	ret = get_thread_area(info);	69	ret = get_thread_area(info);
70	if (ret < 0) {	70	if (ret < 0) {
71	ret = -errno;	71	ret = -errno;
72	}	72	}
73	return ret;	73	return ret;
74	}	74	}
75		75
76	#endif /* UML_CONFIG_MODE_TT */	76	#endif /* UML_CONFIG_MODE_TT */
77		77

arch/um/sys-i386/tls.c

Diff comments View file @ 3feb885

 /*
  * Copyright (C) 2005 Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
  * Licensed under the GPL
  */
 #include "linux/config.h"
 #include "linux/kernel.h"
 #include "linux/sched.h"
 #include "linux/slab.h"
 #include "linux/types.h"
 #include "asm/uaccess.h"
 #include "asm/ptrace.h"
 #include "asm/segment.h"
 #include "asm/smp.h"
 #include "asm/desc.h"
 #include "choose-mode.h"
 #include "kern.h"
 #include "kern_util.h"
 #include "mode_kern.h"
 #include "os.h"
 #include "mode.h"
 #ifdef CONFIG_MODE_SKAS
 #include "skas.h"
 #endif
+/* If needed we can detect when it's uninitialized. */
+static int host_supports_tls = -1;
+int host_gdt_entry_tls_min = -1;
 #ifdef CONFIG_MODE_SKAS
 int do_set_thread_area_skas(struct user_desc *info)
 {
 	int ret;
 	u32 cpu;
 	cpu = get_cpu();
 	ret = os_set_thread_area(info, userspace_pid[cpu]);
 	put_cpu();
 	return ret;
 }
 int do_get_thread_area_skas(struct user_desc *info)
 {
 	int ret;
 	u32 cpu;
 	cpu = get_cpu();
 	ret = os_get_thread_area(info, userspace_pid[cpu]);
 	put_cpu();
 	return ret;
 }
 #endif
 /*
  * sys_get_thread_area: get a yet unused TLS descriptor index.
  * XXX: Consider leaving one free slot for glibc usage at first place. This must
  * be done here (and by changing GDT_ENTRY_TLS_* macros) and nowhere else.
  *
  * Also, this must be tested when compiling in SKAS mode with dinamic linking
  * and running against NPTL.
  */
 static int get_free_idx(struct task_struct* task)
 {
 	struct thread_struct *t = &task->thread;
 	int idx;
 	if (!t->arch.tls_array)
 		return GDT_ENTRY_TLS_MIN;
 	for (idx = 0; idx < GDT_ENTRY_TLS_ENTRIES; idx++)
 		if (!t->arch.tls_array[idx].present)
 			return idx + GDT_ENTRY_TLS_MIN;
 	return -ESRCH;
 }
 static inline void clear_user_desc(struct user_desc* info)
 {
 	/* Postcondition: LDT_empty(info) returns true. */
 	memset(info, 0, sizeof(*info));
 	/* Check the LDT_empty or the i386 sys_get_thread_area code - we obtain
 	 * indeed an empty user_desc.
 	 */
 	info->read_exec_only = 1;
 	info->seg_not_present = 1;
 }
 #define O_FORCE 1
 static int load_TLS(int flags, struct task_struct *to)
 {
 	int ret = 0;
 	int idx;
 	for (idx = GDT_ENTRY_TLS_MIN; idx < GDT_ENTRY_TLS_MAX; idx++) {
 		struct uml_tls_struct* curr = &to->thread.arch.tls_array[idx - GDT_ENTRY_TLS_MIN];
 		/* Actually, now if it wasn't flushed it gets cleared and
 		 * flushed to the host, which will clear it.*/
 		if (!curr->present) {
 			if (!curr->flushed) {
 				clear_user_desc(&curr->tls);
 				curr->tls.entry_number = idx;
 			} else {
 				WARN_ON(!LDT_empty(&curr->tls));
 				continue;
 			}
 		}
 		if (!(flags & O_FORCE) && curr->flushed)
 			continue;
 		ret = do_set_thread_area(&curr->tls);
 		if (ret)
 			goto out;
 		curr->flushed = 1;
 	}
 out:
 	return ret;
 }
 /* Verify if we need to do a flush for the new process, i.e. if there are any
  * present desc's, only if they haven't been flushed.
  */
 static inline int needs_TLS_update(struct task_struct *task)
 {
 	int i;
 	int ret = 0;
 	for (i = GDT_ENTRY_TLS_MIN; i < GDT_ENTRY_TLS_MAX; i++) {
 		struct uml_tls_struct* curr = &task->thread.arch.tls_array[i - GDT_ENTRY_TLS_MIN];
 		/* Can't test curr->present, we may need to clear a descriptor
 		 * which had a value. */
 		if (curr->flushed)
 			continue;
 		ret = 1;
 		break;
 	}
 	return ret;
 }
 /* On a newly forked process, the TLS descriptors haven't yet been flushed. So
  * we mark them as such and the first switch_to will do the job.
  */
 void clear_flushed_tls(struct task_struct *task)
 {
 	int i;
 	for (i = GDT_ENTRY_TLS_MIN; i < GDT_ENTRY_TLS_MAX; i++) {
 		struct uml_tls_struct* curr = &task->thread.arch.tls_array[i - GDT_ENTRY_TLS_MIN];
 		/* Still correct to do this, if it wasn't present on the host it
 		 * will remain as flushed as it was. */
 		if (!curr->present)
 			continue;
 		curr->flushed = 0;
 	}
 }
-/* This in SKAS0 does not need to be used, since we have different host
+/* In SKAS0 mode, currently, multiple guest threads sharing the same ->mm have a
- * processes. Nor will this need to be used when we'll add support to the host
+ * common host process. So this is needed in SKAS0 too.
+ *
+ * However, if each thread had a different host process (and this was discussed
+ * for SMP support) this won't be needed.
+ *
+ * And this will not need be used when (and if) we'll add support to the host
  * SKAS patch. */
 int arch_switch_tls_skas(struct task_struct *from, struct task_struct *to)
 {
+	if (!host_supports_tls)
+		return 0;
 	/* We have no need whatsoever to switch TLS for kernel threads; beyond
 	 * that, that would also result in us calling os_set_thread_area with
 	 * userspace_pid[cpu] == 0, which gives an error. */
 	if (likely(to->mm))
 		return load_TLS(O_FORCE, to);
 	return 0;
 }
 int arch_switch_tls_tt(struct task_struct *from, struct task_struct *to)
 {
+	if (!host_supports_tls)
+		return 0;
 	if (needs_TLS_update(to))
 		return load_TLS(0, to);
 	return 0;
 }
 static int set_tls_entry(struct task_struct* task, struct user_desc *info,
 			 int idx, int flushed)
 {
 	struct thread_struct *t = &task->thread;
 	if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
 		return -EINVAL;
 	t->arch.tls_array[idx - GDT_ENTRY_TLS_MIN].tls = *info;
 	t->arch.tls_array[idx - GDT_ENTRY_TLS_MIN].present = 1;
 	t->arch.tls_array[idx - GDT_ENTRY_TLS_MIN].flushed = flushed;
 	return 0;
 }
 int arch_copy_tls(struct task_struct *new)
 {
 	struct user_desc info;
 	int idx, ret = -EFAULT;
 	if (copy_from_user(&info,
 			   (void __user *) UPT_ESI(&new->thread.regs.regs),
 			   sizeof(info)))
 		goto out;
 	ret = -EINVAL;
 	if (LDT_empty(&info))
 		goto out;
 	idx = info.entry_number;
 	ret = set_tls_entry(new, &info, idx, 0);
 out:
 	return ret;
 }
 /* XXX: use do_get_thread_area to read the host value? I'm not at all sure! */
 static int get_tls_entry(struct task_struct* task, struct user_desc *info, int idx)
 {
 	struct thread_struct *t = &task->thread;
 	if (!t->arch.tls_array)
 		goto clear;
 	if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
 		return -EINVAL;
 	if (!t->arch.tls_array[idx - GDT_ENTRY_TLS_MIN].present)
 		goto clear;
 	*info = t->arch.tls_array[idx - GDT_ENTRY_TLS_MIN].tls;
 out:
 	/* Temporary debugging check, to make sure that things have been
 	 * flushed. This could be triggered if load_TLS() failed.
 	 */
 	if (unlikely(task == current && !t->arch.tls_array[idx - GDT_ENTRY_TLS_MIN].flushed)) {
 		printk(KERN_ERR "get_tls_entry: task with pid %d got here "
 				"without flushed TLS.", current->pid);
 	}
 	return 0;
 clear:
 	/* When the TLS entry has not been set, the values read to user in the
 	 * tls_array are 0 (because it's cleared at boot, see
 	 * arch/i386/kernel/head.S:cpu_gdt_table). Emulate that.
 	 */
 	clear_user_desc(info);
 	info->entry_number = idx;
 	goto out;
 }
 asmlinkage int sys_set_thread_area(struct user_desc __user *user_desc)
 {
 	struct user_desc info;
 	int idx, ret;
+	if (!host_supports_tls)
+		return -ENOSYS;
 	if (copy_from_user(&info, user_desc, sizeof(info)))
 		return -EFAULT;
 	idx = info.entry_number;
 	if (idx == -1) {
 		idx = get_free_idx(current);
 		if (idx < 0)
 			return idx;
 		info.entry_number = idx;
 		/* Tell the user which slot we chose for him.*/
 		if (put_user(idx, &user_desc->entry_number))
 			return -EFAULT;
 	}
 	ret = CHOOSE_MODE_PROC(do_set_thread_area_tt, do_set_thread_area_skas, &info);
 	if (ret)
 		return ret;
 	return set_tls_entry(current, &info, idx, 1);
 }
 /*
  * Perform set_thread_area on behalf of the traced child.
  * Note: error handling is not done on the deferred load, and this differ from
  * i386. However the only possible error are caused by bugs.
  */
 int ptrace_set_thread_area(struct task_struct *child, int idx,
 		struct user_desc __user *user_desc)
 {
 	struct user_desc info;
+	if (!host_supports_tls)
+		return -EIO;
 	if (copy_from_user(&info, user_desc, sizeof(info)))
 		return -EFAULT;
 	return set_tls_entry(child, &info, idx, 0);
 }
 asmlinkage int sys_get_thread_area(struct user_desc __user *user_desc)
 {
 	struct user_desc info;
 	int idx, ret;
+	if (!host_supports_tls)
+		return -ENOSYS;
 	if (get_user(idx, &user_desc->entry_number))
 		return -EFAULT;
 	ret = get_tls_entry(current, &info, idx);
 	if (ret < 0)
 		goto out;
 	if (copy_to_user(user_desc, &info, sizeof(info)))
 		ret = -EFAULT;
 out:
 	return ret;
 }
 /*
  * Perform get_thread_area on behalf of the traced child.
  */
 int ptrace_get_thread_area(struct task_struct *child, int idx,
 		struct user_desc __user *user_desc)
 {
 	struct user_desc info;
 	int ret;
+	if (!host_supports_tls)
+		return -EIO;
 	ret = get_tls_entry(child, &info, idx);
 	if (ret < 0)
 		goto out;
 	if (copy_to_user(user_desc, &info, sizeof(info)))
 		ret = -EFAULT;
 out:
 	return ret;
 }
+/* XXX: This part is probably common to i386 and x86-64. Don't create a common
+ * file for now, do that when implementing x86-64 support.*/
+static int __init __setup_host_supports_tls(void) {
+	check_host_supports_tls(&host_supports_tls, &host_gdt_entry_tls_min);
+	if (host_supports_tls) {
+		printk(KERN_INFO "Host TLS support detected\n");
+		printk(KERN_INFO "Detected host type: ");
+		switch (host_gdt_entry_tls_min) {
+			case GDT_ENTRY_TLS_MIN_I386:
+				printk("i386\n");
+				break;
+			case GDT_ENTRY_TLS_MIN_X86_64:
+				printk("x86_64\n");
+				break;
+		}
+	} else
+		printk(KERN_ERR "  Host TLS support NOT detected! "
+				"TLS support inside UML will not work\n");
+	return 1;
+}
+__initcall(__setup_host_supports_tls);

include/asm-um/segment.h

Diff comments View file @ 3feb885

1	#ifndef __UM_SEGMENT_H	1	#ifndef __UM_SEGMENT_H
2	#define __UM_SEGMENT_H	2	#define __UM_SEGMENT_H
3		3
4	#include "asm/arch/segment.h"	4	extern int host_gdt_entry_tls_min;
		5
		6	#define GDT_ENTRY_TLS_ENTRIES 3
		7	#define GDT_ENTRY_TLS_MIN host_gdt_entry_tls_min
		8	#define GDT_ENTRY_TLS_MAX (GDT_ENTRY_TLS_MIN + GDT_ENTRY_TLS_ENTRIES - 1)
5		9
6	#endif	10	#endif
7		11