| /* |
| * linux/arch/arm26/lib/uaccess-user.S |
| * |
| * Copyright (C) 1995, 1996,1997,1998 Russell King |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 as |
| * published by the Free Software Foundation. |
| * |
| * Routines to block copy data to/from user memory |
| * These are highly optimised both for the 4k page size |
| * and for various alignments. |
| */ |
| #include <linux/linkage.h> |
| #include <asm/assembler.h> |
| #include <asm/errno.h> |
| #include <asm/page.h> |
| |
| .text |
| |
| //FIXME - surely this can be done in C not asm, removing the problem of keeping C and asm in sync? (this is a struct uaccess_t) |
| .globl uaccess_user |
| uaccess_user: |
| .word uaccess_user_put_byte |
| .word uaccess_user_get_byte |
| .word uaccess_user_put_half |
| .word uaccess_user_get_half |
| .word uaccess_user_put_word |
| .word uaccess_user_get_word |
| .word uaccess_user_put_dword |
| .word uaccess_user_copy_from_user |
| .word uaccess_user_copy_to_user |
| .word uaccess_user_clear_user |
| .word uaccess_user_strncpy_from_user |
| .word uaccess_user_strnlen_user |
| |
| |
| @ In : r0 = x, r1 = addr, r2 = error |
| @ Out: r2 = error |
| uaccess_user_put_byte: |
| stmfd sp!, {lr} |
| USER( strbt r0, [r1]) |
| ldmfd sp!, {pc}^ |
| |
| @ In : r0 = x, r1 = addr, r2 = error |
| @ Out: r2 = error |
| uaccess_user_put_half: |
| stmfd sp!, {lr} |
| USER( strbt r0, [r1], #1) |
| mov r0, r0, lsr #8 |
| USER( strbt r0, [r1]) |
| ldmfd sp!, {pc}^ |
| |
| @ In : r0 = x, r1 = addr, r2 = error |
| @ Out: r2 = error |
| uaccess_user_put_word: |
| stmfd sp!, {lr} |
| USER( strt r0, [r1]) |
| ldmfd sp!, {pc}^ |
| |
| @ In : r0 = x, r1 = addr, r2 = error |
| @ Out: r2 = error |
| uaccess_user_put_dword: |
| stmfd sp!, {lr} |
| USER( strt r0, [r1], #4) |
| USER( strt r0, [r1], #0) |
| ldmfd sp!, {pc}^ |
| |
| 9001: mov r2, #-EFAULT |
| ldmfd sp!, {pc}^ |
| |
| |
| @ In : r0 = addr, r1 = error |
| @ Out: r0 = x, r1 = error |
| uaccess_user_get_byte: |
| stmfd sp!, {lr} |
| USER( ldrbt r0, [r0]) |
| ldmfd sp!, {pc}^ |
| |
| @ In : r0 = addr, r1 = error |
| @ Out: r0 = x, r1 = error |
| uaccess_user_get_half: |
| stmfd sp!, {lr} |
| USER( ldrt r0, [r0]) |
| mov r0, r0, lsl #16 |
| mov r0, r0, lsr #16 |
| ldmfd sp!, {pc}^ |
| |
| @ In : r0 = addr, r1 = error |
| @ Out: r0 = x, r1 = error |
| uaccess_user_get_word: |
| stmfd sp!, {lr} |
| USER( ldrt r0, [r0]) |
| ldmfd sp!, {pc}^ |
| |
| 9001: mov r1, #-EFAULT |
| ldmfd sp!, {pc}^ |
| |
| /* Prototype: int uaccess_user_copy_to_user(void *to, const char *from, size_t n) |
| * Purpose : copy a block to user memory from kernel memory |
| * Params : to - user memory |
| * : from - kernel memory |
| * : n - number of bytes to copy |
| * Returns : Number of bytes NOT copied. |
| */ |
| |
| .c2u_dest_not_aligned: |
| rsb ip, ip, #4 |
| cmp ip, #2 |
| ldrb r3, [r1], #1 |
| USER( strbt r3, [r0], #1) @ May fault |
| ldrgeb r3, [r1], #1 |
| USER( strgebt r3, [r0], #1) @ May fault |
| ldrgtb r3, [r1], #1 |
| USER( strgtbt r3, [r0], #1) @ May fault |
| sub r2, r2, ip |
| b .c2u_dest_aligned |
| |
| ENTRY(uaccess_user_copy_to_user) |
| stmfd sp!, {r2, r4 - r7, lr} |
| cmp r2, #4 |
| blt .c2u_not_enough |
| ands ip, r0, #3 |
| bne .c2u_dest_not_aligned |
| .c2u_dest_aligned: |
| |
| ands ip, r1, #3 |
| bne .c2u_src_not_aligned |
| /* |
| * Seeing as there has to be at least 8 bytes to copy, we can |
| * copy one word, and force a user-mode page fault... |
| */ |
| |
| .c2u_0fupi: subs r2, r2, #4 |
| addmi ip, r2, #4 |
| bmi .c2u_0nowords |
| ldr r3, [r1], #4 |
| USER( strt r3, [r0], #4) @ May fault |
| mov ip, r0, lsl #32 - PAGE_SHIFT @ On each page, use a ld/st??t instruction |
| rsb ip, ip, #0 |
| movs ip, ip, lsr #32 - PAGE_SHIFT |
| beq .c2u_0fupi |
| /* |
| * ip = max no. of bytes to copy before needing another "strt" insn |
| */ |
| cmp r2, ip |
| movlt ip, r2 |
| sub r2, r2, ip |
| subs ip, ip, #32 |
| blt .c2u_0rem8lp |
| |
| .c2u_0cpy8lp: ldmia r1!, {r3 - r6} |
| stmia r0!, {r3 - r6} @ Shouldnt fault |
| ldmia r1!, {r3 - r6} |
| stmia r0!, {r3 - r6} @ Shouldnt fault |
| subs ip, ip, #32 |
| bpl .c2u_0cpy8lp |
| .c2u_0rem8lp: cmn ip, #16 |
| ldmgeia r1!, {r3 - r6} |
| stmgeia r0!, {r3 - r6} @ Shouldnt fault |
| tst ip, #8 |
| ldmneia r1!, {r3 - r4} |
| stmneia r0!, {r3 - r4} @ Shouldnt fault |
| tst ip, #4 |
| ldrne r3, [r1], #4 |
| strnet r3, [r0], #4 @ Shouldnt fault |
| ands ip, ip, #3 |
| beq .c2u_0fupi |
| .c2u_0nowords: teq ip, #0 |
| beq .c2u_finished |
| .c2u_nowords: cmp ip, #2 |
| ldrb r3, [r1], #1 |
| USER( strbt r3, [r0], #1) @ May fault |
| ldrgeb r3, [r1], #1 |
| USER( strgebt r3, [r0], #1) @ May fault |
| ldrgtb r3, [r1], #1 |
| USER( strgtbt r3, [r0], #1) @ May fault |
| b .c2u_finished |
| |
| .c2u_not_enough: |
| movs ip, r2 |
| bne .c2u_nowords |
| .c2u_finished: mov r0, #0 |
| LOADREGS(fd,sp!,{r2, r4 - r7, pc}) |
| |
| .c2u_src_not_aligned: |
| bic r1, r1, #3 |
| ldr r7, [r1], #4 |
| cmp ip, #2 |
| bgt .c2u_3fupi |
| beq .c2u_2fupi |
| .c2u_1fupi: subs r2, r2, #4 |
| addmi ip, r2, #4 |
| bmi .c2u_1nowords |
| mov r3, r7, pull #8 |
| ldr r7, [r1], #4 |
| orr r3, r3, r7, push #24 |
| USER( strt r3, [r0], #4) @ May fault |
| mov ip, r0, lsl #32 - PAGE_SHIFT |
| rsb ip, ip, #0 |
| movs ip, ip, lsr #32 - PAGE_SHIFT |
| beq .c2u_1fupi |
| cmp r2, ip |
| movlt ip, r2 |
| sub r2, r2, ip |
| subs ip, ip, #16 |
| blt .c2u_1rem8lp |
| |
| .c2u_1cpy8lp: mov r3, r7, pull #8 |
| ldmia r1!, {r4 - r7} |
| orr r3, r3, r4, push #24 |
| mov r4, r4, pull #8 |
| orr r4, r4, r5, push #24 |
| mov r5, r5, pull #8 |
| orr r5, r5, r6, push #24 |
| mov r6, r6, pull #8 |
| orr r6, r6, r7, push #24 |
| stmia r0!, {r3 - r6} @ Shouldnt fault |
| subs ip, ip, #16 |
| bpl .c2u_1cpy8lp |
| .c2u_1rem8lp: tst ip, #8 |
| movne r3, r7, pull #8 |
| ldmneia r1!, {r4, r7} |
| orrne r3, r3, r4, push #24 |
| movne r4, r4, pull #8 |
| orrne r4, r4, r7, push #24 |
| stmneia r0!, {r3 - r4} @ Shouldnt fault |
| tst ip, #4 |
| movne r3, r7, pull #8 |
| ldrne r7, [r1], #4 |
| orrne r3, r3, r7, push #24 |
| strnet r3, [r0], #4 @ Shouldnt fault |
| ands ip, ip, #3 |
| beq .c2u_1fupi |
| .c2u_1nowords: mov r3, r7, lsr #byte(1) |
| teq ip, #0 |
| beq .c2u_finished |
| cmp ip, #2 |
| USER( strbt r3, [r0], #1) @ May fault |
| movge r3, r7, lsr #byte(2) |
| USER( strgebt r3, [r0], #1) @ May fault |
| movgt r3, r7, lsr #byte(3) |
| USER( strgtbt r3, [r0], #1) @ May fault |
| b .c2u_finished |
| |
| .c2u_2fupi: subs r2, r2, #4 |
| addmi ip, r2, #4 |
| bmi .c2u_2nowords |
| mov r3, r7, pull #16 |
| ldr r7, [r1], #4 |
| orr r3, r3, r7, push #16 |
| USER( strt r3, [r0], #4) @ May fault |
| mov ip, r0, lsl #32 - PAGE_SHIFT |
| rsb ip, ip, #0 |
| movs ip, ip, lsr #32 - PAGE_SHIFT |
| beq .c2u_2fupi |
| cmp r2, ip |
| movlt ip, r2 |
| sub r2, r2, ip |
| subs ip, ip, #16 |
| blt .c2u_2rem8lp |
| |
| .c2u_2cpy8lp: mov r3, r7, pull #16 |
| ldmia r1!, {r4 - r7} |
| orr r3, r3, r4, push #16 |
| mov r4, r4, pull #16 |
| orr r4, r4, r5, push #16 |
| mov r5, r5, pull #16 |
| orr r5, r5, r6, push #16 |
| mov r6, r6, pull #16 |
| orr r6, r6, r7, push #16 |
| stmia r0!, {r3 - r6} @ Shouldnt fault |
| subs ip, ip, #16 |
| bpl .c2u_2cpy8lp |
| .c2u_2rem8lp: tst ip, #8 |
| movne r3, r7, pull #16 |
| ldmneia r1!, {r4, r7} |
| orrne r3, r3, r4, push #16 |
| movne r4, r4, pull #16 |
| orrne r4, r4, r7, push #16 |
| stmneia r0!, {r3 - r4} @ Shouldnt fault |
| tst ip, #4 |
| movne r3, r7, pull #16 |
| ldrne r7, [r1], #4 |
| orrne r3, r3, r7, push #16 |
| strnet r3, [r0], #4 @ Shouldnt fault |
| ands ip, ip, #3 |
| beq .c2u_2fupi |
| .c2u_2nowords: mov r3, r7, lsr #byte(2) |
| teq ip, #0 |
| beq .c2u_finished |
| cmp ip, #2 |
| USER( strbt r3, [r0], #1) @ May fault |
| movge r3, r7, lsr #byte(3) |
| USER( strgebt r3, [r0], #1) @ May fault |
| ldrgtb r3, [r1], #0 |
| USER( strgtbt r3, [r0], #1) @ May fault |
| b .c2u_finished |
| |
| .c2u_3fupi: subs r2, r2, #4 |
| addmi ip, r2, #4 |
| bmi .c2u_3nowords |
| mov r3, r7, pull #24 |
| ldr r7, [r1], #4 |
| orr r3, r3, r7, push #8 |
| USER( strt r3, [r0], #4) @ May fault |
| mov ip, r0, lsl #32 - PAGE_SHIFT |
| rsb ip, ip, #0 |
| movs ip, ip, lsr #32 - PAGE_SHIFT |
| beq .c2u_3fupi |
| cmp r2, ip |
| movlt ip, r2 |
| sub r2, r2, ip |
| subs ip, ip, #16 |
| blt .c2u_3rem8lp |
| |
| .c2u_3cpy8lp: mov r3, r7, pull #24 |
| ldmia r1!, {r4 - r7} |
| orr r3, r3, r4, push #8 |
| mov r4, r4, pull #24 |
| orr r4, r4, r5, push #8 |
| mov r5, r5, pull #24 |
| orr r5, r5, r6, push #8 |
| mov r6, r6, pull #24 |
| orr r6, r6, r7, push #8 |
| stmia r0!, {r3 - r6} @ Shouldnt fault |
| subs ip, ip, #16 |
| bpl .c2u_3cpy8lp |
| .c2u_3rem8lp: tst ip, #8 |
| movne r3, r7, pull #24 |
| ldmneia r1!, {r4, r7} |
| orrne r3, r3, r4, push #8 |
| movne r4, r4, pull #24 |
| orrne r4, r4, r7, push #8 |
| stmneia r0!, {r3 - r4} @ Shouldnt fault |
| tst ip, #4 |
| movne r3, r7, pull #24 |
| ldrne r7, [r1], #4 |
| orrne r3, r3, r7, push #8 |
| strnet r3, [r0], #4 @ Shouldnt fault |
| ands ip, ip, #3 |
| beq .c2u_3fupi |
| .c2u_3nowords: mov r3, r7, lsr #byte(3) |
| teq ip, #0 |
| beq .c2u_finished |
| cmp ip, #2 |
| USER( strbt r3, [r0], #1) @ May fault |
| ldrgeb r3, [r1], #1 |
| USER( strgebt r3, [r0], #1) @ May fault |
| ldrgtb r3, [r1], #0 |
| USER( strgtbt r3, [r0], #1) @ May fault |
| b .c2u_finished |
| |
| .section .fixup,"ax" |
| .align 0 |
| 9001: LOADREGS(fd,sp!, {r0, r4 - r7, pc}) |
| .previous |
| |
| /* Prototype: unsigned long uaccess_user_copy_from_user(void *to,const void *from,unsigned long n); |
| * Purpose : copy a block from user memory to kernel memory |
| * Params : to - kernel memory |
| * : from - user memory |
| * : n - number of bytes to copy |
| * Returns : Number of bytes NOT copied. |
| */ |
| .cfu_dest_not_aligned: |
| rsb ip, ip, #4 |
| cmp ip, #2 |
| USER( ldrbt r3, [r1], #1) @ May fault |
| strb r3, [r0], #1 |
| USER( ldrgebt r3, [r1], #1) @ May fault |
| strgeb r3, [r0], #1 |
| USER( ldrgtbt r3, [r1], #1) @ May fault |
| strgtb r3, [r0], #1 |
| sub r2, r2, ip |
| b .cfu_dest_aligned |
| |
| ENTRY(uaccess_user_copy_from_user) |
| stmfd sp!, {r0, r2, r4 - r7, lr} |
| cmp r2, #4 |
| blt .cfu_not_enough |
| ands ip, r0, #3 |
| bne .cfu_dest_not_aligned |
| .cfu_dest_aligned: |
| ands ip, r1, #3 |
| bne .cfu_src_not_aligned |
| /* |
| * Seeing as there has to be at least 8 bytes to copy, we can |
| * copy one word, and force a user-mode page fault... |
| */ |
| |
| .cfu_0fupi: subs r2, r2, #4 |
| addmi ip, r2, #4 |
| bmi .cfu_0nowords |
| USER( ldrt r3, [r1], #4) |
| str r3, [r0], #4 |
| mov ip, r1, lsl #32 - PAGE_SHIFT @ On each page, use a ld/st??t instruction |
| rsb ip, ip, #0 |
| movs ip, ip, lsr #32 - PAGE_SHIFT |
| beq .cfu_0fupi |
| /* |
| * ip = max no. of bytes to copy before needing another "strt" insn |
| */ |
| cmp r2, ip |
| movlt ip, r2 |
| sub r2, r2, ip |
| subs ip, ip, #32 |
| blt .cfu_0rem8lp |
| |
| .cfu_0cpy8lp: ldmia r1!, {r3 - r6} @ Shouldnt fault |
| stmia r0!, {r3 - r6} |
| ldmia r1!, {r3 - r6} @ Shouldnt fault |
| stmia r0!, {r3 - r6} |
| subs ip, ip, #32 |
| bpl .cfu_0cpy8lp |
| .cfu_0rem8lp: cmn ip, #16 |
| ldmgeia r1!, {r3 - r6} @ Shouldnt fault |
| stmgeia r0!, {r3 - r6} |
| tst ip, #8 |
| ldmneia r1!, {r3 - r4} @ Shouldnt fault |
| stmneia r0!, {r3 - r4} |
| tst ip, #4 |
| ldrnet r3, [r1], #4 @ Shouldnt fault |
| strne r3, [r0], #4 |
| ands ip, ip, #3 |
| beq .cfu_0fupi |
| .cfu_0nowords: teq ip, #0 |
| beq .cfu_finished |
| .cfu_nowords: cmp ip, #2 |
| USER( ldrbt r3, [r1], #1) @ May fault |
| strb r3, [r0], #1 |
| USER( ldrgebt r3, [r1], #1) @ May fault |
| strgeb r3, [r0], #1 |
| USER( ldrgtbt r3, [r1], #1) @ May fault |
| strgtb r3, [r0], #1 |
| b .cfu_finished |
| |
| .cfu_not_enough: |
| movs ip, r2 |
| bne .cfu_nowords |
| .cfu_finished: mov r0, #0 |
| add sp, sp, #8 |
| LOADREGS(fd,sp!,{r4 - r7, pc}) |
| |
| .cfu_src_not_aligned: |
| bic r1, r1, #3 |
| USER( ldrt r7, [r1], #4) @ May fault |
| cmp ip, #2 |
| bgt .cfu_3fupi |
| beq .cfu_2fupi |
| .cfu_1fupi: subs r2, r2, #4 |
| addmi ip, r2, #4 |
| bmi .cfu_1nowords |
| mov r3, r7, pull #8 |
| USER( ldrt r7, [r1], #4) @ May fault |
| orr r3, r3, r7, push #24 |
| str r3, [r0], #4 |
| mov ip, r1, lsl #32 - PAGE_SHIFT |
| rsb ip, ip, #0 |
| movs ip, ip, lsr #32 - PAGE_SHIFT |
| beq .cfu_1fupi |
| cmp r2, ip |
| movlt ip, r2 |
| sub r2, r2, ip |
| subs ip, ip, #16 |
| blt .cfu_1rem8lp |
| |
| .cfu_1cpy8lp: mov r3, r7, pull #8 |
| ldmia r1!, {r4 - r7} @ Shouldnt fault |
| orr r3, r3, r4, push #24 |
| mov r4, r4, pull #8 |
| orr r4, r4, r5, push #24 |
| mov r5, r5, pull #8 |
| orr r5, r5, r6, push #24 |
| mov r6, r6, pull #8 |
| orr r6, r6, r7, push #24 |
| stmia r0!, {r3 - r6} |
| subs ip, ip, #16 |
| bpl .cfu_1cpy8lp |
| .cfu_1rem8lp: tst ip, #8 |
| movne r3, r7, pull #8 |
| ldmneia r1!, {r4, r7} @ Shouldnt fault |
| orrne r3, r3, r4, push #24 |
| movne r4, r4, pull #8 |
| orrne r4, r4, r7, push #24 |
| stmneia r0!, {r3 - r4} |
| tst ip, #4 |
| movne r3, r7, pull #8 |
| USER( ldrnet r7, [r1], #4) @ May fault |
| orrne r3, r3, r7, push #24 |
| strne r3, [r0], #4 |
| ands ip, ip, #3 |
| beq .cfu_1fupi |
| .cfu_1nowords: mov r3, r7, lsr #byte(1) |
| teq ip, #0 |
| beq .cfu_finished |
| cmp ip, #2 |
| strb r3, [r0], #1 |
| movge r3, r7, lsr #byte(2) |
| strgeb r3, [r0], #1 |
| movgt r3, r7, lsr #byte(3) |
| strgtb r3, [r0], #1 |
| b .cfu_finished |
| |
| .cfu_2fupi: subs r2, r2, #4 |
| addmi ip, r2, #4 |
| bmi .cfu_2nowords |
| mov r3, r7, pull #16 |
| USER( ldrt r7, [r1], #4) @ May fault |
| orr r3, r3, r7, push #16 |
| str r3, [r0], #4 |
| mov ip, r1, lsl #32 - PAGE_SHIFT |
| rsb ip, ip, #0 |
| movs ip, ip, lsr #32 - PAGE_SHIFT |
| beq .cfu_2fupi |
| cmp r2, ip |
| movlt ip, r2 |
| sub r2, r2, ip |
| subs ip, ip, #16 |
| blt .cfu_2rem8lp |
| |
| .cfu_2cpy8lp: mov r3, r7, pull #16 |
| ldmia r1!, {r4 - r7} @ Shouldnt fault |
| orr r3, r3, r4, push #16 |
| mov r4, r4, pull #16 |
| orr r4, r4, r5, push #16 |
| mov r5, r5, pull #16 |
| orr r5, r5, r6, push #16 |
| mov r6, r6, pull #16 |
| orr r6, r6, r7, push #16 |
| stmia r0!, {r3 - r6} |
| subs ip, ip, #16 |
| bpl .cfu_2cpy8lp |
| .cfu_2rem8lp: tst ip, #8 |
| movne r3, r7, pull #16 |
| ldmneia r1!, {r4, r7} @ Shouldnt fault |
| orrne r3, r3, r4, push #16 |
| movne r4, r4, pull #16 |
| orrne r4, r4, r7, push #16 |
| stmneia r0!, {r3 - r4} |
| tst ip, #4 |
| movne r3, r7, pull #16 |
| USER( ldrnet r7, [r1], #4) @ May fault |
| orrne r3, r3, r7, push #16 |
| strne r3, [r0], #4 |
| ands ip, ip, #3 |
| beq .cfu_2fupi |
| .cfu_2nowords: mov r3, r7, lsr #byte(2) |
| teq ip, #0 |
| beq .cfu_finished |
| cmp ip, #2 |
| strb r3, [r0], #1 |
| movge r3, r7, lsr #byte(3) |
| strgeb r3, [r0], #1 |
| USER( ldrgtbt r3, [r1], #0) @ May fault |
| strgtb r3, [r0], #1 |
| b .cfu_finished |
| |
| .cfu_3fupi: subs r2, r2, #4 |
| addmi ip, r2, #4 |
| bmi .cfu_3nowords |
| mov r3, r7, pull #24 |
| USER( ldrt r7, [r1], #4) @ May fault |
| orr r3, r3, r7, push #8 |
| str r3, [r0], #4 |
| mov ip, r1, lsl #32 - PAGE_SHIFT |
| rsb ip, ip, #0 |
| movs ip, ip, lsr #32 - PAGE_SHIFT |
| beq .cfu_3fupi |
| cmp r2, ip |
| movlt ip, r2 |
| sub r2, r2, ip |
| subs ip, ip, #16 |
| blt .cfu_3rem8lp |
| |
| .cfu_3cpy8lp: mov r3, r7, pull #24 |
| ldmia r1!, {r4 - r7} @ Shouldnt fault |
| orr r3, r3, r4, push #8 |
| mov r4, r4, pull #24 |
| orr r4, r4, r5, push #8 |
| mov r5, r5, pull #24 |
| orr r5, r5, r6, push #8 |
| mov r6, r6, pull #24 |
| orr r6, r6, r7, push #8 |
| stmia r0!, {r3 - r6} |
| subs ip, ip, #16 |
| bpl .cfu_3cpy8lp |
| .cfu_3rem8lp: tst ip, #8 |
| movne r3, r7, pull #24 |
| ldmneia r1!, {r4, r7} @ Shouldnt fault |
| orrne r3, r3, r4, push #8 |
| movne r4, r4, pull #24 |
| orrne r4, r4, r7, push #8 |
| stmneia r0!, {r3 - r4} |
| tst ip, #4 |
| movne r3, r7, pull #24 |
| USER( ldrnet r7, [r1], #4) @ May fault |
| orrne r3, r3, r7, push #8 |
| strne r3, [r0], #4 |
| ands ip, ip, #3 |
| beq .cfu_3fupi |
| .cfu_3nowords: mov r3, r7, lsr #byte(3) |
| teq ip, #0 |
| beq .cfu_finished |
| cmp ip, #2 |
| strb r3, [r0], #1 |
| USER( ldrgebt r3, [r1], #1) @ May fault |
| strgeb r3, [r0], #1 |
| USER( ldrgtbt r3, [r1], #1) @ May fault |
| strgtb r3, [r0], #1 |
| b .cfu_finished |
| |
| .section .fixup,"ax" |
| .align 0 |
| /* |
| * We took an exception. r0 contains a pointer to |
| * the byte not copied. |
| */ |
| 9001: ldr r2, [sp], #4 @ void *to |
| sub r2, r0, r2 @ bytes copied |
| ldr r1, [sp], #4 @ unsigned long count |
| subs r4, r1, r2 @ bytes left to copy |
| movne r1, r4 |
| blne __memzero |
| mov r0, r4 |
| LOADREGS(fd,sp!, {r4 - r7, pc}) |
| .previous |
| |
| /* Prototype: int uaccess_user_clear_user(void *addr, size_t sz) |
| * Purpose : clear some user memory |
| * Params : addr - user memory address to clear |
| * : sz - number of bytes to clear |
| * Returns : number of bytes NOT cleared |
| */ |
| ENTRY(uaccess_user_clear_user) |
| stmfd sp!, {r1, lr} |
| mov r2, #0 |
| cmp r1, #4 |
| blt 2f |
| ands ip, r0, #3 |
| beq 1f |
| cmp ip, #2 |
| USER( strbt r2, [r0], #1) |
| USER( strlebt r2, [r0], #1) |
| USER( strltbt r2, [r0], #1) |
| rsb ip, ip, #4 |
| sub r1, r1, ip @ 7 6 5 4 3 2 1 |
| 1: subs r1, r1, #8 @ -1 -2 -3 -4 -5 -6 -7 |
| USER( strplt r2, [r0], #4) |
| USER( strplt r2, [r0], #4) |
| bpl 1b |
| adds r1, r1, #4 @ 3 2 1 0 -1 -2 -3 |
| USER( strplt r2, [r0], #4) |
| 2: tst r1, #2 @ 1x 1x 0x 0x 1x 1x 0x |
| USER( strnebt r2, [r0], #1) |
| USER( strnebt r2, [r0], #1) |
| tst r1, #1 @ x1 x0 x1 x0 x1 x0 x1 |
| USER( strnebt r2, [r0], #1) |
| mov r0, #0 |
| LOADREGS(fd,sp!, {r1, pc}) |
| |
| .section .fixup,"ax" |
| .align 0 |
| 9001: LOADREGS(fd,sp!, {r0, pc}) |
| .previous |
| |
| /* |
| * Copy a string from user space to kernel space. |
| * r0 = dst, r1 = src, r2 = byte length |
| * returns the number of characters copied (strlen of copied string), |
| * -EFAULT on exception, or "len" if we fill the whole buffer |
| */ |
| ENTRY(uaccess_user_strncpy_from_user) |
| save_lr |
| mov ip, r1 |
| 1: subs r2, r2, #1 |
| USER( ldrplbt r3, [r1], #1) |
| bmi 2f |
| strb r3, [r0], #1 |
| teq r3, #0 |
| bne 1b |
| sub r1, r1, #1 @ take NUL character out of count |
| 2: sub r0, r1, ip |
| restore_pc |
| |
| .section .fixup,"ax" |
| .align 0 |
| 9001: mov r3, #0 |
| strb r3, [r0, #0] @ null terminate |
| mov r0, #-EFAULT |
| restore_pc |
| .previous |
| |
| /* Prototype: unsigned long uaccess_user_strnlen_user(const char *str, long n) |
| * Purpose : get length of a string in user memory |
| * Params : str - address of string in user memory |
| * Returns : length of string *including terminator* |
| * or zero on exception, or n + 1 if too long |
| */ |
| ENTRY(uaccess_user_strnlen_user) |
| save_lr |
| mov r2, r0 |
| 1: |
| USER( ldrbt r3, [r0], #1) |
| teq r3, #0 |
| beq 2f |
| subs r1, r1, #1 |
| bne 1b |
| add r0, r0, #1 |
| 2: sub r0, r0, r2 |
| restore_pc |
| |
| .section .fixup,"ax" |
| .align 0 |
| 9001: mov r0, #0 |
| restore_pc |
| .previous |
| |
