Ignore:
Timestamp:
Apr 14, 2017, 9:41:36 PM (3 months ago)
Author:
brainslayer
Message:

kernel update

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/linux/universal/linux-4.4/arch/metag/lib/usercopy.c

    r28606 r31859  
    3030                "1:\n"                                           \
    3131                "       .section .fixup,\"ax\"\n"                \
    32                 "       MOV D1Ar1,#0\n"                          \
    3332                FIXUP                                            \
    3433                "       MOVT    D1Ar1,#HI(1b)\n"                 \
     
    261260                "22:\n"                                                 \
    262261                "MSETL  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
     262                "23:\n"                                                 \
    263263                "SUB    %3, %3, #32\n"                                  \
    264                 "23:\n"                                                 \
     264                "24:\n"                                                 \
    265265                "MGETL  D0FrT, D0.5, D0.6, D0.7, [%1++]\n"              \
    266                 "24:\n"                                                 \
     266                "25:\n"                                                 \
    267267                "MSETL  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
     268                "26:\n"                                                 \
    268269                "SUB    %3, %3, #32\n"                                  \
    269270                "DCACHE [%1+#-64], D0Ar6\n"                             \
     
    271272                                                                        \
    272273                "MOV    RAPF, %1\n"                                     \
    273                 "25:\n"                                                 \
    274                 "MGETL  D0FrT, D0.5, D0.6, D0.7, [%1++]\n"              \
    275                 "26:\n"                                                 \
    276                 "MSETL  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
    277                 "SUB    %3, %3, #32\n"                                  \
    278274                "27:\n"                                                 \
    279275                "MGETL  D0FrT, D0.5, D0.6, D0.7, [%1++]\n"              \
    280276                "28:\n"                                                 \
    281277                "MSETL  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
     278                "29:\n"                                                 \
     279                "SUB    %3, %3, #32\n"                                  \
     280                "30:\n"                                                 \
     281                "MGETL  D0FrT, D0.5, D0.6, D0.7, [%1++]\n"              \
     282                "31:\n"                                                 \
     283                "MSETL  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
     284                "32:\n"                                                 \
    282285                "SUB    %0, %0, #8\n"                                   \
    283                 "29:\n"                                                 \
     286                "33:\n"                                                 \
    284287                "SETL   [%0++], D0.7, D1.7\n"                           \
    285288                "SUB    %3, %3, #32\n"                                  \
     
    313316                "       .long 27b,3b\n"                                 \
    314317                "       .long 28b,3b\n"                                 \
    315                 "       .long 29b,4b\n"                                 \
     318                "       .long 29b,3b\n"                                 \
     319                "       .long 30b,3b\n"                                 \
     320                "       .long 31b,3b\n"                                 \
     321                "       .long 32b,3b\n"                                 \
     322                "       .long 33b,4b\n"                                 \
    316323                "       .previous\n"                                    \
    317324                : "=r" (to), "=r" (from), "=r" (ret), "=d" (n)          \
    318325                : "0" (to), "1" (from), "2" (ret), "3" (n)              \
    319                 : "D1Ar1", "D0Ar2", "memory")
     326                : "D1Ar1", "D0Ar2", "cc", "memory")
    320327
    321328/*      rewind 'to' and 'from'  pointers when a fault occurs
     
    343350        __asm_copy_user_64bit_rapf_loop(to, from, ret, n, id,           \
    344351                "LSR    D0Ar2, D0Ar2, #8\n"                             \
    345                 "AND    D0Ar2, D0Ar2, #0x7\n"                           \
     352                "ANDS   D0Ar2, D0Ar2, #0x7\n"                           \
    346353                "ADDZ   D0Ar2, D0Ar2, #4\n"                             \
    347354                "SUB    D0Ar2, D0Ar2, #1\n"                             \
     
    404411                "22:\n"                                                 \
    405412                "MSETD  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
     413                "23:\n"                                                 \
    406414                "SUB    %3, %3, #16\n"                                  \
    407                 "23:\n"                                                 \
     415                "24:\n"                                                 \
    408416                "MGETD  D0FrT, D0.5, D0.6, D0.7, [%1++]\n"              \
    409                 "24:\n"                                                 \
     417                "25:\n"                                                 \
    410418                "MSETD  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
    411                 "SUB    %3, %3, #16\n"                                  \
    412                 "25:\n"                                                 \
    413                 "MGETD  D0FrT, D0.5, D0.6, D0.7, [%1++]\n"              \
    414419                "26:\n"                                                 \
    415                 "MSETD  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
    416420                "SUB    %3, %3, #16\n"                                  \
    417421                "27:\n"                                                 \
     
    419423                "28:\n"                                                 \
    420424                "MSETD  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
     425                "29:\n"                                                 \
     426                "SUB    %3, %3, #16\n"                                  \
     427                "30:\n"                                                 \
     428                "MGETD  D0FrT, D0.5, D0.6, D0.7, [%1++]\n"              \
     429                "31:\n"                                                 \
     430                "MSETD  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
     431                "32:\n"                                                 \
    421432                "SUB    %3, %3, #16\n"                                  \
    422433                "DCACHE [%1+#-64], D0Ar6\n"                             \
     
    424435                                                                        \
    425436                "MOV    RAPF, %1\n"                                     \
    426                 "29:\n"                                                 \
    427                 "MGETD  D0FrT, D0.5, D0.6, D0.7, [%1++]\n"              \
    428                 "30:\n"                                                 \
    429                 "MSETD  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
    430                 "SUB    %3, %3, #16\n"                                  \
    431                 "31:\n"                                                 \
    432                 "MGETD  D0FrT, D0.5, D0.6, D0.7, [%1++]\n"              \
    433                 "32:\n"                                                 \
    434                 "MSETD  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
    435                 "SUB    %3, %3, #16\n"                                  \
    436437                "33:\n"                                                 \
    437438                "MGETD  D0FrT, D0.5, D0.6, D0.7, [%1++]\n"              \
    438439                "34:\n"                                                 \
    439440                "MSETD  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
     441                "35:\n"                                                 \
    440442                "SUB    %3, %3, #16\n"                                  \
    441                 "35:\n"                                                 \
     443                "36:\n"                                                 \
    442444                "MGETD  D0FrT, D0.5, D0.6, D0.7, [%1++]\n"              \
    443                 "36:\n"                                                 \
     445                "37:\n"                                                 \
    444446                "MSETD  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
     447                "38:\n"                                                 \
     448                "SUB    %3, %3, #16\n"                                  \
     449                "39:\n"                                                 \
     450                "MGETD  D0FrT, D0.5, D0.6, D0.7, [%1++]\n"              \
     451                "40:\n"                                                 \
     452                "MSETD  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
     453                "41:\n"                                                 \
     454                "SUB    %3, %3, #16\n"                                  \
     455                "42:\n"                                                 \
     456                "MGETD  D0FrT, D0.5, D0.6, D0.7, [%1++]\n"              \
     457                "43:\n"                                                 \
     458                "MSETD  [%0++], D0FrT, D0.5, D0.6, D0.7\n"              \
     459                "44:\n"                                                 \
    445460                "SUB    %0, %0, #4\n"                                   \
    446                 "37:\n"                                                 \
     461                "45:\n"                                                 \
    447462                "SETD   [%0++], D0.7\n"                                 \
    448463                "SUB    %3, %3, #16\n"                                  \
     
    484499                "       .long 35b,3b\n"                                 \
    485500                "       .long 36b,3b\n"                                 \
    486                 "       .long 37b,4b\n"                                 \
     501                "       .long 37b,3b\n"                                 \
     502                "       .long 38b,3b\n"                                 \
     503                "       .long 39b,3b\n"                                 \
     504                "       .long 40b,3b\n"                                 \
     505                "       .long 41b,3b\n"                                 \
     506                "       .long 42b,3b\n"                                 \
     507                "       .long 43b,3b\n"                                 \
     508                "       .long 44b,3b\n"                                 \
     509                "       .long 45b,4b\n"                                 \
    487510                "       .previous\n"                                    \
    488511                : "=r" (to), "=r" (from), "=r" (ret), "=d" (n)          \
    489512                : "0" (to), "1" (from), "2" (ret), "3" (n)              \
    490                 : "D1Ar1", "D0Ar2", "memory")
     513                : "D1Ar1", "D0Ar2", "cc", "memory")
    491514
    492515/*      rewind 'to' and 'from'  pointers when a fault occurs
     
    514537        __asm_copy_user_32bit_rapf_loop(to, from, ret, n, id,           \
    515538                "LSR    D0Ar2, D0Ar2, #8\n"                             \
    516                 "AND    D0Ar2, D0Ar2, #0x7\n"                           \
     539                "ANDS   D0Ar2, D0Ar2, #0x7\n"                           \
    517540                "ADDZ   D0Ar2, D0Ar2, #4\n"                             \
    518541                "SUB    D0Ar2, D0Ar2, #1\n"                             \
     
    539562                __asm_copy_to_user_1(dst, src, retn);
    540563                n--;
     564                if (retn)
     565                        return retn + n;
    541566        }
    542567        if ((unsigned long) dst & 1) {
     
    545570                        __asm_copy_to_user_1(dst, src, retn);
    546571                        n--;
     572                        if (retn)
     573                                return retn + n;
    547574                }
    548575        }
     
    550577                __asm_copy_to_user_2(dst, src, retn);
    551578                n -= 2;
     579                if (retn)
     580                        return retn + n;
    552581        }
    553582        if ((unsigned long) dst & 2) {
     
    556585                        __asm_copy_to_user_2(dst, src, retn);
    557586                        n -= 2;
     587                        if (retn)
     588                                return retn + n;
    558589                }
    559590        }
     
    570601                        __asm_copy_to_user_8x64(dst, src, retn);
    571602                        n -= 8;
     603                        if (retn)
     604                                return retn + n;
    572605                }
    573606        }
     
    582615                        __asm_copy_to_user_8x64(dst, src, retn);
    583616                        n -= 8;
     617                        if (retn)
     618                                return retn + n;
    584619                }
    585620        }
     
    589624                __asm_copy_to_user_16(dst, src, retn);
    590625                n -= 16;
     626                if (retn)
     627                        return retn + n;
    591628        }
    592629
     
    594631                __asm_copy_to_user_4(dst, src, retn);
    595632                n -= 4;
     633                if (retn)
     634                        return retn + n;
    596635        }
    597636
     
    610649        }
    611650
     651        /*
     652         * If we get here, retn correctly reflects the number of failing
     653         * bytes.
     654         */
    612655        return retn;
    613656}
     
    618661                "       GETB D1Ar1,[%1++]\n"    \
    619662                "2:     SETB [%0++],D1Ar1\n",   \
    620                 "3:     ADD  %2,%2,#1\n"        \
    621                 "       SETB [%0++],D1Ar1\n",   \
     663                "3:     ADD  %2,%2,#1\n",       \
    622664                "       .long 2b,3b\n")
    623665
     
    626668                "       GETW D1Ar1,[%1++]\n"            \
    627669                "2:     SETW [%0++],D1Ar1\n" COPY,      \
    628                 "3:     ADD  %2,%2,#2\n"                \
    629                 "       SETW [%0++],D1Ar1\n" FIXUP,     \
     670                "3:     ADD  %2,%2,#2\n" FIXUP,         \
    630671                "       .long 2b,3b\n" TENTRY)
    631672
     
    637678                "       GETB D1Ar1,[%1++]\n"            \
    638679                "4:     SETB [%0++],D1Ar1\n",           \
    639                 "5:     ADD  %2,%2,#1\n"                \
    640                 "       SETB [%0++],D1Ar1\n",           \
     680                "5:     ADD  %2,%2,#1\n",               \
    641681                "       .long 4b,5b\n")
    642682
     
    645685                "       GETD D1Ar1,[%1++]\n"            \
    646686                "2:     SETD [%0++],D1Ar1\n" COPY,      \
    647                 "3:     ADD  %2,%2,#4\n"                \
    648                 "       SETD [%0++],D1Ar1\n" FIXUP,     \
     687                "3:     ADD  %2,%2,#4\n" FIXUP,         \
    649688                "       .long 2b,3b\n" TENTRY)
    650689
    651690#define __asm_copy_from_user_4(to, from, ret) \
    652691        __asm_copy_from_user_4x_cont(to, from, ret, "", "", "")
    653 
    654 #define __asm_copy_from_user_5(to, from, ret) \
    655         __asm_copy_from_user_4x_cont(to, from, ret,     \
    656                 "       GETB D1Ar1,[%1++]\n"            \
    657                 "4:     SETB [%0++],D1Ar1\n",           \
    658                 "5:     ADD  %2,%2,#1\n"                \
    659                 "       SETB [%0++],D1Ar1\n",           \
    660                 "       .long 4b,5b\n")
    661 
    662 #define __asm_copy_from_user_6x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
    663         __asm_copy_from_user_4x_cont(to, from, ret,     \
    664                 "       GETW D1Ar1,[%1++]\n"            \
    665                 "4:     SETW [%0++],D1Ar1\n" COPY,      \
    666                 "5:     ADD  %2,%2,#2\n"                \
    667                 "       SETW [%0++],D1Ar1\n" FIXUP,     \
    668                 "       .long 4b,5b\n" TENTRY)
    669 
    670 #define __asm_copy_from_user_6(to, from, ret) \
    671         __asm_copy_from_user_6x_cont(to, from, ret, "", "", "")
    672 
    673 #define __asm_copy_from_user_7(to, from, ret) \
    674         __asm_copy_from_user_6x_cont(to, from, ret,     \
    675                 "       GETB D1Ar1,[%1++]\n"            \
    676                 "6:     SETB [%0++],D1Ar1\n",           \
    677                 "7:     ADD  %2,%2,#1\n"                \
    678                 "       SETB [%0++],D1Ar1\n",           \
    679                 "       .long 6b,7b\n")
    680 
    681 #define __asm_copy_from_user_8x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
    682         __asm_copy_from_user_4x_cont(to, from, ret,     \
    683                 "       GETD D1Ar1,[%1++]\n"            \
    684                 "4:     SETD [%0++],D1Ar1\n" COPY,      \
    685                 "5:     ADD  %2,%2,#4\n"                        \
    686                 "       SETD [%0++],D1Ar1\n" FIXUP,             \
    687                 "       .long 4b,5b\n" TENTRY)
    688 
    689 #define __asm_copy_from_user_8(to, from, ret) \
    690         __asm_copy_from_user_8x_cont(to, from, ret, "", "", "")
    691 
    692 #define __asm_copy_from_user_9(to, from, ret) \
    693         __asm_copy_from_user_8x_cont(to, from, ret,     \
    694                 "       GETB D1Ar1,[%1++]\n"            \
    695                 "6:     SETB [%0++],D1Ar1\n",           \
    696                 "7:     ADD  %2,%2,#1\n"                \
    697                 "       SETB [%0++],D1Ar1\n",           \
    698                 "       .long 6b,7b\n")
    699 
    700 #define __asm_copy_from_user_10x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
    701         __asm_copy_from_user_8x_cont(to, from, ret,     \
    702                 "       GETW D1Ar1,[%1++]\n"            \
    703                 "6:     SETW [%0++],D1Ar1\n" COPY,      \
    704                 "7:     ADD  %2,%2,#2\n"                \
    705                 "       SETW [%0++],D1Ar1\n" FIXUP,     \
    706                 "       .long 6b,7b\n" TENTRY)
    707 
    708 #define __asm_copy_from_user_10(to, from, ret) \
    709         __asm_copy_from_user_10x_cont(to, from, ret, "", "", "")
    710 
    711 #define __asm_copy_from_user_11(to, from, ret)          \
    712         __asm_copy_from_user_10x_cont(to, from, ret,    \
    713                 "       GETB D1Ar1,[%1++]\n"            \
    714                 "8:     SETB [%0++],D1Ar1\n",           \
    715                 "9:     ADD  %2,%2,#1\n"                \
    716                 "       SETB [%0++],D1Ar1\n",           \
    717                 "       .long 8b,9b\n")
    718 
    719 #define __asm_copy_from_user_12x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
    720         __asm_copy_from_user_8x_cont(to, from, ret,     \
    721                 "       GETD D1Ar1,[%1++]\n"            \
    722                 "6:     SETD [%0++],D1Ar1\n" COPY,      \
    723                 "7:     ADD  %2,%2,#4\n"                \
    724                 "       SETD [%0++],D1Ar1\n" FIXUP,     \
    725                 "       .long 6b,7b\n" TENTRY)
    726 
    727 #define __asm_copy_from_user_12(to, from, ret) \
    728         __asm_copy_from_user_12x_cont(to, from, ret, "", "", "")
    729 
    730 #define __asm_copy_from_user_13(to, from, ret) \
    731         __asm_copy_from_user_12x_cont(to, from, ret,    \
    732                 "       GETB D1Ar1,[%1++]\n"            \
    733                 "8:     SETB [%0++],D1Ar1\n",           \
    734                 "9:     ADD  %2,%2,#1\n"                \
    735                 "       SETB [%0++],D1Ar1\n",           \
    736                 "       .long 8b,9b\n")
    737 
    738 #define __asm_copy_from_user_14x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
    739         __asm_copy_from_user_12x_cont(to, from, ret,    \
    740                 "       GETW D1Ar1,[%1++]\n"            \
    741                 "8:     SETW [%0++],D1Ar1\n" COPY,      \
    742                 "9:     ADD  %2,%2,#2\n"                \
    743                 "       SETW [%0++],D1Ar1\n" FIXUP,     \
    744                 "       .long 8b,9b\n" TENTRY)
    745 
    746 #define __asm_copy_from_user_14(to, from, ret) \
    747         __asm_copy_from_user_14x_cont(to, from, ret, "", "", "")
    748 
    749 #define __asm_copy_from_user_15(to, from, ret) \
    750         __asm_copy_from_user_14x_cont(to, from, ret,    \
    751                 "       GETB D1Ar1,[%1++]\n"            \
    752                 "10:    SETB [%0++],D1Ar1\n",           \
    753                 "11:    ADD  %2,%2,#1\n"                \
    754                 "       SETB [%0++],D1Ar1\n",           \
    755                 "       .long 10b,11b\n")
    756 
    757 #define __asm_copy_from_user_16x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
    758         __asm_copy_from_user_12x_cont(to, from, ret,    \
    759                 "       GETD D1Ar1,[%1++]\n"            \
    760                 "8:     SETD [%0++],D1Ar1\n" COPY,      \
    761                 "9:     ADD  %2,%2,#4\n"                \
    762                 "       SETD [%0++],D1Ar1\n" FIXUP,     \
    763                 "       .long 8b,9b\n" TENTRY)
    764 
    765 #define __asm_copy_from_user_16(to, from, ret) \
    766         __asm_copy_from_user_16x_cont(to, from, ret, "", "", "")
    767692
    768693#define __asm_copy_from_user_8x64(to, from, ret) \
     
    772697                "1:\n"                                  \
    773698                "       .section .fixup,\"ax\"\n"       \
    774                 "       MOV D1Ar1,#0\n"                 \
    775                 "       MOV D0Ar2,#0\n"                 \
    776699                "3:     ADD  %2,%2,#8\n"                \
    777                 "       SETL [%0++],D0Ar2,D1Ar1\n"      \
    778700                "       MOVT    D0Ar2,#HI(1b)\n"        \
    779701                "       JUMP    D0Ar2,#LO(1b)\n"        \
     
    790712 *      Rationale:
    791713 *              A fault occurs while reading from user buffer, which is the
    792  *              source. Since the fault is at a single address, we only
    793  *              need to rewind by 8 bytes.
     714 *              source.
    794715 *              Since we don't write to kernel buffer until we read first,
    795716 *              the kernel buffer is at the right state and needn't be
    796  *              corrected.
     717 *              corrected, but the source must be rewound to the beginning of
     718 *              the block, which is LSM_STEP*8 bytes.
     719 *              LSM_STEP is bits 10:8 in TXSTATUS which is already read
     720 *              and stored in D0Ar2
     721 *
     722 *              NOTE: If a fault occurs at the last operation in M{G,S}ETL
     723 *                      LSM_STEP will be 0. ie: we do 4 writes in our case, if
     724 *                      a fault happens at the 4th write, LSM_STEP will be 0
     725 *                      instead of 4. The code copes with that.
    797726 */
    798727#define __asm_copy_from_user_64bit_rapf_loop(to, from, ret, n, id)      \
    799728        __asm_copy_user_64bit_rapf_loop(to, from, ret, n, id,           \
    800                 "SUB    %1, %1, #8\n")
     729                "LSR    D0Ar2, D0Ar2, #5\n"                             \
     730                "ANDS   D0Ar2, D0Ar2, #0x38\n"                          \
     731                "ADDZ   D0Ar2, D0Ar2, #32\n"                            \
     732                "SUB    %1, %1, D0Ar2\n")
    801733
    802734/*      rewind 'from' pointer when a fault occurs
     
    804736 *      Rationale:
    805737 *              A fault occurs while reading from user buffer, which is the
    806  *              source. Since the fault is at a single address, we only
    807  *              need to rewind by 4 bytes.
     738 *              source.
    808739 *              Since we don't write to kernel buffer until we read first,
    809740 *              the kernel buffer is at the right state and needn't be
    810  *              corrected.
     741 *              corrected, but the source must be rewound to the beginning of
     742 *              the block, which is LSM_STEP*4 bytes.
     743 *              LSM_STEP is bits 10:8 in TXSTATUS which is already read
     744 *              and stored in D0Ar2
     745 *
     746 *              NOTE: If a fault occurs at the last operation in M{G,S}ETL
     747 *                      LSM_STEP will be 0. ie: we do 4 writes in our case, if
     748 *                      a fault happens at the 4th write, LSM_STEP will be 0
     749 *                      instead of 4. The code copes with that.
    811750 */
    812751#define __asm_copy_from_user_32bit_rapf_loop(to, from, ret, n, id)      \
    813752        __asm_copy_user_32bit_rapf_loop(to, from, ret, n, id,           \
    814                 "SUB    %1, %1, #4\n")
    815 
    816 
    817 /* Copy from user to kernel, zeroing the bytes that were inaccessible in
    818    userland.  The return-value is the number of bytes that were
    819    inaccessible.  */
    820 unsigned long __copy_user_zeroing(void *pdst, const void __user *psrc,
    821                                   unsigned long n)
     753                "LSR    D0Ar2, D0Ar2, #6\n"                             \
     754                "ANDS   D0Ar2, D0Ar2, #0x1c\n"                          \
     755                "ADDZ   D0Ar2, D0Ar2, #16\n"                            \
     756                "SUB    %1, %1, D0Ar2\n")
     757
     758
     759/*
     760 * Copy from user to kernel. The return-value is the number of bytes that were
     761 * inaccessible.
     762 */
     763unsigned long raw_copy_from_user(void *pdst, const void __user *psrc,
     764                                 unsigned long n)
    822765{
    823766        register char *dst asm ("A0.2") = pdst;
     
    831774                __asm_copy_from_user_1(dst, src, retn);
    832775                n--;
     776                if (retn)
     777                        return retn + n;
    833778        }
    834779        if ((unsigned long) dst & 1) {
     
    838783                        n--;
    839784                        if (retn)
    840                                 goto copy_exception_bytes;
     785                                return retn + n;
    841786                }
    842787        }
     
    844789                __asm_copy_from_user_2(dst, src, retn);
    845790                n -= 2;
     791                if (retn)
     792                        return retn + n;
    846793        }
    847794        if ((unsigned long) dst & 2) {
     
    851798                        n -= 2;
    852799                        if (retn)
    853                                 goto copy_exception_bytes;
     800                                return retn + n;
    854801                }
    855802        }
    856 
    857         /* We only need one check after the unalignment-adjustments,
    858            because if both adjustments were done, either both or
    859            neither reference had an exception.  */
    860         if (retn != 0)
    861                 goto copy_exception_bytes;
    862803
    863804#ifdef USE_RAPF
     
    873814                        n -= 8;
    874815                        if (retn)
    875                                 goto copy_exception_bytes;
     816                                return retn + n;
    876817                }
    877818        }
     
    889830                        n -= 8;
    890831                        if (retn)
    891                                 goto copy_exception_bytes;
     832                                return retn + n;
    892833                }
    893834        }
     
    899840
    900841                if (retn)
    901                         goto copy_exception_bytes;
     842                        return retn + n;
    902843        }
    903844
     
    925866           bytes.  */
    926867        return retn;
    927 
    928  copy_exception_bytes:
    929         /* We already have "retn" bytes cleared, and need to clear the
    930            remaining "n" bytes.  A non-optimized simple byte-for-byte in-line
    931            memset is preferred here, since this isn't speed-critical code and
    932            we'd rather have this a leaf-function than calling memset.  */
    933         {
    934                 char *endp;
    935                 for (endp = dst + n; dst < endp; dst++)
    936                         *dst = 0;
    937         }
    938 
    939         return retn + n;
    940868}
    941 EXPORT_SYMBOL(__copy_user_zeroing);
     869EXPORT_SYMBOL(raw_copy_from_user);
    942870
    943871#define __asm_clear_8x64(to, ret) \
Note: See TracChangeset for help on using the changeset viewer.