2 * sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Derived from sys_sparc32.c.
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>
13 * These routines maintain argument size conversion between 32bit and 64bit
17 #include <linux/kernel.h>
18 #include <linux/syscalls.h>
19 #include <linux/sysctl.h>
20 #include <linux/sched.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>
27 #include <linux/smp.h>
28 #include <linux/smp_lock.h>
29 #include <linux/sem.h>
30 #include <linux/msg.h>
32 #include <linux/shm.h>
33 #include <linux/slab.h>
34 #include <linux/uio.h>
35 #include <linux/nfs_fs.h>
36 #include <linux/quota.h>
37 #include <linux/syscalls.h>
38 #include <linux/sunrpc/svc.h>
39 #include <linux/nfsd/nfsd.h>
40 #include <linux/nfsd/cache.h>
41 #include <linux/nfsd/xdr.h>
42 #include <linux/nfsd/syscall.h>
43 #include <linux/poll.h>
44 #include <linux/eventpoll.h>
45 #include <linux/personality.h>
46 #include <linux/ptrace.h>
47 #include <linux/tracehook.h>
48 #include <linux/stat.h>
49 #include <linux/ipc.h>
50 #include <linux/capability.h>
51 #include <linux/compat.h>
52 #include <linux/vfs.h>
53 #include <linux/mman.h>
54 #include <linux/mutex.h>
56 #include <asm/intrinsics.h>
57 #include <asm/types.h>
58 #include <asm/uaccess.h>
59 #include <asm/unistd.h>
69 # define DBG(fmt...) printk(KERN_DEBUG fmt)
74 #define ROUND_UP(x,a) ((__typeof__(x))(((unsigned long)(x) + ((a) - 1)) & ~((a) - 1)))
76 #define OFFSET4K(a) ((a) & 0xfff)
77 #define PAGE_START(addr) ((addr) & PAGE_MASK)
78 #define MINSIGSTKSZ_IA32 2048
80 #define high2lowuid(uid) ((uid) > 65535 ? 65534 : (uid))
81 #define high2lowgid(gid) ((gid) > 65535 ? 65534 : (gid))
84 * Anything that modifies or inspects ia32 user virtual memory must hold this semaphore
87 /* XXX make per-mm: */
88 static DEFINE_MUTEX(ia32_mmap_mutex);
91 sys32_execve (char __user *name, compat_uptr_t __user *argv, compat_uptr_t __user *envp,
96 unsigned long old_map_base, old_task_size, tssd;
98 filename = getname(name);
99 error = PTR_ERR(filename);
100 if (IS_ERR(filename))
103 old_map_base = current->thread.map_base;
104 old_task_size = current->thread.task_size;
105 tssd = ia64_get_kr(IA64_KR_TSSD);
107 /* we may be exec'ing a 64-bit process: reset map base, task-size, and io-base: */
108 current->thread.map_base = DEFAULT_MAP_BASE;
109 current->thread.task_size = DEFAULT_TASK_SIZE;
110 ia64_set_kr(IA64_KR_IO_BASE, current->thread.old_iob);
111 ia64_set_kr(IA64_KR_TSSD, current->thread.old_k1);
113 error = compat_do_execve(filename, argv, envp, regs);
117 /* oops, execve failed, switch back to old values... */
118 ia64_set_kr(IA64_KR_IO_BASE, IA32_IOBASE);
119 ia64_set_kr(IA64_KR_TSSD, tssd);
120 current->thread.map_base = old_map_base;
121 current->thread.task_size = old_task_size;
127 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *ubuf)
132 if ((u64) stat->size > MAX_NON_LFS ||
133 !old_valid_dev(stat->dev) ||
134 !old_valid_dev(stat->rdev))
138 if (sizeof(ino) < sizeof(stat->ino) && ino != stat->ino)
141 if (clear_user(ubuf, sizeof(*ubuf)))
144 err = __put_user(old_encode_dev(stat->dev), &ubuf->st_dev);
145 err |= __put_user(ino, &ubuf->st_ino);
146 err |= __put_user(stat->mode, &ubuf->st_mode);
147 err |= __put_user(stat->nlink, &ubuf->st_nlink);
148 err |= __put_user(high2lowuid(stat->uid), &ubuf->st_uid);
149 err |= __put_user(high2lowgid(stat->gid), &ubuf->st_gid);
150 err |= __put_user(old_encode_dev(stat->rdev), &ubuf->st_rdev);
151 err |= __put_user(stat->size, &ubuf->st_size);
152 err |= __put_user(stat->atime.tv_sec, &ubuf->st_atime);
153 err |= __put_user(stat->atime.tv_nsec, &ubuf->st_atime_nsec);
154 err |= __put_user(stat->mtime.tv_sec, &ubuf->st_mtime);
155 err |= __put_user(stat->mtime.tv_nsec, &ubuf->st_mtime_nsec);
156 err |= __put_user(stat->ctime.tv_sec, &ubuf->st_ctime);
157 err |= __put_user(stat->ctime.tv_nsec, &ubuf->st_ctime_nsec);
158 err |= __put_user(stat->blksize, &ubuf->st_blksize);
159 err |= __put_user(stat->blocks, &ubuf->st_blocks);
163 #if PAGE_SHIFT > IA32_PAGE_SHIFT
167 get_page_prot (struct vm_area_struct *vma, unsigned long addr)
171 if (!vma || vma->vm_start > addr)
174 if (vma->vm_flags & VM_READ)
176 if (vma->vm_flags & VM_WRITE)
178 if (vma->vm_flags & VM_EXEC)
184 * Map a subpage by creating an anonymous page that contains the union of the old page and
188 mmap_subpage (struct file *file, unsigned long start, unsigned long end, int prot, int flags,
193 unsigned long ret = 0;
194 struct vm_area_struct *vma = find_vma(current->mm, start);
195 int old_prot = get_page_prot(vma, start);
197 DBG("mmap_subpage(file=%p,start=0x%lx,end=0x%lx,prot=%x,flags=%x,off=0x%llx)\n",
198 file, start, end, prot, flags, off);
201 /* Optimize the case where the old mmap and the new mmap are both anonymous */
202 if ((old_prot & PROT_WRITE) && (flags & MAP_ANONYMOUS) && !vma->vm_file) {
203 if (clear_user((void __user *) start, end - start)) {
210 page = (void *) get_zeroed_page(GFP_KERNEL);
215 copy_from_user(page, (void __user *) PAGE_START(start), PAGE_SIZE);
217 down_write(¤t->mm->mmap_sem);
219 ret = do_mmap(NULL, PAGE_START(start), PAGE_SIZE, prot | PROT_WRITE,
220 flags | MAP_FIXED | MAP_ANONYMOUS, 0);
222 up_write(¤t->mm->mmap_sem);
224 if (IS_ERR((void *) ret))
228 /* copy back the old page contents. */
229 if (offset_in_page(start))
230 copy_to_user((void __user *) PAGE_START(start), page,
231 offset_in_page(start));
232 if (offset_in_page(end))
233 copy_to_user((void __user *) end, page + offset_in_page(end),
234 PAGE_SIZE - offset_in_page(end));
237 if (!(flags & MAP_ANONYMOUS)) {
238 /* read the file contents */
239 inode = file->f_path.dentry->d_inode;
240 if (!inode->i_fop || !file->f_op->read
241 || ((*file->f_op->read)(file, (char __user *) start, end - start, &off) < 0))
249 if (!(prot & PROT_WRITE))
250 ret = sys_mprotect(PAGE_START(start), PAGE_SIZE, prot | old_prot);
253 free_page((unsigned long) page);
257 /* SLAB cache for partial_page structures */
258 struct kmem_cache *partial_page_cachep;
261 * init partial_page_list.
262 * return 0 means kmalloc fail.
264 struct partial_page_list*
265 ia32_init_pp_list(void)
267 struct partial_page_list *p;
269 if ((p = kmalloc(sizeof(*p), GFP_KERNEL)) == NULL)
274 atomic_set(&p->pp_count, 1);
279 * Search for the partial page with @start in partial page list @ppl.
280 * If finds the partial page, return the found partial page.
281 * Else, return 0 and provide @pprev, @rb_link, @rb_parent to
282 * be used by later __ia32_insert_pp().
284 static struct partial_page *
285 __ia32_find_pp(struct partial_page_list *ppl, unsigned int start,
286 struct partial_page **pprev, struct rb_node ***rb_link,
287 struct rb_node **rb_parent)
289 struct partial_page *pp;
290 struct rb_node **__rb_link, *__rb_parent, *rb_prev;
293 if (pp && pp->base == start)
296 __rb_link = &ppl->ppl_rb.rb_node;
297 rb_prev = __rb_parent = NULL;
300 __rb_parent = *__rb_link;
301 pp = rb_entry(__rb_parent, struct partial_page, pp_rb);
303 if (pp->base == start) {
306 } else if (pp->base < start) {
307 rb_prev = __rb_parent;
308 __rb_link = &__rb_parent->rb_right;
310 __rb_link = &__rb_parent->rb_left;
314 *rb_link = __rb_link;
315 *rb_parent = __rb_parent;
318 *pprev = rb_entry(rb_prev, struct partial_page, pp_rb);
323 * insert @pp into @ppl.
326 __ia32_insert_pp(struct partial_page_list *ppl, struct partial_page *pp,
327 struct partial_page *prev, struct rb_node **rb_link,
328 struct rb_node *rb_parent)
332 pp->next = prev->next;
337 pp->next = rb_entry(rb_parent,
338 struct partial_page, pp_rb);
344 rb_link_node(&pp->pp_rb, rb_parent, rb_link);
345 rb_insert_color(&pp->pp_rb, &ppl->ppl_rb);
351 * delete @pp from partial page list @ppl.
354 __ia32_delete_pp(struct partial_page_list *ppl, struct partial_page *pp,
355 struct partial_page *prev)
358 prev->next = pp->next;
359 if (ppl->pp_hint == pp)
362 ppl->pp_head = pp->next;
363 if (ppl->pp_hint == pp)
364 ppl->pp_hint = pp->next;
366 rb_erase(&pp->pp_rb, &ppl->ppl_rb);
367 kmem_cache_free(partial_page_cachep, pp);
370 static struct partial_page *
371 __pp_prev(struct partial_page *pp)
373 struct rb_node *prev = rb_prev(&pp->pp_rb);
375 return rb_entry(prev, struct partial_page, pp_rb);
381 * Delete partial pages with address between @start and @end.
382 * @start and @end are page aligned.
385 __ia32_delete_pp_range(unsigned int start, unsigned int end)
387 struct partial_page *pp, *prev;
388 struct rb_node **rb_link, *rb_parent;
393 pp = __ia32_find_pp(current->thread.ppl, start, &prev,
394 &rb_link, &rb_parent);
396 prev = __pp_prev(pp);
401 pp = current->thread.ppl->pp_head;
404 while (pp && pp->base < end) {
405 struct partial_page *tmp = pp->next;
406 __ia32_delete_pp(current->thread.ppl, pp, prev);
412 * Set the range between @start and @end in bitmap.
413 * @start and @end should be IA32 page aligned and in the same IA64 page.
416 __ia32_set_pp(unsigned int start, unsigned int end, int flags)
418 struct partial_page *pp, *prev;
419 struct rb_node ** rb_link, *rb_parent;
420 unsigned int pstart, start_bit, end_bit, i;
422 pstart = PAGE_START(start);
423 start_bit = (start % PAGE_SIZE) / IA32_PAGE_SIZE;
424 end_bit = (end % PAGE_SIZE) / IA32_PAGE_SIZE;
426 end_bit = PAGE_SIZE / IA32_PAGE_SIZE;
427 pp = __ia32_find_pp(current->thread.ppl, pstart, &prev,
428 &rb_link, &rb_parent);
430 for (i = start_bit; i < end_bit; i++)
431 set_bit(i, &pp->bitmap);
433 * Check: if this partial page has been set to a full page,
436 if (find_first_zero_bit(&pp->bitmap, sizeof(pp->bitmap)*8) >=
437 PAGE_SIZE/IA32_PAGE_SIZE) {
438 __ia32_delete_pp(current->thread.ppl, pp, __pp_prev(pp));
444 * MAP_FIXED may lead to overlapping mmap.
445 * In this case, the requested mmap area may already mmaped as a full
446 * page. So check vma before adding a new partial page.
448 if (flags & MAP_FIXED) {
449 struct vm_area_struct *vma = find_vma(current->mm, pstart);
450 if (vma && vma->vm_start <= pstart)
454 /* new a partial_page */
455 pp = kmem_cache_alloc(partial_page_cachep, GFP_KERNEL);
460 for (i=start_bit; i<end_bit; i++)
461 set_bit(i, &(pp->bitmap));
463 __ia32_insert_pp(current->thread.ppl, pp, prev, rb_link, rb_parent);
468 * @start and @end should be IA32 page aligned, but don't need to be in the
469 * same IA64 page. Split @start and @end to make sure they're in the same IA64
470 * page, then call __ia32_set_pp().
473 ia32_set_pp(unsigned int start, unsigned int end, int flags)
475 down_write(¤t->mm->mmap_sem);
476 if (flags & MAP_FIXED) {
478 * MAP_FIXED may lead to overlapping mmap. When this happens,
479 * a series of complete IA64 pages results in deletion of
480 * old partial pages in that range.
482 __ia32_delete_pp_range(PAGE_ALIGN(start), PAGE_START(end));
485 if (end < PAGE_ALIGN(start)) {
486 __ia32_set_pp(start, end, flags);
488 if (offset_in_page(start))
489 __ia32_set_pp(start, PAGE_ALIGN(start), flags);
490 if (offset_in_page(end))
491 __ia32_set_pp(PAGE_START(end), end, flags);
493 up_write(¤t->mm->mmap_sem);
497 * Unset the range between @start and @end in bitmap.
498 * @start and @end should be IA32 page aligned and in the same IA64 page.
499 * After doing that, if the bitmap is 0, then free the page and return 1,
501 * If not find the partial page in the list, then
502 * If the vma exists, then the full page is set to a partial page;
503 * Else return -ENOMEM.
506 __ia32_unset_pp(unsigned int start, unsigned int end)
508 struct partial_page *pp, *prev;
509 struct rb_node ** rb_link, *rb_parent;
510 unsigned int pstart, start_bit, end_bit, i;
511 struct vm_area_struct *vma;
513 pstart = PAGE_START(start);
514 start_bit = (start % PAGE_SIZE) / IA32_PAGE_SIZE;
515 end_bit = (end % PAGE_SIZE) / IA32_PAGE_SIZE;
517 end_bit = PAGE_SIZE / IA32_PAGE_SIZE;
519 pp = __ia32_find_pp(current->thread.ppl, pstart, &prev,
520 &rb_link, &rb_parent);
522 for (i = start_bit; i < end_bit; i++)
523 clear_bit(i, &pp->bitmap);
524 if (pp->bitmap == 0) {
525 __ia32_delete_pp(current->thread.ppl, pp, __pp_prev(pp));
531 vma = find_vma(current->mm, pstart);
532 if (!vma || vma->vm_start > pstart) {
536 /* new a partial_page */
537 pp = kmem_cache_alloc(partial_page_cachep, GFP_KERNEL);
542 for (i = 0; i < start_bit; i++)
543 set_bit(i, &(pp->bitmap));
544 for (i = end_bit; i < PAGE_SIZE / IA32_PAGE_SIZE; i++)
545 set_bit(i, &(pp->bitmap));
547 __ia32_insert_pp(current->thread.ppl, pp, prev, rb_link, rb_parent);
552 * Delete pp between PAGE_ALIGN(start) and PAGE_START(end) by calling
553 * __ia32_delete_pp_range(). Unset possible partial pages by calling
555 * The returned value see __ia32_unset_pp().
558 ia32_unset_pp(unsigned int *startp, unsigned int *endp)
560 unsigned int start = *startp, end = *endp;
563 down_write(¤t->mm->mmap_sem);
565 __ia32_delete_pp_range(PAGE_ALIGN(start), PAGE_START(end));
567 if (end < PAGE_ALIGN(start)) {
568 ret = __ia32_unset_pp(start, end);
570 *startp = PAGE_START(start);
571 *endp = PAGE_ALIGN(end);
574 /* to shortcut sys_munmap() in sys32_munmap() */
575 *startp = PAGE_START(start);
576 *endp = PAGE_START(end);
579 if (offset_in_page(start)) {
580 ret = __ia32_unset_pp(start, PAGE_ALIGN(start));
582 *startp = PAGE_START(start);
584 *startp = PAGE_ALIGN(start);
588 if (offset_in_page(end)) {
589 ret = __ia32_unset_pp(PAGE_START(end), end);
591 *endp = PAGE_ALIGN(end);
593 *endp = PAGE_START(end);
598 up_write(¤t->mm->mmap_sem);
603 * Compare the range between @start and @end with bitmap in partial page.
604 * @start and @end should be IA32 page aligned and in the same IA64 page.
607 __ia32_compare_pp(unsigned int start, unsigned int end)
609 struct partial_page *pp, *prev;
610 struct rb_node ** rb_link, *rb_parent;
611 unsigned int pstart, start_bit, end_bit, size;
612 unsigned int first_bit, next_zero_bit; /* the first range in bitmap */
614 pstart = PAGE_START(start);
616 pp = __ia32_find_pp(current->thread.ppl, pstart, &prev,
617 &rb_link, &rb_parent);
621 start_bit = (start % PAGE_SIZE) / IA32_PAGE_SIZE;
622 end_bit = (end % PAGE_SIZE) / IA32_PAGE_SIZE;
623 size = sizeof(pp->bitmap) * 8;
624 first_bit = find_first_bit(&pp->bitmap, size);
625 next_zero_bit = find_next_zero_bit(&pp->bitmap, size, first_bit);
626 if ((start_bit < first_bit) || (end_bit > next_zero_bit)) {
627 /* exceeds the first range in bitmap */
629 } else if ((start_bit == first_bit) && (end_bit == next_zero_bit)) {
630 first_bit = find_next_bit(&pp->bitmap, size, next_zero_bit);
631 if ((next_zero_bit < first_bit) && (first_bit < size))
632 return 1; /* has next range */
634 return 0; /* no next range */
640 * @start and @end should be IA32 page aligned, but don't need to be in the
641 * same IA64 page. Split @start and @end to make sure they're in the same IA64
642 * page, then call __ia32_compare_pp().
644 * Take this as example: the range is the 1st and 2nd 4K page.
645 * Return 0 if they fit bitmap exactly, i.e. bitmap = 00000011;
646 * Return 1 if the range doesn't cover whole bitmap, e.g. bitmap = 00001111;
647 * Return -ENOMEM if the range exceeds the bitmap, e.g. bitmap = 00000001 or
651 ia32_compare_pp(unsigned int *startp, unsigned int *endp)
653 unsigned int start = *startp, end = *endp;
656 down_write(¤t->mm->mmap_sem);
658 if (end < PAGE_ALIGN(start)) {
659 retval = __ia32_compare_pp(start, end);
661 *startp = PAGE_START(start);
662 *endp = PAGE_ALIGN(end);
665 if (offset_in_page(start)) {
666 retval = __ia32_compare_pp(start,
669 *startp = PAGE_START(start);
673 if (offset_in_page(end)) {
674 retval = __ia32_compare_pp(PAGE_START(end), end);
676 *endp = PAGE_ALIGN(end);
681 up_write(¤t->mm->mmap_sem);
686 __ia32_drop_pp_list(struct partial_page_list *ppl)
688 struct partial_page *pp = ppl->pp_head;
691 struct partial_page *next = pp->next;
692 kmem_cache_free(partial_page_cachep, pp);
700 ia32_drop_partial_page_list(struct task_struct *task)
702 struct partial_page_list* ppl = task->thread.ppl;
704 if (ppl && atomic_dec_and_test(&ppl->pp_count))
705 __ia32_drop_pp_list(ppl);
709 * Copy current->thread.ppl to ppl (already initialized).
712 __ia32_copy_pp_list(struct partial_page_list *ppl)
714 struct partial_page *pp, *tmp, *prev;
715 struct rb_node **rb_link, *rb_parent;
719 ppl->ppl_rb = RB_ROOT;
720 rb_link = &ppl->ppl_rb.rb_node;
724 for (pp = current->thread.ppl->pp_head; pp; pp = pp->next) {
725 tmp = kmem_cache_alloc(partial_page_cachep, GFP_KERNEL);
729 __ia32_insert_pp(ppl, tmp, prev, rb_link, rb_parent);
731 rb_link = &tmp->pp_rb.rb_right;
732 rb_parent = &tmp->pp_rb;
738 ia32_copy_partial_page_list(struct task_struct *p, unsigned long clone_flags)
742 if (clone_flags & CLONE_VM) {
743 atomic_inc(¤t->thread.ppl->pp_count);
744 p->thread.ppl = current->thread.ppl;
746 p->thread.ppl = ia32_init_pp_list();
749 down_write(¤t->mm->mmap_sem);
751 retval = __ia32_copy_pp_list(p->thread.ppl);
753 up_write(¤t->mm->mmap_sem);
760 emulate_mmap (struct file *file, unsigned long start, unsigned long len, int prot, int flags,
763 unsigned long tmp, end, pend, pstart, ret, is_congruent, fudge = 0;
768 pstart = PAGE_START(start);
769 pend = PAGE_ALIGN(end);
771 if (flags & MAP_FIXED) {
772 ia32_set_pp((unsigned int)start, (unsigned int)end, flags);
773 if (start > pstart) {
774 if (flags & MAP_SHARED)
776 "%s(%d): emulate_mmap() can't share head (addr=0x%lx)\n",
777 current->comm, current->pid, start);
778 ret = mmap_subpage(file, start, min(PAGE_ALIGN(start), end), prot, flags,
780 if (IS_ERR((void *) ret))
787 if (flags & MAP_SHARED)
789 "%s(%d): emulate_mmap() can't share tail (end=0x%lx)\n",
790 current->comm, current->pid, end);
791 ret = mmap_subpage(file, max(start, PAGE_START(end)), end, prot, flags,
792 (off + len) - offset_in_page(end));
793 if (IS_ERR((void *) ret))
801 * If a start address was specified, use it if the entire rounded out area
804 if (start && !pstart)
805 fudge = 1; /* handle case of mapping to range (0,PAGE_SIZE) */
806 tmp = arch_get_unmapped_area(file, pstart - fudge, pend - pstart, 0, flags);
809 start = pstart + offset_in_page(off); /* make start congruent with off */
811 pend = PAGE_ALIGN(end);
815 poff = off + (pstart - start); /* note: (pstart - start) may be negative */
816 is_congruent = (flags & MAP_ANONYMOUS) || (offset_in_page(poff) == 0);
818 if ((flags & MAP_SHARED) && !is_congruent)
819 printk(KERN_INFO "%s(%d): emulate_mmap() can't share contents of incongruent mmap "
820 "(addr=0x%lx,off=0x%llx)\n", current->comm, current->pid, start, off);
822 DBG("mmap_body: mapping [0x%lx-0x%lx) %s with poff 0x%llx\n", pstart, pend,
823 is_congruent ? "congruent" : "not congruent", poff);
825 down_write(¤t->mm->mmap_sem);
827 if (!(flags & MAP_ANONYMOUS) && is_congruent)
828 ret = do_mmap(file, pstart, pend - pstart, prot, flags | MAP_FIXED, poff);
830 ret = do_mmap(NULL, pstart, pend - pstart,
831 prot | ((flags & MAP_ANONYMOUS) ? 0 : PROT_WRITE),
832 flags | MAP_FIXED | MAP_ANONYMOUS, 0);
834 up_write(¤t->mm->mmap_sem);
836 if (IS_ERR((void *) ret))
840 /* read the file contents */
841 inode = file->f_path.dentry->d_inode;
842 if (!inode->i_fop || !file->f_op->read
843 || ((*file->f_op->read)(file, (char __user *) pstart, pend - pstart, &poff)
846 sys_munmap(pstart, pend - pstart);
849 if (!(prot & PROT_WRITE) && sys_mprotect(pstart, pend - pstart, prot) < 0)
853 if (!(flags & MAP_FIXED))
854 ia32_set_pp((unsigned int)start, (unsigned int)end, flags);
859 #endif /* PAGE_SHIFT > IA32_PAGE_SHIFT */
861 static inline unsigned int
862 get_prot32 (unsigned int prot)
864 if (prot & PROT_WRITE)
865 /* on x86, PROT_WRITE implies PROT_READ which implies PROT_EEC */
866 prot |= PROT_READ | PROT_WRITE | PROT_EXEC;
867 else if (prot & (PROT_READ | PROT_EXEC))
868 /* on x86, there is no distinction between PROT_READ and PROT_EXEC */
869 prot |= (PROT_READ | PROT_EXEC);
875 ia32_do_mmap (struct file *file, unsigned long addr, unsigned long len, int prot, int flags,
878 DBG("ia32_do_mmap(file=%p,addr=0x%lx,len=0x%lx,prot=%x,flags=%x,offset=0x%llx)\n",
879 file, addr, len, prot, flags, offset);
881 if (file && (!file->f_op || !file->f_op->mmap))
884 len = IA32_PAGE_ALIGN(len);
888 if (len > IA32_PAGE_OFFSET || addr > IA32_PAGE_OFFSET - len)
890 if (flags & MAP_FIXED)
896 if (OFFSET4K(offset))
899 prot = get_prot32(prot);
901 #if PAGE_SHIFT > IA32_PAGE_SHIFT
902 mutex_lock(&ia32_mmap_mutex);
904 addr = emulate_mmap(file, addr, len, prot, flags, offset);
906 mutex_unlock(&ia32_mmap_mutex);
908 down_write(¤t->mm->mmap_sem);
910 addr = do_mmap(file, addr, len, prot, flags, offset);
912 up_write(¤t->mm->mmap_sem);
914 DBG("ia32_do_mmap: returning 0x%lx\n", addr);
919 * Linux/i386 didn't use to be able to handle more than 4 system call parameters, so these
920 * system calls used a memory block for parameter passing..
923 struct mmap_arg_struct {
933 sys32_mmap (struct mmap_arg_struct __user *arg)
935 struct mmap_arg_struct a;
936 struct file *file = NULL;
940 if (copy_from_user(&a, arg, sizeof(a)))
943 if (OFFSET4K(a.offset))
948 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
949 if (!(flags & MAP_ANONYMOUS)) {
955 addr = ia32_do_mmap(file, a.addr, a.len, a.prot, flags, a.offset);
963 sys32_mmap2 (unsigned int addr, unsigned int len, unsigned int prot, unsigned int flags,
964 unsigned int fd, unsigned int pgoff)
966 struct file *file = NULL;
967 unsigned long retval;
969 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
970 if (!(flags & MAP_ANONYMOUS)) {
976 retval = ia32_do_mmap(file, addr, len, prot, flags,
977 (unsigned long) pgoff << IA32_PAGE_SHIFT);
985 sys32_munmap (unsigned int start, unsigned int len)
987 unsigned int end = start + len;
990 #if PAGE_SHIFT <= IA32_PAGE_SHIFT
991 ret = sys_munmap(start, end - start);
996 end = IA32_PAGE_ALIGN(end);
1000 ret = ia32_unset_pp(&start, &end);
1007 mutex_lock(&ia32_mmap_mutex);
1008 ret = sys_munmap(start, end - start);
1009 mutex_unlock(&ia32_mmap_mutex);
1014 #if PAGE_SHIFT > IA32_PAGE_SHIFT
1017 * When mprotect()ing a partial page, we set the permission to the union of the old
1018 * settings and the new settings. In other words, it's only possible to make access to a
1019 * partial page less restrictive.
1022 mprotect_subpage (unsigned long address, int new_prot)
1025 struct vm_area_struct *vma;
1027 if (new_prot == PROT_NONE)
1028 return 0; /* optimize case where nothing changes... */
1029 vma = find_vma(current->mm, address);
1030 old_prot = get_page_prot(vma, address);
1031 return sys_mprotect(address, PAGE_SIZE, new_prot | old_prot);
1034 #endif /* PAGE_SHIFT > IA32_PAGE_SHIFT */
1037 sys32_mprotect (unsigned int start, unsigned int len, int prot)
1039 unsigned int end = start + len;
1040 #if PAGE_SHIFT > IA32_PAGE_SHIFT
1044 prot = get_prot32(prot);
1046 #if PAGE_SHIFT <= IA32_PAGE_SHIFT
1047 return sys_mprotect(start, end - start, prot);
1049 if (OFFSET4K(start))
1052 end = IA32_PAGE_ALIGN(end);
1056 retval = ia32_compare_pp(&start, &end);
1061 mutex_lock(&ia32_mmap_mutex);
1063 if (offset_in_page(start)) {
1064 /* start address is 4KB aligned but not page aligned. */
1065 retval = mprotect_subpage(PAGE_START(start), prot);
1069 start = PAGE_ALIGN(start);
1071 goto out; /* retval is already zero... */
1074 if (offset_in_page(end)) {
1075 /* end address is 4KB aligned but not page aligned. */
1076 retval = mprotect_subpage(PAGE_START(end), prot);
1080 end = PAGE_START(end);
1082 retval = sys_mprotect(start, end - start, prot);
1085 mutex_unlock(&ia32_mmap_mutex);
1091 sys32_mremap (unsigned int addr, unsigned int old_len, unsigned int new_len,
1092 unsigned int flags, unsigned int new_addr)
1096 #if PAGE_SHIFT <= IA32_PAGE_SHIFT
1097 ret = sys_mremap(addr, old_len, new_len, flags, new_addr);
1099 unsigned int old_end, new_end;
1104 old_len = IA32_PAGE_ALIGN(old_len);
1105 new_len = IA32_PAGE_ALIGN(new_len);
1106 old_end = addr + old_len;
1107 new_end = addr + new_len;
1112 if ((flags & MREMAP_FIXED) && (OFFSET4K(new_addr)))
1115 if (old_len >= new_len) {
1116 ret = sys32_munmap(addr + new_len, old_len - new_len);
1117 if (ret && old_len != new_len)
1120 if (!(flags & MREMAP_FIXED) || (new_addr == addr))
1125 addr = PAGE_START(addr);
1126 old_len = PAGE_ALIGN(old_end) - addr;
1127 new_len = PAGE_ALIGN(new_end) - addr;
1129 mutex_lock(&ia32_mmap_mutex);
1130 ret = sys_mremap(addr, old_len, new_len, flags, new_addr);
1131 mutex_unlock(&ia32_mmap_mutex);
1133 if ((ret >= 0) && (old_len < new_len)) {
1134 /* mremap expanded successfully */
1135 ia32_set_pp(old_end, new_end, flags);
1142 sys32_pipe (int __user *fd)
1147 retval = do_pipe(fds);
1150 if (copy_to_user(fd, fds, sizeof(fds)))
1157 get_tv32 (struct timeval *o, struct compat_timeval __user *i)
1159 return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
1160 (__get_user(o->tv_sec, &i->tv_sec) | __get_user(o->tv_usec, &i->tv_usec)));
1164 put_tv32 (struct compat_timeval __user *o, struct timeval *i)
1166 return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
1167 (__put_user(i->tv_sec, &o->tv_sec) | __put_user(i->tv_usec, &o->tv_usec)));
1170 asmlinkage unsigned long
1171 sys32_alarm (unsigned int seconds)
1173 return alarm_setitimer(seconds);
1176 /* Translations due to time_t size differences. Which affects all
1177 sorts of things, like timeval and itimerval. */
1179 extern struct timezone sys_tz;
1182 sys32_gettimeofday (struct compat_timeval __user *tv, struct timezone __user *tz)
1186 vx_gettimeofday(&ktv);
1187 if (put_tv32(tv, &ktv))
1191 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
1198 sys32_settimeofday (struct compat_timeval __user *tv, struct timezone __user *tz)
1201 struct timespec kts;
1202 struct timezone ktz;
1205 if (get_tv32(&ktv, tv))
1207 kts.tv_sec = ktv.tv_sec;
1208 kts.tv_nsec = ktv.tv_usec * 1000;
1211 if (copy_from_user(&ktz, tz, sizeof(ktz)))
1215 return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
1218 struct getdents32_callback {
1219 struct compat_dirent __user *current_dir;
1220 struct compat_dirent __user *previous;
1225 struct readdir32_callback {
1226 struct old_linux32_dirent __user * dirent;
1231 filldir32 (void *__buf, const char *name, int namlen, loff_t offset, u64 ino,
1232 unsigned int d_type)
1234 struct compat_dirent __user * dirent;
1235 struct getdents32_callback * buf = (struct getdents32_callback *) __buf;
1236 int reclen = ROUND_UP(offsetof(struct compat_dirent, d_name) + namlen + 1, 4);
1239 buf->error = -EINVAL; /* only used if we fail.. */
1240 if (reclen > buf->count)
1243 if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
1245 buf->error = -EFAULT; /* only used if we fail.. */
1246 dirent = buf->previous;
1248 if (put_user(offset, &dirent->d_off))
1250 dirent = buf->current_dir;
1251 buf->previous = dirent;
1252 if (put_user(d_ino, &dirent->d_ino)
1253 || put_user(reclen, &dirent->d_reclen)
1254 || copy_to_user(dirent->d_name, name, namlen)
1255 || put_user(0, dirent->d_name + namlen))
1257 dirent = (struct compat_dirent __user *) ((char __user *) dirent + reclen);
1258 buf->current_dir = dirent;
1259 buf->count -= reclen;
1264 sys32_getdents (unsigned int fd, struct compat_dirent __user *dirent, unsigned int count)
1267 struct compat_dirent __user * lastdirent;
1268 struct getdents32_callback buf;
1276 buf.current_dir = dirent;
1277 buf.previous = NULL;
1281 error = vfs_readdir(file, filldir32, &buf);
1285 lastdirent = buf.previous;
1288 if (put_user(file->f_pos, &lastdirent->d_off))
1290 error = count - buf.count;
1300 fillonedir32 (void * __buf, const char * name, int namlen, loff_t offset, u64 ino,
1301 unsigned int d_type)
1303 struct readdir32_callback * buf = (struct readdir32_callback *) __buf;
1304 struct old_linux32_dirent __user * dirent;
1310 if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
1313 dirent = buf->dirent;
1314 if (put_user(d_ino, &dirent->d_ino)
1315 || put_user(offset, &dirent->d_offset)
1316 || put_user(namlen, &dirent->d_namlen)
1317 || copy_to_user(dirent->d_name, name, namlen)
1318 || put_user(0, dirent->d_name + namlen))
1324 sys32_readdir (unsigned int fd, void __user *dirent, unsigned int count)
1328 struct readdir32_callback buf;
1336 buf.dirent = dirent;
1338 error = vfs_readdir(file, fillonedir32, &buf);
1346 struct sel_arg_struct {
1355 sys32_old_select (struct sel_arg_struct __user *arg)
1357 struct sel_arg_struct a;
1359 if (copy_from_user(&a, arg, sizeof(a)))
1361 return compat_sys_select(a.n, compat_ptr(a.inp), compat_ptr(a.outp),
1362 compat_ptr(a.exp), compat_ptr(a.tvp));
1368 #define SEMTIMEDOP 4
1379 sys32_ipc(u32 call, int first, int second, int third, u32 ptr, u32 fifth)
1383 version = call >> 16; /* hack for backward compatibility */
1389 return compat_sys_semtimedop(first, compat_ptr(ptr),
1390 second, compat_ptr(fifth));
1391 /* else fall through for normal semop() */
1393 /* struct sembuf is the same on 32 and 64bit :)) */
1394 return sys_semtimedop(first, compat_ptr(ptr), second,
1397 return sys_semget(first, second, third);
1399 return compat_sys_semctl(first, second, third, compat_ptr(ptr));
1402 return compat_sys_msgsnd(first, second, third, compat_ptr(ptr));
1404 return compat_sys_msgrcv(first, second, fifth, third, version, compat_ptr(ptr));
1406 return sys_msgget((key_t) first, second);
1408 return compat_sys_msgctl(first, second, compat_ptr(ptr));
1411 return compat_sys_shmat(first, second, third, version, compat_ptr(ptr));
1414 return sys_shmdt(compat_ptr(ptr));
1416 return sys_shmget(first, (unsigned)second, third);
1418 return compat_sys_shmctl(first, second, compat_ptr(ptr));
1427 compat_sys_wait4 (compat_pid_t pid, compat_uint_t * stat_addr, int options,
1428 struct compat_rusage *ru);
1431 sys32_waitpid (int pid, unsigned int *stat_addr, int options)
1433 return compat_sys_wait4(pid, stat_addr, options, NULL);
1437 * The order in which registers are stored in the ptrace regs structure
1450 #define PT_ORIG_EAX 11
1458 getreg (struct task_struct *child, int regno)
1460 struct pt_regs *child_regs;
1462 child_regs = task_pt_regs(child);
1463 switch (regno / sizeof(int)) {
1464 case PT_EBX: return child_regs->r11;
1465 case PT_ECX: return child_regs->r9;
1466 case PT_EDX: return child_regs->r10;
1467 case PT_ESI: return child_regs->r14;
1468 case PT_EDI: return child_regs->r15;
1469 case PT_EBP: return child_regs->r13;
1470 case PT_EAX: return child_regs->r8;
1471 case PT_ORIG_EAX: return child_regs->r1; /* see dispatch_to_ia32_handler() */
1472 case PT_EIP: return child_regs->cr_iip;
1473 case PT_UESP: return child_regs->r12;
1474 case PT_EFL: return child->thread.eflag;
1475 case PT_DS: case PT_ES: case PT_FS: case PT_GS: case PT_SS:
1477 case PT_CS: return __USER_CS;
1479 printk(KERN_ERR "ia32.getreg(): unknown register %d\n", regno);
1486 putreg (struct task_struct *child, int regno, unsigned int value)
1488 struct pt_regs *child_regs;
1490 child_regs = task_pt_regs(child);
1491 switch (regno / sizeof(int)) {
1492 case PT_EBX: child_regs->r11 = value; break;
1493 case PT_ECX: child_regs->r9 = value; break;
1494 case PT_EDX: child_regs->r10 = value; break;
1495 case PT_ESI: child_regs->r14 = value; break;
1496 case PT_EDI: child_regs->r15 = value; break;
1497 case PT_EBP: child_regs->r13 = value; break;
1498 case PT_EAX: child_regs->r8 = value; break;
1499 case PT_ORIG_EAX: child_regs->r1 = value; break;
1500 case PT_EIP: child_regs->cr_iip = value; break;
1501 case PT_UESP: child_regs->r12 = value; break;
1502 case PT_EFL: child->thread.eflag = value; break;
1503 case PT_DS: case PT_ES: case PT_FS: case PT_GS: case PT_SS:
1504 if (value != __USER_DS)
1506 "ia32.putreg: attempt to set invalid segment register %d = %x\n",
1510 if (value != __USER_CS)
1512 "ia32.putreg: attempt to to set invalid segment register %d = %x\n",
1516 printk(KERN_ERR "ia32.putreg: unknown register %d\n", regno);
1522 put_fpreg (int regno, struct _fpreg_ia32 __user *reg, struct pt_regs *ptp,
1523 struct switch_stack *swp, int tos)
1525 struct _fpreg_ia32 *f;
1528 f = (struct _fpreg_ia32 *)(((unsigned long)buf + 15) & ~15);
1529 if ((regno += tos) >= 8)
1533 ia64f2ia32f(f, &ptp->f8);
1536 ia64f2ia32f(f, &ptp->f9);
1539 ia64f2ia32f(f, &ptp->f10);
1542 ia64f2ia32f(f, &ptp->f11);
1548 ia64f2ia32f(f, &swp->f12 + (regno - 4));
1551 copy_to_user(reg, f, sizeof(*reg));
1555 get_fpreg (int regno, struct _fpreg_ia32 __user *reg, struct pt_regs *ptp,
1556 struct switch_stack *swp, int tos)
1559 if ((regno += tos) >= 8)
1563 copy_from_user(&ptp->f8, reg, sizeof(*reg));
1566 copy_from_user(&ptp->f9, reg, sizeof(*reg));
1569 copy_from_user(&ptp->f10, reg, sizeof(*reg));
1572 copy_from_user(&ptp->f11, reg, sizeof(*reg));
1578 copy_from_user(&swp->f12 + (regno - 4), reg, sizeof(*reg));
1585 save_ia32_fpstate (struct task_struct *tsk, struct ia32_user_i387_struct __user *save)
1587 struct switch_stack *swp;
1588 struct pt_regs *ptp;
1591 if (!access_ok(VERIFY_WRITE, save, sizeof(*save)))
1594 __put_user(tsk->thread.fcr & 0xffff, &save->cwd);
1595 __put_user(tsk->thread.fsr & 0xffff, &save->swd);
1596 __put_user((tsk->thread.fsr>>16) & 0xffff, &save->twd);
1597 __put_user(tsk->thread.fir, &save->fip);
1598 __put_user((tsk->thread.fir>>32) & 0xffff, &save->fcs);
1599 __put_user(tsk->thread.fdr, &save->foo);
1600 __put_user((tsk->thread.fdr>>32) & 0xffff, &save->fos);
1603 * Stack frames start with 16-bytes of temp space
1605 swp = (struct switch_stack *)(tsk->thread.ksp + 16);
1606 ptp = task_pt_regs(tsk);
1607 tos = (tsk->thread.fsr >> 11) & 7;
1608 for (i = 0; i < 8; i++)
1609 put_fpreg(i, &save->st_space[i], ptp, swp, tos);
1614 restore_ia32_fpstate (struct task_struct *tsk, struct ia32_user_i387_struct __user *save)
1616 struct switch_stack *swp;
1617 struct pt_regs *ptp;
1619 unsigned int fsrlo, fsrhi, num32;
1621 if (!access_ok(VERIFY_READ, save, sizeof(*save)))
1624 __get_user(num32, (unsigned int __user *)&save->cwd);
1625 tsk->thread.fcr = (tsk->thread.fcr & (~0x1f3f)) | (num32 & 0x1f3f);
1626 __get_user(fsrlo, (unsigned int __user *)&save->swd);
1627 __get_user(fsrhi, (unsigned int __user *)&save->twd);
1628 num32 = (fsrhi << 16) | fsrlo;
1629 tsk->thread.fsr = (tsk->thread.fsr & (~0xffffffff)) | num32;
1630 __get_user(num32, (unsigned int __user *)&save->fip);
1631 tsk->thread.fir = (tsk->thread.fir & (~0xffffffff)) | num32;
1632 __get_user(num32, (unsigned int __user *)&save->foo);
1633 tsk->thread.fdr = (tsk->thread.fdr & (~0xffffffff)) | num32;
1636 * Stack frames start with 16-bytes of temp space
1638 swp = (struct switch_stack *)(tsk->thread.ksp + 16);
1639 ptp = task_pt_regs(tsk);
1640 tos = (tsk->thread.fsr >> 11) & 7;
1641 for (i = 0; i < 8; i++)
1642 get_fpreg(i, &save->st_space[i], ptp, swp, tos);
1647 save_ia32_fpxstate (struct task_struct *tsk, struct ia32_user_fxsr_struct __user *save)
1649 struct switch_stack *swp;
1650 struct pt_regs *ptp;
1652 unsigned long mxcsr=0;
1653 unsigned long num128[2];
1655 if (!access_ok(VERIFY_WRITE, save, sizeof(*save)))
1658 __put_user(tsk->thread.fcr & 0xffff, &save->cwd);
1659 __put_user(tsk->thread.fsr & 0xffff, &save->swd);
1660 __put_user((tsk->thread.fsr>>16) & 0xffff, &save->twd);
1661 __put_user(tsk->thread.fir, &save->fip);
1662 __put_user((tsk->thread.fir>>32) & 0xffff, &save->fcs);
1663 __put_user(tsk->thread.fdr, &save->foo);
1664 __put_user((tsk->thread.fdr>>32) & 0xffff, &save->fos);
1667 * Stack frames start with 16-bytes of temp space
1669 swp = (struct switch_stack *)(tsk->thread.ksp + 16);
1670 ptp = task_pt_regs(tsk);
1671 tos = (tsk->thread.fsr >> 11) & 7;
1672 for (i = 0; i < 8; i++)
1673 put_fpreg(i, (struct _fpreg_ia32 __user *)&save->st_space[4*i], ptp, swp, tos);
1675 mxcsr = ((tsk->thread.fcr>>32) & 0xff80) | ((tsk->thread.fsr>>32) & 0x3f);
1676 __put_user(mxcsr & 0xffff, &save->mxcsr);
1677 for (i = 0; i < 8; i++) {
1678 memcpy(&(num128[0]), &(swp->f16) + i*2, sizeof(unsigned long));
1679 memcpy(&(num128[1]), &(swp->f17) + i*2, sizeof(unsigned long));
1680 copy_to_user(&save->xmm_space[0] + 4*i, num128, sizeof(struct _xmmreg_ia32));
1686 restore_ia32_fpxstate (struct task_struct *tsk, struct ia32_user_fxsr_struct __user *save)
1688 struct switch_stack *swp;
1689 struct pt_regs *ptp;
1691 unsigned int fsrlo, fsrhi, num32;
1693 unsigned long num64;
1694 unsigned long num128[2];
1696 if (!access_ok(VERIFY_READ, save, sizeof(*save)))
1699 __get_user(num32, (unsigned int __user *)&save->cwd);
1700 tsk->thread.fcr = (tsk->thread.fcr & (~0x1f3f)) | (num32 & 0x1f3f);
1701 __get_user(fsrlo, (unsigned int __user *)&save->swd);
1702 __get_user(fsrhi, (unsigned int __user *)&save->twd);
1703 num32 = (fsrhi << 16) | fsrlo;
1704 tsk->thread.fsr = (tsk->thread.fsr & (~0xffffffff)) | num32;
1705 __get_user(num32, (unsigned int __user *)&save->fip);
1706 tsk->thread.fir = (tsk->thread.fir & (~0xffffffff)) | num32;
1707 __get_user(num32, (unsigned int __user *)&save->foo);
1708 tsk->thread.fdr = (tsk->thread.fdr & (~0xffffffff)) | num32;
1711 * Stack frames start with 16-bytes of temp space
1713 swp = (struct switch_stack *)(tsk->thread.ksp + 16);
1714 ptp = task_pt_regs(tsk);
1715 tos = (tsk->thread.fsr >> 11) & 7;
1716 for (i = 0; i < 8; i++)
1717 get_fpreg(i, (struct _fpreg_ia32 __user *)&save->st_space[4*i], ptp, swp, tos);
1719 __get_user(mxcsr, (unsigned int __user *)&save->mxcsr);
1720 num64 = mxcsr & 0xff10;
1721 tsk->thread.fcr = (tsk->thread.fcr & (~0xff1000000000UL)) | (num64<<32);
1722 num64 = mxcsr & 0x3f;
1723 tsk->thread.fsr = (tsk->thread.fsr & (~0x3f00000000UL)) | (num64<<32);
1725 for (i = 0; i < 8; i++) {
1726 copy_from_user(num128, &save->xmm_space[0] + 4*i, sizeof(struct _xmmreg_ia32));
1727 memcpy(&(swp->f16) + i*2, &(num128[0]), sizeof(unsigned long));
1728 memcpy(&(swp->f17) + i*2, &(num128[1]), sizeof(unsigned long));
1735 sys32_ptrace (int request, pid_t pid, unsigned int addr, unsigned int data)
1737 struct task_struct *child;
1738 unsigned int value, tmp;
1742 if (request == PTRACE_TRACEME) {
1743 ret = ptrace_traceme();
1747 child = ptrace_get_task_struct(pid);
1748 if (IS_ERR(child)) {
1749 ret = PTR_ERR(child);
1753 if (request == PTRACE_ATTACH) {
1754 ret = sys_ptrace(request, pid, addr, data);
1758 ret = ptrace_check_attach(child, request == PTRACE_KILL);
1763 case PTRACE_PEEKTEXT:
1764 case PTRACE_PEEKDATA: /* read word at location addr */
1765 ret = ia32_peek(child, addr, &value);
1767 ret = put_user(value, (unsigned int __user *) compat_ptr(data));
1772 case PTRACE_POKETEXT:
1773 case PTRACE_POKEDATA: /* write the word at location addr */
1774 ret = ia32_poke(child, addr, data);
1777 case PTRACE_PEEKUSR: /* read word at addr in USER area */
1779 if ((addr & 3) || addr > 17*sizeof(int))
1782 tmp = getreg(child, addr);
1783 if (!put_user(tmp, (unsigned int __user *) compat_ptr(data)))
1787 case PTRACE_POKEUSR: /* write word at addr in USER area */
1789 if ((addr & 3) || addr > 17*sizeof(int))
1792 putreg(child, addr, data);
1796 case IA32_PTRACE_GETREGS:
1797 if (!access_ok(VERIFY_WRITE, compat_ptr(data), 17*sizeof(int))) {
1801 for (i = 0; i < (int) (17*sizeof(int)); i += sizeof(int) ) {
1802 put_user(getreg(child, i), (unsigned int __user *) compat_ptr(data));
1803 data += sizeof(int);
1808 case IA32_PTRACE_SETREGS:
1809 if (!access_ok(VERIFY_READ, compat_ptr(data), 17*sizeof(int))) {
1813 for (i = 0; i < (int) (17*sizeof(int)); i += sizeof(int) ) {
1814 get_user(tmp, (unsigned int __user *) compat_ptr(data));
1815 putreg(child, i, tmp);
1816 data += sizeof(int);
1821 case IA32_PTRACE_GETFPREGS:
1822 ret = save_ia32_fpstate(child, (struct ia32_user_i387_struct __user *)
1826 case IA32_PTRACE_GETFPXREGS:
1827 ret = save_ia32_fpxstate(child, (struct ia32_user_fxsr_struct __user *)
1831 case IA32_PTRACE_SETFPREGS:
1832 ret = restore_ia32_fpstate(child, (struct ia32_user_i387_struct __user *)
1836 case IA32_PTRACE_SETFPXREGS:
1837 ret = restore_ia32_fpxstate(child, (struct ia32_user_fxsr_struct __user *)
1842 case PTRACE_GETEVENTMSG:
1843 ret = put_user(child->ptrace_message, (unsigned int __user *) compat_ptr(data));
1847 case PTRACE_SYSCALL: /* continue, stop after next syscall */
1848 case PTRACE_CONT: /* restart after signal. */
1850 case PTRACE_SINGLESTEP: /* execute chile for one instruction */
1851 case PTRACE_DETACH: /* detach a process */
1852 ret = sys_ptrace(request, pid, addr, data);
1856 ret = ptrace_request(child, request, addr, data);
1861 put_task_struct(child);
1868 #ifdef CONFIG_UTRACE
1869 typedef struct utrace_get {
1874 typedef struct utrace_set {
1876 const void __user *ubuf;
1879 typedef struct utrace_getset {
1880 struct task_struct *target;
1881 const struct utrace_regset *regset;
1891 static void getfpreg(struct task_struct *task, int regno,int *val)
1893 switch (regno / sizeof(int)) {
1894 case 0: *val = task->thread.fcr & 0xffff; break;
1895 case 1: *val = task->thread.fsr & 0xffff; break;
1896 case 2: *val = (task->thread.fsr>>16) & 0xffff; break;
1897 case 3: *val = task->thread.fir; break;
1898 case 4: *val = (task->thread.fir>>32) & 0xffff; break;
1899 case 5: *val = task->thread.fdr; break;
1900 case 6: *val = (task->thread.fdr >> 32) & 0xffff; break;
1904 static void setfpreg(struct task_struct *task, int regno, int val)
1906 switch (regno / sizeof(int)) {
1908 task->thread.fcr = (task->thread.fcr & (~0x1f3f))
1912 task->thread.fsr = (task->thread.fsr & (~0xffff)) | val;
1915 task->thread.fsr = (task->thread.fsr & (~0xffff0000))
1919 task->thread.fir = (task->thread.fir & (~0xffffffff)) | val;
1922 task->thread.fdr = (task->thread.fdr & (~0xffffffff)) | val;
1927 static void access_fpreg_ia32(int regno, void *reg,
1928 struct pt_regs *pt, struct switch_stack *sw,
1933 if ((regno += tos) >= 8)
1936 f = &pt->f8 + regno;
1937 else if (regno <= 7)
1938 f = &sw->f12 + (regno - 4);
1940 printk(" regno must be less than 7 \n");
1945 memcpy(f, reg, sizeof(struct _fpreg_ia32));
1947 memcpy(reg, f, sizeof(struct _fpreg_ia32));
1950 static void do_fpregs_get(struct unw_frame_info *info, void *arg)
1952 utrace_getset_t *dst = arg;
1953 struct task_struct *task = dst->target;
1955 int start, end, tos;
1958 if (dst->count == 0 || unw_unwind_to_user(info) < 0)
1960 if (dst->pos < 7 * sizeof(int)) {
1961 end = min((dst->pos + dst->count), (unsigned int)(7 * sizeof(int)));
1962 for (start = dst->pos; start < end; start += sizeof(int))
1963 getfpreg(task, start,(int *)( buf + start));
1964 dst->ret = utrace_regset_copyout(&dst->pos, &dst->count,
1965 &dst->u.get.kbuf, &dst->u.get.ubuf, buf,
1966 0, 7 * sizeof(int));
1967 if (dst->ret || dst->count == 0)
1970 if (dst->pos < sizeof(struct ia32_user_i387_struct)) {
1971 pt = task_pt_regs(task);
1972 tos = (task->thread.fsr >> 11) & 7;
1973 end = min(dst->pos + dst->count,
1974 (unsigned int)(sizeof(struct ia32_user_i387_struct)));
1975 start = (dst->pos - 7 * sizeof(int)) / sizeof(struct _fpreg_ia32);
1976 end = (end - 7 * sizeof(int)) / sizeof(struct _fpreg_ia32);
1977 for (; start < end; start++)
1978 access_fpreg_ia32(start, (struct _fpreg_ia32 *)buf + start,
1979 pt, info->sw, tos, 0);
1980 dst->ret = utrace_regset_copyout(&dst->pos, &dst->count,
1981 &dst->u.get.kbuf, &dst->u.get.ubuf,
1982 buf, 7 * sizeof(int),
1983 sizeof(struct ia32_user_i387_struct));
1984 if (dst->ret || dst->count == 0)
1989 static void do_fpregs_set(struct unw_frame_info *info, void *arg)
1991 utrace_getset_t *dst = arg;
1992 struct task_struct *task = dst->target;
1995 int end, start, tos;
1997 if (dst->count == 0 || unw_unwind_to_user(info) < 0)
2000 if (dst->pos < 7 * sizeof(int)) {
2002 dst->ret = utrace_regset_copyin(&dst->pos, &dst->count,
2003 &dst->u.set.kbuf, &dst->u.set.ubuf, buf,
2004 0, 7 * sizeof(int));
2007 for (; start < dst->pos; start += sizeof(int))
2008 setfpreg(task, start, *((int*)(buf + start)));
2009 if (dst->count == 0)
2012 if (dst->pos < sizeof(struct ia32_user_i387_struct)) {
2013 start = (dst->pos - 7 * sizeof(int)) / sizeof(struct _fpreg_ia32);
2014 dst->ret = utrace_regset_copyin(&dst->pos, &dst->count,
2015 &dst->u.set.kbuf, &dst->u.set.ubuf,
2016 buf, 7 * sizeof(int),
2017 sizeof(struct ia32_user_i387_struct));
2020 pt = task_pt_regs(task);
2021 tos = (task->thread.fsr >> 11) & 7;
2022 end = (dst->pos - 7 * sizeof(int)) / sizeof(struct _fpreg_ia32);
2023 for (; start < end; start++)
2024 access_fpreg_ia32(start, (struct _fpreg_ia32 *)buf + start,
2025 pt, info->sw, tos, 0);
2026 if (dst->count == 0)
2031 #define OFFSET(member) ((int)(offsetof(struct ia32_user_fxsr_struct, member)))
2032 static void getfpxreg(struct task_struct *task, int start, int end, char *buf)
2036 min_val = min(end, OFFSET(fop));
2037 while (start < min_val) {
2038 if (start == OFFSET(cwd))
2039 *((short *)buf) = task->thread.fcr & 0xffff;
2040 else if (start == OFFSET(swd))
2041 *((short *)buf) = task->thread.fsr & 0xffff;
2042 else if (start == OFFSET(twd))
2043 *((short *)buf) = (task->thread.fsr>>16) & 0xffff;
2047 /* skip fop element */
2048 if (start == OFFSET(fop)) {
2052 while (start < end) {
2053 if (start == OFFSET(fip))
2054 *((int *)buf) = task->thread.fir;
2055 else if (start == OFFSET(fcs))
2056 *((int *)buf) = (task->thread.fir>>32) & 0xffff;
2057 else if (start == OFFSET(foo))
2058 *((int *)buf) = task->thread.fdr;
2059 else if (start == OFFSET(fos))
2060 *((int *)buf) = (task->thread.fdr>>32) & 0xffff;
2061 else if (start == OFFSET(mxcsr))
2062 *((int *)buf) = ((task->thread.fcr>>32) & 0xff80)
2063 | ((task->thread.fsr>>32) & 0x3f);
2069 static void setfpxreg(struct task_struct *task, int start, int end, char *buf)
2073 unsigned long num64;
2075 min_val = min(end, OFFSET(fop));
2076 while (start < min_val) {
2077 num = *((short *)buf);
2078 if (start == OFFSET(cwd)) {
2079 task->thread.fcr = (task->thread.fcr & (~0x1f3f))
2081 } else if (start == OFFSET(swd)) {
2082 task->thread.fsr = (task->thread.fsr & (~0xffff)) | num;
2083 } else if (start == OFFSET(twd)) {
2084 task->thread.fsr = (task->thread.fsr & (~0xffff0000)) | num;
2089 /* skip fop element */
2090 if (start == OFFSET(fop)) {
2094 while (start < end) {
2095 num32 = *((int *)buf);
2096 if (start == OFFSET(fip))
2097 task->thread.fir = (task->thread.fir & (~0xffffffff))
2099 else if (start == OFFSET(foo))
2100 task->thread.fdr = (task->thread.fdr & (~0xffffffff))
2102 else if (start == OFFSET(mxcsr)) {
2103 num64 = num32 & 0xff10;
2104 task->thread.fcr = (task->thread.fcr & (~0xff1000000000UL))
2106 num64 = num32 & 0x3f;
2107 task->thread.fsr = (task->thread.fsr & (~0x3f00000000UL))
2115 static void do_fpxregs_get(struct unw_frame_info *info, void *arg)
2117 utrace_getset_t *dst = arg;
2118 struct task_struct *task = dst->target;
2121 int start, end, tos;
2123 if (dst->count == 0 || unw_unwind_to_user(info) < 0)
2125 if (dst->pos < OFFSET(st_space[0])) {
2126 end = min(dst->pos + dst->count, (unsigned int)32);
2127 getfpxreg(task, dst->pos, end, buf);
2128 dst->ret = utrace_regset_copyout(&dst->pos, &dst->count,
2129 &dst->u.get.kbuf, &dst->u.get.ubuf, buf,
2130 0, OFFSET(st_space[0]));
2131 if (dst->ret || dst->count == 0)
2134 if (dst->pos < OFFSET(xmm_space[0])) {
2135 pt = task_pt_regs(task);
2136 tos = (task->thread.fsr >> 11) & 7;
2137 end = min(dst->pos + dst->count,
2138 (unsigned int)OFFSET(xmm_space[0]));
2139 start = (dst->pos - OFFSET(st_space[0])) / 16;
2140 end = (end - OFFSET(st_space[0])) / 16;
2141 for (; start < end; start++)
2142 access_fpreg_ia32(start, buf + 16 * start, pt,
2144 dst->ret = utrace_regset_copyout(&dst->pos, &dst->count,
2145 &dst->u.get.kbuf, &dst->u.get.ubuf,
2146 buf, OFFSET(st_space[0]), OFFSET(xmm_space[0]));
2147 if (dst->ret || dst->count == 0)
2150 if (dst->pos < OFFSET(padding[0]))
2151 dst->ret = utrace_regset_copyout(&dst->pos, &dst->count,
2152 &dst->u.get.kbuf, &dst->u.get.ubuf,
2153 &info->sw->f16, OFFSET(xmm_space[0]),
2154 OFFSET(padding[0]));
2157 static void do_fpxregs_set(struct unw_frame_info *info, void *arg)
2159 utrace_getset_t *dst = arg;
2160 struct task_struct *task = dst->target;
2164 if (dst->count == 0 || unw_unwind_to_user(info) < 0)
2167 if (dst->pos < OFFSET(st_space[0])) {
2169 dst->ret = utrace_regset_copyin(&dst->pos, &dst->count,
2170 &dst->u.set.kbuf, &dst->u.set.ubuf,
2171 buf, 0, OFFSET(st_space[0]));
2174 setfpxreg(task, start, dst->pos, buf);
2175 if (dst->count == 0)
2178 if (dst->pos < OFFSET(xmm_space[0])) {
2181 pt = task_pt_regs(task);
2182 tos = (task->thread.fsr >> 11) & 7;
2183 start = (dst->pos - OFFSET(st_space[0])) / 16;
2184 dst->ret = utrace_regset_copyin(&dst->pos, &dst->count,
2185 &dst->u.set.kbuf, &dst->u.set.ubuf,
2186 buf, OFFSET(st_space[0]), OFFSET(xmm_space[0]));
2189 end = (dst->pos - OFFSET(st_space[0])) / 16;
2190 for (; start < end; start++)
2191 access_fpreg_ia32(start, buf + 16 * start, pt, info->sw,
2193 if (dst->count == 0)
2196 if (dst->pos < OFFSET(padding[0]))
2197 dst->ret = utrace_regset_copyin(&dst->pos, &dst->count,
2198 &dst->u.set.kbuf, &dst->u.set.ubuf,
2199 &info->sw->f16, OFFSET(xmm_space[0]),
2200 OFFSET(padding[0]));
2204 static int do_regset_call(void (*call)(struct unw_frame_info *, void *),
2205 struct task_struct *target,
2206 const struct utrace_regset *regset,
2207 unsigned int pos, unsigned int count,
2208 const void *kbuf, const void __user *ubuf)
2210 utrace_getset_t info = { .target = target, .regset = regset,
2211 .pos = pos, .count = count,
2212 .u.set = { .kbuf = kbuf, .ubuf = ubuf },
2215 if (target == current)
2216 unw_init_running(call, &info);
2218 struct unw_frame_info ufi;
2219 memset(&ufi, 0, sizeof(ufi));
2220 unw_init_from_blocked_task(&ufi, target);
2221 (*call)(&ufi, &info);
2227 static int ia32_fpregs_get(struct task_struct *target,
2228 const struct utrace_regset *regset,
2229 unsigned int pos, unsigned int count,
2230 void *kbuf, void __user *ubuf)
2232 return do_regset_call(do_fpregs_get, target, regset, pos, count, kbuf, ubuf);
2235 static int ia32_fpregs_set(struct task_struct *target,
2236 const struct utrace_regset *regset,
2237 unsigned int pos, unsigned int count,
2238 const void *kbuf, const void __user *ubuf)
2240 return do_regset_call(do_fpregs_set, target, regset, pos, count, kbuf, ubuf);
2243 static int ia32_fpxregs_get(struct task_struct *target,
2244 const struct utrace_regset *regset,
2245 unsigned int pos, unsigned int count,
2246 void *kbuf, void __user *ubuf)
2248 return do_regset_call(do_fpxregs_get, target, regset, pos, count, kbuf, ubuf);
2251 static int ia32_fpxregs_set(struct task_struct *target,
2252 const struct utrace_regset *regset,
2253 unsigned int pos, unsigned int count,
2254 const void *kbuf, const void __user *ubuf)
2256 return do_regset_call(do_fpxregs_set, target, regset, pos, count, kbuf, ubuf);
2259 static int ia32_genregs_get(struct task_struct *target,
2260 const struct utrace_regset *regset,
2261 unsigned int pos, unsigned int count,
2262 void *kbuf, void __user *ubuf)
2267 *kp++ = getreg(target, pos);
2272 u32 __user *up = ubuf;
2274 if (__put_user(getreg(target, pos), up++))
2283 static int ia32_genregs_set(struct task_struct *target,
2284 const struct utrace_regset *regset,
2285 unsigned int pos, unsigned int count,
2286 const void *kbuf, const void __user *ubuf)
2291 const u32 *kp = kbuf;
2292 while (!ret && count > 0) {
2293 putreg(target, pos, *kp++);
2298 const u32 __user *up = ubuf;
2300 while (!ret && count > 0) {
2301 ret = __get_user(val, up++);
2303 putreg(target, pos, val);
2312 * This should match arch/i386/kernel/ptrace.c:native_regsets.
2315 static const struct utrace_regset ia32_regsets[] = {
2317 .n = sizeof(struct user_regs_struct32)/4,
2318 .size = 4, .align = 4,
2319 .get = ia32_genregs_get, .set = ia32_genregs_set
2322 .n = sizeof(struct ia32_user_i387_struct) / 4,
2323 .size = 4, .align = 4,
2324 .get = ia32_fpregs_get, .set = ia32_fpregs_set
2327 .n = sizeof(struct ia32_user_fxsr_struct) / 4,
2328 .size = 4, .align = 4,
2329 .get = ia32_fpxregs_get, .set = ia32_fpxregs_set
2333 const struct utrace_regset_view utrace_ia32_view = {
2334 .name = "i386", .e_machine = EM_386,
2335 .regsets = ia32_regsets, .n = ARRAY_SIZE(ia32_regsets)
2337 EXPORT_SYMBOL_GPL(utrace_ia32_view);
2340 #ifdef CONFIG_PTRACE
2342 * This matches the arch/i386/kernel/ptrace.c definitions.
2345 static const struct ptrace_layout_segment ia32_uarea[] = {
2346 {0, sizeof(struct user_regs_struct32), 0, 0},
2350 fastcall int arch_compat_ptrace(compat_long_t *request,
2351 struct task_struct *child,
2352 struct utrace_attached_engine *engine,
2353 compat_ulong_t addr, compat_ulong_t data,
2354 compat_long_t *retval)
2357 case PTRACE_PEEKUSR:
2358 return ptrace_compat_peekusr(child, engine, ia32_uarea,
2360 case PTRACE_POKEUSR:
2361 return ptrace_compat_pokeusr(child, engine, ia32_uarea,
2363 case IA32_PTRACE_GETREGS:
2364 return ptrace_whole_regset(child, engine, data, 0, 0);
2365 case IA32_PTRACE_SETREGS:
2366 return ptrace_whole_regset(child, engine, data, 0, 1);
2367 case IA32_PTRACE_GETFPREGS:
2368 return ptrace_whole_regset(child, engine, data, 1, 0);
2369 case IA32_PTRACE_SETFPREGS:
2370 return ptrace_whole_regset(child, engine, data, 1, 1);
2371 case IA32_PTRACE_GETFPXREGS:
2372 return ptrace_whole_regset(child, engine, data, 2, 0);
2373 case IA32_PTRACE_SETFPXREGS:
2374 return ptrace_whole_regset(child, engine, data, 2, 1);
2382 unsigned int ss_flags;
2383 unsigned int ss_size;
2387 sys32_sigaltstack (ia32_stack_t __user *uss32, ia32_stack_t __user *uoss32,
2388 long arg2, long arg3, long arg4, long arg5, long arg6,
2389 long arg7, struct pt_regs pt)
2394 mm_segment_t old_fs = get_fs();
2397 if (copy_from_user(&buf32, uss32, sizeof(ia32_stack_t)))
2399 uss.ss_sp = (void __user *) (long) buf32.ss_sp;
2400 uss.ss_flags = buf32.ss_flags;
2401 /* MINSIGSTKSZ is different for ia32 vs ia64. We lie here to pass the
2402 check and set it to the user requested value later */
2403 if ((buf32.ss_flags != SS_DISABLE) && (buf32.ss_size < MINSIGSTKSZ_IA32)) {
2407 uss.ss_size = MINSIGSTKSZ;
2410 ret = do_sigaltstack(uss32 ? (stack_t __user *) &uss : NULL,
2411 (stack_t __user *) &uoss, pt.r12);
2412 current->sas_ss_size = buf32.ss_size;
2418 buf32.ss_sp = (long __user) uoss.ss_sp;
2419 buf32.ss_flags = uoss.ss_flags;
2420 buf32.ss_size = uoss.ss_size;
2421 if (copy_to_user(uoss32, &buf32, sizeof(ia32_stack_t)))
2430 current->state = TASK_INTERRUPTIBLE;
2432 return -ERESTARTNOHAND;
2436 sys32_msync (unsigned int start, unsigned int len, int flags)
2440 if (OFFSET4K(start))
2442 addr = PAGE_START(start);
2443 return sys_msync(addr, len + (start - addr), flags);
2449 unsigned int oldval;
2450 unsigned int oldlenp;
2451 unsigned int newval;
2452 unsigned int newlen;
2453 unsigned int __unused[4];
2456 #ifdef CONFIG_SYSCTL_SYSCALL
2458 sys32_sysctl (struct sysctl32 __user *args)
2460 struct sysctl32 a32;
2461 mm_segment_t old_fs = get_fs ();
2462 void __user *oldvalp, *newvalp;
2467 if (copy_from_user(&a32, args, sizeof(a32)))
2471 * We need to pre-validate these because we have to disable address checking
2472 * before calling do_sysctl() because of OLDLEN but we can't run the risk of the
2473 * user specifying bad addresses here. Well, since we're dealing with 32 bit
2474 * addresses, we KNOW that access_ok() will always succeed, so this is an
2475 * expensive NOP, but so what...
2477 namep = (int __user *) compat_ptr(a32.name);
2478 oldvalp = compat_ptr(a32.oldval);
2479 newvalp = compat_ptr(a32.newval);
2481 if ((oldvalp && get_user(oldlen, (int __user *) compat_ptr(a32.oldlenp)))
2482 || !access_ok(VERIFY_WRITE, namep, 0)
2483 || !access_ok(VERIFY_WRITE, oldvalp, 0)
2484 || !access_ok(VERIFY_WRITE, newvalp, 0))
2489 ret = do_sysctl(namep, a32.nlen, oldvalp, (size_t __user *) &oldlen,
2490 newvalp, (size_t) a32.newlen);
2494 if (oldvalp && put_user (oldlen, (int __user *) compat_ptr(a32.oldlenp)))
2502 sys32_newuname (struct new_utsname __user *name)
2504 int ret = sys_newuname(name);
2507 if (copy_to_user(name->machine, "i686\0\0\0", 8))
2513 sys32_getresuid16 (u16 __user *ruid, u16 __user *euid, u16 __user *suid)
2517 mm_segment_t old_fs = get_fs();
2520 ret = sys_getresuid((uid_t __user *) &a, (uid_t __user *) &b, (uid_t __user *) &c);
2523 if (put_user(a, ruid) || put_user(b, euid) || put_user(c, suid))
2529 sys32_getresgid16 (u16 __user *rgid, u16 __user *egid, u16 __user *sgid)
2533 mm_segment_t old_fs = get_fs();
2536 ret = sys_getresgid((gid_t __user *) &a, (gid_t __user *) &b, (gid_t __user *) &c);
2542 return put_user(a, rgid) | put_user(b, egid) | put_user(c, sgid);
2546 sys32_lseek (unsigned int fd, int offset, unsigned int whence)
2548 /* Sign-extension of "offset" is important here... */
2549 return sys_lseek(fd, offset, whence);
2553 groups16_to_user(short __user *grouplist, struct group_info *group_info)
2558 for (i = 0; i < group_info->ngroups; i++) {
2559 group = (short)GROUP_AT(group_info, i);
2560 if (put_user(group, grouplist+i))
2568 groups16_from_user(struct group_info *group_info, short __user *grouplist)
2573 for (i = 0; i < group_info->ngroups; i++) {
2574 if (get_user(group, grouplist+i))
2576 GROUP_AT(group_info, i) = (gid_t)group;
2583 sys32_getgroups16 (int gidsetsize, short __user *grouplist)
2590 get_group_info(current->group_info);
2591 i = current->group_info->ngroups;
2593 if (i > gidsetsize) {
2597 if (groups16_to_user(grouplist, current->group_info)) {
2603 put_group_info(current->group_info);
2608 sys32_setgroups16 (int gidsetsize, short __user *grouplist)
2610 struct group_info *group_info;
2613 if (!capable(CAP_SETGID))
2615 if ((unsigned)gidsetsize > NGROUPS_MAX)
2618 group_info = groups_alloc(gidsetsize);
2621 retval = groups16_from_user(group_info, grouplist);
2623 put_group_info(group_info);
2627 retval = set_current_groups(group_info);
2628 put_group_info(group_info);
2634 sys32_truncate64 (unsigned int path, unsigned int len_lo, unsigned int len_hi)
2636 return sys_truncate(compat_ptr(path), ((unsigned long) len_hi << 32) | len_lo);
2640 sys32_ftruncate64 (int fd, unsigned int len_lo, unsigned int len_hi)
2642 return sys_ftruncate(fd, ((unsigned long) len_hi << 32) | len_lo);
2646 putstat64 (struct stat64 __user *ubuf, struct kstat *kbuf)
2651 if (clear_user(ubuf, sizeof(*ubuf)))
2654 hdev = huge_encode_dev(kbuf->dev);
2655 err = __put_user(hdev, (u32 __user*)&ubuf->st_dev);
2656 err |= __put_user(hdev >> 32, ((u32 __user*)&ubuf->st_dev) + 1);
2657 err |= __put_user(kbuf->ino, &ubuf->__st_ino);
2658 err |= __put_user(kbuf->ino, &ubuf->st_ino_lo);
2659 err |= __put_user(kbuf->ino >> 32, &ubuf->st_ino_hi);
2660 err |= __put_user(kbuf->mode, &ubuf->st_mode);
2661 err |= __put_user(kbuf->nlink, &ubuf->st_nlink);
2662 err |= __put_user(kbuf->uid, &ubuf->st_uid);
2663 err |= __put_user(kbuf->gid, &ubuf->st_gid);
2664 hdev = huge_encode_dev(kbuf->rdev);
2665 err = __put_user(hdev, (u32 __user*)&ubuf->st_rdev);
2666 err |= __put_user(hdev >> 32, ((u32 __user*)&ubuf->st_rdev) + 1);
2667 err |= __put_user(kbuf->size, &ubuf->st_size_lo);
2668 err |= __put_user((kbuf->size >> 32), &ubuf->st_size_hi);
2669 err |= __put_user(kbuf->atime.tv_sec, &ubuf->st_atime);
2670 err |= __put_user(kbuf->atime.tv_nsec, &ubuf->st_atime_nsec);
2671 err |= __put_user(kbuf->mtime.tv_sec, &ubuf->st_mtime);
2672 err |= __put_user(kbuf->mtime.tv_nsec, &ubuf->st_mtime_nsec);
2673 err |= __put_user(kbuf->ctime.tv_sec, &ubuf->st_ctime);
2674 err |= __put_user(kbuf->ctime.tv_nsec, &ubuf->st_ctime_nsec);
2675 err |= __put_user(kbuf->blksize, &ubuf->st_blksize);
2676 err |= __put_user(kbuf->blocks, &ubuf->st_blocks);
2681 sys32_stat64 (char __user *filename, struct stat64 __user *statbuf)
2684 long ret = vfs_stat(filename, &s);
2686 ret = putstat64(statbuf, &s);
2691 sys32_lstat64 (char __user *filename, struct stat64 __user *statbuf)
2694 long ret = vfs_lstat(filename, &s);
2696 ret = putstat64(statbuf, &s);
2701 sys32_fstat64 (unsigned int fd, struct stat64 __user *statbuf)
2704 long ret = vfs_fstat(fd, &s);
2706 ret = putstat64(statbuf, &s);
2728 sys32_sysinfo (struct sysinfo32 __user *info)
2733 mm_segment_t old_fs = get_fs();
2736 ret = sys_sysinfo((struct sysinfo __user *) &s);
2738 /* Check to see if any memory value is too large for 32-bit and
2739 * scale down if needed.
2741 if ((s.totalram >> 32) || (s.totalswap >> 32)) {
2742 while (s.mem_unit < PAGE_SIZE) {
2746 s.totalram >>= bitcount;
2747 s.freeram >>= bitcount;
2748 s.sharedram >>= bitcount;
2749 s.bufferram >>= bitcount;
2750 s.totalswap >>= bitcount;
2751 s.freeswap >>= bitcount;
2752 s.totalhigh >>= bitcount;
2753 s.freehigh >>= bitcount;
2756 if (!access_ok(VERIFY_WRITE, info, sizeof(*info)))
2759 err = __put_user(s.uptime, &info->uptime);
2760 err |= __put_user(s.loads[0], &info->loads[0]);
2761 err |= __put_user(s.loads[1], &info->loads[1]);
2762 err |= __put_user(s.loads[2], &info->loads[2]);
2763 err |= __put_user(s.totalram, &info->totalram);
2764 err |= __put_user(s.freeram, &info->freeram);
2765 err |= __put_user(s.sharedram, &info->sharedram);
2766 err |= __put_user(s.bufferram, &info->bufferram);
2767 err |= __put_user(s.totalswap, &info->totalswap);
2768 err |= __put_user(s.freeswap, &info->freeswap);
2769 err |= __put_user(s.procs, &info->procs);
2770 err |= __put_user (s.totalhigh, &info->totalhigh);
2771 err |= __put_user (s.freehigh, &info->freehigh);
2772 err |= __put_user (s.mem_unit, &info->mem_unit);
2779 sys32_sched_rr_get_interval (pid_t pid, struct compat_timespec __user *interval)
2781 mm_segment_t old_fs = get_fs();
2786 ret = sys_sched_rr_get_interval(pid, (struct timespec __user *) &t);
2788 if (put_compat_timespec(&t, interval))
2794 sys32_pread (unsigned int fd, void __user *buf, unsigned int count, u32 pos_lo, u32 pos_hi)
2796 return sys_pread64(fd, buf, count, ((unsigned long) pos_hi << 32) | pos_lo);
2800 sys32_pwrite (unsigned int fd, void __user *buf, unsigned int count, u32 pos_lo, u32 pos_hi)
2802 return sys_pwrite64(fd, buf, count, ((unsigned long) pos_hi << 32) | pos_lo);
2806 sys32_sendfile (int out_fd, int in_fd, int __user *offset, unsigned int count)
2808 mm_segment_t old_fs = get_fs();
2812 if (offset && get_user(of, offset))
2816 ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *) &of : NULL, count);
2819 if (offset && put_user(of, offset))
2826 sys32_personality (unsigned int personality)
2830 if (current->personality == PER_LINUX32 && personality == PER_LINUX)
2831 personality = PER_LINUX32;
2832 ret = sys_personality(personality);
2833 if (ret == PER_LINUX32)
2838 asmlinkage unsigned long
2839 sys32_brk (unsigned int brk)
2841 unsigned long ret, obrk;
2842 struct mm_struct *mm = current->mm;
2847 clear_user(compat_ptr(ret), PAGE_ALIGN(ret) - ret);
2851 /* Structure for ia32 emulation on ia64 */
2852 struct epoll_event32
2859 sys32_epoll_ctl(int epfd, int op, int fd, struct epoll_event32 __user *event)
2861 mm_segment_t old_fs = get_fs();
2862 struct epoll_event event64;
2866 if (!access_ok(VERIFY_READ, event, sizeof(struct epoll_event32)))
2869 __get_user(event64.events, &event->events);
2870 __get_user(data_halfword, &event->data[0]);
2871 event64.data = data_halfword;
2872 __get_user(data_halfword, &event->data[1]);
2873 event64.data |= (u64)data_halfword << 32;
2876 error = sys_epoll_ctl(epfd, op, fd, (struct epoll_event __user *) &event64);
2883 sys32_epoll_wait(int epfd, struct epoll_event32 __user * events, int maxevents,
2886 struct epoll_event *events64 = NULL;
2887 mm_segment_t old_fs = get_fs();
2888 int numevents, size;
2890 int do_free_pages = 0;
2892 if (maxevents <= 0) {
2896 /* Verify that the area passed by the user is writeable */
2897 if (!access_ok(VERIFY_WRITE, events, maxevents * sizeof(struct epoll_event32)))
2901 * Allocate space for the intermediate copy. If the space needed
2902 * is large enough to cause kmalloc to fail, then try again with
2905 size = maxevents * sizeof(struct epoll_event);
2906 events64 = kmalloc(size, GFP_KERNEL);
2907 if (events64 == NULL) {
2908 events64 = (struct epoll_event *)
2909 __get_free_pages(GFP_KERNEL, get_order(size));
2910 if (events64 == NULL)
2915 /* Do the system call */
2916 set_fs(KERNEL_DS); /* copy_to/from_user should work on kernel mem*/
2917 numevents = sys_epoll_wait(epfd, (struct epoll_event __user *) events64,
2918 maxevents, timeout);
2921 /* Don't modify userspace memory if we're returning an error */
2922 if (numevents > 0) {
2923 /* Translate the 64-bit structures back into the 32-bit
2925 for (evt_idx = 0; evt_idx < numevents; evt_idx++) {
2926 __put_user(events64[evt_idx].events,
2927 &events[evt_idx].events);
2928 __put_user((u32)events64[evt_idx].data,
2929 &events[evt_idx].data[0]);
2930 __put_user((u32)(events64[evt_idx].data >> 32),
2931 &events[evt_idx].data[1]);
2936 free_pages((unsigned long) events64, get_order(size));
2943 * Get a yet unused TLS descriptor index.
2948 struct thread_struct *t = ¤t->thread;
2951 for (idx = 0; idx < GDT_ENTRY_TLS_ENTRIES; idx++)
2952 if (desc_empty(t->tls_array + idx))
2953 return idx + GDT_ENTRY_TLS_MIN;
2958 * Set a given TLS descriptor:
2961 sys32_set_thread_area (struct ia32_user_desc __user *u_info)
2963 struct thread_struct *t = ¤t->thread;
2964 struct ia32_user_desc info;
2965 struct desc_struct *desc;
2968 if (copy_from_user(&info, u_info, sizeof(info)))
2970 idx = info.entry_number;
2973 * index -1 means the kernel should try to find and allocate an empty descriptor:
2976 idx = get_free_idx();
2979 if (put_user(idx, &u_info->entry_number))
2983 if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
2986 desc = t->tls_array + idx - GDT_ENTRY_TLS_MIN;
2988 cpu = smp_processor_id();
2990 if (LDT_empty(&info)) {
2994 desc->a = LDT_entry_a(&info);
2995 desc->b = LDT_entry_b(&info);
3002 * Get the current Thread-Local Storage area:
3005 #define GET_BASE(desc) ( \
3006 (((desc)->a >> 16) & 0x0000ffff) | \
3007 (((desc)->b << 16) & 0x00ff0000) | \
3008 ( (desc)->b & 0xff000000) )
3010 #define GET_LIMIT(desc) ( \
3011 ((desc)->a & 0x0ffff) | \
3012 ((desc)->b & 0xf0000) )
3014 #define GET_32BIT(desc) (((desc)->b >> 22) & 1)
3015 #define GET_CONTENTS(desc) (((desc)->b >> 10) & 3)
3016 #define GET_WRITABLE(desc) (((desc)->b >> 9) & 1)
3017 #define GET_LIMIT_PAGES(desc) (((desc)->b >> 23) & 1)
3018 #define GET_PRESENT(desc) (((desc)->b >> 15) & 1)
3019 #define GET_USEABLE(desc) (((desc)->b >> 20) & 1)
3022 sys32_get_thread_area (struct ia32_user_desc __user *u_info)
3024 struct ia32_user_desc info;
3025 struct desc_struct *desc;
3028 if (get_user(idx, &u_info->entry_number))
3030 if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
3033 desc = current->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;
3035 info.entry_number = idx;
3036 info.base_addr = GET_BASE(desc);
3037 info.limit = GET_LIMIT(desc);
3038 info.seg_32bit = GET_32BIT(desc);
3039 info.contents = GET_CONTENTS(desc);
3040 info.read_exec_only = !GET_WRITABLE(desc);
3041 info.limit_in_pages = GET_LIMIT_PAGES(desc);
3042 info.seg_not_present = !GET_PRESENT(desc);
3043 info.useable = GET_USEABLE(desc);
3045 if (copy_to_user(u_info, &info, sizeof(info)))
3050 long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high,
3051 __u32 len_low, __u32 len_high, int advice)
3053 return sys_fadvise64_64(fd,
3054 (((u64)offset_high)<<32) | offset_low,
3055 (((u64)len_high)<<32) | len_low,
3059 #ifdef NOTYET /* UNTESTED FOR IA64 FROM HERE DOWN */
3061 asmlinkage long sys32_setreuid(compat_uid_t ruid, compat_uid_t euid)
3065 sruid = (ruid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)ruid);
3066 seuid = (euid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)euid);
3067 return sys_setreuid(sruid, seuid);
3071 sys32_setresuid(compat_uid_t ruid, compat_uid_t euid,
3074 uid_t sruid, seuid, ssuid;
3076 sruid = (ruid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)ruid);
3077 seuid = (euid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)euid);
3078 ssuid = (suid == (compat_uid_t)-1) ? ((uid_t)-1) : ((uid_t)suid);
3079 return sys_setresuid(sruid, seuid, ssuid);
3083 sys32_setregid(compat_gid_t rgid, compat_gid_t egid)
3087 srgid = (rgid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)rgid);
3088 segid = (egid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)egid);
3089 return sys_setregid(srgid, segid);
3093 sys32_setresgid(compat_gid_t rgid, compat_gid_t egid,
3096 gid_t srgid, segid, ssgid;
3098 srgid = (rgid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)rgid);
3099 segid = (egid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)egid);
3100 ssgid = (sgid == (compat_gid_t)-1) ? ((gid_t)-1) : ((gid_t)sgid);
3101 return sys_setresgid(srgid, segid, ssgid);