1 | /* Convenience function to catch expected signals during an operation. |
2 | Copyright (C) 1996-2022 Free Software Foundation, Inc. |
3 | This file is part of the GNU C Library. |
4 | |
5 | The GNU C Library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Lesser General Public |
7 | License as published by the Free Software Foundation; either |
8 | version 2.1 of the License, or (at your option) any later version. |
9 | |
10 | The GNU C Library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Lesser General Public License for more details. |
14 | |
15 | You should have received a copy of the GNU Lesser General Public |
16 | License along with the GNU C Library; if not, see |
17 | <https://www.gnu.org/licenses/>. */ |
18 | |
19 | #include <hurd/signal.h> |
20 | #include <hurd/sigpreempt.h> |
21 | #include <string.h> |
22 | #include <assert.h> |
23 | |
24 | error_t |
25 | __hurd_catch_signal (sigset_t sigset, |
26 | unsigned long int first, unsigned long int last, |
27 | error_t (*operate) (struct hurd_signal_preemptor *), |
28 | sighandler_t handler) |
29 | { |
30 | /* We need to restore the signal mask, because otherwise the |
31 | signal-handling code will have blocked the caught signal and for |
32 | instance calling hurd_catch_signal again would then dump core. */ |
33 | sigjmp_buf buf; |
34 | void throw (int signo, long int sigcode, struct sigcontext *scp) |
35 | { siglongjmp (buf, scp->sc_error ?: EGRATUITOUS); } |
36 | |
37 | struct hurd_signal_preemptor preemptor = |
38 | { |
39 | sigset, first, last, |
40 | NULL, handler == SIG_ERR ? (sighandler_t) &throw : handler, |
41 | }; |
42 | |
43 | struct hurd_sigstate *const ss = _hurd_self_sigstate (); |
44 | error_t error; |
45 | |
46 | if (handler != SIG_ERR) |
47 | /* Not our handler; don't bother saving state. */ |
48 | error = 0; |
49 | else |
50 | /* This returns again with nonzero value when we preempt a signal. */ |
51 | error = sigsetjmp (buf, 1); |
52 | |
53 | if (error == 0) |
54 | { |
55 | /* Install a signal preemptor for the thread. */ |
56 | __spin_lock (&ss->lock); |
57 | preemptor.next = ss->preemptors; |
58 | ss->preemptors = &preemptor; |
59 | __spin_unlock (&ss->lock); |
60 | |
61 | /* Try the operation that might crash. */ |
62 | (*operate) (&preemptor); |
63 | } |
64 | |
65 | /* Either FUNCTION completed happily and ERROR is still zero, or it hit |
66 | an expected signal and `throw' made setjmp return the signal error |
67 | code in ERROR. Now we can remove the preemptor and return. */ |
68 | |
69 | __spin_lock (&ss->lock); |
70 | assert (ss->preemptors == &preemptor); |
71 | ss->preemptors = preemptor.next; |
72 | __spin_unlock (&ss->lock); |
73 | |
74 | return error; |
75 | } |
76 | strong_alias (__hurd_catch_signal, hurd_catch_signal) |
77 | |
78 | |
79 | error_t |
80 | hurd_safe_memset (void *dest, int byte, size_t nbytes) |
81 | { |
82 | error_t operate (struct hurd_signal_preemptor *preemptor) |
83 | { |
84 | memset (dest, byte, nbytes); |
85 | return 0; |
86 | } |
87 | return __hurd_catch_signal (__sigmask (SIGBUS) | __sigmask (SIGSEGV), |
88 | (vm_address_t) dest, (vm_address_t) dest + nbytes, |
89 | &operate, SIG_ERR); |
90 | } |
91 | |
92 | |
93 | error_t |
94 | hurd_safe_copyout (void *dest, const void *src, size_t nbytes) |
95 | { |
96 | error_t operate (struct hurd_signal_preemptor *preemptor) |
97 | { |
98 | memcpy (dest, src, nbytes); |
99 | return 0; |
100 | } |
101 | return __hurd_catch_signal (__sigmask (SIGBUS) | __sigmask (SIGSEGV), |
102 | (vm_address_t) dest, (vm_address_t) dest + nbytes, |
103 | &operate, SIG_ERR); |
104 | } |
105 | |
106 | error_t |
107 | hurd_safe_copyin (void *dest, const void *src, size_t nbytes) |
108 | { |
109 | error_t operate (struct hurd_signal_preemptor *preemptor) |
110 | { |
111 | memcpy (dest, src, nbytes); |
112 | return 0; |
113 | } |
114 | return __hurd_catch_signal (__sigmask (SIGBUS) | __sigmask (SIGSEGV), |
115 | (vm_address_t) src, (vm_address_t) src + nbytes, |
116 | &operate, SIG_ERR); |
117 | } |
118 | |
119 | error_t |
120 | hurd_safe_memmove (void *dest, const void *src, size_t nbytes) |
121 | { |
122 | jmp_buf buf; |
123 | void throw (int signo, long int sigcode, struct sigcontext *scp) |
124 | { longjmp (buf, scp->sc_error ?: EGRATUITOUS); } |
125 | |
126 | struct hurd_signal_preemptor src_preemptor = |
127 | { |
128 | __sigmask (SIGBUS) | __sigmask (SIGSEGV), |
129 | (vm_address_t) src, (vm_address_t) src + nbytes, |
130 | NULL, (sighandler_t) &throw, |
131 | }; |
132 | struct hurd_signal_preemptor dest_preemptor = |
133 | { |
134 | __sigmask (SIGBUS) | __sigmask (SIGSEGV), |
135 | (vm_address_t) dest, (vm_address_t) dest + nbytes, |
136 | NULL, (sighandler_t) &throw, |
137 | &src_preemptor |
138 | }; |
139 | |
140 | struct hurd_sigstate *const ss = _hurd_self_sigstate (); |
141 | error_t error; |
142 | |
143 | /* This returns again with nonzero value when we preempt a signal. */ |
144 | error = setjmp (buf); |
145 | |
146 | if (error == 0) |
147 | { |
148 | /* Install a signal preemptor for the thread. */ |
149 | __spin_lock (&ss->lock); |
150 | src_preemptor.next = ss->preemptors; |
151 | ss->preemptors = &dest_preemptor; |
152 | __spin_unlock (&ss->lock); |
153 | |
154 | /* Do the copy; it might fault. */ |
155 | memmove (dest: dest, src: src, n: nbytes); |
156 | } |
157 | |
158 | /* Either memmove completed happily and ERROR is still zero, or it hit |
159 | an expected signal and `throw' made setjmp return the signal error |
160 | code in ERROR. Now we can remove the preemptor and return. */ |
161 | |
162 | __spin_lock (&ss->lock); |
163 | assert (ss->preemptors == &dest_preemptor); |
164 | ss->preemptors = src_preemptor.next; |
165 | __spin_unlock (&ss->lock); |
166 | |
167 | return error; |
168 | } |
169 | |