Linux Kernel
3.7.1
Main Page
Related Pages
Modules
Namespaces
Data Structures
Files
File List
Globals
All
Data Structures
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Macros
Groups
Pages
arch
m32r
include
asm
uaccess.h
Go to the documentation of this file.
1
#ifndef _ASM_M32R_UACCESS_H
2
#define _ASM_M32R_UACCESS_H
3
4
/*
5
* linux/include/asm-m32r/uaccess.h
6
*
7
* M32R version.
8
* Copyright (C) 2004, 2006 Hirokazu Takata <takata at linux-m32r.org>
9
*/
10
11
/*
12
* User space memory access functions
13
*/
14
#include <linux/errno.h>
15
#include <
linux/thread_info.h
>
16
#include <asm/page.h>
17
#include <asm/setup.h>
18
19
#define VERIFY_READ 0
20
#define VERIFY_WRITE 1
21
22
/*
23
* The fs value determines whether argument validity checking should be
24
* performed or not. If get_fs() == USER_DS, checking is performed, with
25
* get_fs() == KERNEL_DS, checking is bypassed.
26
*
27
* For historical reasons, these macros are grossly misnamed.
28
*/
29
30
#define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
31
32
#ifdef CONFIG_MMU
33
34
#define KERNEL_DS MAKE_MM_SEG(0xFFFFFFFF)
35
#define USER_DS MAKE_MM_SEG(PAGE_OFFSET)
36
#define get_ds() (KERNEL_DS)
37
#define get_fs() (current_thread_info()->addr_limit)
38
#define set_fs(x) (current_thread_info()->addr_limit = (x))
39
40
#else
/* not CONFIG_MMU */
41
42
#define KERNEL_DS MAKE_MM_SEG(0xFFFFFFFF)
43
#define USER_DS MAKE_MM_SEG(0xFFFFFFFF)
44
#define get_ds() (KERNEL_DS)
45
46
static
inline
mm_segment_t
get_fs
(
void
)
47
{
48
return
USER_DS
;
49
}
50
51
static
inline
void
set_fs
(
mm_segment_t
s
)
52
{
53
}
54
55
#endif
/* not CONFIG_MMU */
56
57
#define segment_eq(a,b) ((a).seg == (b).seg)
58
59
#define __addr_ok(addr) \
60
((unsigned long)(addr) < (current_thread_info()->addr_limit.seg))
61
62
/*
63
* Test whether a block of memory is a valid user space address.
64
* Returns 0 if the range is valid, nonzero otherwise.
65
*
66
* This is equivalent to the following test:
67
* (u33)addr + (u33)size >= (u33)current->addr_limit.seg
68
*
69
* This needs 33-bit arithmetic. We have a carry...
70
*/
71
#define __range_ok(addr,size) ({ \
72
unsigned long flag, roksum; \
73
__chk_user_ptr(addr); \
74
asm ( \
75
" cmpu %1, %1 ; clear cbit\n" \
76
" addx %1, %3 ; set cbit if overflow\n" \
77
" subx %0, %0\n" \
78
" cmpu %4, %1\n" \
79
" subx %0, %5\n" \
80
: "=&r" (flag), "=r" (roksum) \
81
: "1" (addr), "r" ((int)(size)), \
82
"r" (current_thread_info()->addr_limit.seg), "r" (0) \
83
: "cbit" ); \
84
flag; })
85
105
#ifdef CONFIG_MMU
106
#define access_ok(type,addr,size) (likely(__range_ok(addr,size) == 0))
107
#else
108
static
inline
int
access_ok
(
int
type
,
const
void
*
addr
,
unsigned
long
size
)
109
{
110
unsigned
long
val
= (
unsigned
long
)addr;
111
112
return
((val >=
memory_start
) && ((val +
size
) <
memory_end
));
113
}
114
#endif
/* CONFIG_MMU */
115
116
/*
117
* The exception table consists of pairs of addresses: the first is the
118
* address of an instruction that is allowed to fault, and the second is
119
* the address at which the program should continue. No registers are
120
* modified, so it is entirely up to the continuation code to figure out
121
* what to do.
122
*
123
* All the routines below use bits of fixup code that are out of line
124
* with the main instruction path. This means when everything is well,
125
* we don't even have to jump over them. Further, they do not intrude
126
* on our cache or tlb entries.
127
*/
128
129
struct
exception_table_entry
130
{
131
unsigned
long
insn
,
fixup
;
132
};
133
134
extern
int
fixup_exception
(
struct
pt_regs
*
regs
);
135
136
/*
137
* These are the main single-value transfer routines. They automatically
138
* use the right size if we just have the right pointer type.
139
*
140
* This gets kind of ugly. We want to return _two_ values in "get_user()"
141
* and yet we don't want to do any pointers, because that is too much
142
* of a performance impact. Thus we have a few rather ugly macros here,
143
* and hide all the uglyness from the user.
144
*
145
* The "__xxx" versions of the user access functions are versions that
146
* do not verify the address space, that must have been done previously
147
* with a separate "access_ok()" call (this is used when we do multiple
148
* accesses to the same area of user memory).
149
*/
150
151
/* Careful: we have to cast the result to the type of the pointer for sign
152
reasons */
170
#define get_user(x,ptr) \
171
__get_user_check((x),(ptr),sizeof(*(ptr)))
172
189
#define put_user(x,ptr) \
190
__put_user_check((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
191
212
#define __get_user(x,ptr) \
213
__get_user_nocheck((x),(ptr),sizeof(*(ptr)))
214
215
#define __get_user_nocheck(x,ptr,size) \
216
({ \
217
long __gu_err = 0; \
218
unsigned long __gu_val; \
219
might_sleep(); \
220
__get_user_size(__gu_val,(ptr),(size),__gu_err); \
221
(x) = (__typeof__(*(ptr)))__gu_val; \
222
__gu_err; \
223
})
224
225
#define __get_user_check(x,ptr,size) \
226
({ \
227
long __gu_err = -EFAULT; \
228
unsigned long __gu_val = 0; \
229
const __typeof__(*(ptr)) __user *__gu_addr = (ptr); \
230
might_sleep(); \
231
if (access_ok(VERIFY_READ,__gu_addr,size)) \
232
__get_user_size(__gu_val,__gu_addr,(size),__gu_err); \
233
(x) = (__typeof__(*(ptr)))__gu_val; \
234
__gu_err; \
235
})
236
237
extern
long
__get_user_bad
(
void
);
238
239
#define __get_user_size(x,ptr,size,retval) \
240
do { \
241
retval = 0; \
242
__chk_user_ptr(ptr); \
243
switch (size) { \
244
case 1: __get_user_asm(x,ptr,retval,"ub"); break; \
245
case 2: __get_user_asm(x,ptr,retval,"uh"); break; \
246
case 4: __get_user_asm(x,ptr,retval,""); break; \
247
default: (x) = __get_user_bad(); \
248
} \
249
} while (0)
250
251
#define __get_user_asm(x, addr, err, itype) \
252
__asm__ __volatile__( \
253
" .fillinsn\n" \
254
"1: ld"itype" %1,@%2\n" \
255
" .fillinsn\n" \
256
"2:\n" \
257
".section .fixup,\"ax\"\n" \
258
" .balign 4\n" \
259
"3: ldi %0,%3\n" \
260
" seth r14,#high(2b)\n" \
261
" or3 r14,r14,#low(2b)\n" \
262
" jmp r14\n" \
263
".previous\n" \
264
".section __ex_table,\"a\"\n" \
265
" .balign 4\n" \
266
" .long 1b,3b\n" \
267
".previous" \
268
: "=&r" (err), "=&r" (x) \
269
: "r" (addr), "i" (-EFAULT), "0" (err) \
270
: "r14", "memory")
271
291
#define __put_user(x,ptr) \
292
__put_user_nocheck((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
293
294
295
#define __put_user_nocheck(x,ptr,size) \
296
({ \
297
long __pu_err; \
298
might_sleep(); \
299
__put_user_size((x),(ptr),(size),__pu_err); \
300
__pu_err; \
301
})
302
303
304
#define __put_user_check(x,ptr,size) \
305
({ \
306
long __pu_err = -EFAULT; \
307
__typeof__(*(ptr)) __user *__pu_addr = (ptr); \
308
might_sleep(); \
309
if (access_ok(VERIFY_WRITE,__pu_addr,size)) \
310
__put_user_size((x),__pu_addr,(size),__pu_err); \
311
__pu_err; \
312
})
313
314
#if defined(__LITTLE_ENDIAN__)
315
#define __put_user_u64(x, addr, err) \
316
__asm__ __volatile__( \
317
" .fillinsn\n" \
318
"1: st %L1,@%2\n" \
319
" .fillinsn\n" \
320
"2: st %H1,@(4,%2)\n" \
321
" .fillinsn\n" \
322
"3:\n" \
323
".section .fixup,\"ax\"\n" \
324
" .balign 4\n" \
325
"4: ldi %0,%3\n" \
326
" seth r14,#high(3b)\n" \
327
" or3 r14,r14,#low(3b)\n" \
328
" jmp r14\n" \
329
".previous\n" \
330
".section __ex_table,\"a\"\n" \
331
" .balign 4\n" \
332
" .long 1b,4b\n" \
333
" .long 2b,4b\n" \
334
".previous" \
335
: "=&r" (err) \
336
: "r" (x), "r" (addr), "i" (-EFAULT), "0" (err) \
337
: "r14", "memory")
338
339
#elif defined(__BIG_ENDIAN__)
340
#define __put_user_u64(x, addr, err) \
341
__asm__ __volatile__( \
342
" .fillinsn\n" \
343
"1: st %H1,@%2\n" \
344
" .fillinsn\n" \
345
"2: st %L1,@(4,%2)\n" \
346
" .fillinsn\n" \
347
"3:\n" \
348
".section .fixup,\"ax\"\n" \
349
" .balign 4\n" \
350
"4: ldi %0,%3\n" \
351
" seth r14,#high(3b)\n" \
352
" or3 r14,r14,#low(3b)\n" \
353
" jmp r14\n" \
354
".previous\n" \
355
".section __ex_table,\"a\"\n" \
356
" .balign 4\n" \
357
" .long 1b,4b\n" \
358
" .long 2b,4b\n" \
359
".previous" \
360
: "=&r" (err) \
361
: "r" (x), "r" (addr), "i" (-EFAULT), "0" (err) \
362
: "r14", "memory")
363
#else
364
#error no endian defined
365
#endif
366
367
extern
void
__put_user_bad
(
void
);
368
369
#define __put_user_size(x,ptr,size,retval) \
370
do { \
371
retval = 0; \
372
__chk_user_ptr(ptr); \
373
switch (size) { \
374
case 1: __put_user_asm(x,ptr,retval,"b"); break; \
375
case 2: __put_user_asm(x,ptr,retval,"h"); break; \
376
case 4: __put_user_asm(x,ptr,retval,""); break; \
377
case 8: __put_user_u64((__typeof__(*ptr))(x),ptr,retval); break;\
378
default: __put_user_bad(); \
379
} \
380
} while (0)
381
382
struct
__large_struct
{
unsigned
long
buf
[100]; };
383
#define __m(x) (*(struct __large_struct *)(x))
384
385
/*
386
* Tell gcc we read from memory instead of writing: this is because
387
* we do not write to any memory gcc knows about, so there are no
388
* aliasing issues.
389
*/
390
#define __put_user_asm(x, addr, err, itype) \
391
__asm__ __volatile__( \
392
" .fillinsn\n" \
393
"1: st"itype" %1,@%2\n" \
394
" .fillinsn\n" \
395
"2:\n" \
396
".section .fixup,\"ax\"\n" \
397
" .balign 4\n" \
398
"3: ldi %0,%3\n" \
399
" seth r14,#high(2b)\n" \
400
" or3 r14,r14,#low(2b)\n" \
401
" jmp r14\n" \
402
".previous\n" \
403
".section __ex_table,\"a\"\n" \
404
" .balign 4\n" \
405
" .long 1b,3b\n" \
406
".previous" \
407
: "=&r" (err) \
408
: "r" (x), "r" (addr), "i" (-EFAULT), "0" (err) \
409
: "r14", "memory")
410
411
/*
412
* Here we special-case 1, 2 and 4-byte copy_*_user invocations. On a fault
413
* we return the initial request size (1, 2 or 4), as copy_*_user should do.
414
* If a store crosses a page boundary and gets a fault, the m32r will not write
415
* anything, so this is accurate.
416
*/
417
418
/*
419
* Copy To/From Userspace
420
*/
421
422
/* Generic arbitrary sized copy. */
423
/* Return the number of bytes NOT copied. */
424
#define __copy_user(to,from,size) \
425
do { \
426
unsigned long __dst, __src, __c; \
427
__asm__ __volatile__ ( \
428
" mv r14, %0\n" \
429
" or r14, %1\n" \
430
" beq %0, %1, 9f\n" \
431
" beqz %2, 9f\n" \
432
" and3 r14, r14, #3\n" \
433
" bnez r14, 2f\n" \
434
" and3 %2, %2, #3\n" \
435
" beqz %3, 2f\n" \
436
" addi %0, #-4 ; word_copy \n" \
437
" .fillinsn\n" \
438
"0: ld r14, @%1+\n" \
439
" addi %3, #-1\n" \
440
" .fillinsn\n" \
441
"1: st r14, @+%0\n" \
442
" bnez %3, 0b\n" \
443
" beqz %2, 9f\n" \
444
" addi %0, #4\n" \
445
" .fillinsn\n" \
446
"2: ldb r14, @%1 ; byte_copy \n" \
447
" .fillinsn\n" \
448
"3: stb r14, @%0\n" \
449
" addi %1, #1\n" \
450
" addi %2, #-1\n" \
451
" addi %0, #1\n" \
452
" bnez %2, 2b\n" \
453
" .fillinsn\n" \
454
"9:\n" \
455
".section .fixup,\"ax\"\n" \
456
" .balign 4\n" \
457
"5: addi %3, #1\n" \
458
" addi %1, #-4\n" \
459
" .fillinsn\n" \
460
"6: slli %3, #2\n" \
461
" add %2, %3\n" \
462
" addi %0, #4\n" \
463
" .fillinsn\n" \
464
"7: seth r14, #high(9b)\n" \
465
" or3 r14, r14, #low(9b)\n" \
466
" jmp r14\n" \
467
".previous\n" \
468
".section __ex_table,\"a\"\n" \
469
" .balign 4\n" \
470
" .long 0b,6b\n" \
471
" .long 1b,5b\n" \
472
" .long 2b,9b\n" \
473
" .long 3b,9b\n" \
474
".previous\n" \
475
: "=&r" (__dst), "=&r" (__src), "=&r" (size), \
476
"=&r" (__c) \
477
: "0" (to), "1" (from), "2" (size), "3" (size / 4) \
478
: "r14", "memory"); \
479
} while (0)
480
481
#define __copy_user_zeroing(to,from,size) \
482
do { \
483
unsigned long __dst, __src, __c; \
484
__asm__ __volatile__ ( \
485
" mv r14, %0\n" \
486
" or r14, %1\n" \
487
" beq %0, %1, 9f\n" \
488
" beqz %2, 9f\n" \
489
" and3 r14, r14, #3\n" \
490
" bnez r14, 2f\n" \
491
" and3 %2, %2, #3\n" \
492
" beqz %3, 2f\n" \
493
" addi %0, #-4 ; word_copy \n" \
494
" .fillinsn\n" \
495
"0: ld r14, @%1+\n" \
496
" addi %3, #-1\n" \
497
" .fillinsn\n" \
498
"1: st r14, @+%0\n" \
499
" bnez %3, 0b\n" \
500
" beqz %2, 9f\n" \
501
" addi %0, #4\n" \
502
" .fillinsn\n" \
503
"2: ldb r14, @%1 ; byte_copy \n" \
504
" .fillinsn\n" \
505
"3: stb r14, @%0\n" \
506
" addi %1, #1\n" \
507
" addi %2, #-1\n" \
508
" addi %0, #1\n" \
509
" bnez %2, 2b\n" \
510
" .fillinsn\n" \
511
"9:\n" \
512
".section .fixup,\"ax\"\n" \
513
" .balign 4\n" \
514
"5: addi %3, #1\n" \
515
" addi %1, #-4\n" \
516
" .fillinsn\n" \
517
"6: slli %3, #2\n" \
518
" add %2, %3\n" \
519
" addi %0, #4\n" \
520
" .fillinsn\n" \
521
"7: ldi r14, #0 ; store zero \n" \
522
" .fillinsn\n" \
523
"8: addi %2, #-1\n" \
524
" stb r14, @%0 ; ACE? \n" \
525
" addi %0, #1\n" \
526
" bnez %2, 8b\n" \
527
" seth r14, #high(9b)\n" \
528
" or3 r14, r14, #low(9b)\n" \
529
" jmp r14\n" \
530
".previous\n" \
531
".section __ex_table,\"a\"\n" \
532
" .balign 4\n" \
533
" .long 0b,6b\n" \
534
" .long 1b,5b\n" \
535
" .long 2b,7b\n" \
536
" .long 3b,7b\n" \
537
".previous\n" \
538
: "=&r" (__dst), "=&r" (__src), "=&r" (size), \
539
"=&r" (__c) \
540
: "0" (to), "1" (from), "2" (size), "3" (size / 4) \
541
: "r14", "memory"); \
542
} while (0)
543
544
545
/* We let the __ versions of copy_from/to_user inline, because they're often
546
* used in fast paths and have only a small space overhead.
547
*/
548
static
inline
unsigned
long
__generic_copy_from_user_nocheck(
void
*to,
549
const
void
__user *
from
,
unsigned
long
n
)
550
{
551
__copy_user_zeroing
(to,from,n);
552
return
n
;
553
}
554
555
static
inline
unsigned
long
__generic_copy_to_user_nocheck(
void
__user *to,
556
const
void
*
from
,
unsigned
long
n
)
557
{
558
__copy_user
(to,from,n);
559
return
n
;
560
}
561
562
unsigned
long
__generic_copy_to_user
(
void
__user *,
const
void
*,
unsigned
long
);
563
unsigned
long
__generic_copy_from_user
(
void
*,
const
void
__user *,
unsigned
long
);
564
579
#define __copy_to_user(to,from,n) \
580
__generic_copy_to_user_nocheck((to),(from),(n))
581
582
#define __copy_to_user_inatomic __copy_to_user
583
#define __copy_from_user_inatomic __copy_from_user
584
598
#define copy_to_user(to,from,n) \
599
({ \
600
might_sleep(); \
601
__generic_copy_to_user((to),(from),(n)); \
602
})
603
620
#define __copy_from_user(to,from,n) \
621
__generic_copy_from_user_nocheck((to),(from),(n))
622
639
#define copy_from_user(to,from,n) \
640
({ \
641
might_sleep(); \
642
__generic_copy_from_user((to),(from),(n)); \
643
})
644
645
long
__must_check
strncpy_from_user
(
char
*
dst
,
const
char
__user *
src
,
646
long
count
);
647
long
__must_check
__strncpy_from_user
(
char
*
dst
,
648
const
char
__user *
src
,
long
count
);
649
661
unsigned
long
__clear_user
(
void
__user *
mem
,
unsigned
long
len);
662
674
unsigned
long
clear_user
(
void
__user *
mem
,
unsigned
long
len);
675
690
#define strlen_user(str) strnlen_user(str, ~0UL >> 1)
691
long
strnlen_user
(
const
char
__user *
str
,
long
n
);
692
693
#endif
/* _ASM_M32R_UACCESS_H */
Generated on Thu Jan 10 2013 12:50:45 for Linux Kernel by
1.8.2