Commit | Line | Data |
---|---|---|
ba423fda CH |
1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
2 | /* | |
3 | * Copyright (c) 2020 Christoph Hellwig. | |
4 | * | |
5 | * Support for "universal" pointers that can point to either kernel or userspace | |
6 | * memory. | |
7 | */ | |
8 | #ifndef _LINUX_SOCKPTR_H | |
9 | #define _LINUX_SOCKPTR_H | |
10 | ||
11 | #include <linux/slab.h> | |
12 | #include <linux/uaccess.h> | |
13 | ||
14 | typedef struct { | |
15 | union { | |
16 | void *kernel; | |
17 | void __user *user; | |
18 | }; | |
19 | bool is_kernel : 1; | |
20 | } sockptr_t; | |
21 | ||
22 | static inline bool sockptr_is_kernel(sockptr_t sockptr) | |
23 | { | |
24 | return sockptr.is_kernel; | |
25 | } | |
26 | ||
27 | static inline sockptr_t KERNEL_SOCKPTR(void *p) | |
28 | { | |
29 | return (sockptr_t) { .kernel = p, .is_kernel = true }; | |
30 | } | |
31 | ||
519a8a6c | 32 | static inline sockptr_t USER_SOCKPTR(void __user *p) |
ba423fda | 33 | { |
519a8a6c | 34 | return (sockptr_t) { .user = p }; |
ba423fda CH |
35 | } |
36 | ||
37 | static inline bool sockptr_is_null(sockptr_t sockptr) | |
38 | { | |
035bfd05 CH |
39 | if (sockptr_is_kernel(sockptr)) |
40 | return !sockptr.kernel; | |
41 | return !sockptr.user; | |
ba423fda CH |
42 | } |
43 | ||
d3c48151 CH |
44 | static inline int copy_from_sockptr_offset(void *dst, sockptr_t src, |
45 | size_t offset, size_t size) | |
ba423fda CH |
46 | { |
47 | if (!sockptr_is_kernel(src)) | |
d3c48151 CH |
48 | return copy_from_user(dst, src.user + offset, size); |
49 | memcpy(dst, src.kernel + offset, size); | |
ba423fda CH |
50 | return 0; |
51 | } | |
52 | ||
d3c48151 CH |
53 | static inline int copy_from_sockptr(void *dst, sockptr_t src, size_t size) |
54 | { | |
55 | return copy_from_sockptr_offset(dst, src, 0, size); | |
56 | } | |
57 | ||
58 | static inline int copy_to_sockptr_offset(sockptr_t dst, size_t offset, | |
59 | const void *src, size_t size) | |
ba423fda CH |
60 | { |
61 | if (!sockptr_is_kernel(dst)) | |
d3c48151 CH |
62 | return copy_to_user(dst.user + offset, src, size); |
63 | memcpy(dst.kernel + offset, src, size); | |
ba423fda CH |
64 | return 0; |
65 | } | |
66 | ||
4ff09db1 MKL |
67 | static inline int copy_to_sockptr(sockptr_t dst, const void *src, size_t size) |
68 | { | |
69 | return copy_to_sockptr_offset(dst, 0, src, size); | |
70 | } | |
71 | ||
ba423fda CH |
72 | static inline void *memdup_sockptr(sockptr_t src, size_t len) |
73 | { | |
74 | void *p = kmalloc_track_caller(len, GFP_USER | __GFP_NOWARN); | |
75 | ||
76 | if (!p) | |
77 | return ERR_PTR(-ENOMEM); | |
78 | if (copy_from_sockptr(p, src, len)) { | |
79 | kfree(p); | |
80 | return ERR_PTR(-EFAULT); | |
81 | } | |
82 | return p; | |
83 | } | |
84 | ||
85 | static inline void *memdup_sockptr_nul(sockptr_t src, size_t len) | |
86 | { | |
87 | char *p = kmalloc_track_caller(len + 1, GFP_KERNEL); | |
88 | ||
89 | if (!p) | |
90 | return ERR_PTR(-ENOMEM); | |
91 | if (copy_from_sockptr(p, src, len)) { | |
92 | kfree(p); | |
93 | return ERR_PTR(-EFAULT); | |
94 | } | |
95 | p[len] = '\0'; | |
96 | return p; | |
97 | } | |
98 | ||
ba423fda CH |
99 | static inline long strncpy_from_sockptr(char *dst, sockptr_t src, size_t count) |
100 | { | |
101 | if (sockptr_is_kernel(src)) { | |
102 | size_t len = min(strnlen(src.kernel, count - 1) + 1, count); | |
103 | ||
104 | memcpy(dst, src.kernel, len); | |
105 | return len; | |
106 | } | |
107 | return strncpy_from_user(dst, src.user, count); | |
108 | } | |
109 | ||
88527790 JK |
110 | static inline int check_zeroed_sockptr(sockptr_t src, size_t offset, |
111 | size_t size) | |
112 | { | |
113 | if (!sockptr_is_kernel(src)) | |
114 | return check_zeroed_user(src.user + offset, size); | |
115 | return memchr_inv(src.kernel + offset, 0, size) == NULL; | |
116 | } | |
117 | ||
ba423fda | 118 | #endif /* _LINUX_SOCKPTR_H */ |