1 #include <linux/kernel.h> 2 #include <linux/errno.h> 3 #include <linux/sched.h> 4 #include <linux/user.h> 5 #include <linux/regset.h> 6 7 #include <asm/uaccess.h> 8 #include <asm/desc.h> 9 #include <asm/ldt.h> 10 #include <asm/processor.h> 11 #include <asm/proto.h> 12 #include <asm/syscalls.h> 13 14 #include "tls.h" 15 16 /* 17 * sys_alloc_thread_area: get a yet unused TLS descriptor index. 18 */ 19 static int get_free_idx(void) 20 { 21 struct thread_struct *t = ¤t->thread; 22 int idx; 23 24 for (idx = 0; idx < GDT_ENTRY_TLS_ENTRIES; idx++) 25 if (desc_empty(&t->tls_array[idx])) 26 return idx + GDT_ENTRY_TLS_MIN; 27 return -ESRCH; 28 } 29 30 static void set_tls_desc(struct task_struct *p, int idx, 31 const struct user_desc *info, int n) 32 { 33 struct thread_struct *t = &p->thread; 34 struct desc_struct *desc = &t->tls_array[idx - GDT_ENTRY_TLS_MIN]; 35 int cpu; 36 37 /* 38 * We must not get preempted while modifying the TLS. 39 */ 40 cpu = get_cpu(); 41 42 while (n-- > 0) { 43 if (LDT_empty(info)) 44 desc->a = desc->b = 0; 45 else 46 fill_ldt(desc, info); 47 ++info; 48 ++desc; 49 } 50 51 if (t == ¤t->thread) 52 load_TLS(t, cpu); 53 54 put_cpu(); 55 } 56 57 /* 58 * Set a given TLS descriptor: 59 */ 60 int do_set_thread_area(struct task_struct *p, int idx, 61 struct user_desc __user *u_info, 62 int can_allocate) 63 { 64 struct user_desc info; 65 66 if (copy_from_user(&info, u_info, sizeof(info))) 67 return -EFAULT; 68 69 if (idx == -1) 70 idx = info.entry_number; 71 72 /* 73 * index -1 means the kernel should try to find and 74 * allocate an empty descriptor: 75 */ 76 if (idx == -1 && can_allocate) { 77 idx = get_free_idx(); 78 if (idx < 0) 79 return idx; 80 if (put_user(idx, &u_info->entry_number)) 81 return -EFAULT; 82 } 83 84 if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX) 85 return -EINVAL; 86 87 set_tls_desc(p, idx, &info, 1); 88 89 return 0; 90 } 91 92 asmlinkage int sys_set_thread_area(struct user_desc __user *u_info) 93 { 94 int ret = do_set_thread_area(current, -1, u_info, 1); 95 asmlinkage_protect(1, ret, u_info); 96 return ret; 97 } 98 99 100 /* 101 * Get the current Thread-Local Storage area: 102 */ 103 104 static void fill_user_desc(struct user_desc *info, int idx, 105 const struct desc_struct *desc) 106 107 { 108 memset(info, 0, sizeof(*info)); 109 info->entry_number = idx; 110 info->base_addr = get_desc_base(desc); 111 info->limit = get_desc_limit(desc); 112 info->seg_32bit = desc->d; 113 info->contents = desc->type >> 2; 114 info->read_exec_only = !(desc->type & 2); 115 info->limit_in_pages = desc->g; 116 info->seg_not_present = !desc->p; 117 info->useable = desc->avl; 118 #ifdef CONFIG_X86_64 119 info->lm = desc->l; 120 #endif 121 } 122 123 int do_get_thread_area(struct task_struct *p, int idx, 124 struct user_desc __user *u_info) 125 { 126 struct user_desc info; 127 128 if (idx == -1 && get_user(idx, &u_info->entry_number)) 129 return -EFAULT; 130 131 if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX) 132 return -EINVAL; 133 134 fill_user_desc(&info, idx, 135 &p->thread.tls_array[idx - GDT_ENTRY_TLS_MIN]); 136 137 if (copy_to_user(u_info, &info, sizeof(info))) 138 return -EFAULT; 139 return 0; 140 } 141 142 asmlinkage int sys_get_thread_area(struct user_desc __user *u_info) 143 { 144 int ret = do_get_thread_area(current, -1, u_info); 145 asmlinkage_protect(1, ret, u_info); 146 return ret; 147 } 148 149 int regset_tls_active(struct task_struct *target, 150 const struct user_regset *regset) 151 { 152 struct thread_struct *t = &target->thread; 153 int n = GDT_ENTRY_TLS_ENTRIES; 154 while (n > 0 && desc_empty(&t->tls_array[n - 1])) 155 --n; 156 return n; 157 } 158 159 int regset_tls_get(struct task_struct *target, const struct user_regset *regset, 160 unsigned int pos, unsigned int count, 161 void *kbuf, void __user *ubuf) 162 { 163 const struct desc_struct *tls; 164 165 if (pos >= GDT_ENTRY_TLS_ENTRIES * sizeof(struct user_desc) || 166 (pos % sizeof(struct user_desc)) != 0 || 167 (count % sizeof(struct user_desc)) != 0) 168 return -EINVAL; 169 170 pos /= sizeof(struct user_desc); 171 count /= sizeof(struct user_desc); 172 173 tls = &target->thread.tls_array[pos]; 174 175 if (kbuf) { 176 struct user_desc *info = kbuf; 177 while (count-- > 0) 178 fill_user_desc(info++, GDT_ENTRY_TLS_MIN + pos++, 179 tls++); 180 } else { 181 struct user_desc __user *u_info = ubuf; 182 while (count-- > 0) { 183 struct user_desc info; 184 fill_user_desc(&info, GDT_ENTRY_TLS_MIN + pos++, tls++); 185 if (__copy_to_user(u_info++, &info, sizeof(info))) 186 return -EFAULT; 187 } 188 } 189 190 return 0; 191 } 192 193 int regset_tls_set(struct task_struct *target, const struct user_regset *regset, 194 unsigned int pos, unsigned int count, 195 const void *kbuf, const void __user *ubuf) 196 { 197 struct user_desc infobuf[GDT_ENTRY_TLS_ENTRIES]; 198 const struct user_desc *info; 199 200 if (pos >= GDT_ENTRY_TLS_ENTRIES * sizeof(struct user_desc) || 201 (pos % sizeof(struct user_desc)) != 0 || 202 (count % sizeof(struct user_desc)) != 0) 203 return -EINVAL; 204 205 if (kbuf) 206 info = kbuf; 207 else if (__copy_from_user(infobuf, ubuf, count)) 208 return -EFAULT; 209 else 210 info = infobuf; 211 212 set_tls_desc(target, 213 GDT_ENTRY_TLS_MIN + (pos / sizeof(struct user_desc)), 214 info, count / sizeof(struct user_desc)); 215 216 return 0; 217 } 218