projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
CRED: Separate task security context from task_struct
[linux-2.6-block.git] / arch / ia64 / ia32 / sys_ia32.c
CommitLineData
1da177e4
LT		 1/*
2 * sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Derived from sys_sparc32.c.
3 *
4 * Copyright (C) 2000 VA Linux Co
5 * Copyright (C) 2000 Don Dugger <n0ano@valinux.com>
6 * Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com>
7 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
8 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
9 * Copyright (C) 2000-2003, 2005 Hewlett-Packard Co
10 * David Mosberger-Tang <davidm@hpl.hp.com>
11 * Copyright (C) 2004 Gordon Jin <gordon.jin@intel.com>
12 *
13 * These routines maintain argument size conversion between 32bit and 64bit
14 * environment.
15 */
16
1da177e4
LT		 17#include <linux/kernel.h>
18#include <linux/syscalls.h>
19#include <linux/sysctl.h>
20#include <linux/sched.h>
21#include <linux/fs.h>
22#include <linux/file.h>
23#include <linux/signal.h>
24#include <linux/resource.h>
25#include <linux/times.h>
26#include <linux/utsname.h>
1da177e4
LT		 27#include <linux/smp.h>
28#include <linux/smp_lock.h>
29#include <linux/sem.h>
30#include <linux/msg.h>
31#include <linux/mm.h>
32#include <linux/shm.h>
33#include <linux/slab.h>
34#include <linux/uio.h>
2d9b06c7 35#include <linux/socket.h>
1da177e4 36#include <linux/quota.h>
1da177e4
LT		 37#include <linux/poll.h>
38#include <linux/eventpoll.h>
39#include <linux/personality.h>
40#include <linux/ptrace.h>
75529219 41#include <linux/regset.h>
1da177e4
LT		 42#include <linux/stat.h>
43#include <linux/ipc.h>
a9415644 44#include <linux/capability.h>
1da177e4
LT		 45#include <linux/compat.h>
46#include <linux/vfs.h>
47#include <linux/mman.h>
92ff2ecd 48#include <linux/mutex.h>
1da177e4
LT		 49
50#include <asm/intrinsics.h>
1da177e4
LT		 51#include <asm/types.h>
52#include <asm/uaccess.h>
53#include <asm/unistd.h>
54
55#include "ia32priv.h"
56
57#include <net/scm.h>
58#include <net/sock.h>
59
60#define DEBUG 0
61
62#if DEBUG
63# define DBG(fmt...) printk(KERN_DEBUG fmt)
64#else
65# define DBG(fmt...)
66#endif
67
68#define ROUND_UP(x,a) ((__typeof__(x))(((unsigned long)(x) + ((a) - 1)) & ~((a) - 1)))
69
70#define OFFSET4K(a) ((a) & 0xfff)
71#define PAGE_START(addr) ((addr) & PAGE_MASK)
72#define MINSIGSTKSZ_IA32 2048
73
74#define high2lowuid(uid) ((uid) > 65535 ? 65534 : (uid))
75#define high2lowgid(gid) ((gid) > 65535 ? 65534 : (gid))
76
77/*
78 * Anything that modifies or inspects ia32 user virtual memory must hold this semaphore
79 * while doing so.
80 */
81/* XXX make per-mm: */
92ff2ecd 82static DEFINE_MUTEX(ia32_mmap_mutex);
1da177e4
LT		 83
84asmlinkage long
85sys32_execve (char __user *name, compat_uptr_t __user *argv, compat_uptr_t __user *envp,
86 struct pt_regs *regs)
87{
88 long error;
89 char *filename;
90 unsigned long old_map_base, old_task_size, tssd;
91
92 filename = getname(name);
93 error = PTR_ERR(filename);
94 if (IS_ERR(filename))
95 return error;
96
97 old_map_base = current->thread.map_base;
98 old_task_size = current->thread.task_size;
99 tssd = ia64_get_kr(IA64_KR_TSSD);
100
101 /* we may be exec'ing a 64-bit process: reset map base, task-size, and io-base: */
102 current->thread.map_base = DEFAULT_MAP_BASE;
103 current->thread.task_size = DEFAULT_TASK_SIZE;
104 ia64_set_kr(IA64_KR_IO_BASE, current->thread.old_iob);
105 ia64_set_kr(IA64_KR_TSSD, current->thread.old_k1);
106
107 error = compat_do_execve(filename, argv, envp, regs);
108 putname(filename);
109
110 if (error < 0) {
111 /* oops, execve failed, switch back to old values... */
112 ia64_set_kr(IA64_KR_IO_BASE, IA32_IOBASE);
113 ia64_set_kr(IA64_KR_TSSD, tssd);
114 current->thread.map_base = old_map_base;
115 current->thread.task_size = old_task_size;
116 }
117
118 return error;
119}
120
1da177e4
LT		 121
122#if PAGE_SHIFT > IA32_PAGE_SHIFT
123
124
125static int
126get_page_prot (struct vm_area_struct *vma, unsigned long addr)
127{
128 int prot = 0;
129
130 if (!vma || vma->vm_start > addr)
131 return 0;
132
133 if (vma->vm_flags & VM_READ)
134 prot |= PROT_READ;
135 if (vma->vm_flags & VM_WRITE)
136 prot |= PROT_WRITE;
137 if (vma->vm_flags & VM_EXEC)
138 prot |= PROT_EXEC;
139 return prot;
140}
141
142/*
143 * Map a subpage by creating an anonymous page that contains the union of the old page and
144 * the subpage.
145 */
146static unsigned long
147mmap_subpage (struct file *file, unsigned long start, unsigned long end, int prot, int flags,
148 loff_t off)
149{
150 void *page = NULL;
151 struct inode *inode;
152 unsigned long ret = 0;
153 struct vm_area_struct *vma = find_vma(current->mm, start);
154 int old_prot = get_page_prot(vma, start);
155
156 DBG("mmap_subpage(file=%p,start=0x%lx,end=0x%lx,prot=%x,flags=%x,off=0x%llx)\n",
157 file, start, end, prot, flags, off);
158
159
160 /* Optimize the case where the old mmap and the new mmap are both anonymous */
161 if ((old_prot & PROT_WRITE) && (flags & MAP_ANONYMOUS) && !vma->vm_file) {
162 if (clear_user((void __user *) start, end - start)) {
163 ret = -EFAULT;
164 goto out;
165 }
166 goto skip_mmap;
167 }
168
169 page = (void *) get_zeroed_page(GFP_KERNEL);
170 if (!page)
171 return -ENOMEM;
172
173 if (old_prot)
174 copy_from_user(page, (void __user *) PAGE_START(start), PAGE_SIZE);
175
176 down_write(&current->mm->mmap_sem);
177 {
178 ret = do_mmap(NULL, PAGE_START(start), PAGE_SIZE, prot | PROT_WRITE,
179 flags | MAP_FIXED | MAP_ANONYMOUS, 0);
180 }
181 up_write(&current->mm->mmap_sem);
182
183 if (IS_ERR((void *) ret))
184 goto out;
185
186 if (old_prot) {
187 /* copy back the old page contents. */
188 if (offset_in_page(start))
189 copy_to_user((void __user *) PAGE_START(start), page,
190 offset_in_page(start));
191 if (offset_in_page(end))
192 copy_to_user((void __user *) end, page + offset_in_page(end),
193 PAGE_SIZE - offset_in_page(end));
194 }
195
196 if (!(flags & MAP_ANONYMOUS)) {
197 /* read the file contents */
b66ffad9 198 inode = file->f_path.dentry->d_inode;
1da177e4
LT		 199 if (!inode->i_fop || !file->f_op->read
200 || ((*file->f_op->read)(file, (char __user *) start, end - start, &off) < 0))
201 {
202 ret = -EINVAL;
203 goto out;
204 }
205 }
206
207 skip_mmap:
208 if (!(prot & PROT_WRITE))
209 ret = sys_mprotect(PAGE_START(start), PAGE_SIZE, prot | old_prot);
210 out:
211 if (page)
212 free_page((unsigned long) page);
213 return ret;
214}
215
3b74d18e 216/* SLAB cache for ia64_partial_page structures */
217struct kmem_cache *ia64_partial_page_cachep;
1da177e4
LT		 218
219/*
3b74d18e 220 * init ia64_partial_page_list.
1da177e4
LT		 221 * return 0 means kmalloc fail.
222 */
3b74d18e 223struct ia64_partial_page_list*
1da177e4
LT		 224ia32_init_pp_list(void)
225{
3b74d18e 226 struct ia64_partial_page_list *p;
1da177e4
LT		 227
228 if ((p = kmalloc(sizeof(*p), GFP_KERNEL)) == NULL)
229 return p;
230 p->pp_head = NULL;
231 p->ppl_rb = RB_ROOT;
232 p->pp_hint = NULL;
233 atomic_set(&p->pp_count, 1);
234 return p;
235}
236
237/*
238 * Search for the partial page with @start in partial page list @ppl.
239 * If finds the partial page, return the found partial page.
240 * Else, return 0 and provide @pprev, @rb_link, @rb_parent to
241 * be used by later __ia32_insert_pp().
242 */
3b74d18e 243static struct ia64_partial_page *
244__ia32_find_pp(struct ia64_partial_page_list *ppl, unsigned int start,
245 struct ia64_partial_page **pprev, struct rb_node ***rb_link,
1da177e4
LT		 246 struct rb_node **rb_parent)
247{
3b74d18e 248 struct ia64_partial_page *pp;
1da177e4
LT		 249 struct rb_node **__rb_link, *__rb_parent, *rb_prev;
250
251 pp = ppl->pp_hint;
252 if (pp && pp->base == start)
253 return pp;
254
255 __rb_link = &ppl->ppl_rb.rb_node;
256 rb_prev = __rb_parent = NULL;
257
258 while (*__rb_link) {
259 __rb_parent = *__rb_link;
3b74d18e 260 pp = rb_entry(__rb_parent, struct ia64_partial_page, pp_rb);
1da177e4
LT		 261
262 if (pp->base == start) {
263 ppl->pp_hint = pp;
264 return pp;
265 } else if (pp->base < start) {
266 rb_prev = __rb_parent;
267 __rb_link = &__rb_parent->rb_right;
268 } else {
269 __rb_link = &__rb_parent->rb_left;
270 }
271 }
272
273 *rb_link = __rb_link;
274 *rb_parent = __rb_parent;
275 *pprev = NULL;
276 if (rb_prev)
3b74d18e 277 *pprev = rb_entry(rb_prev, struct ia64_partial_page, pp_rb);
1da177e4
LT		 278 return NULL;
279}
280
281/*
282 * insert @pp into @ppl.
283 */
284static void
3b74d18e 285__ia32_insert_pp(struct ia64_partial_page_list *ppl,
286 struct ia64_partial_page *pp, struct ia64_partial_page *prev,
287 struct rb_node **rb_link, struct rb_node *rb_parent)
1da177e4
LT		 288{
289 /* link list */
290 if (prev) {
291 pp->next = prev->next;
292 prev->next = pp;
293 } else {
294 ppl->pp_head = pp;
295 if (rb_parent)
296 pp->next = rb_entry(rb_parent,
3b74d18e 297 struct ia64_partial_page, pp_rb);
1da177e4
LT		 298 else
299 pp->next = NULL;
300 }
301
302 /* link rb */
303 rb_link_node(&pp->pp_rb, rb_parent, rb_link);
304 rb_insert_color(&pp->pp_rb, &ppl->ppl_rb);
305
306 ppl->pp_hint = pp;
307}
308
309/*
310 * delete @pp from partial page list @ppl.
311 */
312static void
3b74d18e 313__ia32_delete_pp(struct ia64_partial_page_list *ppl,
314 struct ia64_partial_page *pp, struct ia64_partial_page *prev)
1da177e4
LT		 315{
316 if (prev) {
317 prev->next = pp->next;
318 if (ppl->pp_hint == pp)
319 ppl->pp_hint = prev;
320 } else {
321 ppl->pp_head = pp->next;
322 if (ppl->pp_hint == pp)
323 ppl->pp_hint = pp->next;
324 }
325 rb_erase(&pp->pp_rb, &ppl->ppl_rb);
3b74d18e 326 kmem_cache_free(ia64_partial_page_cachep, pp);
1da177e4
LT		 327}
328
3b74d18e 329static struct ia64_partial_page *
330__pp_prev(struct ia64_partial_page *pp)
1da177e4
LT		 331{
332 struct rb_node *prev = rb_prev(&pp->pp_rb);
333 if (prev)
3b74d18e 334 return rb_entry(prev, struct ia64_partial_page, pp_rb);
1da177e4
LT		 335 else
336 return NULL;
337}
338
339/*
340 * Delete partial pages with address between @start and @end.
341 * @start and @end are page aligned.
342 */
343static void
344__ia32_delete_pp_range(unsigned int start, unsigned int end)
345{
3b74d18e 346 struct ia64_partial_page *pp, *prev;
1da177e4
LT		 347 struct rb_node **rb_link, *rb_parent;
348
349 if (start >= end)
350 return;
351
352 pp = __ia32_find_pp(current->thread.ppl, start, &prev,
353 &rb_link, &rb_parent);
354 if (pp)
355 prev = __pp_prev(pp);
356 else {
357 if (prev)
358 pp = prev->next;
359 else
360 pp = current->thread.ppl->pp_head;
361 }
362
363 while (pp && pp->base < end) {
3b74d18e 364 struct ia64_partial_page *tmp = pp->next;
1da177e4
LT		 365 __ia32_delete_pp(current->thread.ppl, pp, prev);
366 pp = tmp;
367 }
368}
369
370/*
371 * Set the range between @start and @end in bitmap.
372 * @start and @end should be IA32 page aligned and in the same IA64 page.
373 */
374static int
375__ia32_set_pp(unsigned int start, unsigned int end, int flags)
376{
3b74d18e 377 struct ia64_partial_page *pp, *prev;
1da177e4
LT		 378 struct rb_node ** rb_link, *rb_parent;
379 unsigned int pstart, start_bit, end_bit, i;
380
381 pstart = PAGE_START(start);
382 start_bit = (start % PAGE_SIZE) / IA32_PAGE_SIZE;
383 end_bit = (end % PAGE_SIZE) / IA32_PAGE_SIZE;
384 if (end_bit == 0)
385 end_bit = PAGE_SIZE / IA32_PAGE_SIZE;
386 pp = __ia32_find_pp(current->thread.ppl, pstart, &prev,
387 &rb_link, &rb_parent);
388 if (pp) {
389 for (i = start_bit; i < end_bit; i++)
390 set_bit(i, &pp->bitmap);
391 /*
392 * Check: if this partial page has been set to a full page,
393 * then delete it.
394 */
395 if (find_first_zero_bit(&pp->bitmap, sizeof(pp->bitmap)*8) >=
396 PAGE_SIZE/IA32_PAGE_SIZE) {
397 __ia32_delete_pp(current->thread.ppl, pp, __pp_prev(pp));
398 }
399 return 0;
400 }
401
402 /*
403 * MAP_FIXED may lead to overlapping mmap.
404 * In this case, the requested mmap area may already mmaped as a full
405 * page. So check vma before adding a new partial page.
406 */
407 if (flags & MAP_FIXED) {
408 struct vm_area_struct *vma = find_vma(current->mm, pstart);
409 if (vma && vma->vm_start <= pstart)
410 return 0;
411 }
412
3b74d18e 413 /* new a ia64_partial_page */
414 pp = kmem_cache_alloc(ia64_partial_page_cachep, GFP_KERNEL);
1da177e4
LT		 415 if (!pp)
416 return -ENOMEM;
417 pp->base = pstart;
418 pp->bitmap = 0;
419 for (i=start_bit; i<end_bit; i++)
420 set_bit(i, &(pp->bitmap));
421 pp->next = NULL;
422 __ia32_insert_pp(current->thread.ppl, pp, prev, rb_link, rb_parent);
423 return 0;
424}
425
426/*
427 * @start and @end should be IA32 page aligned, but don't need to be in the
428 * same IA64 page. Split @start and @end to make sure they're in the same IA64
429 * page, then call __ia32_set_pp().
430 */
431static void
432ia32_set_pp(unsigned int start, unsigned int end, int flags)
433{
434 down_write(&current->mm->mmap_sem);
435 if (flags & MAP_FIXED) {
436 /*
437 * MAP_FIXED may lead to overlapping mmap. When this happens,
438 * a series of complete IA64 pages results in deletion of
439 * old partial pages in that range.
440 */
441 __ia32_delete_pp_range(PAGE_ALIGN(start), PAGE_START(end));
442 }
443
444 if (end < PAGE_ALIGN(start)) {
445 __ia32_set_pp(start, end, flags);
446 } else {
447 if (offset_in_page(start))
448 __ia32_set_pp(start, PAGE_ALIGN(start), flags);
449 if (offset_in_page(end))
450 __ia32_set_pp(PAGE_START(end), end, flags);
451 }
452 up_write(&current->mm->mmap_sem);
453}
454
455/*
456 * Unset the range between @start and @end in bitmap.
457 * @start and @end should be IA32 page aligned and in the same IA64 page.
458 * After doing that, if the bitmap is 0, then free the page and return 1,
459 * else return 0;
460 * If not find the partial page in the list, then
461 * If the vma exists, then the full page is set to a partial page;
462 * Else return -ENOMEM.
463 */
464static int
465__ia32_unset_pp(unsigned int start, unsigned int end)
466{
3b74d18e 467 struct ia64_partial_page *pp, *prev;
1da177e4
LT		 468 struct rb_node ** rb_link, *rb_parent;
469 unsigned int pstart, start_bit, end_bit, i;
470 struct vm_area_struct *vma;
471
472 pstart = PAGE_START(start);
473 start_bit = (start % PAGE_SIZE) / IA32_PAGE_SIZE;
474 end_bit = (end % PAGE_SIZE) / IA32_PAGE_SIZE;
475 if (end_bit == 0)
476 end_bit = PAGE_SIZE / IA32_PAGE_SIZE;
477
478 pp = __ia32_find_pp(current->thread.ppl, pstart, &prev,
479 &rb_link, &rb_parent);
480 if (pp) {
481 for (i = start_bit; i < end_bit; i++)
482 clear_bit(i, &pp->bitmap);
483 if (pp->bitmap == 0) {
484 __ia32_delete_pp(current->thread.ppl, pp, __pp_prev(pp));
485 return 1;
486 }
487 return 0;
488 }
489
490 vma = find_vma(current->mm, pstart);
491 if (!vma || vma->vm_start > pstart) {
492 return -ENOMEM;
493 }
494
3b74d18e 495 /* new a ia64_partial_page */
496 pp = kmem_cache_alloc(ia64_partial_page_cachep, GFP_KERNEL);
1da177e4
LT		 497 if (!pp)
498 return -ENOMEM;
499 pp->base = pstart;
500 pp->bitmap = 0;
501 for (i = 0; i < start_bit; i++)
502 set_bit(i, &(pp->bitmap));
503 for (i = end_bit; i < PAGE_SIZE / IA32_PAGE_SIZE; i++)
504 set_bit(i, &(pp->bitmap));
505 pp->next = NULL;
506 __ia32_insert_pp(current->thread.ppl, pp, prev, rb_link, rb_parent);
507 return 0;
508}
509
510/*
511 * Delete pp between PAGE_ALIGN(start) and PAGE_START(end) by calling
512 * __ia32_delete_pp_range(). Unset possible partial pages by calling
513 * __ia32_unset_pp().
514 * The returned value see __ia32_unset_pp().
515 */
516static int
517ia32_unset_pp(unsigned int *startp, unsigned int *endp)
518{
519 unsigned int start = *startp, end = *endp;
520 int ret = 0;
521
522 down_write(&current->mm->mmap_sem);
523
524 __ia32_delete_pp_range(PAGE_ALIGN(start), PAGE_START(end));
525
526 if (end < PAGE_ALIGN(start)) {
527 ret = __ia32_unset_pp(start, end);
528 if (ret == 1) {
529 *startp = PAGE_START(start);
530 *endp = PAGE_ALIGN(end);
531 }
532 if (ret == 0) {
533 /* to shortcut sys_munmap() in sys32_munmap() */
534 *startp = PAGE_START(start);
535 *endp = PAGE_START(end);
536 }
537 } else {
538 if (offset_in_page(start)) {
539 ret = __ia32_unset_pp(start, PAGE_ALIGN(start));
540 if (ret == 1)
541 *startp = PAGE_START(start);
542 if (ret == 0)
543 *startp = PAGE_ALIGN(start);
544 if (ret < 0)
545 goto out;
546 }
547 if (offset_in_page(end)) {
548 ret = __ia32_unset_pp(PAGE_START(end), end);
549 if (ret == 1)
550 *endp = PAGE_ALIGN(end);
551 if (ret == 0)
552 *endp = PAGE_START(end);
553 }
554 }
555
556 out:
557 up_write(&current->mm->mmap_sem);
558 return ret;
559}
560
561/*
562 * Compare the range between @start and @end with bitmap in partial page.
563 * @start and @end should be IA32 page aligned and in the same IA64 page.
564 */
565static int
566__ia32_compare_pp(unsigned int start, unsigned int end)
567{
3b74d18e 568 struct ia64_partial_page *pp, *prev;
1da177e4
LT		 569 struct rb_node ** rb_link, *rb_parent;
570 unsigned int pstart, start_bit, end_bit, size;
571 unsigned int first_bit, next_zero_bit; /* the first range in bitmap */
572
573 pstart = PAGE_START(start);
574
575 pp = __ia32_find_pp(current->thread.ppl, pstart, &prev,
576 &rb_link, &rb_parent);
577 if (!pp)
578 return 1;
579
580 start_bit = (start % PAGE_SIZE) / IA32_PAGE_SIZE;
581 end_bit = (end % PAGE_SIZE) / IA32_PAGE_SIZE;
582 size = sizeof(pp->bitmap) * 8;
583 first_bit = find_first_bit(&pp->bitmap, size);
584 next_zero_bit = find_next_zero_bit(&pp->bitmap, size, first_bit);
585 if ((start_bit < first_bit) || (end_bit > next_zero_bit)) {
586 /* exceeds the first range in bitmap */
587 return -ENOMEM;
588 } else if ((start_bit == first_bit) && (end_bit == next_zero_bit)) {
589 first_bit = find_next_bit(&pp->bitmap, size, next_zero_bit);
590 if ((next_zero_bit < first_bit) && (first_bit < size))
591 return 1; /* has next range */
592 else
593 return 0; /* no next range */
594 } else
595 return 1;
596}
597
598/*
599 * @start and @end should be IA32 page aligned, but don't need to be in the
600 * same IA64 page. Split @start and @end to make sure they're in the same IA64
601 * page, then call __ia32_compare_pp().
602 *
603 * Take this as example: the range is the 1st and 2nd 4K page.
604 * Return 0 if they fit bitmap exactly, i.e. bitmap = 00000011;
605 * Return 1 if the range doesn't cover whole bitmap, e.g. bitmap = 00001111;
606 * Return -ENOMEM if the range exceeds the bitmap, e.g. bitmap = 00000001 or
607 * bitmap = 00000101.
608 */
609static int
610ia32_compare_pp(unsigned int *startp, unsigned int *endp)
611{
612 unsigned int start = *startp, end = *endp;
613 int retval = 0;
614
615 down_write(&current->mm->mmap_sem);
616
617 if (end < PAGE_ALIGN(start)) {
618 retval = __ia32_compare_pp(start, end);
619 if (retval == 0) {
620 *startp = PAGE_START(start);
621 *endp = PAGE_ALIGN(end);
622 }
623 } else {
624 if (offset_in_page(start)) {
625 retval = __ia32_compare_pp(start,
626 PAGE_ALIGN(start));
627 if (retval == 0)
628 *startp = PAGE_START(start);
629 if (retval < 0)
630 goto out;
631 }
632 if (offset_in_page(end)) {
633 retval = __ia32_compare_pp(PAGE_START(end), end);
634 if (retval == 0)
635 *endp = PAGE_ALIGN(end);
636 }
637 }
638
639 out:
640 up_write(&current->mm->mmap_sem);
641 return retval;
642}
643
644static void
3b74d18e 645__ia32_drop_pp_list(struct ia64_partial_page_list *ppl)
1da177e4 646{
3b74d18e 647 struct ia64_partial_page *pp = ppl->pp_head;
1da177e4
LT		 648
649 while (pp) {
3b74d18e 650 struct ia64_partial_page *next = pp->next;
651 kmem_cache_free(ia64_partial_page_cachep, pp);
1da177e4
LT		 652 pp = next;
653 }
654
655 kfree(ppl);
656}
657
658void
3b74d18e 659ia32_drop_ia64_partial_page_list(struct task_struct *task)
1da177e4 660{
3b74d18e 661 struct ia64_partial_page_list* ppl = task->thread.ppl;
1da177e4
LT		 662
663 if (ppl && atomic_dec_and_test(&ppl->pp_count))
664 __ia32_drop_pp_list(ppl);
665}
666
667/*
668 * Copy current->thread.ppl to ppl (already initialized).
669 */
670static int
3b74d18e 671__ia32_copy_pp_list(struct ia64_partial_page_list *ppl)
1da177e4 672{
3b74d18e 673 struct ia64_partial_page *pp, *tmp, *prev;
1da177e4
LT		 674 struct rb_node **rb_link, *rb_parent;
675
676 ppl->pp_head = NULL;
677 ppl->pp_hint = NULL;
678 ppl->ppl_rb = RB_ROOT;
679 rb_link = &ppl->ppl_rb.rb_node;
680 rb_parent = NULL;
681 prev = NULL;
682
683 for (pp = current->thread.ppl->pp_head; pp; pp = pp->next) {
3b74d18e 684 tmp = kmem_cache_alloc(ia64_partial_page_cachep, GFP_KERNEL);
1da177e4
LT		 685 if (!tmp)
686 return -ENOMEM;
687 *tmp = *pp;
688 __ia32_insert_pp(ppl, tmp, prev, rb_link, rb_parent);
689 prev = tmp;
690 rb_link = &tmp->pp_rb.rb_right;
691 rb_parent = &tmp->pp_rb;
692 }
693 return 0;
694}
695
696int
3b74d18e 697ia32_copy_ia64_partial_page_list(struct task_struct *p,
698 unsigned long clone_flags)
1da177e4
LT		 699{
700 int retval = 0;
701
702 if (clone_flags & CLONE_VM) {
703 atomic_inc(&current->thread.ppl->pp_count);
704 p->thread.ppl = current->thread.ppl;
705 } else {
706 p->thread.ppl = ia32_init_pp_list();
707 if (!p->thread.ppl)
708 return -ENOMEM;
709 down_write(&current->mm->mmap_sem);
710 {
711 retval = __ia32_copy_pp_list(p->thread.ppl);
712 }
713 up_write(&current->mm->mmap_sem);
714 }
715
716 return retval;
717}
718
719static unsigned long
720emulate_mmap (struct file *file, unsigned long start, unsigned long len, int prot, int flags,
721 loff_t off)
722{
723 unsigned long tmp, end, pend, pstart, ret, is_congruent, fudge = 0;
724 struct inode *inode;
725 loff_t poff;
726
727 end = start + len;
728 pstart = PAGE_START(start);
729 pend = PAGE_ALIGN(end);
730
731 if (flags & MAP_FIXED) {
732 ia32_set_pp((unsigned int)start, (unsigned int)end, flags);
733 if (start > pstart) {
734 if (flags & MAP_SHARED)
735 printk(KERN_INFO
736 "%s(%d): emulate_mmap() can't share head (addr=0x%lx)\n",
19c5870c 737 current->comm, task_pid_nr(current), start);
1da177e4
LT		 738 ret = mmap_subpage(file, start, min(PAGE_ALIGN(start), end), prot, flags,
739 off);
740 if (IS_ERR((void *) ret))
741 return ret;
742 pstart += PAGE_SIZE;
743 if (pstart >= pend)
744 goto out; /* done */
745 }
746 if (end < pend) {
747 if (flags & MAP_SHARED)
748 printk(KERN_INFO
749 "%s(%d): emulate_mmap() can't share tail (end=0x%lx)\n",
19c5870c 750 current->comm, task_pid_nr(current), end);
1da177e4
LT		 751 ret = mmap_subpage(file, max(start, PAGE_START(end)), end, prot, flags,
752 (off + len) - offset_in_page(end));
753 if (IS_ERR((void *) ret))
754 return ret;
755 pend -= PAGE_SIZE;
756 if (pstart >= pend)
757 goto out; /* done */
758 }
759 } else {
760 /*
761 * If a start address was specified, use it if the entire rounded out area
762 * is available.
763 */
764 if (start && !pstart)
765 fudge = 1; /* handle case of mapping to range (0,PAGE_SIZE) */
766 tmp = arch_get_unmapped_area(file, pstart - fudge, pend - pstart, 0, flags);
767 if (tmp != pstart) {
768 pstart = tmp;
769 start = pstart + offset_in_page(off); /* make start congruent with off */
770 end = start + len;
771 pend = PAGE_ALIGN(end);
772 }
773 }
774
775 poff = off + (pstart - start); /* note: (pstart - start) may be negative */
776 is_congruent = (flags & MAP_ANONYMOUS) || (offset_in_page(poff) == 0);
777
778 if ((flags & MAP_SHARED) && !is_congruent)
779 printk(KERN_INFO "%s(%d): emulate_mmap() can't share contents of incongruent mmap "
19c5870c 780 "(addr=0x%lx,off=0x%llx)\n", current->comm, task_pid_nr(current), start, off);
1da177e4
LT		 781
782 DBG("mmap_body: mapping [0x%lx-0x%lx) %s with poff 0x%llx\n", pstart, pend,
783 is_congruent ? "congruent" : "not congruent", poff);
784
785 down_write(&current->mm->mmap_sem);
786 {
787 if (!(flags & MAP_ANONYMOUS) && is_congruent)
788 ret = do_mmap(file, pstart, pend - pstart, prot, flags | MAP_FIXED, poff);
789 else
790 ret = do_mmap(NULL, pstart, pend - pstart,
791 prot | ((flags & MAP_ANONYMOUS) ? 0 : PROT_WRITE),
792 flags | MAP_FIXED | MAP_ANONYMOUS, 0);
793 }
794 up_write(&current->mm->mmap_sem);
795
796 if (IS_ERR((void *) ret))
797 return ret;
798
799 if (!is_congruent) {
800 /* read the file contents */
b66ffad9 801 inode = file->f_path.dentry->d_inode;
1da177e4
LT		 802 if (!inode->i_fop || !file->f_op->read
803 || ((*file->f_op->read)(file, (char __user *) pstart, pend - pstart, &poff)
804 < 0))
805 {
806 sys_munmap(pstart, pend - pstart);
807 return -EINVAL;
808 }
809 if (!(prot & PROT_WRITE) && sys_mprotect(pstart, pend - pstart, prot) < 0)
810 return -EINVAL;
811 }
812
813 if (!(flags & MAP_FIXED))
814 ia32_set_pp((unsigned int)start, (unsigned int)end, flags);
815out:
816 return start;
817}
818
819#endif /* PAGE_SHIFT > IA32_PAGE_SHIFT */
820
821static inline unsigned int
822get_prot32 (unsigned int prot)
823{
824 if (prot & PROT_WRITE)
825 /* on x86, PROT_WRITE implies PROT_READ which implies PROT_EEC */
826 prot |= PROT_READ | PROT_WRITE | PROT_EXEC;
827 else if (prot & (PROT_READ | PROT_EXEC))
828 /* on x86, there is no distinction between PROT_READ and PROT_EXEC */
829 prot |= (PROT_READ | PROT_EXEC);
830
831 return prot;
832}
833
834unsigned long
835ia32_do_mmap (struct file *file, unsigned long addr, unsigned long len, int prot, int flags,
836 loff_t offset)
837{
838 DBG("ia32_do_mmap(file=%p,addr=0x%lx,len=0x%lx,prot=%x,flags=%x,offset=0x%llx)\n",
839 file, addr, len, prot, flags, offset);
840
841 if (file && (!file->f_op || !file->f_op->mmap))
842 return -ENODEV;
843
844 len = IA32_PAGE_ALIGN(len);
845 if (len == 0)
846 return addr;
847
848 if (len > IA32_PAGE_OFFSET || addr > IA32_PAGE_OFFSET - len)
849 {
850 if (flags & MAP_FIXED)
851 return -ENOMEM;
852 else
853 return -EINVAL;
854 }
855
856 if (OFFSET4K(offset))
857 return -EINVAL;
858
859 prot = get_prot32(prot);
860
861#if PAGE_SHIFT > IA32_PAGE_SHIFT
92ff2ecd 862 mutex_lock(&ia32_mmap_mutex);
1da177e4
LT		 863 {
864 addr = emulate_mmap(file, addr, len, prot, flags, offset);
865 }
92ff2ecd 866 mutex_unlock(&ia32_mmap_mutex);
1da177e4
LT		 867#else
868 down_write(&current->mm->mmap_sem);
869 {
870 addr = do_mmap(file, addr, len, prot, flags, offset);
871 }
872 up_write(&current->mm->mmap_sem);
873#endif
874 DBG("ia32_do_mmap: returning 0x%lx\n", addr);
875 return addr;
876}
877
878/*
879 * Linux/i386 didn't use to be able to handle more than 4 system call parameters, so these
880 * system calls used a memory block for parameter passing..
881 */
882
883struct mmap_arg_struct {
884 unsigned int addr;
885 unsigned int len;
886 unsigned int prot;
887 unsigned int flags;
888 unsigned int fd;
889 unsigned int offset;
890};
891
892asmlinkage long
893sys32_mmap (struct mmap_arg_struct __user *arg)
894{
895 struct mmap_arg_struct a;
896 struct file *file = NULL;
897 unsigned long addr;
898 int flags;
899
900 if (copy_from_user(&a, arg, sizeof(a)))
901 return -EFAULT;
902
903 if (OFFSET4K(a.offset))
904 return -EINVAL;
905
906 flags = a.flags;
907
908 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
909 if (!(flags & MAP_ANONYMOUS)) {
910 file = fget(a.fd);
911 if (!file)
912 return -EBADF;
913 }
914
915 addr = ia32_do_mmap(file, a.addr, a.len, a.prot, flags, a.offset);
916
917 if (file)
918 fput(file);
919 return addr;
920}
921
922asmlinkage long
923sys32_mmap2 (unsigned int addr, unsigned int len, unsigned int prot, unsigned int flags,
924 unsigned int fd, unsigned int pgoff)
925{
926 struct file *file = NULL;
927 unsigned long retval;
928
929 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
930 if (!(flags & MAP_ANONYMOUS)) {
931 file = fget(fd);
932 if (!file)
933 return -EBADF;
934 }
935
936 retval = ia32_do_mmap(file, addr, len, prot, flags,
937 (unsigned long) pgoff << IA32_PAGE_SHIFT);
938
939 if (file)
940 fput(file);
941 return retval;
942}
943
944asmlinkage long
945sys32_munmap (unsigned int start, unsigned int len)
946{
947 unsigned int end = start + len;
948 long ret;
949
950#if PAGE_SHIFT <= IA32_PAGE_SHIFT
951 ret = sys_munmap(start, end - start);
952#else
953 if (OFFSET4K(start))
954 return -EINVAL;
955
956 end = IA32_PAGE_ALIGN(end);
957 if (start >= end)
958 return -EINVAL;
959
960 ret = ia32_unset_pp(&start, &end);
961 if (ret < 0)
962 return ret;
963
964 if (start >= end)
965 return 0;
966
92ff2ecd
JS		 967 mutex_lock(&ia32_mmap_mutex);
968 ret = sys_munmap(start, end - start);
969 mutex_unlock(&ia32_mmap_mutex);
1da177e4
LT		 970#endif
971 return ret;
972}
973
974#if PAGE_SHIFT > IA32_PAGE_SHIFT
975
976/*
977 * When mprotect()ing a partial page, we set the permission to the union of the old
978 * settings and the new settings. In other words, it's only possible to make access to a
979 * partial page less restrictive.
980 */
981static long
982mprotect_subpage (unsigned long address, int new_prot)
983{
984 int old_prot;
985 struct vm_area_struct *vma;
986
987 if (new_prot == PROT_NONE)
988 return 0; /* optimize case where nothing changes... */
989 vma = find_vma(current->mm, address);
990 old_prot = get_page_prot(vma, address);
991 return sys_mprotect(address, PAGE_SIZE, new_prot | old_prot);
992}
993
994#endif /* PAGE_SHIFT > IA32_PAGE_SHIFT */
995
996asmlinkage long
997sys32_mprotect (unsigned int start, unsigned int len, int prot)
998{
999 unsigned int end = start + len;
1000#if PAGE_SHIFT > IA32_PAGE_SHIFT
1001 long retval = 0;
1002#endif
1003
1004 prot = get_prot32(prot);
1005
1006#if PAGE_SHIFT <= IA32_PAGE_SHIFT
1007 return sys_mprotect(start, end - start, prot);
1008#else
1009 if (OFFSET4K(start))
1010 return -EINVAL;
1011
1012 end = IA32_PAGE_ALIGN(end);
1013 if (end < start)
1014 return -EINVAL;
1015
1016 retval = ia32_compare_pp(&start, &end);
1017
1018 if (retval < 0)
1019 return retval;
1020
92ff2ecd 1021 mutex_lock(&ia32_mmap_mutex);
1da177e4
LT		 1022 {
1023 if (offset_in_page(start)) {
1024 /* start address is 4KB aligned but not page aligned. */
1025 retval = mprotect_subpage(PAGE_START(start), prot);
1026 if (retval < 0)
1027 goto out;
1028
1029 start = PAGE_ALIGN(start);
1030 if (start >= end)
1031 goto out; /* retval is already zero... */
1032 }
1033
1034 if (offset_in_page(end)) {
1035 /* end address is 4KB aligned but not page aligned. */
1036 retval = mprotect_subpage(PAGE_START(end), prot);
1037 if (retval < 0)
1038 goto out;
1039
1040 end = PAGE_START(end);
1041 }
1042 retval = sys_mprotect(start, end - start, prot);
1043 }
1044 out:
92ff2ecd 1045 mutex_unlock(&ia32_mmap_mutex);
1da177e4
LT		 1046 return retval;
1047#endif
1048}
1049
1050asmlinkage long
1051sys32_mremap (unsigned int addr, unsigned int old_len, unsigned int new_len,
1052 unsigned int flags, unsigned int new_addr)
1053{
1054 long ret;
1055
1056#if PAGE_SHIFT <= IA32_PAGE_SHIFT
1057 ret = sys_mremap(addr, old_len, new_len, flags, new_addr);
1058#else
1059 unsigned int old_end, new_end;
1060
1061 if (OFFSET4K(addr))
1062 return -EINVAL;
1063
1064 old_len = IA32_PAGE_ALIGN(old_len);
1065 new_len = IA32_PAGE_ALIGN(new_len);
1066 old_end = addr + old_len;
1067 new_end = addr + new_len;
1068
1069 if (!new_len)
1070 return -EINVAL;
1071
1072 if ((flags & MREMAP_FIXED) && (OFFSET4K(new_addr)))
1073 return -EINVAL;
1074
1075 if (old_len >= new_len) {
1076 ret = sys32_munmap(addr + new_len, old_len - new_len);
1077 if (ret && old_len != new_len)
1078 return ret;
1079 ret = addr;
1080 if (!(flags & MREMAP_FIXED) || (new_addr == addr))
1081 return ret;
1082 old_len = new_len;
1083 }
1084
1085 addr = PAGE_START(addr);
1086 old_len = PAGE_ALIGN(old_end) - addr;
1087 new_len = PAGE_ALIGN(new_end) - addr;
1088
92ff2ecd
JS		 1089 mutex_lock(&ia32_mmap_mutex);
1090 ret = sys_mremap(addr, old_len, new_len, flags, new_addr);
1091 mutex_unlock(&ia32_mmap_mutex);
1da177e4
LT		 1092
1093 if ((ret >= 0) && (old_len < new_len)) {
1094 /* mremap expanded successfully */
1095 ia32_set_pp(old_end, new_end, flags);
1096 }
1097#endif
1098 return ret;
1099}
1100
1da177e4
LT		 1101asmlinkage unsigned long
1102sys32_alarm (unsigned int seconds)
1103{
c08b8a49 1104 return alarm_setitimer(seconds);
1da177e4
LT		 1105}
1106
1da177e4
LT		 1107struct sel_arg_struct {
1108 unsigned int n;
1109 unsigned int inp;
1110 unsigned int outp;
1111 unsigned int exp;
1112 unsigned int tvp;
1113};
1114
1115asmlinkage long
1116sys32_old_select (struct sel_arg_struct __user *arg)
1117{
1118 struct sel_arg_struct a;
1119
1120 if (copy_from_user(&a, arg, sizeof(a)))
1121 return -EFAULT;
1122 return compat_sys_select(a.n, compat_ptr(a.inp), compat_ptr(a.outp),
1123 compat_ptr(a.exp), compat_ptr(a.tvp));
1124}
1125
1126#define SEMOP 1
1127#define SEMGET 2
1128#define SEMCTL 3
1129#define SEMTIMEDOP 4
1130#define MSGSND 11
1131#define MSGRCV 12
1132#define MSGGET 13
1133#define MSGCTL 14
1134#define SHMAT 21
1135#define SHMDT 22
1136#define SHMGET 23
1137#define SHMCTL 24
1138
1139asmlinkage long
1140sys32_ipc(u32 call, int first, int second, int third, u32 ptr, u32 fifth)
1141{
1142 int version;
1143
1144 version = call >> 16; /* hack for backward compatibility */
1145 call &= 0xffff;
1146
1147 switch (call) {
1148 case SEMTIMEDOP:
1149 if (fifth)
1150 return compat_sys_semtimedop(first, compat_ptr(ptr),
1151 second, compat_ptr(fifth));
1152 /* else fall through for normal semop() */
1153 case SEMOP:
1154 /* struct sembuf is the same on 32 and 64bit :)) */
1155 return sys_semtimedop(first, compat_ptr(ptr), second,
1156 NULL);
1157 case SEMGET:
1158 return sys_semget(first, second, third);
1159 case SEMCTL:
1160 return compat_sys_semctl(first, second, third, compat_ptr(ptr));
1161
1162 case MSGSND:
1163 return compat_sys_msgsnd(first, second, third, compat_ptr(ptr));
1164 case MSGRCV:
1165 return compat_sys_msgrcv(first, second, fifth, third, version, compat_ptr(ptr));
1166 case MSGGET:
1167 return sys_msgget((key_t) first, second);
1168 case MSGCTL:
1169 return compat_sys_msgctl(first, second, compat_ptr(ptr));
1170
1171 case SHMAT:
1172 return compat_sys_shmat(first, second, third, version, compat_ptr(ptr));
1173 break;
1174 case SHMDT:
1175 return sys_shmdt(compat_ptr(ptr));
1176 case SHMGET:
1177 return sys_shmget(first, (unsigned)second, third);
1178 case SHMCTL:
1179 return compat_sys_shmctl(first, second, compat_ptr(ptr));
1180
1181 default:
1182 return -ENOSYS;
1183 }
1184 return -EINVAL;
1185}
1186
1187asmlinkage long
1188compat_sys_wait4 (compat_pid_t pid, compat_uint_t * stat_addr, int options,
1189 struct compat_rusage *ru);
1190
1191asmlinkage long
1192sys32_waitpid (int pid, unsigned int *stat_addr, int options)
1193{
1194 return compat_sys_wait4(pid, stat_addr, options, NULL);
1195}
1196
1da177e4
LT		 1197/*
1198 * The order in which registers are stored in the ptrace regs structure
1199 */
1200#define PT_EBX 0
1201#define PT_ECX 1
1202#define PT_EDX 2
1203#define PT_ESI 3
1204#define PT_EDI 4
1205#define PT_EBP 5
1206#define PT_EAX 6
1207#define PT_DS 7
1208#define PT_ES 8
1209#define PT_FS 9
1210#define PT_GS 10
1211#define PT_ORIG_EAX 11
1212#define PT_EIP 12
1213#define PT_CS 13
1214#define PT_EFL 14
1215#define PT_UESP 15
1216#define PT_SS 16
1217
1218static unsigned int
1219getreg (struct task_struct *child, int regno)
1220{
1221 struct pt_regs *child_regs;
1222
6450578f 1223 child_regs = task_pt_regs(child);
1da177e4
LT		 1224 switch (regno / sizeof(int)) {
1225 case PT_EBX: return child_regs->r11;
1226 case PT_ECX: return child_regs->r9;
1227 case PT_EDX: return child_regs->r10;
1228 case PT_ESI: return child_regs->r14;
1229 case PT_EDI: return child_regs->r15;
1230 case PT_EBP: return child_regs->r13;
1231 case PT_EAX: return child_regs->r8;
1232 case PT_ORIG_EAX: return child_regs->r1; /* see dispatch_to_ia32_handler() */
1233 case PT_EIP: return child_regs->cr_iip;
1234 case PT_UESP: return child_regs->r12;
1235 case PT_EFL: return child->thread.eflag;
1236 case PT_DS: case PT_ES: case PT_FS: case PT_GS: case PT_SS:
1237 return __USER_DS;
1238 case PT_CS: return __USER_CS;
1239 default:
1240 printk(KERN_ERR "ia32.getreg(): unknown register %d\n", regno);
1241 break;
1242 }
1243 return 0;
1244}
1245
1246static void
1247putreg (struct task_struct *child, int regno, unsigned int value)
1248{
1249 struct pt_regs *child_regs;
1250
6450578f 1251 child_regs = task_pt_regs(child);
1da177e4
LT		 1252 switch (regno / sizeof(int)) {
1253 case PT_EBX: child_regs->r11 = value; break;
1254 case PT_ECX: child_regs->r9 = value; break;
1255 case PT_EDX: child_regs->r10 = value; break;
1256 case PT_ESI: child_regs->r14 = value; break;
1257 case PT_EDI: child_regs->r15 = value; break;
1258 case PT_EBP: child_regs->r13 = value; break;
1259 case PT_EAX: child_regs->r8 = value; break;
1260 case PT_ORIG_EAX: child_regs->r1 = value; break;
1261 case PT_EIP: child_regs->cr_iip = value; break;
1262 case PT_UESP: child_regs->r12 = value; break;
1263 case PT_EFL: child->thread.eflag = value; break;
1264 case PT_DS: case PT_ES: case PT_FS: case PT_GS: case PT_SS:
1265 if (value != __USER_DS)
1266 printk(KERN_ERR
1267 "ia32.putreg: attempt to set invalid segment register %d = %x\n",
1268 regno, value);
1269 break;
1270 case PT_CS:
1271 if (value != __USER_CS)
1272 printk(KERN_ERR
1273 "ia32.putreg: attempt to to set invalid segment register %d = %x\n",
1274 regno, value);
1275 break;
1276 default:
1277 printk(KERN_ERR "ia32.putreg: unknown register %d\n", regno);
1278 break;
1279 }
1280}
1281
1282static void
1283put_fpreg (int regno, struct _fpreg_ia32 __user *reg, struct pt_regs *ptp,
1284 struct switch_stack *swp, int tos)
1285{
1286 struct _fpreg_ia32 *f;
1287 char buf[32];
1288
1289 f = (struct _fpreg_ia32 *)(((unsigned long)buf + 15) & ~15);
1290 if ((regno += tos) >= 8)
1291 regno -= 8;
1292 switch (regno) {
1293 case 0:
1294 ia64f2ia32f(f, &ptp->f8);
1295 break;
1296 case 1:
1297 ia64f2ia32f(f, &ptp->f9);
1298 break;
1299 case 2:
1300 ia64f2ia32f(f, &ptp->f10);
1301 break;
1302 case 3:
1303 ia64f2ia32f(f, &ptp->f11);
1304 break;
1305 case 4:
1306 case 5:
1307 case 6:
1308 case 7:
1309 ia64f2ia32f(f, &swp->f12 + (regno - 4));
1310 break;
1311 }
1312 copy_to_user(reg, f, sizeof(*reg));
1313}
1314
1315static void
1316get_fpreg (int regno, struct _fpreg_ia32 __user *reg, struct pt_regs *ptp,
1317 struct switch_stack *swp, int tos)
1318{
1319
1320 if ((regno += tos) >= 8)
1321 regno -= 8;
1322 switch (regno) {
1323 case 0:
1324 copy_from_user(&ptp->f8, reg, sizeof(*reg));
1325 break;
1326 case 1:
1327 copy_from_user(&ptp->f9, reg, sizeof(*reg));
1328 break;
1329 case 2:
1330 copy_from_user(&ptp->f10, reg, sizeof(*reg));
1331 break;
1332 case 3:
1333 copy_from_user(&ptp->f11, reg, sizeof(*reg));
1334 break;
1335 case 4:
1336 case 5:
1337 case 6:
1338 case 7:
1339 copy_from_user(&swp->f12 + (regno - 4), reg, sizeof(*reg));
1340 break;
1341 }
1342 return;
1343}
1344
1345int
1346save_ia32_fpstate (struct task_struct *tsk, struct ia32_user_i387_struct __user *save)
1347{
1348 struct switch_stack *swp;
1349 struct pt_regs *ptp;
1350 int i, tos;
1351
1352 if (!access_ok(VERIFY_WRITE, save, sizeof(*save)))
1353 return -EFAULT;
1354
1355 __put_user(tsk->thread.fcr & 0xffff, &save->cwd);
1356 __put_user(tsk->thread.fsr & 0xffff, &save->swd);
1357 __put_user((tsk->thread.fsr>>16) & 0xffff, &save->twd);
1358 __put_user(tsk->thread.fir, &save->fip);
1359 __put_user((tsk->thread.fir>>32) & 0xffff, &save->fcs);
1360 __put_user(tsk->thread.fdr, &save->foo);
1361 __put_user((tsk->thread.fdr>>32) & 0xffff, &save->fos);
1362
1363 /*
1364 * Stack frames start with 16-bytes of temp space
1365 */
1366 swp = (struct switch_stack *)(tsk->thread.ksp + 16);
6450578f 1367 ptp = task_pt_regs(tsk);
1da177e4
LT		 1368 tos = (tsk->thread.fsr >> 11) & 7;
1369 for (i = 0; i < 8; i++)
1370 put_fpreg(i, &save->st_space[i], ptp, swp, tos);
1371 return 0;
1372}
1373
1374static int
1375restore_ia32_fpstate (struct task_struct *tsk, struct ia32_user_i387_struct __user *save)
1376{
1377 struct switch_stack *swp;
1378 struct pt_regs *ptp;
1379 int i, tos;
1380 unsigned int fsrlo, fsrhi, num32;
1381
1382 if (!access_ok(VERIFY_READ, save, sizeof(*save)))
1383 return(-EFAULT);
1384
1385 __get_user(num32, (unsigned int __user *)&save->cwd);
1386 tsk->thread.fcr = (tsk->thread.fcr & (~0x1f3f)) | (num32 & 0x1f3f);
1387 __get_user(fsrlo, (unsigned int __user *)&save->swd);
1388 __get_user(fsrhi, (unsigned int __user *)&save->twd);
1389 num32 = (fsrhi << 16) | fsrlo;
1390 tsk->thread.fsr = (tsk->thread.fsr & (~0xffffffff)) | num32;
1391 __get_user(num32, (unsigned int __user *)&save->fip);
1392 tsk->thread.fir = (tsk->thread.fir & (~0xffffffff)) | num32;
1393 __get_user(num32, (unsigned int __user *)&save->foo);
1394 tsk->thread.fdr = (tsk->thread.fdr & (~0xffffffff)) | num32;
1395
1396 /*
1397 * Stack frames start with 16-bytes of temp space
1398 */
1399 swp = (struct switch_stack *)(tsk->thread.ksp + 16);
6450578f 1400 ptp = task_pt_regs(tsk);
1da177e4
LT		 1401 tos = (tsk->thread.fsr >> 11) & 7;
1402 for (i = 0; i < 8; i++)
1403 get_fpreg(i, &save->st_space[i], ptp, swp, tos);
1404 return 0;
1405}
1406
1407int
1408save_ia32_fpxstate (struct task_struct *tsk, struct ia32_user_fxsr_struct __user *save)
1409{
1410 struct switch_stack *swp;
1411 struct pt_regs *ptp;
1412 int i, tos;
1413 unsigned long mxcsr=0;
1414 unsigned long num128[2];
1415
1416 if (!access_ok(VERIFY_WRITE, save, sizeof(*save)))
1417 return -EFAULT;
1418
1419 __put_user(tsk->thread.fcr & 0xffff, &save->cwd);
1420 __put_user(tsk->thread.fsr & 0xffff, &save->swd);
1421 __put_user((tsk->thread.fsr>>16) & 0xffff, &save->twd);
1422 __put_user(tsk->thread.fir, &save->fip);
1423 __put_user((tsk->thread.fir>>32) & 0xffff, &save->fcs);
1424 __put_user(tsk->thread.fdr, &save->foo);
1425 __put_user((tsk->thread.fdr>>32) & 0xffff, &save->fos);
1426
1427 /*
1428 * Stack frames start with 16-bytes of temp space
1429 */
1430 swp = (struct switch_stack *)(tsk->thread.ksp + 16);
6450578f 1431 ptp = task_pt_regs(tsk);
1da177e4
LT		 1432 tos = (tsk->thread.fsr >> 11) & 7;
1433 for (i = 0; i < 8; i++)
1434 put_fpreg(i, (struct _fpreg_ia32 __user *)&save->st_space[4*i], ptp, swp, tos);
1435
1436 mxcsr = ((tsk->thread.fcr>>32) & 0xff80) | ((tsk->thread.fsr>>32) & 0x3f);
1437 __put_user(mxcsr & 0xffff, &save->mxcsr);
1438 for (i = 0; i < 8; i++) {
1439 memcpy(&(num128[0]), &(swp->f16) + i*2, sizeof(unsigned long));
1440 memcpy(&(num128[1]), &(swp->f17) + i*2, sizeof(unsigned long));
1441 copy_to_user(&save->xmm_space[0] + 4*i, num128, sizeof(struct _xmmreg_ia32));
1442 }
1443 return 0;
1444}
1445
1446static int
1447restore_ia32_fpxstate (struct task_struct *tsk, struct ia32_user_fxsr_struct __user *save)
1448{
1449 struct switch_stack *swp;
1450 struct pt_regs *ptp;
1451 int i, tos;
1452 unsigned int fsrlo, fsrhi, num32;
1453 int mxcsr;
1454 unsigned long num64;
1455 unsigned long num128[2];
1456
1457 if (!access_ok(VERIFY_READ, save, sizeof(*save)))
1458 return(-EFAULT);
1459
1460 __get_user(num32, (unsigned int __user *)&save->cwd);
1461 tsk->thread.fcr = (tsk->thread.fcr & (~0x1f3f)) | (num32 & 0x1f3f);
1462 __get_user(fsrlo, (unsigned int __user *)&save->swd);
1463 __get_user(fsrhi, (unsigned int __user *)&save->twd);
1464 num32 = (fsrhi << 16) | fsrlo;
1465 tsk->thread.fsr = (tsk->thread.fsr & (~0xffffffff)) | num32;
1466 __get_user(num32, (unsigned int __user *)&save->fip);
1467 tsk->thread.fir = (tsk->thread.fir & (~0xffffffff)) | num32;
1468 __get_user(num32, (unsigned int __user *)&save->foo);
1469 tsk->thread.fdr = (tsk->thread.fdr & (~0xffffffff)) | num32;
1470
1471 /*
1472 * Stack frames start with 16-bytes of temp space
1473 */
1474 swp = (struct switch_stack *)(tsk->thread.ksp + 16);
6450578f 1475 ptp = task_pt_regs(tsk);
1da177e4
LT		 1476 tos = (tsk->thread.fsr >> 11) & 7;
1477 for (i = 0; i < 8; i++)
1478 get_fpreg(i, (struct _fpreg_ia32 __user *)&save->st_space[4*i], ptp, swp, tos);
1479
1480 __get_user(mxcsr, (unsigned int __user *)&save->mxcsr);
1481 num64 = mxcsr & 0xff10;
1482 tsk->thread.fcr = (tsk->thread.fcr & (~0xff1000000000UL)) | (num64<<32);
1483 num64 = mxcsr & 0x3f;
1484 tsk->thread.fsr = (tsk->thread.fsr & (~0x3f00000000UL)) | (num64<<32);
1485
1486 for (i = 0; i < 8; i++) {
1487 copy_from_user(num128, &save->xmm_space[0] + 4*i, sizeof(struct _xmmreg_ia32));
1488 memcpy(&(swp->f16) + i*2, &(num128[0]), sizeof(unsigned long));
1489 memcpy(&(swp->f17) + i*2, &(num128[1]), sizeof(unsigned long));
1490 }
1491 return 0;
1492}
1493
680973ed
SL		 1494long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
1495 compat_ulong_t caddr, compat_ulong_t cdata)
1da177e4 1496{
680973ed
SL		 1497 unsigned long addr = caddr;
1498 unsigned long data = cdata;
1499 unsigned int tmp;
1da177e4
LT		 1500 long i, ret;
1501
1da177e4 1502 switch (request) {
1da177e4
LT		 1503 case PTRACE_PEEKUSR: /* read word at addr in USER area */
1504 ret = -EIO;
1505 if ((addr & 3) || addr > 17*sizeof(int))
1506 break;
1507
1508 tmp = getreg(child, addr);
1509 if (!put_user(tmp, (unsigned int __user *) compat_ptr(data)))
1510 ret = 0;
1511 break;
1512
1513 case PTRACE_POKEUSR: /* write word at addr in USER area */
1514 ret = -EIO;
1515 if ((addr & 3) || addr > 17*sizeof(int))
1516 break;
1517
1518 putreg(child, addr, data);
1519 ret = 0;
1520 break;
1521
1522 case IA32_PTRACE_GETREGS:
1523 if (!access_ok(VERIFY_WRITE, compat_ptr(data), 17*sizeof(int))) {
1524 ret = -EIO;
1525 break;
1526 }
1527 for (i = 0; i < (int) (17*sizeof(int)); i += sizeof(int) ) {
1528 put_user(getreg(child, i), (unsigned int __user *) compat_ptr(data));
1529 data += sizeof(int);
1530 }
1531 ret = 0;
1532 break;
1533
1534 case IA32_PTRACE_SETREGS:
1535 if (!access_ok(VERIFY_READ, compat_ptr(data), 17*sizeof(int))) {
1536 ret = -EIO;
1537 break;
1538 }
1539 for (i = 0; i < (int) (17*sizeof(int)); i += sizeof(int) ) {
1540 get_user(tmp, (unsigned int __user *) compat_ptr(data));
1541 putreg(child, i, tmp);
1542 data += sizeof(int);
1543 }
1544 ret = 0;
1545 break;
1546
1547 case IA32_PTRACE_GETFPREGS:
1548 ret = save_ia32_fpstate(child, (struct ia32_user_i387_struct __user *)
1549 compat_ptr(data));
1550 break;
1551
1552 case IA32_PTRACE_GETFPXREGS:
1553 ret = save_ia32_fpxstate(child, (struct ia32_user_fxsr_struct __user *)
1554 compat_ptr(data));
1555 break;
1556
1557 case IA32_PTRACE_SETFPREGS:
1558 ret = restore_ia32_fpstate(child, (struct ia32_user_i387_struct __user *)
1559 compat_ptr(data));
1560 break;
1561
1562 case IA32_PTRACE_SETFPXREGS:
1563 ret = restore_ia32_fpxstate(child, (struct ia32_user_fxsr_struct __user *)
1564 compat_ptr(data));
1565 break;
1566
1da177e4 1567 default:
680973ed 1568 return compat_ptrace_request(child, request, caddr, cdata);
1da177e4 1569 }
1da177e4
LT		 1570 return ret;
1571}
1572
1573typedef struct {
1574 unsigned int ss_sp;
1575 unsigned int ss_flags;
1576 unsigned int ss_size;
1577} ia32_stack_t;
1578
1579asmlinkage long
1580sys32_sigaltstack (ia32_stack_t __user *uss32, ia32_stack_t __user *uoss32,
1581 long arg2, long arg3, long arg4, long arg5, long arg6,
1582 long arg7, struct pt_regs pt)
1583{
1584 stack_t uss, uoss;
1585 ia32_stack_t buf32;
1586 int ret;
1587 mm_segment_t old_fs = get_fs();
1588
1589 if (uss32) {
1590 if (copy_from_user(&buf32, uss32, sizeof(ia32_stack_t)))
1591 return -EFAULT;
1592 uss.ss_sp = (void __user *) (long) buf32.ss_sp;
1593 uss.ss_flags = buf32.ss_flags;
1594 /* MINSIGSTKSZ is different for ia32 vs ia64. We lie here to pass the
1595 check and set it to the user requested value later */
1596 if ((buf32.ss_flags != SS_DISABLE) && (buf32.ss_size < MINSIGSTKSZ_IA32)) {
1597 ret = -ENOMEM;
1598 goto out;
1599 }
1600 uss.ss_size = MINSIGSTKSZ;
1601 }
1602 set_fs(KERNEL_DS);
1603 ret = do_sigaltstack(uss32 ? (stack_t __user *) &uss : NULL,
1604 (stack_t __user *) &uoss, pt.r12);
1605 current->sas_ss_size = buf32.ss_size;
1606 set_fs(old_fs);
1607out:
1608 if (ret < 0)
1609 return(ret);
1610 if (uoss32) {
1611 buf32.ss_sp = (long __user) uoss.ss_sp;
1612 buf32.ss_flags = uoss.ss_flags;
1613 buf32.ss_size = uoss.ss_size;
1614 if (copy_to_user(uoss32, &buf32, sizeof(ia32_stack_t)))
1615 return -EFAULT;
1616 }
1617 return ret;
1618}
1619
1da177e4
LT		 1620asmlinkage int
1621sys32_msync (unsigned int start, unsigned int len, int flags)
1622{
1623 unsigned int addr;
1624
1625 if (OFFSET4K(start))
1626 return -EINVAL;
1627 addr = PAGE_START(start);
1628 return sys_msync(addr, len + (start - addr), flags);
1629}
1630
1631struct sysctl32 {
1632 unsigned int name;
1633 int nlen;
1634 unsigned int oldval;
1635 unsigned int oldlenp;
1636 unsigned int newval;
1637 unsigned int newlen;
1638 unsigned int __unused[4];
1639};
1640
b89a8171 1641#ifdef CONFIG_SYSCTL_SYSCALL
1da177e4
LT		 1642asmlinkage long
1643sys32_sysctl (struct sysctl32 __user *args)
1644{
1645 struct sysctl32 a32;
1646 mm_segment_t old_fs = get_fs ();
1647 void __user *oldvalp, *newvalp;
1648 size_t oldlen;
1649 int __user *namep;
1650 long ret;
1651
1652 if (copy_from_user(&a32, args, sizeof(a32)))
1653 return -EFAULT;
1654
1655 /*
1656 * We need to pre-validate these because we have to disable address checking
1657 * before calling do_sysctl() because of OLDLEN but we can't run the risk of the
1658 * user specifying bad addresses here. Well, since we're dealing with 32 bit
1659 * addresses, we KNOW that access_ok() will always succeed, so this is an
1660 * expensive NOP, but so what...
1661 */
1662 namep = (int __user *) compat_ptr(a32.name);
1663 oldvalp = compat_ptr(a32.oldval);
1664 newvalp = compat_ptr(a32.newval);
1665
1666 if ((oldvalp && get_user(oldlen, (int __user *) compat_ptr(a32.oldlenp)))
1667 || !access_ok(VERIFY_WRITE, namep, 0)
1668 || !access_ok(VERIFY_WRITE, oldvalp, 0)
1669 || !access_ok(VERIFY_WRITE, newvalp, 0))
1670 return -EFAULT;
1671
1672 set_fs(KERNEL_DS);
1673 lock_kernel();
1674 ret = do_sysctl(namep, a32.nlen, oldvalp, (size_t __user *) &oldlen,
1675 newvalp, (size_t) a32.newlen);
1676 unlock_kernel();
1677 set_fs(old_fs);
1678
1679 if (oldvalp && put_user (oldlen, (int __user *) compat_ptr(a32.oldlenp)))
1680 return -EFAULT;
1681
1682 return ret;
1683}
1684#endif
1685
1686asmlinkage long
1687sys32_newuname (struct new_utsname __user *name)
1688{
1689 int ret = sys_newuname(name);
1690
1691 if (!ret)
1692 if (copy_to_user(name->machine, "i686\0\0\0", 8))
1693 ret = -EFAULT;
1694 return ret;
1695}
1696
1697asmlinkage long
1698sys32_getresuid16 (u16 __user *ruid, u16 __user *euid, u16 __user *suid)
1699{
1700 uid_t a, b, c;
1701 int ret;
1702 mm_segment_t old_fs = get_fs();
1703
1704 set_fs(KERNEL_DS);
1705 ret = sys_getresuid((uid_t __user *) &a, (uid_t __user *) &b, (uid_t __user *) &c);
1706 set_fs(old_fs);
1707
1708 if (put_user(a, ruid) || put_user(b, euid) || put_user(c, suid))
1709 return -EFAULT;
1710 return ret;
1711}
1712
1713asmlinkage long
1714sys32_getresgid16 (u16 __user *rgid, u16 __user *egid, u16 __user *sgid)
1715{
1716 gid_t a, b, c;
1717 int ret;
1718 mm_segment_t old_fs = get_fs();
1719
1720 set_fs(KERNEL_DS);
1721 ret = sys_getresgid((gid_t __user *) &a, (gid_t __user *) &b, (gid_t __user *) &c);
1722 set_fs(old_fs);
1723
1724 if (ret)
1725 return ret;
1726
1727 return put_user(a, rgid) | put_user(b, egid) | put_user(c, sgid);
1728}
1729
1730asmlinkage long
1731sys32_lseek (unsigned int fd, int offset, unsigned int whence)
1732{
1733 /* Sign-extension of "offset" is important here... */
1734 return sys_lseek(fd, offset, whence);
1735}
1736
1737static int
1738groups16_to_user(short __user *grouplist, struct group_info *group_info)
1739{
1740 int i;
1741 short group;
1742
1743 for (i = 0; i < group_info->ngroups; i++) {
1744 group = (short)GROUP_AT(group_info, i);
1745 if (put_user(group, grouplist+i))
1746 return -EFAULT;
1747 }
1748
1749 return 0;
1750}
1751
1752static int
1753groups16_from_user(struct group_info *group_info, short __user *grouplist)
1754{
1755 int i;
1756 short group;
1757
1758 for (i = 0; i < group_info->ngroups; i++) {
1759 if (get_user(group, grouplist+i))
1760 return -EFAULT;
1761 GROUP_AT(group_info, i) = (gid_t)group;
1762 }
1763
1764 return 0;
1765}
1766
1767asmlinkage long
1768sys32_getgroups16 (int gidsetsize, short __user *grouplist)
1769{
1770 int i;
1771
1772 if (gidsetsize < 0)
1773 return -EINVAL;
1774
b6dff3ec
DH		 1775 get_group_info(current->cred->group_info);
1776 i = current->cred->group_info->ngroups;
1da177e4
LT		 1777 if (gidsetsize) {
1778 if (i > gidsetsize) {
1779 i = -EINVAL;
1780 goto out;
1781 }
b6dff3ec 1782 if (groups16_to_user(grouplist, current->cred->group_info)) {
1da177e4
LT		 1783 i = -EFAULT;
1784 goto out;
1785 }
1786 }
1787out:
b6dff3ec 1788 put_group_info(current->cred->group_info);
1da177e4
LT		 1789 return i;
1790}
1791
1792asmlinkage long
1793sys32_setgroups16 (int gidsetsize, short __user *grouplist)
1794{
1795 struct group_info *group_info;
1796 int retval;
1797
1798 if (!capable(CAP_SETGID))
1799 return -EPERM;
1800 if ((unsigned)gidsetsize > NGROUPS_MAX)
1801 return -EINVAL;
1802
1803 group_info = groups_alloc(gidsetsize);
1804 if (!group_info)
1805 return -ENOMEM;
1806 retval = groups16_from_user(group_info, grouplist);
1807 if (retval) {
1808 put_group_info(group_info);
1809 return retval;
1810 }
1811
1812 retval = set_current_groups(group_info);
1813 put_group_info(group_info);
1814
1815 return retval;
1816}
1817
1818asmlinkage long
1819sys32_truncate64 (unsigned int path, unsigned int len_lo, unsigned int len_hi)
1820{
1821 return sys_truncate(compat_ptr(path), ((unsigned long) len_hi << 32) | len_lo);
1822}
1823
1824asmlinkage long
1825sys32_ftruncate64 (int fd, unsigned int len_lo, unsigned int len_hi)
1826{
1827 return sys_ftruncate(fd, ((unsigned long) len_hi << 32) | len_lo);
1828}
1829
1830static int
1831putstat64 (struct stat64 __user *ubuf, struct kstat *kbuf)
1832{
1833 int err;
1834 u64 hdev;
1835
1836 if (clear_user(ubuf, sizeof(*ubuf)))
1837 return -EFAULT;
1838
1839 hdev = huge_encode_dev(kbuf->dev);
1840 err = __put_user(hdev, (u32 __user*)&ubuf->st_dev);
1841 err |= __put_user(hdev >> 32, ((u32 __user*)&ubuf->st_dev) + 1);
1842 err |= __put_user(kbuf->ino, &ubuf->__st_ino);
1843 err |= __put_user(kbuf->ino, &ubuf->st_ino_lo);
1844 err |= __put_user(kbuf->ino >> 32, &ubuf->st_ino_hi);
1845 err |= __put_user(kbuf->mode, &ubuf->st_mode);
1846 err |= __put_user(kbuf->nlink, &ubuf->st_nlink);
1847 err |= __put_user(kbuf->uid, &ubuf->st_uid);
1848 err |= __put_user(kbuf->gid, &ubuf->st_gid);
1849 hdev = huge_encode_dev(kbuf->rdev);
1850 err = __put_user(hdev, (u32 __user*)&ubuf->st_rdev);
1851 err |= __put_user(hdev >> 32, ((u32 __user*)&ubuf->st_rdev) + 1);
1852 err |= __put_user(kbuf->size, &ubuf->st_size_lo);
1853 err |= __put_user((kbuf->size >> 32), &ubuf->st_size_hi);
1854 err |= __put_user(kbuf->atime.tv_sec, &ubuf->st_atime);
1855 err |= __put_user(kbuf->atime.tv_nsec, &ubuf->st_atime_nsec);
1856 err |= __put_user(kbuf->mtime.tv_sec, &ubuf->st_mtime);
1857 err |= __put_user(kbuf->mtime.tv_nsec, &ubuf->st_mtime_nsec);
1858 err |= __put_user(kbuf->ctime.tv_sec, &ubuf->st_ctime);
1859 err |= __put_user(kbuf->ctime.tv_nsec, &ubuf->st_ctime_nsec);
1860 err |= __put_user(kbuf->blksize, &ubuf->st_blksize);
1861 err |= __put_user(kbuf->blocks, &ubuf->st_blocks);
1862 return err;
1863}
1864
1865asmlinkage long
1866sys32_stat64 (char __user *filename, struct stat64 __user *statbuf)
1867{
1868 struct kstat s;
1869 long ret = vfs_stat(filename, &s);
1870 if (!ret)
1871 ret = putstat64(statbuf, &s);
1872 return ret;
1873}
1874
1875asmlinkage long
1876sys32_lstat64 (char __user *filename, struct stat64 __user *statbuf)
1877{
1878 struct kstat s;
1879 long ret = vfs_lstat(filename, &s);
1880 if (!ret)
1881 ret = putstat64(statbuf, &s);
1882 return ret;
1883}
1884
1885asmlinkage long
1886sys32_fstat64 (unsigned int fd, struct stat64 __user *statbuf)
1887{
1888 struct kstat s;
1889 long ret = vfs_fstat(fd, &s);
1890 if (!ret)
1891 ret = putstat64(statbuf, &s);
1892 return ret;
1893}
1894
1da177e4
LT		 1895asmlinkage long
1896sys32_sched_rr_get_interval (pid_t pid, struct compat_timespec __user *interval)
1897{
1898 mm_segment_t old_fs = get_fs();
1899 struct timespec t;
1900 long ret;
1901
1902 set_fs(KERNEL_DS);
1903 ret = sys_sched_rr_get_interval(pid, (struct timespec __user *) &t);
1904 set_fs(old_fs);
1905 if (put_compat_timespec(&t, interval))
1906 return -EFAULT;
1907 return ret;
1908}
1909
1910asmlinkage long
1911sys32_pread (unsigned int fd, void __user *buf, unsigned int count, u32 pos_lo, u32 pos_hi)
1912{
1913 return sys_pread64(fd, buf, count, ((unsigned long) pos_hi << 32) | pos_lo);
1914}
1915
1916asmlinkage long
1917sys32_pwrite (unsigned int fd, void __user *buf, unsigned int count, u32 pos_lo, u32 pos_hi)
1918{
1919 return sys_pwrite64(fd, buf, count, ((unsigned long) pos_hi << 32) | pos_lo);
1920}
1921
1922asmlinkage long
1923sys32_sendfile (int out_fd, int in_fd, int __user *offset, unsigned int count)
1924{
1925 mm_segment_t old_fs = get_fs();
1926 long ret;
1927 off_t of;
1928
1929 if (offset && get_user(of, offset))
1930 return -EFAULT;
1931
1932 set_fs(KERNEL_DS);
1933 ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *) &of : NULL, count);
1934 set_fs(old_fs);
1935
83b942bd 1936 if (offset && put_user(of, offset))
1da177e4
LT		 1937 return -EFAULT;
1938
1939 return ret;
1940}
1941
1942asmlinkage long
1943sys32_personality (unsigned int personality)
1944{
1945 long ret;
1946
1947 if (current->personality == PER_LINUX32 && personality == PER_LINUX)
1948 personality = PER_LINUX32;
1949 ret = sys_personality(personality);
1950 if (ret == PER_LINUX32)
1951 ret = PER_LINUX;
1952 return ret;
1953}
1954
1955asmlinkage unsigned long
1956sys32_brk (unsigned int brk)
1957{
1958 unsigned long ret, obrk;
1959 struct mm_struct *mm = current->mm;
1960
1961 obrk = mm->brk;
1962 ret = sys_brk(brk);
1963 if (ret < obrk)
1964 clear_user(compat_ptr(ret), PAGE_ALIGN(ret) - ret);
1965 return ret;
1966}
1967
1da177e4
LT		 1968/* Structure for ia32 emulation on ia64 */
1969struct epoll_event32
1970{
1971 u32 events;
1972 u32 data[2];
1973};
1974
1975asmlinkage long
1976sys32_epoll_ctl(int epfd, int op, int fd, struct epoll_event32 __user *event)
1977{
1978 mm_segment_t old_fs = get_fs();
1979 struct epoll_event event64;
1980 int error;
1981 u32 data_halfword;
1982
1983 if (!access_ok(VERIFY_READ, event, sizeof(struct epoll_event32)))
1984 return -EFAULT;
1985
1986 __get_user(event64.events, &event->events);
1987 __get_user(data_halfword, &event->data[0]);
1988 event64.data = data_halfword;
1989 __get_user(data_halfword, &event->data[1]);
1990 event64.data |= (u64)data_halfword << 32;
1991
1992 set_fs(KERNEL_DS);
1993 error = sys_epoll_ctl(epfd, op, fd, (struct epoll_event __user *) &event64);
1994 set_fs(old_fs);
1995
1996 return error;
1997}
1998
1999asmlinkage long
2000sys32_epoll_wait(int epfd, struct epoll_event32 __user * events, int maxevents,
2001 int timeout)
2002{
2003 struct epoll_event *events64 = NULL;
2004 mm_segment_t old_fs = get_fs();
d8caebd2 2005 int numevents, size;
1da177e4
LT		 2006 int evt_idx;
2007 int do_free_pages = 0;
2008
2009 if (maxevents <= 0) {
2010 return -EINVAL;
2011 }
2012
2013 /* Verify that the area passed by the user is writeable */
2014 if (!access_ok(VERIFY_WRITE, events, maxevents * sizeof(struct epoll_event32)))
2015 return -EFAULT;
2016
2017 /*
2018 * Allocate space for the intermediate copy. If the space needed
2019 * is large enough to cause kmalloc to fail, then try again with
2020 * __get_free_pages.
2021 */
2022 size = maxevents * sizeof(struct epoll_event);
2023 events64 = kmalloc(size, GFP_KERNEL);
2024 if (events64 == NULL) {
2025 events64 = (struct epoll_event *)
2026 __get_free_pages(GFP_KERNEL, get_order(size));
2027 if (events64 == NULL)
2028 return -ENOMEM;
2029 do_free_pages = 1;
2030 }
2031
2032 /* Do the system call */
2033 set_fs(KERNEL_DS); /* copy_to/from_user should work on kernel mem*/
2034 numevents = sys_epoll_wait(epfd, (struct epoll_event __user *) events64,
2035 maxevents, timeout);
2036 set_fs(old_fs);
2037
2038 /* Don't modify userspace memory if we're returning an error */
2039 if (numevents > 0) {
2040 /* Translate the 64-bit structures back into the 32-bit
2041 structures */
2042 for (evt_idx = 0; evt_idx < numevents; evt_idx++) {
2043 __put_user(events64[evt_idx].events,
2044 &events[evt_idx].events);
2045 __put_user((u32)events64[evt_idx].data,
2046 &events[evt_idx].data[0]);
2047 __put_user((u32)(events64[evt_idx].data >> 32),
2048 &events[evt_idx].data[1]);
2049 }
2050 }
2051
2052 if (do_free_pages)
2053 free_pages((unsigned long) events64, get_order(size));
2054 else
2055 kfree(events64);
2056 return numevents;
2057}
2058
2059/*
2060 * Get a yet unused TLS descriptor index.
2061 */
2062static int
2063get_free_idx (void)
2064{
2065 struct thread_struct *t = &current->thread;
2066 int idx;
2067
2068 for (idx = 0; idx < GDT_ENTRY_TLS_ENTRIES; idx++)
2069 if (desc_empty(t->tls_array + idx))
2070 return idx + GDT_ENTRY_TLS_MIN;
2071 return -ESRCH;
2072}
2073
75529219
SL		 2074static void set_tls_desc(struct task_struct *p, int idx,
2075 const struct ia32_user_desc *info, int n)
2076{
2077 struct thread_struct *t = &p->thread;
2078 struct desc_struct *desc = &t->tls_array[idx - GDT_ENTRY_TLS_MIN];
2079 int cpu;
2080
2081 /*
2082 * We must not get preempted while modifying the TLS.
2083 */
2084 cpu = get_cpu();
2085
2086 while (n-- > 0) {
2087 if (LDT_empty(info)) {
2088 desc->a = 0;
2089 desc->b = 0;
2090 } else {
2091 desc->a = LDT_entry_a(info);
2092 desc->b = LDT_entry_b(info);
2093 }
2094
2095 ++info;
2096 ++desc;
2097 }
2098
2099 if (t == &current->thread)
2100 load_TLS(t, cpu);
2101
2102 put_cpu();
2103}
2104
1da177e4
LT		 2105/*
2106 * Set a given TLS descriptor:
2107 */
2108asmlinkage int
2109sys32_set_thread_area (struct ia32_user_desc __user *u_info)
2110{
1da177e4 2111 struct ia32_user_desc info;
75529219 2112 int idx;
1da177e4
LT		 2113
2114 if (copy_from_user(&info, u_info, sizeof(info)))
2115 return -EFAULT;
2116 idx = info.entry_number;
2117
2118 /*
2119 * index -1 means the kernel should try to find and allocate an empty descriptor:
2120 */
2121 if (idx == -1) {
2122 idx = get_free_idx();
2123 if (idx < 0)
2124 return idx;
2125 if (put_user(idx, &u_info->entry_number))
2126 return -EFAULT;
2127 }
2128
2129 if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
2130 return -EINVAL;
2131
75529219 2132 set_tls_desc(current, idx, &info, 1);
1da177e4
LT		 2133 return 0;
2134}
2135
2136/*
2137 * Get the current Thread-Local Storage area:
2138 */
2139
2140#define GET_BASE(desc) ( \
2141 (((desc)->a >> 16) & 0x0000ffff) | \
2142 (((desc)->b << 16) & 0x00ff0000) | \
2143 ( (desc)->b & 0xff000000) )
2144
2145#define GET_LIMIT(desc) ( \
2146 ((desc)->a & 0x0ffff) | \
2147 ((desc)->b & 0xf0000) )
2148
2149#define GET_32BIT(desc) (((desc)->b >> 22) & 1)
2150#define GET_CONTENTS(desc) (((desc)->b >> 10) & 3)
2151#define GET_WRITABLE(desc) (((desc)->b >> 9) & 1)
2152#define GET_LIMIT_PAGES(desc) (((desc)->b >> 23) & 1)
2153#define GET_PRESENT(desc) (((desc)->b >> 15) & 1)
2154#define GET_USEABLE(desc) (((desc)->b >> 20) & 1)
2155
75529219
SL		 2156static void fill_user_desc(struct ia32_user_desc *info, int idx,
2157 const struct desc_struct *desc)
2158{
2159 info->entry_number = idx;
2160 info->base_addr = GET_BASE(desc);
2161 info->limit = GET_LIMIT(desc);
2162 info->seg_32bit = GET_32BIT(desc);
2163 info->contents = GET_CONTENTS(desc);
2164 info->read_exec_only = !GET_WRITABLE(desc);
2165 info->limit_in_pages = GET_LIMIT_PAGES(desc);
2166 info->seg_not_present = !GET_PRESENT(desc);
2167 info->useable = GET_USEABLE(desc);
2168}
2169
1da177e4
LT		 2170asmlinkage int
2171sys32_get_thread_area (struct ia32_user_desc __user *u_info)
2172{
2173 struct ia32_user_desc info;
2174 struct desc_struct *desc;
2175 int idx;
2176
2177 if (get_user(idx, &u_info->entry_number))
2178 return -EFAULT;
2179 if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
2180 return -EINVAL;
2181
2182 desc = current->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;
75529219 2183 fill_user_desc(&info, idx, desc);
1da177e4
LT		 2184
2185 if (copy_to_user(u_info, &info, sizeof(info)))
2186 return -EFAULT;
2187 return 0;
2188}
2189
75529219
SL		 2190struct regset_get {
2191 void *kbuf;
2192 void __user *ubuf;
2193};
2194
2195struct regset_set {
2196 const void *kbuf;
2197 const void __user *ubuf;
2198};
2199
2200struct regset_getset {
2201 struct task_struct *target;
2202 const struct user_regset *regset;
2203 union {
2204 struct regset_get get;
2205 struct regset_set set;
2206 } u;
2207 unsigned int pos;
2208 unsigned int count;
2209 int ret;
2210};
2211
2212static void getfpreg(struct task_struct *task, int regno, int *val)
2213{
2214 switch (regno / sizeof(int)) {
2215 case 0:
2216 *val = task->thread.fcr & 0xffff;
2217 break;
2218 case 1:
2219 *val = task->thread.fsr & 0xffff;
2220 break;
2221 case 2:
2222 *val = (task->thread.fsr>>16) & 0xffff;
2223 break;
2224 case 3:
2225 *val = task->thread.fir;
2226 break;
2227 case 4:
2228 *val = (task->thread.fir>>32) & 0xffff;
2229 break;
2230 case 5:
2231 *val = task->thread.fdr;
2232 break;
2233 case 6:
2234 *val = (task->thread.fdr >> 32) & 0xffff;
2235 break;
2236 }
2237}
2238
2239static void setfpreg(struct task_struct *task, int regno, int val)
2240{
2241 switch (regno / sizeof(int)) {
2242 case 0:
2243 task->thread.fcr = (task->thread.fcr & (~0x1f3f))
2244 | (val & 0x1f3f);
2245 break;
2246 case 1:
2247 task->thread.fsr = (task->thread.fsr & (~0xffff)) | val;
2248 break;
2249 case 2:
2250 task->thread.fsr = (task->thread.fsr & (~0xffff0000))
2251 | (val << 16);
2252 break;
2253 case 3:
2254 task->thread.fir = (task->thread.fir & (~0xffffffff)) | val;
2255 break;
2256 case 5:
2257 task->thread.fdr = (task->thread.fdr & (~0xffffffff)) | val;
2258 break;
2259 }
2260}
2261
2262static void access_fpreg_ia32(int regno, void *reg,
2263 struct pt_regs *pt, struct switch_stack *sw,
2264 int tos, int write)
2265{
2266 void *f;
2267
2268 if ((regno += tos) >= 8)
2269 regno -= 8;
2270 if (regno < 4)
2271 f = &pt->f8 + regno;
2272 else if (regno <= 7)
2273 f = &sw->f12 + (regno - 4);
2274 else {
2275 printk(KERN_ERR "regno must be less than 7 \n");
2276 return;
2277 }
2278
2279 if (write)
2280 memcpy(f, reg, sizeof(struct _fpreg_ia32));
2281 else
2282 memcpy(reg, f, sizeof(struct _fpreg_ia32));
2283}
2284
2285static void do_fpregs_get(struct unw_frame_info *info, void *arg)
2286{
2287 struct regset_getset *dst = arg;
2288 struct task_struct *task = dst->target;
2289 struct pt_regs *pt;
2290 int start, end, tos;
2291 char buf[80];
2292
2293 if (dst->count == 0 || unw_unwind_to_user(info) < 0)
2294 return;
2295 if (dst->pos < 7 * sizeof(int)) {
2296 end = min((dst->pos + dst->count),
2297 (unsigned int)(7 * sizeof(int)));
2298 for (start = dst->pos; start < end; start += sizeof(int))
2299 getfpreg(task, start, (int *)(buf + start));
2300 dst->ret = user_regset_copyout(&dst->pos, &dst->count,
2301 &dst->u.get.kbuf, &dst->u.get.ubuf, buf,
2302 0, 7 * sizeof(int));
2303 if (dst->ret || dst->count == 0)
2304 return;
2305 }
2306 if (dst->pos < sizeof(struct ia32_user_i387_struct)) {
2307 pt = task_pt_regs(task);
2308 tos = (task->thread.fsr >> 11) & 7;
2309 end = min(dst->pos + dst->count,
2310 (unsigned int)(sizeof(struct ia32_user_i387_struct)));
2311 start = (dst->pos - 7 * sizeof(int)) /
2312 sizeof(struct _fpreg_ia32);
2313 end = (end - 7 * sizeof(int)) / sizeof(struct _fpreg_ia32);
2314 for (; start < end; start++)
2315 access_fpreg_ia32(start,
2316 (struct _fpreg_ia32 *)buf + start,
2317 pt, info->sw, tos, 0);
2318 dst->ret = user_regset_copyout(&dst->pos, &dst->count,
2319 &dst->u.get.kbuf, &dst->u.get.ubuf,
2320 buf, 7 * sizeof(int),
2321 sizeof(struct ia32_user_i387_struct));
2322 if (dst->ret || dst->count == 0)
2323 return;
2324 }
2325}
2326
2327static void do_fpregs_set(struct unw_frame_info *info, void *arg)
2328{
2329 struct regset_getset *dst = arg;
2330 struct task_struct *task = dst->target;
2331 struct pt_regs *pt;
2332 char buf[80];
2333 int end, start, tos;
2334
2335 if (dst->count == 0 || unw_unwind_to_user(info) < 0)
2336 return;
2337
2338 if (dst->pos < 7 * sizeof(int)) {
2339 start = dst->pos;
2340 dst->ret = user_regset_copyin(&dst->pos, &dst->count,
2341 &dst->u.set.kbuf, &dst->u.set.ubuf, buf,
2342 0, 7 * sizeof(int));
2343 if (dst->ret)
2344 return;
2345 for (; start < dst->pos; start += sizeof(int))
2346 setfpreg(task, start, *((int *)(buf + start)));
2347 if (dst->count == 0)
2348 return;
2349 }
2350 if (dst->pos < sizeof(struct ia32_user_i387_struct)) {
2351 start = (dst->pos - 7 * sizeof(int)) /
2352 sizeof(struct _fpreg_ia32);
2353 dst->ret = user_regset_copyin(&dst->pos, &dst->count,
2354 &dst->u.set.kbuf, &dst->u.set.ubuf,
2355 buf, 7 * sizeof(int),
2356 sizeof(struct ia32_user_i387_struct));
2357 if (dst->ret)
2358 return;
2359 pt = task_pt_regs(task);
2360 tos = (task->thread.fsr >> 11) & 7;
2361 end = (dst->pos - 7 * sizeof(int)) / sizeof(struct _fpreg_ia32);
2362 for (; start < end; start++)
2363 access_fpreg_ia32(start,
2364 (struct _fpreg_ia32 *)buf + start,
2365 pt, info->sw, tos, 1);
2366 if (dst->count == 0)
2367 return;
2368 }
2369}
2370
2371#define OFFSET(member) ((int)(offsetof(struct ia32_user_fxsr_struct, member)))
2372static void getfpxreg(struct task_struct *task, int start, int end, char *buf)
2373{
2374 int min_val;
2375
2376 min_val = min(end, OFFSET(fop));
2377 while (start < min_val) {
2378 if (start == OFFSET(cwd))
2379 *((short *)buf) = task->thread.fcr & 0xffff;
2380 else if (start == OFFSET(swd))
2381 *((short *)buf) = task->thread.fsr & 0xffff;
2382 else if (start == OFFSET(twd))
2383 *((short *)buf) = (task->thread.fsr>>16) & 0xffff;
2384 buf += 2;
2385 start += 2;
2386 }
2387 /* skip fop element */
2388 if (start == OFFSET(fop)) {
2389 start += 2;
2390 buf += 2;
2391 }
2392 while (start < end) {
2393 if (start == OFFSET(fip))
2394 *((int *)buf) = task->thread.fir;
2395 else if (start == OFFSET(fcs))
2396 *((int *)buf) = (task->thread.fir>>32) & 0xffff;
2397 else if (start == OFFSET(foo))
2398 *((int *)buf) = task->thread.fdr;
2399 else if (start == OFFSET(fos))
2400 *((int *)buf) = (task->thread.fdr>>32) & 0xffff;
2401 else if (start == OFFSET(mxcsr))
2402 *((int *)buf) = ((task->thread.fcr>>32) & 0xff80)
2403 | ((task->thread.fsr>>32) & 0x3f);
2404 buf += 4;
2405 start += 4;
2406 }
2407}
2408
2409static void setfpxreg(struct task_struct *task, int start, int end, char *buf)
2410{
2411 int min_val, num32;
2412 short num;
2413 unsigned long num64;
2414
2415 min_val = min(end, OFFSET(fop));
2416 while (start < min_val) {
2417 num = *((short *)buf);
2418 if (start == OFFSET(cwd)) {
2419 task->thread.fcr = (task->thread.fcr & (~0x1f3f))
2420 | (num & 0x1f3f);
2421 } else if (start == OFFSET(swd)) {
2422 task->thread.fsr = (task->thread.fsr & (~0xffff)) | num;
2423 } else if (start == OFFSET(twd)) {
2424 task->thread.fsr = (task->thread.fsr & (~0xffff0000))
2425 | (((int)num) << 16);
2426 }
2427 buf += 2;
2428 start += 2;
2429 }
2430 /* skip fop element */
2431 if (start == OFFSET(fop)) {
2432 start += 2;
2433 buf += 2;
2434 }
2435 while (start < end) {
2436 num32 = *((int *)buf);
2437 if (start == OFFSET(fip))
2438 task->thread.fir = (task->thread.fir & (~0xffffffff))
2439 | num32;
2440 else if (start == OFFSET(foo))
2441 task->thread.fdr = (task->thread.fdr & (~0xffffffff))
2442 | num32;
2443 else if (start == OFFSET(mxcsr)) {
2444 num64 = num32 & 0xff10;
2445 task->thread.fcr = (task->thread.fcr &
2446 (~0xff1000000000UL)) | (num64<<32);
2447 num64 = num32 & 0x3f;
2448 task->thread.fsr = (task->thread.fsr &
2449 (~0x3f00000000UL)) | (num64<<32);
2450 }
2451 buf += 4;
2452 start += 4;
2453 }
2454}
2455
2456static void do_fpxregs_get(struct unw_frame_info *info, void *arg)
2457{
2458 struct regset_getset *dst = arg;
2459 struct task_struct *task = dst->target;
2460 struct pt_regs *pt;
2461 char buf[128];
2462 int start, end, tos;
2463
2464 if (dst->count == 0 || unw_unwind_to_user(info) < 0)
2465 return;
2466 if (dst->pos < OFFSET(st_space[0])) {
2467 end = min(dst->pos + dst->count, (unsigned int)32);
2468 getfpxreg(task, dst->pos, end, buf);
2469 dst->ret = user_regset_copyout(&dst->pos, &dst->count,
2470 &dst->u.get.kbuf, &dst->u.get.ubuf, buf,
2471 0, OFFSET(st_space[0]));
2472 if (dst->ret || dst->count == 0)
2473 return;
2474 }
2475 if (dst->pos < OFFSET(xmm_space[0])) {
2476 pt = task_pt_regs(task);
2477 tos = (task->thread.fsr >> 11) & 7;
2478 end = min(dst->pos + dst->count,
2479 (unsigned int)OFFSET(xmm_space[0]));
2480 start = (dst->pos - OFFSET(st_space[0])) / 16;
2481 end = (end - OFFSET(st_space[0])) / 16;
2482 for (; start < end; start++)
2483 access_fpreg_ia32(start, buf + 16 * start, pt,
2484 info->sw, tos, 0);
2485 dst->ret = user_regset_copyout(&dst->pos, &dst->count,
2486 &dst->u.get.kbuf, &dst->u.get.ubuf,
2487 buf, OFFSET(st_space[0]), OFFSET(xmm_space[0]));
2488 if (dst->ret || dst->count == 0)
2489 return;
2490 }
2491 if (dst->pos < OFFSET(padding[0]))
2492 dst->ret = user_regset_copyout(&dst->pos, &dst->count,
2493 &dst->u.get.kbuf, &dst->u.get.ubuf,
2494 &info->sw->f16, OFFSET(xmm_space[0]),
2495 OFFSET(padding[0]));
2496}
2497
2498static void do_fpxregs_set(struct unw_frame_info *info, void *arg)
2499{
2500 struct regset_getset *dst = arg;
2501 struct task_struct *task = dst->target;
2502 char buf[128];
2503 int start, end;
2504
2505 if (dst->count == 0 || unw_unwind_to_user(info) < 0)
2506 return;
2507
2508 if (dst->pos < OFFSET(st_space[0])) {
2509 start = dst->pos;
2510 dst->ret = user_regset_copyin(&dst->pos, &dst->count,
2511 &dst->u.set.kbuf, &dst->u.set.ubuf,
2512 buf, 0, OFFSET(st_space[0]));
2513 if (dst->ret)
2514 return;
2515 setfpxreg(task, start, dst->pos, buf);
2516 if (dst->count == 0)
2517 return;
2518 }
2519 if (dst->pos < OFFSET(xmm_space[0])) {
2520 struct pt_regs *pt;
2521 int tos;
2522 pt = task_pt_regs(task);
2523 tos = (task->thread.fsr >> 11) & 7;
2524 start = (dst->pos - OFFSET(st_space[0])) / 16;
2525 dst->ret = user_regset_copyin(&dst->pos, &dst->count,
2526 &dst->u.set.kbuf, &dst->u.set.ubuf,
2527 buf, OFFSET(st_space[0]), OFFSET(xmm_space[0]));
2528 if (dst->ret)
2529 return;
2530 end = (dst->pos - OFFSET(st_space[0])) / 16;
2531 for (; start < end; start++)
2532 access_fpreg_ia32(start, buf + 16 * start, pt, info->sw,
2533 tos, 1);
2534 if (dst->count == 0)
2535 return;
2536 }
2537 if (dst->pos < OFFSET(padding[0]))
2538 dst->ret = user_regset_copyin(&dst->pos, &dst->count,
2539 &dst->u.set.kbuf, &dst->u.set.ubuf,
2540 &info->sw->f16, OFFSET(xmm_space[0]),
2541 OFFSET(padding[0]));
2542}
2543#undef OFFSET
2544
2545static int do_regset_call(void (*call)(struct unw_frame_info *, void *),
2546 struct task_struct *target,
2547 const struct user_regset *regset,
2548 unsigned int pos, unsigned int count,
2549 const void *kbuf, const void __user *ubuf)
2550{
2551 struct regset_getset info = { .target = target, .regset = regset,
2552 .pos = pos, .count = count,
2553 .u.set = { .kbuf = kbuf, .ubuf = ubuf },
2554 .ret = 0 };
2555
2556 if (target == current)
2557 unw_init_running(call, &info);
2558 else {
2559 struct unw_frame_info ufi;
2560 memset(&ufi, 0, sizeof(ufi));
2561 unw_init_from_blocked_task(&ufi, target);
2562 (*call)(&ufi, &info);
2563 }
2564
2565 return info.ret;
2566}
2567
2568static int ia32_fpregs_get(struct task_struct *target,
2569 const struct user_regset *regset,
2570 unsigned int pos, unsigned int count,
2571 void *kbuf, void __user *ubuf)
2572{
2573 return do_regset_call(do_fpregs_get, target, regset, pos, count,
2574 kbuf, ubuf);
2575}
2576
2577static int ia32_fpregs_set(struct task_struct *target,
2578 const struct user_regset *regset,
2579 unsigned int pos, unsigned int count,
2580 const void *kbuf, const void __user *ubuf)
2581{
2582 return do_regset_call(do_fpregs_set, target, regset, pos, count,
2583 kbuf, ubuf);
2584}
2585
2586static int ia32_fpxregs_get(struct task_struct *target,
2587 const struct user_regset *regset,
2588 unsigned int pos, unsigned int count,
2589 void *kbuf, void __user *ubuf)
2590{
2591 return do_regset_call(do_fpxregs_get, target, regset, pos, count,
2592 kbuf, ubuf);
2593}
2594
2595static int ia32_fpxregs_set(struct task_struct *target,
2596 const struct user_regset *regset,
2597 unsigned int pos, unsigned int count,
2598 const void *kbuf, const void __user *ubuf)
2599{
2600 return do_regset_call(do_fpxregs_set, target, regset, pos, count,
2601 kbuf, ubuf);
2602}
2603
2604static int ia32_genregs_get(struct task_struct *target,
2605 const struct user_regset *regset,
2606 unsigned int pos, unsigned int count,
2607 void *kbuf, void __user *ubuf)
2608{
2609 if (kbuf) {
2610 u32 *kp = kbuf;
2611 while (count > 0) {
2612 *kp++ = getreg(target, pos);
2613 pos += 4;
2614 count -= 4;
2615 }
2616 } else {
2617 u32 __user *up = ubuf;
2618 while (count > 0) {
2619 if (__put_user(getreg(target, pos), up++))
2620 return -EFAULT;
2621 pos += 4;
2622 count -= 4;
2623 }
2624 }
2625 return 0;
2626}
2627
2628static int ia32_genregs_set(struct task_struct *target,
2629 const struct user_regset *regset,
2630 unsigned int pos, unsigned int count,
2631 const void *kbuf, const void __user *ubuf)
2632{
2633 int ret = 0;
2634
2635 if (kbuf) {
2636 const u32 *kp = kbuf;
2637 while (!ret && count > 0) {
2638 putreg(target, pos, *kp++);
2639 pos += 4;
2640 count -= 4;
2641 }
2642 } else {
2643 const u32 __user *up = ubuf;
2644 u32 val;
2645 while (!ret && count > 0) {
2646 ret = __get_user(val, up++);
2647 if (!ret)
2648 putreg(target, pos, val);
2649 pos += 4;
2650 count -= 4;
2651 }
2652 }
2653 return ret;
2654}
2655
2656static int ia32_tls_active(struct task_struct *target,
2657 const struct user_regset *regset)
2658{
2659 struct thread_struct *t = &target->thread;
2660 int n = GDT_ENTRY_TLS_ENTRIES;
2661 while (n > 0 && desc_empty(&t->tls_array[n -1]))
2662 --n;
2663 return n;
2664}
2665
2666static int ia32_tls_get(struct task_struct *target,
2667 const struct user_regset *regset, unsigned int pos,
2668 unsigned int count, void *kbuf, void __user *ubuf)
2669{
2670 const struct desc_struct *tls;
2671
2672 if (pos > GDT_ENTRY_TLS_ENTRIES * sizeof(struct ia32_user_desc) ||
2673 (pos % sizeof(struct ia32_user_desc)) != 0 ||
2674 (count % sizeof(struct ia32_user_desc)) != 0)
2675 return -EINVAL;
2676
2677 pos /= sizeof(struct ia32_user_desc);
2678 count /= sizeof(struct ia32_user_desc);
2679
2680 tls = &target->thread.tls_array[pos];
2681
2682 if (kbuf) {
2683 struct ia32_user_desc *info = kbuf;
2684 while (count-- > 0)
2685 fill_user_desc(info++, GDT_ENTRY_TLS_MIN + pos++,
2686 tls++);
2687 } else {
2688 struct ia32_user_desc __user *u_info = ubuf;
2689 while (count-- > 0) {
2690 struct ia32_user_desc info;
2691 fill_user_desc(&info, GDT_ENTRY_TLS_MIN + pos++, tls++);
2692 if (__copy_to_user(u_info++, &info, sizeof(info)))
2693 return -EFAULT;
2694 }
2695 }
2696
2697 return 0;
2698}
2699
2700static int ia32_tls_set(struct task_struct *target,
2701 const struct user_regset *regset, unsigned int pos,
2702 unsigned int count, const void *kbuf, const void __user *ubuf)
2703{
2704 struct ia32_user_desc infobuf[GDT_ENTRY_TLS_ENTRIES];
2705 const struct ia32_user_desc *info;
2706
2707 if (pos > GDT_ENTRY_TLS_ENTRIES * sizeof(struct ia32_user_desc) ||
2708 (pos % sizeof(struct ia32_user_desc)) != 0 ||
2709 (count % sizeof(struct ia32_user_desc)) != 0)
2710 return -EINVAL;
2711
2712 if (kbuf)
2713 info = kbuf;
2714 else if (__copy_from_user(infobuf, ubuf, count))
2715 return -EFAULT;
2716 else
2717 info = infobuf;
2718
2719 set_tls_desc(target,
2720 GDT_ENTRY_TLS_MIN + (pos / sizeof(struct ia32_user_desc)),
2721 info, count / sizeof(struct ia32_user_desc));
2722
2723 return 0;
2724}
2725
2726/*
2727 * This should match arch/i386/kernel/ptrace.c:native_regsets.
2728 * XXX ioperm? vm86?
2729 */
2730static const struct user_regset ia32_regsets[] = {
2731 {
2732 .core_note_type = NT_PRSTATUS,
2733 .n = sizeof(struct user_regs_struct32)/4,
2734 .size = 4, .align = 4,
2735 .get = ia32_genregs_get, .set = ia32_genregs_set
2736 },
2737 {
2738 .core_note_type = NT_PRFPREG,
2739 .n = sizeof(struct ia32_user_i387_struct) / 4,
2740 .size = 4, .align = 4,
2741 .get = ia32_fpregs_get, .set = ia32_fpregs_set
2742 },
2743 {
2744 .core_note_type = NT_PRXFPREG,
2745 .n = sizeof(struct ia32_user_fxsr_struct) / 4,
2746 .size = 4, .align = 4,
2747 .get = ia32_fpxregs_get, .set = ia32_fpxregs_set
2748 },
2749 {
2750 .core_note_type = NT_386_TLS,
2751 .n = GDT_ENTRY_TLS_ENTRIES,
2752 .bias = GDT_ENTRY_TLS_MIN,
2753 .size = sizeof(struct ia32_user_desc),
2754 .align = sizeof(struct ia32_user_desc),
2755 .active = ia32_tls_active,
2756 .get = ia32_tls_get, .set = ia32_tls_set,
2757 },
2758};
2759
2760const struct user_regset_view user_ia32_view = {
2761 .name = "i386", .e_machine = EM_386,
2762 .regsets = ia32_regsets, .n = ARRAY_SIZE(ia32_regsets)
2763};
2764
1da177e4
LT		 2765long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high,
2766 __u32 len_low, __u32 len_high, int advice)
2767{
2768 return sys_fadvise64_64(fd,
2769 (((u64)offset_high)<<32) | offset_low,
2770 (((u64)len_high)<<32) | len_low,
2771 advice);
2772}
2773
2774#ifdef NOTYET /* UNTESTED FOR IA64 FROM HERE DOWN */
2775
2776asmlinkage long sys32_setreuid(compat_uid_t ruid, compat_uid_t euid)
2777{
2778 uid_t sruid, seuid;
2779
2780 sruid = (ruid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)ruid);
2781 seuid = (euid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)euid);
2782 return sys_setreuid(sruid, seuid);
2783}
2784
2785asmlinkage long
2786sys32_setresuid(compat_uid_t ruid, compat_uid_t euid,
2787 compat_uid_t suid)
2788{
2789 uid_t sruid, seuid, ssuid;
2790
2791 sruid = (ruid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)ruid);
2792 seuid = (euid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)euid);
2793 ssuid = (suid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)suid);
2794 return sys_setresuid(sruid, seuid, ssuid);
2795}
2796
2797asmlinkage long
2798sys32_setregid(compat_gid_t rgid, compat_gid_t egid)
2799{
2800 gid_t srgid, segid;
2801
2802 srgid = (rgid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)rgid);
2803 segid = (egid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)egid);
2804 return sys_setregid(srgid, segid);
2805}
2806
2807asmlinkage long
2808sys32_setresgid(compat_gid_t rgid, compat_gid_t egid,
2809 compat_gid_t sgid)
2810{
2811 gid_t srgid, segid, ssgid;
2812
2813 srgid = (rgid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)rgid);
2814 segid = (egid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)egid);
2815 ssgid = (sgid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)sgid);
2816 return sys_setresgid(srgid, segid, ssgid);
2817}
1da177e4 2818#endif /* NOTYET */
Linux 6.x block layer and io_uring tree(s)