~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/cris/include/arch-v32/arch/uaccess.h

Version: ~ [ linux-5.5-rc1 ] ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Authors:    Hans-Peter Nilsson (hp@axis.com)
  3  *
  4  */
  5 #ifndef _CRIS_ARCH_UACCESS_H
  6 #define _CRIS_ARCH_UACCESS_H
  7 
  8 /*
  9  * We don't tell gcc that we are accessing memory, but this is OK
 10  * because we do not write to any memory gcc knows about, so there
 11  * are no aliasing issues.
 12  *
 13  * Note that PC at a fault is the address *at* the faulting
 14  * instruction for CRISv32.
 15  */
 16 #define __put_user_asm(x, addr, err, op)                        \
 17         __asm__ __volatile__(                                   \
 18                 "2:     "op" %1,[%2]\n"                         \
 19                 "4:\n"                                          \
 20                 "       .section .fixup,\"ax\"\n"               \
 21                 "3:     move.d %3,%0\n"                         \
 22                 "       jump 4b\n"                              \
 23                 "       nop\n"                                  \
 24                 "       .previous\n"                            \
 25                 "       .section __ex_table,\"a\"\n"            \
 26                 "       .dword 2b,3b\n"                         \
 27                 "       .previous\n"                            \
 28                 : "=r" (err)                                    \
 29                 : "r" (x), "r" (addr), "g" (-EFAULT), "" (err))
 30 
 31 #define __put_user_asm_64(x, addr, err) do {                    \
 32         int dummy_for_put_user_asm_64_;                         \
 33         __asm__ __volatile__(                                   \
 34                 "2:     move.d %M2,[%1+]\n"                     \
 35                 "4:     move.d %H2,[%1]\n"                      \
 36                 "5:\n"                                          \
 37                 "       .section .fixup,\"ax\"\n"               \
 38                 "3:     move.d %4,%0\n"                         \
 39                 "       jump 5b\n"                              \
 40                 "       .previous\n"                            \
 41                 "       .section __ex_table,\"a\"\n"            \
 42                 "       .dword 2b,3b\n"                         \
 43                 "       .dword 4b,3b\n"                         \
 44                 "       .previous\n"                            \
 45                 : "=r" (err), "=b" (dummy_for_put_user_asm_64_) \
 46                 : "r" (x), "1" (addr), "g" (-EFAULT),           \
 47                   "" (err));                                   \
 48         } while (0)
 49 
 50 /* See comment before __put_user_asm.  */
 51 
 52 #define __get_user_asm(x, addr, err, op)                \
 53         __asm__ __volatile__(                           \
 54                 "2:     "op" [%2],%1\n"                 \
 55                 "4:\n"                                  \
 56                 "       .section .fixup,\"ax\"\n"       \
 57                 "3:     move.d %3,%0\n"                 \
 58                 "       jump 4b\n"                      \
 59                 "       moveq 0,%1\n"                   \
 60                 "       .previous\n"                    \
 61                 "       .section __ex_table,\"a\"\n"    \
 62                 "       .dword 2b,3b\n"                 \
 63                 "       .previous\n"                    \
 64                 : "=r" (err), "=r" (x)                  \
 65                 : "r" (addr), "g" (-EFAULT), "" (err))
 66 
 67 #define __get_user_asm_64(x, addr, err) do {            \
 68         int dummy_for_get_user_asm_64_;                 \
 69         __asm__ __volatile__(                           \
 70                 "2:     move.d [%2+],%M1\n"             \
 71                 "4:     move.d [%2],%H1\n"              \
 72                 "5:\n"                                  \
 73                 "       .section .fixup,\"ax\"\n"       \
 74                 "3:     move.d %4,%0\n"                 \
 75                 "       jump 5b\n"                      \
 76                 "       moveq 0,%1\n"                   \
 77                 "       .previous\n"                    \
 78                 "       .section __ex_table,\"a\"\n"    \
 79                 "       .dword 2b,3b\n"                 \
 80                 "       .dword 4b,3b\n"                 \
 81                 "       .previous\n"                    \
 82                 : "=r" (err), "=r" (x),                 \
 83                   "=b" (dummy_for_get_user_asm_64_)     \
 84                 : "2" (addr), "g" (-EFAULT), "" (err));\
 85         } while (0)
 86 
 87 /*
 88  * Copy a null terminated string from userspace.
 89  *
 90  * Must return:
 91  * -EFAULT              for an exception
 92  * count                if we hit the buffer limit
 93  * bytes copied         if we hit a null byte
 94  * (without the null byte)
 95  */
 96 static inline long
 97 __do_strncpy_from_user(char *dst, const char *src, long count)
 98 {
 99         long res;
100 
101         if (count == 0)
102                 return 0;
103 
104         /*
105          * Currently, in 2.4.0-test9, most ports use a simple byte-copy loop.
106          *  So do we.
107          *
108          *  This code is deduced from:
109          *
110          *      char tmp2;
111          *      long tmp1, tmp3;
112          *      tmp1 = count;
113          *      while ((*dst++ = (tmp2 = *src++)) != 0
114          *             && --tmp1)
115          *        ;
116          *
117          *      res = count - tmp1;
118          *
119          *  with tweaks.
120          */
121 
122         __asm__ __volatile__ (
123                 "       move.d %3,%0\n"
124                 "5:     move.b [%2+],$acr\n"
125                 "1:     beq 6f\n"
126                 "       move.b $acr,[%1+]\n"
127 
128                 "       subq 1,%0\n"
129                 "2:     bne 1b\n"
130                 "       move.b [%2+],$acr\n"
131 
132                 "6:     sub.d %3,%0\n"
133                 "       neg.d %0,%0\n"
134                 "3:\n"
135                 "       .section .fixup,\"ax\"\n"
136                 "4:     move.d %7,%0\n"
137                 "       jump 3b\n"
138                 "       nop\n"
139 
140                 /* The address for a fault at the first move is trivial.
141                    The address for a fault at the second move is that of
142                    the preceding branch insn, since the move insn is in
143                    its delay-slot.  Just so you don't get confused...  */
144                 "       .previous\n"
145                 "       .section __ex_table,\"a\"\n"
146                 "       .dword 5b,4b\n"
147                 "       .dword 2b,4b\n"
148                 "       .previous"
149                 : "=r" (res), "=b" (dst), "=b" (src), "=r" (count)
150                 : "3" (count), "1" (dst), "2" (src), "g" (-EFAULT)
151                 : "acr");
152 
153         return res;
154 }
155 
156 /* A few copy asms to build up the more complex ones from.
157 
158    Note again, a post-increment is performed regardless of whether a bus
159    fault occurred in that instruction, and PC for a faulted insn is the
160    address for the insn, or for the preceding branch when in a delay-slot.  */
161 
162 #define __asm_copy_user_cont(to, from, ret, COPY, FIXUP, TENTRY) \
163         __asm__ __volatile__ (                          \
164                         COPY                            \
165                 "1:\n"                                  \
166                 "       .section .fixup,\"ax\"\n"       \
167                         FIXUP                           \
168                 "       .previous\n"                    \
169                 "       .section __ex_table,\"a\"\n"    \
170                         TENTRY                          \
171                 "       .previous\n"                    \
172                 : "=b" (to), "=b" (from), "=r" (ret)    \
173                 : "" (to), "1" (from), "2" (ret)       \
174                 : "acr", "memory")
175 
176 #define __asm_copy_from_user_1(to, from, ret) \
177         __asm_copy_user_cont(to, from, ret,     \
178                 "2:     move.b [%1+],$acr\n"    \
179                 "       move.b $acr,[%0+]\n",   \
180                 "3:     addq 1,%2\n"            \
181                 "       jump 1b\n"              \
182                 "       clear.b [%0+]\n",       \
183                 "       .dword 2b,3b\n")
184 
185 #define __asm_copy_from_user_2x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
186         __asm_copy_user_cont(to, from, ret,             \
187                         COPY                            \
188                 "2:     move.w [%1+],$acr\n"            \
189                 "       move.w $acr,[%0+]\n",           \
190                         FIXUP                           \
191                 "3:     addq 2,%2\n"                    \
192                 "       jump 1b\n"                      \
193                 "       clear.w [%0+]\n",               \
194                         TENTRY                          \
195                 "       .dword 2b,3b\n")
196 
197 #define __asm_copy_from_user_2(to, from, ret) \
198         __asm_copy_from_user_2x_cont(to, from, ret, "", "", "")
199 
200 #define __asm_copy_from_user_3(to, from, ret)           \
201         __asm_copy_from_user_2x_cont(to, from, ret,     \
202                 "4:     move.b [%1+],$acr\n"            \
203                 "       move.b $acr,[%0+]\n",           \
204                 "5:     addq 1,%2\n"                    \
205                 "       clear.b [%0+]\n",               \
206                 "       .dword 4b,5b\n")
207 
208 #define __asm_copy_from_user_4x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
209         __asm_copy_user_cont(to, from, ret,             \
210                         COPY                            \
211                 "2:     move.d [%1+],$acr\n"            \
212                 "       move.d $acr,[%0+]\n",           \
213                         FIXUP                           \
214                 "3:     addq 4,%2\n"                    \
215                 "       jump 1b\n"                      \
216                 "       clear.d [%0+]\n",               \
217                         TENTRY                          \
218                 "       .dword 2b,3b\n")
219 
220 #define __asm_copy_from_user_4(to, from, ret) \
221         __asm_copy_from_user_4x_cont(to, from, ret, "", "", "")
222 
223 #define __asm_copy_from_user_5(to, from, ret) \
224         __asm_copy_from_user_4x_cont(to, from, ret,     \
225                 "4:     move.b [%1+],$acr\n"            \
226                 "       move.b $acr,[%0+]\n",           \
227                 "5:     addq 1,%2\n"                    \
228                 "       clear.b [%0+]\n",               \
229                 "       .dword 4b,5b\n")
230 
231 #define __asm_copy_from_user_6x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
232         __asm_copy_from_user_4x_cont(to, from, ret,     \
233                         COPY                            \
234                 "4:     move.w [%1+],$acr\n"            \
235                 "       move.w $acr,[%0+]\n",           \
236                         FIXUP                           \
237                 "5:     addq 2,%2\n"                    \
238                 "       clear.w [%0+]\n",               \
239                         TENTRY                          \
240                 "       .dword 4b,5b\n")
241 
242 #define __asm_copy_from_user_6(to, from, ret) \
243         __asm_copy_from_user_6x_cont(to, from, ret, "", "", "")
244 
245 #define __asm_copy_from_user_7(to, from, ret) \
246         __asm_copy_from_user_6x_cont(to, from, ret,     \
247                 "6:     move.b [%1+],$acr\n"            \
248                 "       move.b $acr,[%0+]\n",           \
249                 "7:     addq 1,%2\n"                    \
250                 "       clear.b [%0+]\n",               \
251                 "       .dword 6b,7b\n")
252 
253 #define __asm_copy_from_user_8x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
254         __asm_copy_from_user_4x_cont(to, from, ret,     \
255                         COPY                            \
256                 "4:     move.d [%1+],$acr\n"            \
257                 "       move.d $acr,[%0+]\n",           \
258                         FIXUP                           \
259                 "5:     addq 4,%2\n"                    \
260                 "       clear.d [%0+]\n",               \
261                         TENTRY                          \
262                 "       .dword 4b,5b\n")
263 
264 #define __asm_copy_from_user_8(to, from, ret) \
265         __asm_copy_from_user_8x_cont(to, from, ret, "", "", "")
266 
267 #define __asm_copy_from_user_9(to, from, ret) \
268         __asm_copy_from_user_8x_cont(to, from, ret,     \
269                 "6:     move.b [%1+],$acr\n"            \
270                 "       move.b $acr,[%0+]\n",           \
271                 "7:     addq 1,%2\n"                    \
272                 "       clear.b [%0+]\n",               \
273                 "       .dword 6b,7b\n")
274 
275 #define __asm_copy_from_user_10x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
276         __asm_copy_from_user_8x_cont(to, from, ret,     \
277                         COPY                            \
278                 "6:     move.w [%1+],$acr\n"            \
279                 "       move.w $acr,[%0+]\n",           \
280                         FIXUP                           \
281                 "7:     addq 2,%2\n"                    \
282                 "       clear.w [%0+]\n",               \
283                         TENTRY                          \
284                 "       .dword 6b,7b\n")
285 
286 #define __asm_copy_from_user_10(to, from, ret) \
287         __asm_copy_from_user_10x_cont(to, from, ret, "", "", "")
288 
289 #define __asm_copy_from_user_11(to, from, ret)          \
290         __asm_copy_from_user_10x_cont(to, from, ret,    \
291                 "8:     move.b [%1+],$acr\n"            \
292                 "       move.b $acr,[%0+]\n",           \
293                 "9:     addq 1,%2\n"                    \
294                 "       clear.b [%0+]\n",               \
295                 "       .dword 8b,9b\n")
296 
297 #define __asm_copy_from_user_12x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
298         __asm_copy_from_user_8x_cont(to, from, ret,     \
299                         COPY                            \
300                 "6:     move.d [%1+],$acr\n"            \
301                 "       move.d $acr,[%0+]\n",           \
302                         FIXUP                           \
303                 "7:     addq 4,%2\n"                    \
304                 "       clear.d [%0+]\n",               \
305                         TENTRY                          \
306                 "       .dword 6b,7b\n")
307 
308 #define __asm_copy_from_user_12(to, from, ret) \
309         __asm_copy_from_user_12x_cont(to, from, ret, "", "", "")
310 
311 #define __asm_copy_from_user_13(to, from, ret) \
312         __asm_copy_from_user_12x_cont(to, from, ret,    \
313                 "8:     move.b [%1+],$acr\n"            \
314                 "       move.b $acr,[%0+]\n",           \
315                 "9:     addq 1,%2\n"                    \
316                 "       clear.b [%0+]\n",               \
317                 "       .dword 8b,9b\n")
318 
319 #define __asm_copy_from_user_14x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
320         __asm_copy_from_user_12x_cont(to, from, ret,    \
321                         COPY                            \
322                 "8:     move.w [%1+],$acr\n"            \
323                 "       move.w $acr,[%0+]\n",           \
324                         FIXUP                           \
325                 "9:     addq 2,%2\n"                    \
326                 "       clear.w [%0+]\n",               \
327                         TENTRY                          \
328                 "       .dword 8b,9b\n")
329 
330 #define __asm_copy_from_user_14(to, from, ret) \
331         __asm_copy_from_user_14x_cont(to, from, ret, "", "", "")
332 
333 #define __asm_copy_from_user_15(to, from, ret) \
334         __asm_copy_from_user_14x_cont(to, from, ret,    \
335                 "10:    move.b [%1+],$acr\n"            \
336                 "       move.b $acr,[%0+]\n",           \
337                 "11:    addq 1,%2\n"                    \
338                 "       clear.b [%0+]\n",               \
339                 "       .dword 10b,11b\n")
340 
341 #define __asm_copy_from_user_16x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
342         __asm_copy_from_user_12x_cont(to, from, ret,    \
343                         COPY                            \
344                 "8:     move.d [%1+],$acr\n"            \
345                 "       move.d $acr,[%0+]\n",           \
346                         FIXUP                           \
347                 "9:     addq 4,%2\n"                    \
348                 "       clear.d [%0+]\n",               \
349                         TENTRY                          \
350                 "       .dword 8b,9b\n")
351 
352 #define __asm_copy_from_user_16(to, from, ret) \
353         __asm_copy_from_user_16x_cont(to, from, ret, "", "", "")
354 
355 #define __asm_copy_from_user_20x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
356         __asm_copy_from_user_16x_cont(to, from, ret,    \
357                         COPY                            \
358                 "10:    move.d [%1+],$acr\n"            \
359                 "       move.d $acr,[%0+]\n",           \
360                         FIXUP                           \
361                 "11:    addq 4,%2\n"                    \
362                 "       clear.d [%0+]\n",               \
363                         TENTRY                          \
364                 "       .dword 10b,11b\n")
365 
366 #define __asm_copy_from_user_20(to, from, ret) \
367         __asm_copy_from_user_20x_cont(to, from, ret, "", "", "")
368 
369 #define __asm_copy_from_user_24x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
370         __asm_copy_from_user_20x_cont(to, from, ret,    \
371                         COPY                            \
372                 "12:    move.d [%1+],$acr\n"            \
373                 "       move.d $acr,[%0+]\n",           \
374                         FIXUP                           \
375                 "13:    addq 4,%2\n"                    \
376                 "       clear.d [%0+]\n",               \
377                         TENTRY                          \
378                 "       .dword 12b,13b\n")
379 
380 #define __asm_copy_from_user_24(to, from, ret) \
381         __asm_copy_from_user_24x_cont(to, from, ret, "", "", "")
382 
383 /* And now, the to-user ones.  */
384 
385 #define __asm_copy_to_user_1(to, from, ret)     \
386         __asm_copy_user_cont(to, from, ret,     \
387                 "       move.b [%1+],$acr\n"    \
388                 "2:     move.b $acr,[%0+]\n",   \
389                 "3:     jump 1b\n"              \
390                 "       addq 1,%2\n",           \
391                 "       .dword 2b,3b\n")
392 
393 #define __asm_copy_to_user_2x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
394         __asm_copy_user_cont(to, from, ret,             \
395                         COPY                            \
396                 "       move.w [%1+],$acr\n"            \
397                 "2:     move.w $acr,[%0+]\n",           \
398                         FIXUP                           \
399                 "3:     jump 1b\n"                      \
400                 "       addq 2,%2\n",                   \
401                         TENTRY                          \
402                 "       .dword 2b,3b\n")
403 
404 #define __asm_copy_to_user_2(to, from, ret) \
405         __asm_copy_to_user_2x_cont(to, from, ret, "", "", "")
406 
407 #define __asm_copy_to_user_3(to, from, ret) \
408         __asm_copy_to_user_2x_cont(to, from, ret,       \
409                 "       move.b [%1+],$acr\n"            \
410                 "4:     move.b $acr,[%0+]\n",           \
411                 "5:     addq 1,%2\n",                   \
412                 "       .dword 4b,5b\n")
413 
414 #define __asm_copy_to_user_4x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
415         __asm_copy_user_cont(to, from, ret,             \
416                         COPY                            \
417                 "       move.d [%1+],$acr\n"            \
418                 "2:     move.d $acr,[%0+]\n",           \
419                         FIXUP                           \
420                 "3:     jump 1b\n"                      \
421                 "       addq 4,%2\n",                   \
422                         TENTRY                          \
423                 "       .dword 2b,3b\n")
424 
425 #define __asm_copy_to_user_4(to, from, ret) \
426         __asm_copy_to_user_4x_cont(to, from, ret, "", "", "")
427 
428 #define __asm_copy_to_user_5(to, from, ret) \
429         __asm_copy_to_user_4x_cont(to, from, ret,       \
430                 "       move.b [%1+],$acr\n"            \
431                 "4:     move.b $acr,[%0+]\n",           \
432                 "5:     addq 1,%2\n",                   \
433                 "       .dword 4b,5b\n")
434 
435 #define __asm_copy_to_user_6x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
436         __asm_copy_to_user_4x_cont(to, from, ret,       \
437                         COPY                            \
438                 "       move.w [%1+],$acr\n"            \
439                 "4:     move.w $acr,[%0+]\n",           \
440                         FIXUP                           \
441                 "5:     addq 2,%2\n",                   \
442                         TENTRY                          \
443                 "       .dword 4b,5b\n")
444 
445 #define __asm_copy_to_user_6(to, from, ret) \
446         __asm_copy_to_user_6x_cont(to, from, ret, "", "", "")
447 
448 #define __asm_copy_to_user_7(to, from, ret) \
449         __asm_copy_to_user_6x_cont(to, from, ret,       \
450                 "       move.b [%1+],$acr\n"            \
451                 "6:     move.b $acr,[%0+]\n",           \
452                 "7:     addq 1,%2\n",                   \
453                 "       .dword 6b,7b\n")
454 
455 #define __asm_copy_to_user_8x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
456         __asm_copy_to_user_4x_cont(to, from, ret,       \
457                         COPY                            \
458                 "       move.d [%1+],$acr\n"            \
459                 "4:     move.d $acr,[%0+]\n",           \
460                         FIXUP                           \
461                 "5:     addq 4,%2\n",                   \
462                         TENTRY                          \
463                 "       .dword 4b,5b\n")
464 
465 #define __asm_copy_to_user_8(to, from, ret) \
466         __asm_copy_to_user_8x_cont(to, from, ret, "", "", "")
467 
468 #define __asm_copy_to_user_9(to, from, ret) \
469         __asm_copy_to_user_8x_cont(to, from, ret,       \
470                 "       move.b [%1+],$acr\n"            \
471                 "6:     move.b $acr,[%0+]\n",           \
472                 "7:     addq 1,%2\n",                   \
473                 "       .dword 6b,7b\n")
474 
475 #define __asm_copy_to_user_10x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
476         __asm_copy_to_user_8x_cont(to, from, ret,       \
477                         COPY                            \
478                 "       move.w [%1+],$acr\n"            \
479                 "6:     move.w $acr,[%0+]\n",           \
480                         FIXUP                           \
481                 "7:     addq 2,%2\n",                   \
482                         TENTRY                          \
483                 "       .dword 6b,7b\n")
484 
485 #define __asm_copy_to_user_10(to, from, ret) \
486         __asm_copy_to_user_10x_cont(to, from, ret, "", "", "")
487 
488 #define __asm_copy_to_user_11(to, from, ret) \
489         __asm_copy_to_user_10x_cont(to, from, ret,      \
490                 "       move.b [%1+],$acr\n"            \
491                 "8:     move.b $acr,[%0+]\n",           \
492                 "9:     addq 1,%2\n",                   \
493                 "       .dword 8b,9b\n")
494 
495 #define __asm_copy_to_user_12x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
496         __asm_copy_to_user_8x_cont(to, from, ret,       \
497                         COPY                            \
498                 "       move.d [%1+],$acr\n"            \
499                 "6:     move.d $acr,[%0+]\n",           \
500                         FIXUP                           \
501                 "7:     addq 4,%2\n",                   \
502                         TENTRY                          \
503                 "       .dword 6b,7b\n")
504 
505 #define __asm_copy_to_user_12(to, from, ret) \
506         __asm_copy_to_user_12x_cont(to, from, ret, "", "", "")
507 
508 #define __asm_copy_to_user_13(to, from, ret) \
509         __asm_copy_to_user_12x_cont(to, from, ret,      \
510                 "       move.b [%1+],$acr\n"            \
511                 "8:     move.b $acr,[%0+]\n",           \
512                 "9:     addq 1,%2\n",                   \
513                 "       .dword 8b,9b\n")
514 
515 #define __asm_copy_to_user_14x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
516         __asm_copy_to_user_12x_cont(to, from, ret,      \
517                         COPY                            \
518                 "       move.w [%1+],$acr\n"            \
519                 "8:     move.w $acr,[%0+]\n",           \
520                         FIXUP                           \
521                 "9:     addq 2,%2\n",                   \
522                         TENTRY                          \
523                 "       .dword 8b,9b\n")
524 
525 #define __asm_copy_to_user_14(to, from, ret)    \
526         __asm_copy_to_user_14x_cont(to, from, ret, "", "", "")
527 
528 #define __asm_copy_to_user_15(to, from, ret) \
529         __asm_copy_to_user_14x_cont(to, from, ret,      \
530                 "       move.b [%1+],$acr\n"            \
531                 "10:    move.b $acr,[%0+]\n",           \
532                 "11:    addq 1,%2\n",                   \
533                 "       .dword 10b,11b\n")
534 
535 #define __asm_copy_to_user_16x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
536         __asm_copy_to_user_12x_cont(to, from, ret,      \
537                         COPY                            \
538                 "       move.d [%1+],$acr\n"            \
539                 "8:     move.d $acr,[%0+]\n",           \
540                         FIXUP                           \
541                 "9:     addq 4,%2\n",                   \
542                         TENTRY                          \
543                 "       .dword 8b,9b\n")
544 
545 #define __asm_copy_to_user_16(to, from, ret) \
546         __asm_copy_to_user_16x_cont(to, from, ret, "", "", "")
547 
548 #define __asm_copy_to_user_20x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
549         __asm_copy_to_user_16x_cont(to, from, ret,      \
550                         COPY                            \
551                 "       move.d [%1+],$acr\n"            \
552                 "10:    move.d $acr,[%0+]\n",           \
553                         FIXUP                           \
554                 "11:    addq 4,%2\n",                   \
555                         TENTRY                          \
556                 "       .dword 10b,11b\n")
557 
558 #define __asm_copy_to_user_20(to, from, ret) \
559         __asm_copy_to_user_20x_cont(to, from, ret, "", "", "")
560 
561 #define __asm_copy_to_user_24x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
562         __asm_copy_to_user_20x_cont(to, from, ret,      \
563                         COPY                            \
564                 "       move.d [%1+],$acr\n"            \
565                 "12:    move.d $acr,[%0+]\n",           \
566                         FIXUP                           \
567                 "13:    addq 4,%2\n",                   \
568                         TENTRY                          \
569                 "       .dword 12b,13b\n")
570 
571 #define __asm_copy_to_user_24(to, from, ret)    \
572         __asm_copy_to_user_24x_cont(to, from, ret, "", "", "")
573 
574 /* Define a few clearing asms with exception handlers.  */
575 
576 /* This frame-asm is like the __asm_copy_user_cont one, but has one less
577    input.  */
578 
579 #define __asm_clear(to, ret, CLEAR, FIXUP, TENTRY) \
580         __asm__ __volatile__ (                          \
581                         CLEAR                           \
582                 "1:\n"                                  \
583                 "       .section .fixup,\"ax\"\n"       \
584                         FIXUP                           \
585                 "       .previous\n"                    \
586                 "       .section __ex_table,\"a\"\n"    \
587                         TENTRY                          \
588                 "       .previous"                      \
589                 : "=b" (to), "=r" (ret)                 \
590                 : "" (to), "1" (ret)                   \
591                 : "memory")
592 
593 #define __asm_clear_1(to, ret) \
594         __asm_clear(to, ret,                    \
595                 "2:     clear.b [%0+]\n",       \
596                 "3:     jump 1b\n"              \
597                 "       addq 1,%1\n",           \
598                 "       .dword 2b,3b\n")
599 
600 #define __asm_clear_2(to, ret) \
601         __asm_clear(to, ret,                    \
602                 "2:     clear.w [%0+]\n",       \
603                 "3:     jump 1b\n"              \
604                 "       addq 2,%1\n",           \
605                 "       .dword 2b,3b\n")
606 
607 #define __asm_clear_3(to, ret) \
608      __asm_clear(to, ret,                       \
609                  "2:    clear.w [%0+]\n"        \
610                  "3:    clear.b [%0+]\n",       \
611                  "4:    addq 2,%1\n"            \
612                  "5:    jump 1b\n"              \
613                  "      addq 1,%1\n",           \
614                  "      .dword 2b,4b\n"         \
615                  "      .dword 3b,5b\n")
616 
617 #define __asm_clear_4x_cont(to, ret, CLEAR, FIXUP, TENTRY) \
618         __asm_clear(to, ret,                            \
619                         CLEAR                           \
620                 "2:     clear.d [%0+]\n",               \
621                         FIXUP                           \
622                 "3:     jump 1b\n"                      \
623                 "       addq 4,%1\n",                   \
624                         TENTRY                          \
625                 "       .dword 2b,3b\n")
626 
627 #define __asm_clear_4(to, ret) \
628         __asm_clear_4x_cont(to, ret, "", "", "")
629 
630 #define __asm_clear_8x_cont(to, ret, CLEAR, FIXUP, TENTRY) \
631         __asm_clear_4x_cont(to, ret,                    \
632                         CLEAR                           \
633                 "4:     clear.d [%0+]\n",               \
634                         FIXUP                           \
635                 "5:     addq 4,%1\n",                   \
636                         TENTRY                          \
637                 "       .dword 4b,5b\n")
638 
639 #define __asm_clear_8(to, ret) \
640         __asm_clear_8x_cont(to, ret, "", "", "")
641 
642 #define __asm_clear_12x_cont(to, ret, CLEAR, FIXUP, TENTRY) \
643         __asm_clear_8x_cont(to, ret,                    \
644                         CLEAR                           \
645                 "6:     clear.d [%0+]\n",               \
646                         FIXUP                           \
647                 "7:     addq 4,%1\n",                   \
648                         TENTRY                          \
649                 "       .dword 6b,7b\n")
650 
651 #define __asm_clear_12(to, ret) \
652         __asm_clear_12x_cont(to, ret, "", "", "")
653 
654 #define __asm_clear_16x_cont(to, ret, CLEAR, FIXUP, TENTRY) \
655         __asm_clear_12x_cont(to, ret,                   \
656                         CLEAR                           \
657                 "8:     clear.d [%0+]\n",               \
658                         FIXUP                           \
659                 "9:     addq 4,%1\n",                   \
660                         TENTRY                          \
661                 "       .dword 8b,9b\n")
662 
663 #define __asm_clear_16(to, ret) \
664         __asm_clear_16x_cont(to, ret, "", "", "")
665 
666 #define __asm_clear_20x_cont(to, ret, CLEAR, FIXUP, TENTRY) \
667         __asm_clear_16x_cont(to, ret,                   \
668                         CLEAR                           \
669                 "10:    clear.d [%0+]\n",               \
670                         FIXUP                           \
671                 "11:    addq 4,%1\n",                   \
672                         TENTRY                          \
673                 "       .dword 10b,11b\n")
674 
675 #define __asm_clear_20(to, ret) \
676         __asm_clear_20x_cont(to, ret, "", "", "")
677 
678 #define __asm_clear_24x_cont(to, ret, CLEAR, FIXUP, TENTRY) \
679         __asm_clear_20x_cont(to, ret,                   \
680                         CLEAR                           \
681                 "12:    clear.d [%0+]\n",               \
682                         FIXUP                           \
683                 "13:    addq 4,%1\n",                   \
684                         TENTRY                          \
685                 "       .dword 12b,13b\n")
686 
687 #define __asm_clear_24(to, ret) \
688         __asm_clear_24x_cont(to, ret, "", "", "")
689 
690 /*
691  * Return the size of a string (including the ending 0)
692  *
693  * Return length of string in userspace including terminating 0
694  * or 0 for error.  Return a value greater than N if too long.
695  */
696 
697 static inline long
698 strnlen_user(const char *s, long n)
699 {
700         long res, tmp1;
701 
702         if (!access_ok(VERIFY_READ, s, 0))
703                 return 0;
704 
705         /*
706          * This code is deduced from:
707          *
708          *      tmp1 = n;
709          *      while (tmp1-- > 0 && *s++)
710          *        ;
711          *
712          *      res = n - tmp1;
713          *
714          *  (with tweaks).
715          */
716 
717         __asm__ __volatile__ (
718                 "       move.d %1,$acr\n"
719                 "       cmpq 0,$acr\n"
720                 "0:\n"
721                 "       ble 1f\n"
722                 "       subq 1,$acr\n"
723 
724                 "4:     test.b [%0+]\n"
725                 "       bne 0b\n"
726                 "       cmpq 0,$acr\n"
727                 "1:\n"
728                 "       move.d %1,%0\n"
729                 "       sub.d $acr,%0\n"
730                 "2:\n"
731                 "       .section .fixup,\"ax\"\n"
732 
733                 "3:     jump 2b\n"
734                 "       clear.d %0\n"
735 
736                 "       .previous\n"
737                 "       .section __ex_table,\"a\"\n"
738                 "       .dword 4b,3b\n"
739                 "       .previous\n"
740                 : "=r" (res), "=r" (tmp1)
741                 : "" (s), "1" (n)
742                 : "acr");
743 
744         return res;
745 }
746 
747 #endif
748 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp