arch/parisc/lib/memcpy.c

   1 /*
   2  *    Optimized memory copy routines.
   3  *
   4  *    Copyright (C) 2004 Randolph Chung <tausq@debian.org>
   5  *    Copyright (C) 2013 Helge Deller <deller@gmx.de>
   6  *
   7  *    This program is free software; you can redistribute it and/or modify
   8  *    it under the terms of the GNU General Public License as published by
   9  *    the Free Software Foundation; either version 2, or (at your option)
  10  *    any later version.
  11  *
  12  *    This program is distributed in the hope that it will be useful,
  13  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *    GNU General Public License for more details.
  16  *
  17  *    You should have received a copy of the GNU General Public License
  18  *    along with this program; if not, write to the Free Software
  19  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  *    Portions derived from the GNU C Library
  22  *    Copyright (C) 1991, 1997, 2003 Free Software Foundation, Inc.
  23  *
  24  * Several strategies are tried to try to get the best performance for various
  25  * conditions. In the optimal case, we copy 64-bytes in an unrolled loop using
  26  * fp regs. This is followed by loops that copy 32- or 16-bytes at a time using
  27  * general registers.  Unaligned copies are handled either by aligning the
  28  * destination and then using shift-and-write method, or in a few cases by
  29  * falling back to a byte-at-a-time copy.
  30  *
  31  * I chose to implement this in C because it is easier to maintain and debug,
  32  * and in my experiments it appears that the C code generated by gcc (3.3/3.4
  33  * at the time of writing) is fairly optimal. Unfortunately some of the
  34  * semantics of the copy routine (exception handling) is difficult to express
  35  * in C, so we have to play some tricks to get it to work.
  36  *
  37  * All the loads and stores are done via explicit asm() code in order to use
  38  * the right space registers.
  39  *
  40  * Testing with various alignments and buffer sizes shows that this code is
  41  * often >10x faster than a simple byte-at-a-time copy, even for strangely
  42  * aligned operands. It is interesting to note that the glibc version
  43  * of memcpy (written in C) is actually quite fast already. This routine is
  44  * able to beat it by 30-40% for aligned copies because of the loop unrolling,
  45  * but in some cases the glibc version is still slightly faster. This lends
  46  * more credibility that gcc can generate very good code as long as we are
  47  * careful.
  48  *
  49  * TODO:
  50  * - cache prefetching needs more experimentation to get optimal settings
  51  * - try not to use the post-increment address modifiers; they create additional
  52  *   interlocks
  53  * - replace byte-copy loops with stybs sequences
  54  */
  55
  56 #ifdef __KERNEL__
  57 #include <linux/module.h>
  58 #include <linux/compiler.h>
  59 #include <linux/uaccess.h>
  60 #define s_space "%%sr1"
  61 #define d_space "%%sr2"
  62 #else
  63 #include "memcpy.h"
  64 #define s_space "%%sr0"
  65 #define d_space "%%sr0"
  66 #define pa_memcpy new2_copy
  67 #endif
  68
  69 DECLARE_PER_CPU(struct exception_data, exception_data);
  70
  71 #define preserve_branch(label)  do {                                    \
  72         volatile int dummy = 0;                                         \
  73         /* The following branch is never taken, it's just here to  */   \
  74         /* prevent gcc from optimizing away our exception code. */      \
  75         if (unlikely(dummy != dummy))                                   \
  76                 goto label;                                             \
  77 } while (0)
  78
  79 #define get_user_space() (segment_eq(get_fs(), KERNEL_DS) ? 0 : mfsp(3))
  80 #define get_kernel_space() (0)
  81
  82 #define MERGE(w0, sh_1, w1, sh_2)  ({                                   \
  83         unsigned int _r;                                                \
  84         asm volatile (                                                  \
  85         "mtsar %3\n"                                                    \
  86         "shrpw %1, %2, %%sar, %0\n"                                     \
  87         : "=r"(_r)                                                      \
  88         : "r"(w0), "r"(w1), "r"(sh_2)                                   \
  89         );                                                              \
  90         _r;                                                             \
  91 })
  92 #define THRESHOLD       16
  93
  94 #ifdef DEBUG_MEMCPY
  95 #define DPRINTF(fmt, args...) do { printk(KERN_DEBUG "%s:%d:%s ", __FILE__, __LINE__, __func__ ); printk(KERN_DEBUG fmt, ##args ); } while (0)
  96 #else
  97 #define DPRINTF(fmt, args...)
  98 #endif
  99
 100 #define def_load_ai_insn(_insn,_sz,_tt,_s,_a,_t,_e)     \
 101         __asm__ __volatile__ (                          \
 102         "1:\t" #_insn ",ma " #_sz "(" _s ",%1), %0\n\t" \
 103         ASM_EXCEPTIONTABLE_ENTRY(1b,_e)                 \
 104         : _tt(_t), "+r"(_a)                             \
 105         :                                               \
 106         : "r8")
 107
 108 #define def_store_ai_insn(_insn,_sz,_tt,_s,_a,_t,_e)    \
 109         __asm__ __volatile__ (                          \
 110         "1:\t" #_insn ",ma %1, " #_sz "(" _s ",%0)\n\t" \
 111         ASM_EXCEPTIONTABLE_ENTRY(1b,_e)                 \
 112         : "+r"(_a)                                      \
 113         : _tt(_t)                                       \
 114         : "r8")
 115
 116 #define ldbma(_s, _a, _t, _e) def_load_ai_insn(ldbs,1,"=r",_s,_a,_t,_e)
 117 #define stbma(_s, _t, _a, _e) def_store_ai_insn(stbs,1,"r",_s,_a,_t,_e)
 118 #define ldwma(_s, _a, _t, _e) def_load_ai_insn(ldw,4,"=r",_s,_a,_t,_e)
 119 #define stwma(_s, _t, _a, _e) def_store_ai_insn(stw,4,"r",_s,_a,_t,_e)
 120 #define flddma(_s, _a, _t, _e) def_load_ai_insn(fldd,8,"=f",_s,_a,_t,_e)
 121 #define fstdma(_s, _t, _a, _e) def_store_ai_insn(fstd,8,"f",_s,_a,_t,_e)
 122
 123 #define def_load_insn(_insn,_tt,_s,_o,_a,_t,_e)         \
 124         __asm__ __volatile__ (                          \
 125         "1:\t" #_insn " " #_o "(" _s ",%1), %0\n\t"     \
 126         ASM_EXCEPTIONTABLE_ENTRY(1b,_e)                 \
 127         : _tt(_t)                                       \
 128         : "r"(_a)                                       \
 129         : "r8")
 130
 131 #define def_store_insn(_insn,_tt,_s,_t,_o,_a,_e)        \
 132         __asm__ __volatile__ (                          \
 133         "1:\t" #_insn " %0, " #_o "(" _s ",%1)\n\t"     \
 134         ASM_EXCEPTIONTABLE_ENTRY(1b,_e)                 \
 135         :                                               \
 136         : _tt(_t), "r"(_a)                              \
 137         : "r8")
 138
 139 #define ldw(_s,_o,_a,_t,_e)     def_load_insn(ldw,"=r",_s,_o,_a,_t,_e)
 140 #define stw(_s,_t,_o,_a,_e)     def_store_insn(stw,"r",_s,_t,_o,_a,_e)
 141
 142 #ifdef  CONFIG_PREFETCH
 143 static inline void prefetch_src(const void *addr)
 144 {
 145         __asm__("ldw 0(" s_space ",%0), %%r0" : : "r" (addr));
 146 }
 147
 148 static inline void prefetch_dst(const void *addr)
 149 {
 150         __asm__("ldd 0(" d_space ",%0), %%r0" : : "r" (addr));
 151 }
 152 #else
 153 #define prefetch_src(addr) do { } while(0)
 154 #define prefetch_dst(addr) do { } while(0)
 155 #endif
 156
 157 #define PA_MEMCPY_OK            0
 158 #define PA_MEMCPY_LOAD_ERROR    1
 159 #define PA_MEMCPY_STORE_ERROR   2
 160
 161 /* Copy from a not-aligned src to an aligned dst, using shifts. Handles 4 words
 162  * per loop.  This code is derived from glibc.
 163  */
 164 static noinline unsigned long copy_dstaligned(unsigned long dst,
 165                                         unsigned long src, unsigned long len)
 166 {
 167         /* gcc complains that a2 and a3 may be uninitialized, but actually
 168          * they cannot be.  Initialize a2/a3 to shut gcc up.
 169          */
 170         register unsigned int a0, a1, a2 = 0, a3 = 0;
 171         int sh_1, sh_2;
 172
 173         /* prefetch_src((const void *)src); */
 174
 175         /* Calculate how to shift a word read at the memory operation
 176            aligned srcp to make it aligned for copy.  */
 177         sh_1 = 8 * (src % sizeof(unsigned int));
 178         sh_2 = 8 * sizeof(unsigned int) - sh_1;
 179
 180         /* Make src aligned by rounding it down.  */
 181         src &= -sizeof(unsigned int);
 182
 183         switch (len % 4)
 184         {
 185                 case 2:
 186                         /* a1 = ((unsigned int *) src)[0];
 187                            a2 = ((unsigned int *) src)[1]; */
 188                         ldw(s_space, 0, src, a1, cda_ldw_exc);
 189                         ldw(s_space, 4, src, a2, cda_ldw_exc);
 190                         src -= 1 * sizeof(unsigned int);
 191                         dst -= 3 * sizeof(unsigned int);
 192                         len += 2;
 193                         goto do1;
 194                 case 3:
 195                         /* a0 = ((unsigned int *) src)[0];
 196                            a1 = ((unsigned int *) src)[1]; */
 197                         ldw(s_space, 0, src, a0, cda_ldw_exc);
 198                         ldw(s_space, 4, src, a1, cda_ldw_exc);
 199                         src -= 0 * sizeof(unsigned int);
 200                         dst -= 2 * sizeof(unsigned int);
 201                         len += 1;
 202                         goto do2;
 203                 case 0:
 204                         if (len == 0)
 205                                 return PA_MEMCPY_OK;
 206                         /* a3 = ((unsigned int *) src)[0];
 207                            a0 = ((unsigned int *) src)[1]; */
 208                         ldw(s_space, 0, src, a3, cda_ldw_exc);
 209                         ldw(s_space, 4, src, a0, cda_ldw_exc);
 210                         src -=-1 * sizeof(unsigned int);
 211                         dst -= 1 * sizeof(unsigned int);
 212                         len += 0;
 213                         goto do3;
 214                 case 1:
 215                         /* a2 = ((unsigned int *) src)[0];
 216                            a3 = ((unsigned int *) src)[1]; */
 217                         ldw(s_space, 0, src, a2, cda_ldw_exc);
 218                         ldw(s_space, 4, src, a3, cda_ldw_exc);
 219                         src -=-2 * sizeof(unsigned int);
 220                         dst -= 0 * sizeof(unsigned int);
 221                         len -= 1;
 222                         if (len == 0)
 223                                 goto do0;
 224                         goto do4;                       /* No-op.  */
 225         }
 226
 227         do
 228         {
 229                 /* prefetch_src((const void *)(src + 4 * sizeof(unsigned int))); */
 230 do4:
 231                 /* a0 = ((unsigned int *) src)[0]; */
 232                 ldw(s_space, 0, src, a0, cda_ldw_exc);
 233                 /* ((unsigned int *) dst)[0] = MERGE (a2, sh_1, a3, sh_2); */
 234                 stw(d_space, MERGE (a2, sh_1, a3, sh_2), 0, dst, cda_stw_exc);
 235 do3:
 236                 /* a1 = ((unsigned int *) src)[1]; */
 237                 ldw(s_space, 4, src, a1, cda_ldw_exc);
 238                 /* ((unsigned int *) dst)[1] = MERGE (a3, sh_1, a0, sh_2); */
 239                 stw(d_space, MERGE (a3, sh_1, a0, sh_2), 4, dst, cda_stw_exc);
 240 do2:
 241                 /* a2 = ((unsigned int *) src)[2]; */
 242                 ldw(s_space, 8, src, a2, cda_ldw_exc);
 243                 /* ((unsigned int *) dst)[2] = MERGE (a0, sh_1, a1, sh_2); */
 244                 stw(d_space, MERGE (a0, sh_1, a1, sh_2), 8, dst, cda_stw_exc);
 245 do1:
 246                 /* a3 = ((unsigned int *) src)[3]; */
 247                 ldw(s_space, 12, src, a3, cda_ldw_exc);
 248                 /* ((unsigned int *) dst)[3] = MERGE (a1, sh_1, a2, sh_2); */
 249                 stw(d_space, MERGE (a1, sh_1, a2, sh_2), 12, dst, cda_stw_exc);
 250
 251                 src += 4 * sizeof(unsigned int);
 252                 dst += 4 * sizeof(unsigned int);
 253                 len -= 4;
 254         }
 255         while (len != 0);
 256
 257 do0:
 258         /* ((unsigned int *) dst)[0] = MERGE (a2, sh_1, a3, sh_2); */
 259         stw(d_space, MERGE (a2, sh_1, a3, sh_2), 0, dst, cda_stw_exc);
 260
 261         preserve_branch(handle_load_error);
 262         preserve_branch(handle_store_error);
 263
 264         return PA_MEMCPY_OK;
 265
 266 handle_load_error:
 267         __asm__ __volatile__ ("cda_ldw_exc:\n");
 268         return PA_MEMCPY_LOAD_ERROR;
 269
 270 handle_store_error:
 271         __asm__ __volatile__ ("cda_stw_exc:\n");
 272         return PA_MEMCPY_STORE_ERROR;
 273 }
 274
 275
 276 /* Returns PA_MEMCPY_OK, PA_MEMCPY_LOAD_ERROR or PA_MEMCPY_STORE_ERROR.
 277  * In case of an access fault the faulty address can be read from the per_cpu
 278  * exception data struct. */
 279 static noinline unsigned long pa_memcpy_internal(void *dstp, const void *srcp,
 280                                         unsigned long len)
 281 {
 282         register unsigned long src, dst, t1, t2, t3;
 283         register unsigned char *pcs, *pcd;
 284         register unsigned int *pws, *pwd;
 285         register double *pds, *pdd;
 286         unsigned long ret;
 287
 288         src = (unsigned long)srcp;
 289         dst = (unsigned long)dstp;
 290         pcs = (unsigned char *)srcp;
 291         pcd = (unsigned char *)dstp;
 292
 293         /* prefetch_src((const void *)srcp); */
 294
 295         if (len < THRESHOLD)
 296                 goto byte_copy;
 297
 298         /* Check alignment */
 299         t1 = (src ^ dst);
 300         if (unlikely(t1 & (sizeof(double)-1)))
 301                 goto unaligned_copy;
 302
 303         /* src and dst have same alignment. */
 304
 305         /* Copy bytes till we are double-aligned. */
 306         t2 = src & (sizeof(double) - 1);
 307         if (unlikely(t2 != 0)) {
 308                 t2 = sizeof(double) - t2;
 309                 while (t2 && len) {
 310                         /* *pcd++ = *pcs++; */
 311                         ldbma(s_space, pcs, t3, pmc_load_exc);
 312                         len--;
 313                         stbma(d_space, t3, pcd, pmc_store_exc);
 314                         t2--;
 315                 }
 316         }
 317
 318         pds = (double *)pcs;
 319         pdd = (double *)pcd;
 320
 321 #if 0
 322         /* Copy 8 doubles at a time */
 323         while (len >= 8*sizeof(double)) {
 324                 register double r1, r2, r3, r4, r5, r6, r7, r8;
 325                 /* prefetch_src((char *)pds + L1_CACHE_BYTES); */
 326                 flddma(s_space, pds, r1, pmc_load_exc);
 327                 flddma(s_space, pds, r2, pmc_load_exc);
 328                 flddma(s_space, pds, r3, pmc_load_exc);
 329                 flddma(s_space, pds, r4, pmc_load_exc);
 330                 fstdma(d_space, r1, pdd, pmc_store_exc);
 331                 fstdma(d_space, r2, pdd, pmc_store_exc);
 332                 fstdma(d_space, r3, pdd, pmc_store_exc);
 333                 fstdma(d_space, r4, pdd, pmc_store_exc);
 334
 335 #if 0
 336                 if (L1_CACHE_BYTES <= 32)
 337                         prefetch_src((char *)pds + L1_CACHE_BYTES);
 338 #endif
 339                 flddma(s_space, pds, r5, pmc_load_exc);
 340                 flddma(s_space, pds, r6, pmc_load_exc);
 341                 flddma(s_space, pds, r7, pmc_load_exc);
 342                 flddma(s_space, pds, r8, pmc_load_exc);
 343                 fstdma(d_space, r5, pdd, pmc_store_exc);
 344                 fstdma(d_space, r6, pdd, pmc_store_exc);
 345                 fstdma(d_space, r7, pdd, pmc_store_exc);
 346                 fstdma(d_space, r8, pdd, pmc_store_exc);
 347                 len -= 8*sizeof(double);
 348         }
 349 #endif
 350
 351         pws = (unsigned int *)pds;
 352         pwd = (unsigned int *)pdd;
 353
 354 word_copy:
 355         while (len >= 8*sizeof(unsigned int)) {
 356                 register unsigned int r1,r2,r3,r4,r5,r6,r7,r8;
 357                 /* prefetch_src((char *)pws + L1_CACHE_BYTES); */
 358                 ldwma(s_space, pws, r1, pmc_load_exc);
 359                 ldwma(s_space, pws, r2, pmc_load_exc);
 360                 ldwma(s_space, pws, r3, pmc_load_exc);
 361                 ldwma(s_space, pws, r4, pmc_load_exc);
 362                 stwma(d_space, r1, pwd, pmc_store_exc);
 363                 stwma(d_space, r2, pwd, pmc_store_exc);
 364                 stwma(d_space, r3, pwd, pmc_store_exc);
 365                 stwma(d_space, r4, pwd, pmc_store_exc);
 366
 367                 ldwma(s_space, pws, r5, pmc_load_exc);
 368                 ldwma(s_space, pws, r6, pmc_load_exc);
 369                 ldwma(s_space, pws, r7, pmc_load_exc);
 370                 ldwma(s_space, pws, r8, pmc_load_exc);
 371                 stwma(d_space, r5, pwd, pmc_store_exc);
 372                 stwma(d_space, r6, pwd, pmc_store_exc);
 373                 stwma(d_space, r7, pwd, pmc_store_exc);
 374                 stwma(d_space, r8, pwd, pmc_store_exc);
 375                 len -= 8*sizeof(unsigned int);
 376         }
 377
 378         while (len >= 4*sizeof(unsigned int)) {
 379                 register unsigned int r1,r2,r3,r4;
 380                 ldwma(s_space, pws, r1, pmc_load_exc);
 381                 ldwma(s_space, pws, r2, pmc_load_exc);
 382                 ldwma(s_space, pws, r3, pmc_load_exc);
 383                 ldwma(s_space, pws, r4, pmc_load_exc);
 384                 stwma(d_space, r1, pwd, pmc_store_exc);
 385                 stwma(d_space, r2, pwd, pmc_store_exc);
 386                 stwma(d_space, r3, pwd, pmc_store_exc);
 387                 stwma(d_space, r4, pwd, pmc_store_exc);
 388                 len -= 4*sizeof(unsigned int);
 389         }
 390
 391         pcs = (unsigned char *)pws;
 392         pcd = (unsigned char *)pwd;
 393
 394 byte_copy:
 395         while (len) {
 396                 /* *pcd++ = *pcs++; */
 397                 ldbma(s_space, pcs, t3, pmc_load_exc);
 398                 stbma(d_space, t3, pcd, pmc_store_exc);
 399                 len--;
 400         }
 401
 402         return PA_MEMCPY_OK;
 403
 404 unaligned_copy:
 405         /* possibly we are aligned on a word, but not on a double... */
 406         if (likely((t1 & (sizeof(unsigned int)-1)) == 0)) {
 407                 t2 = src & (sizeof(unsigned int) - 1);
 408
 409                 if (unlikely(t2 != 0)) {
 410                         t2 = sizeof(unsigned int) - t2;
 411                         while (t2) {
 412                                 /* *pcd++ = *pcs++; */
 413                                 ldbma(s_space, pcs, t3, pmc_load_exc);
 414                                 stbma(d_space, t3, pcd, pmc_store_exc);
 415                                 len--;
 416                                 t2--;
 417                         }
 418                 }
 419
 420                 pws = (unsigned int *)pcs;
 421                 pwd = (unsigned int *)pcd;
 422                 goto word_copy;
 423         }
 424
 425         /* Align the destination.  */
 426         if (unlikely((dst & (sizeof(unsigned int) - 1)) != 0)) {
 427                 t2 = sizeof(unsigned int) - (dst & (sizeof(unsigned int) - 1));
 428                 while (t2) {
 429                         /* *pcd++ = *pcs++; */
 430                         ldbma(s_space, pcs, t3, pmc_load_exc);
 431                         stbma(d_space, t3, pcd, pmc_store_exc);
 432                         len--;
 433                         t2--;
 434                 }
 435                 dst = (unsigned long)pcd;
 436                 src = (unsigned long)pcs;
 437         }
 438
 439         ret = copy_dstaligned(dst, src, len / sizeof(unsigned int));
 440         if (ret)
 441                 return ret;
 442
 443         pcs += (len & -sizeof(unsigned int));
 444         pcd += (len & -sizeof(unsigned int));
 445         len %= sizeof(unsigned int);
 446
 447         preserve_branch(handle_load_error);
 448         preserve_branch(handle_store_error);
 449
 450         goto byte_copy;
 451
 452 handle_load_error:
 453         __asm__ __volatile__ ("pmc_load_exc:\n");
 454         return PA_MEMCPY_LOAD_ERROR;
 455
 456 handle_store_error:
 457         __asm__ __volatile__ ("pmc_store_exc:\n");
 458         return PA_MEMCPY_STORE_ERROR;
 459 }
 460
 461
 462 /* Returns 0 for success, otherwise, returns number of bytes not transferred. */
 463 static unsigned long pa_memcpy(void *dstp, const void *srcp, unsigned long len)
 464 {
 465         unsigned long ret, fault_addr, reference;
 466         struct exception_data *d;
 467
 468         ret = pa_memcpy_internal(dstp, srcp, len);
 469         if (likely(ret == PA_MEMCPY_OK))
 470                 return 0;
 471
 472         /* if a load or store fault occured we can get the faulty addr */
 473         d = &__get_cpu_var(exception_data);
 474         fault_addr = d->fault_addr;
 475
 476         /* error in load or store? */
 477         if (ret == PA_MEMCPY_LOAD_ERROR)
 478                 reference = (unsigned long) srcp;
 479         else
 480                 reference = (unsigned long) dstp;
 481
 482         DPRINTF("pa_memcpy: fault type = %lu, len=%lu fault_addr=%lu ref=%lu\n",
 483                 ret, len, fault_addr, reference);
 484
 485         if (fault_addr >= reference)
 486                 return len - (fault_addr - reference);
 487         else
 488                 return len;
 489 }
 490
 491 #ifdef __KERNEL__
 492 unsigned long copy_to_user(void __user *dst, const void *src, unsigned long len)
 493 {
 494         mtsp(get_kernel_space(), 1);
 495         mtsp(get_user_space(), 2);
 496         return pa_memcpy((void __force *)dst, src, len);
 497 }
 498
 499 EXPORT_SYMBOL(__copy_from_user);
 500 unsigned long __copy_from_user(void *dst, const void __user *src, unsigned long len)
 501 {
 502         mtsp(get_user_space(), 1);
 503         mtsp(get_kernel_space(), 2);
 504         return pa_memcpy(dst, (void __force *)src, len);
 505 }
 506
 507 unsigned long copy_in_user(void __user *dst, const void __user *src, unsigned long len)
 508 {
 509         mtsp(get_user_space(), 1);
 510         mtsp(get_user_space(), 2);
 511         return pa_memcpy((void __force *)dst, (void __force *)src, len);
 512 }
 513
 514
 515 void * memcpy(void * dst,const void *src, size_t count)
 516 {
 517         mtsp(get_kernel_space(), 1);
 518         mtsp(get_kernel_space(), 2);
 519         pa_memcpy(dst, src, count);
 520         return dst;
 521 }
 522
 523 EXPORT_SYMBOL(copy_to_user);
 524 EXPORT_SYMBOL(copy_from_user);
 525 EXPORT_SYMBOL(copy_in_user);
 526 EXPORT_SYMBOL(memcpy);
 527
 528 long probe_kernel_read(void *dst, const void *src, size_t size)
 529 {
 530         unsigned long addr = (unsigned long)src;
 531
 532         if (addr < PAGE_SIZE)
 533                 return -EFAULT;
 534
 535         /* check for I/O space F_EXTEND(0xfff00000) access as well? */
 536
 537         return __probe_kernel_read(dst, src, size);
 538 }
 539
 540 #endif