diff options
Diffstat (limited to 'include')
-rw-r--r-- | include/asm-ia64/kprobes.h | 6 | ||||
-rw-r--r-- | include/asm-ia64/sn/sn_sal.h | 5 | ||||
-rw-r--r-- | include/asm-ia64/sn/xp.h | 4 | ||||
-rw-r--r-- | include/asm-ia64/sn/xpc.h | 1274 | ||||
-rw-r--r-- | include/asm-ia64/thread_info.h | 4 |
5 files changed, 1289 insertions, 4 deletions
diff --git a/include/asm-ia64/kprobes.h b/include/asm-ia64/kprobes.h index a74b68104559..8c0fc227f0fb 100644 --- a/include/asm-ia64/kprobes.h +++ b/include/asm-ia64/kprobes.h | |||
@@ -68,10 +68,14 @@ struct prev_kprobe { | |||
68 | unsigned long status; | 68 | unsigned long status; |
69 | }; | 69 | }; |
70 | 70 | ||
71 | #define MAX_PARAM_RSE_SIZE (0x60+0x60/0x3f) | ||
71 | /* per-cpu kprobe control block */ | 72 | /* per-cpu kprobe control block */ |
72 | struct kprobe_ctlblk { | 73 | struct kprobe_ctlblk { |
73 | unsigned long kprobe_status; | 74 | unsigned long kprobe_status; |
74 | struct pt_regs jprobe_saved_regs; | 75 | struct pt_regs jprobe_saved_regs; |
76 | unsigned long jprobes_saved_stacked_regs[MAX_PARAM_RSE_SIZE]; | ||
77 | unsigned long *bsp; | ||
78 | unsigned long cfm; | ||
75 | struct prev_kprobe prev_kprobe; | 79 | struct prev_kprobe prev_kprobe; |
76 | }; | 80 | }; |
77 | 81 | ||
@@ -118,5 +122,7 @@ extern int kprobe_exceptions_notify(struct notifier_block *self, | |||
118 | static inline void jprobe_return(void) | 122 | static inline void jprobe_return(void) |
119 | { | 123 | { |
120 | } | 124 | } |
125 | extern void invalidate_stacked_regs(void); | ||
126 | extern void flush_register_stack(void); | ||
121 | 127 | ||
122 | #endif /* _ASM_KPROBES_H */ | 128 | #endif /* _ASM_KPROBES_H */ |
diff --git a/include/asm-ia64/sn/sn_sal.h b/include/asm-ia64/sn/sn_sal.h index 2a8b0d92a5d6..8b9e10e7cdba 100644 --- a/include/asm-ia64/sn/sn_sal.h +++ b/include/asm-ia64/sn/sn_sal.h | |||
@@ -75,7 +75,8 @@ | |||
75 | #define SN_SAL_IOIF_GET_HUBDEV_INFO 0x02000055 | 75 | #define SN_SAL_IOIF_GET_HUBDEV_INFO 0x02000055 |
76 | #define SN_SAL_IOIF_GET_PCIBUS_INFO 0x02000056 | 76 | #define SN_SAL_IOIF_GET_PCIBUS_INFO 0x02000056 |
77 | #define SN_SAL_IOIF_GET_PCIDEV_INFO 0x02000057 | 77 | #define SN_SAL_IOIF_GET_PCIDEV_INFO 0x02000057 |
78 | #define SN_SAL_IOIF_GET_WIDGET_DMAFLUSH_LIST 0x02000058 | 78 | #define SN_SAL_IOIF_GET_WIDGET_DMAFLUSH_LIST 0x02000058 // deprecated |
79 | #define SN_SAL_IOIF_GET_DEVICE_DMAFLUSH_LIST 0x0200005a | ||
79 | 80 | ||
80 | #define SN_SAL_HUB_ERROR_INTERRUPT 0x02000060 | 81 | #define SN_SAL_HUB_ERROR_INTERRUPT 0x02000060 |
81 | #define SN_SAL_BTE_RECOVER 0x02000061 | 82 | #define SN_SAL_BTE_RECOVER 0x02000061 |
@@ -1100,7 +1101,7 @@ ia64_sn_bte_recovery(nasid_t nasid) | |||
1100 | struct ia64_sal_retval rv; | 1101 | struct ia64_sal_retval rv; |
1101 | 1102 | ||
1102 | rv.status = 0; | 1103 | rv.status = 0; |
1103 | SAL_CALL_NOLOCK(rv, SN_SAL_BTE_RECOVER, 0, 0, 0, 0, 0, 0, 0); | 1104 | SAL_CALL_NOLOCK(rv, SN_SAL_BTE_RECOVER, (u64)nasid, 0, 0, 0, 0, 0, 0); |
1104 | if (rv.status == SALRET_NOT_IMPLEMENTED) | 1105 | if (rv.status == SALRET_NOT_IMPLEMENTED) |
1105 | return 0; | 1106 | return 0; |
1106 | return (int) rv.status; | 1107 | return (int) rv.status; |
diff --git a/include/asm-ia64/sn/xp.h b/include/asm-ia64/sn/xp.h index 49faf8f26430..203945ae034e 100644 --- a/include/asm-ia64/sn/xp.h +++ b/include/asm-ia64/sn/xp.h | |||
@@ -227,7 +227,9 @@ enum xpc_retval { | |||
227 | 227 | ||
228 | xpcOpenCloseError, /* 50: channel open/close protocol error */ | 228 | xpcOpenCloseError, /* 50: channel open/close protocol error */ |
229 | 229 | ||
230 | xpcUnknownReason /* 51: unknown reason -- must be last in list */ | 230 | xpcDisconnected, /* 51: channel disconnected (closed) */ |
231 | |||
232 | xpcUnknownReason /* 52: unknown reason -- must be last in list */ | ||
231 | }; | 233 | }; |
232 | 234 | ||
233 | 235 | ||
diff --git a/include/asm-ia64/sn/xpc.h b/include/asm-ia64/sn/xpc.h new file mode 100644 index 000000000000..87e9cd588510 --- /dev/null +++ b/include/asm-ia64/sn/xpc.h | |||
@@ -0,0 +1,1274 @@ | |||
1 | /* | ||
2 | * This file is subject to the terms and conditions of the GNU General Public | ||
3 | * License. See the file "COPYING" in the main directory of this archive | ||
4 | * for more details. | ||
5 | * | ||
6 | * Copyright (c) 2004-2006 Silicon Graphics, Inc. All Rights Reserved. | ||
7 | */ | ||
8 | |||
9 | |||
10 | /* | ||
11 | * Cross Partition Communication (XPC) structures and macros. | ||
12 | */ | ||
13 | |||
14 | #ifndef _ASM_IA64_SN_XPC_H | ||
15 | #define _ASM_IA64_SN_XPC_H | ||
16 | |||
17 | |||
18 | #include <linux/config.h> | ||
19 | #include <linux/interrupt.h> | ||
20 | #include <linux/sysctl.h> | ||
21 | #include <linux/device.h> | ||
22 | #include <asm/pgtable.h> | ||
23 | #include <asm/processor.h> | ||
24 | #include <asm/sn/bte.h> | ||
25 | #include <asm/sn/clksupport.h> | ||
26 | #include <asm/sn/addrs.h> | ||
27 | #include <asm/sn/mspec.h> | ||
28 | #include <asm/sn/shub_mmr.h> | ||
29 | #include <asm/sn/xp.h> | ||
30 | |||
31 | |||
32 | /* | ||
33 | * XPC Version numbers consist of a major and minor number. XPC can always | ||
34 | * talk to versions with same major #, and never talk to versions with a | ||
35 | * different major #. | ||
36 | */ | ||
37 | #define _XPC_VERSION(_maj, _min) (((_maj) << 4) | ((_min) & 0xf)) | ||
38 | #define XPC_VERSION_MAJOR(_v) ((_v) >> 4) | ||
39 | #define XPC_VERSION_MINOR(_v) ((_v) & 0xf) | ||
40 | |||
41 | |||
42 | /* | ||
43 | * The next macros define word or bit representations for given | ||
44 | * C-brick nasid in either the SAL provided bit array representing | ||
45 | * nasids in the partition/machine or the AMO_t array used for | ||
46 | * inter-partition initiation communications. | ||
47 | * | ||
48 | * For SN2 machines, C-Bricks are alway even numbered NASIDs. As | ||
49 | * such, some space will be saved by insisting that nasid information | ||
50 | * passed from SAL always be packed for C-Bricks and the | ||
51 | * cross-partition interrupts use the same packing scheme. | ||
52 | */ | ||
53 | #define XPC_NASID_W_INDEX(_n) (((_n) / 64) / 2) | ||
54 | #define XPC_NASID_B_INDEX(_n) (((_n) / 2) & (64 - 1)) | ||
55 | #define XPC_NASID_IN_ARRAY(_n, _p) ((_p)[XPC_NASID_W_INDEX(_n)] & \ | ||
56 | (1UL << XPC_NASID_B_INDEX(_n))) | ||
57 | #define XPC_NASID_FROM_W_B(_w, _b) (((_w) * 64 + (_b)) * 2) | ||
58 | |||
59 | #define XPC_HB_DEFAULT_INTERVAL 5 /* incr HB every x secs */ | ||
60 | #define XPC_HB_CHECK_DEFAULT_INTERVAL 20 /* check HB every x secs */ | ||
61 | |||
62 | /* define the process name of HB checker and the CPU it is pinned to */ | ||
63 | #define XPC_HB_CHECK_THREAD_NAME "xpc_hb" | ||
64 | #define XPC_HB_CHECK_CPU 0 | ||
65 | |||
66 | /* define the process name of the discovery thread */ | ||
67 | #define XPC_DISCOVERY_THREAD_NAME "xpc_discovery" | ||
68 | |||
69 | |||
70 | /* | ||
71 | * the reserved page | ||
72 | * | ||
73 | * SAL reserves one page of memory per partition for XPC. Though a full page | ||
74 | * in length (16384 bytes), its starting address is not page aligned, but it | ||
75 | * is cacheline aligned. The reserved page consists of the following: | ||
76 | * | ||
77 | * reserved page header | ||
78 | * | ||
79 | * The first cacheline of the reserved page contains the header | ||
80 | * (struct xpc_rsvd_page). Before SAL initialization has completed, | ||
81 | * SAL has set up the following fields of the reserved page header: | ||
82 | * SAL_signature, SAL_version, partid, and nasids_size. The other | ||
83 | * fields are set up by XPC. (xpc_rsvd_page points to the local | ||
84 | * partition's reserved page.) | ||
85 | * | ||
86 | * part_nasids mask | ||
87 | * mach_nasids mask | ||
88 | * | ||
89 | * SAL also sets up two bitmaps (or masks), one that reflects the actual | ||
90 | * nasids in this partition (part_nasids), and the other that reflects | ||
91 | * the actual nasids in the entire machine (mach_nasids). We're only | ||
92 | * interested in the even numbered nasids (which contain the processors | ||
93 | * and/or memory), so we only need half as many bits to represent the | ||
94 | * nasids. The part_nasids mask is located starting at the first cacheline | ||
95 | * following the reserved page header. The mach_nasids mask follows right | ||
96 | * after the part_nasids mask. The size in bytes of each mask is reflected | ||
97 | * by the reserved page header field 'nasids_size'. (Local partition's | ||
98 | * mask pointers are xpc_part_nasids and xpc_mach_nasids.) | ||
99 | * | ||
100 | * vars | ||
101 | * vars part | ||
102 | * | ||
103 | * Immediately following the mach_nasids mask are the XPC variables | ||
104 | * required by other partitions. First are those that are generic to all | ||
105 | * partitions (vars), followed on the next available cacheline by those | ||
106 | * which are partition specific (vars part). These are setup by XPC. | ||
107 | * (Local partition's vars pointers are xpc_vars and xpc_vars_part.) | ||
108 | * | ||
109 | * Note: Until vars_pa is set, the partition XPC code has not been initialized. | ||
110 | */ | ||
111 | struct xpc_rsvd_page { | ||
112 | u64 SAL_signature; /* SAL: unique signature */ | ||
113 | u64 SAL_version; /* SAL: version */ | ||
114 | u8 partid; /* SAL: partition ID */ | ||
115 | u8 version; | ||
116 | u8 pad1[6]; /* align to next u64 in cacheline */ | ||
117 | volatile u64 vars_pa; | ||
118 | struct timespec stamp; /* time when reserved page was setup by XPC */ | ||
119 | u64 pad2[9]; /* align to last u64 in cacheline */ | ||
120 | u64 nasids_size; /* SAL: size of each nasid mask in bytes */ | ||
121 | }; | ||
122 | |||
123 | #define XPC_RP_VERSION _XPC_VERSION(1,1) /* version 1.1 of the reserved page */ | ||
124 | |||
125 | #define XPC_SUPPORTS_RP_STAMP(_version) \ | ||
126 | (_version >= _XPC_VERSION(1,1)) | ||
127 | |||
128 | /* | ||
129 | * compare stamps - the return value is: | ||
130 | * | ||
131 | * < 0, if stamp1 < stamp2 | ||
132 | * = 0, if stamp1 == stamp2 | ||
133 | * > 0, if stamp1 > stamp2 | ||
134 | */ | ||
135 | static inline int | ||
136 | xpc_compare_stamps(struct timespec *stamp1, struct timespec *stamp2) | ||
137 | { | ||
138 | int ret; | ||
139 | |||
140 | |||
141 | if ((ret = stamp1->tv_sec - stamp2->tv_sec) == 0) { | ||
142 | ret = stamp1->tv_nsec - stamp2->tv_nsec; | ||
143 | } | ||
144 | return ret; | ||
145 | } | ||
146 | |||
147 | |||
148 | /* | ||
149 | * Define the structures by which XPC variables can be exported to other | ||
150 | * partitions. (There are two: struct xpc_vars and struct xpc_vars_part) | ||
151 | */ | ||
152 | |||
153 | /* | ||
154 | * The following structure describes the partition generic variables | ||
155 | * needed by other partitions in order to properly initialize. | ||
156 | * | ||
157 | * struct xpc_vars version number also applies to struct xpc_vars_part. | ||
158 | * Changes to either structure and/or related functionality should be | ||
159 | * reflected by incrementing either the major or minor version numbers | ||
160 | * of struct xpc_vars. | ||
161 | */ | ||
162 | struct xpc_vars { | ||
163 | u8 version; | ||
164 | u64 heartbeat; | ||
165 | u64 heartbeating_to_mask; | ||
166 | u64 heartbeat_offline; /* if 0, heartbeat should be changing */ | ||
167 | int act_nasid; | ||
168 | int act_phys_cpuid; | ||
169 | u64 vars_part_pa; | ||
170 | u64 amos_page_pa; /* paddr of page of AMOs from MSPEC driver */ | ||
171 | AMO_t *amos_page; /* vaddr of page of AMOs from MSPEC driver */ | ||
172 | }; | ||
173 | |||
174 | #define XPC_V_VERSION _XPC_VERSION(3,1) /* version 3.1 of the cross vars */ | ||
175 | |||
176 | #define XPC_SUPPORTS_DISENGAGE_REQUEST(_version) \ | ||
177 | (_version >= _XPC_VERSION(3,1)) | ||
178 | |||
179 | |||
180 | static inline int | ||
181 | xpc_hb_allowed(partid_t partid, struct xpc_vars *vars) | ||
182 | { | ||
183 | return ((vars->heartbeating_to_mask & (1UL << partid)) != 0); | ||
184 | } | ||
185 | |||
186 | static inline void | ||
187 | xpc_allow_hb(partid_t partid, struct xpc_vars *vars) | ||
188 | { | ||
189 | u64 old_mask, new_mask; | ||
190 | |||
191 | do { | ||
192 | old_mask = vars->heartbeating_to_mask; | ||
193 | new_mask = (old_mask | (1UL << partid)); | ||
194 | } while (cmpxchg(&vars->heartbeating_to_mask, old_mask, new_mask) != | ||
195 | old_mask); | ||
196 | } | ||
197 | |||
198 | static inline void | ||
199 | xpc_disallow_hb(partid_t partid, struct xpc_vars *vars) | ||
200 | { | ||
201 | u64 old_mask, new_mask; | ||
202 | |||
203 | do { | ||
204 | old_mask = vars->heartbeating_to_mask; | ||
205 | new_mask = (old_mask & ~(1UL << partid)); | ||
206 | } while (cmpxchg(&vars->heartbeating_to_mask, old_mask, new_mask) != | ||
207 | old_mask); | ||
208 | } | ||
209 | |||
210 | |||
211 | /* | ||
212 | * The AMOs page consists of a number of AMO variables which are divided into | ||
213 | * four groups, The first two groups are used to identify an IRQ's sender. | ||
214 | * These two groups consist of 64 and 128 AMO variables respectively. The last | ||
215 | * two groups, consisting of just one AMO variable each, are used to identify | ||
216 | * the remote partitions that are currently engaged (from the viewpoint of | ||
217 | * the XPC running on the remote partition). | ||
218 | */ | ||
219 | #define XPC_NOTIFY_IRQ_AMOS 0 | ||
220 | #define XPC_ACTIVATE_IRQ_AMOS (XPC_NOTIFY_IRQ_AMOS + XP_MAX_PARTITIONS) | ||
221 | #define XPC_ENGAGED_PARTITIONS_AMO (XPC_ACTIVATE_IRQ_AMOS + XP_NASID_MASK_WORDS) | ||
222 | #define XPC_DISENGAGE_REQUEST_AMO (XPC_ENGAGED_PARTITIONS_AMO + 1) | ||
223 | |||
224 | |||
225 | /* | ||
226 | * The following structure describes the per partition specific variables. | ||
227 | * | ||
228 | * An array of these structures, one per partition, will be defined. As a | ||
229 | * partition becomes active XPC will copy the array entry corresponding to | ||
230 | * itself from that partition. It is desirable that the size of this | ||
231 | * structure evenly divide into a cacheline, such that none of the entries | ||
232 | * in this array crosses a cacheline boundary. As it is now, each entry | ||
233 | * occupies half a cacheline. | ||
234 | */ | ||
235 | struct xpc_vars_part { | ||
236 | volatile u64 magic; | ||
237 | |||
238 | u64 openclose_args_pa; /* physical address of open and close args */ | ||
239 | u64 GPs_pa; /* physical address of Get/Put values */ | ||
240 | |||
241 | u64 IPI_amo_pa; /* physical address of IPI AMO_t structure */ | ||
242 | int IPI_nasid; /* nasid of where to send IPIs */ | ||
243 | int IPI_phys_cpuid; /* physical CPU ID of where to send IPIs */ | ||
244 | |||
245 | u8 nchannels; /* #of defined channels supported */ | ||
246 | |||
247 | u8 reserved[23]; /* pad to a full 64 bytes */ | ||
248 | }; | ||
249 | |||
250 | /* | ||
251 | * The vars_part MAGIC numbers play a part in the first contact protocol. | ||
252 | * | ||
253 | * MAGIC1 indicates that the per partition specific variables for a remote | ||
254 | * partition have been initialized by this partition. | ||
255 | * | ||
256 | * MAGIC2 indicates that this partition has pulled the remote partititions | ||
257 | * per partition variables that pertain to this partition. | ||
258 | */ | ||
259 | #define XPC_VP_MAGIC1 0x0053524156435058L /* 'XPCVARS\0'L (little endian) */ | ||
260 | #define XPC_VP_MAGIC2 0x0073726176435058L /* 'XPCvars\0'L (little endian) */ | ||
261 | |||
262 | |||
263 | /* the reserved page sizes and offsets */ | ||
264 | |||
265 | #define XPC_RP_HEADER_SIZE L1_CACHE_ALIGN(sizeof(struct xpc_rsvd_page)) | ||
266 | #define XPC_RP_VARS_SIZE L1_CACHE_ALIGN(sizeof(struct xpc_vars)) | ||
267 | |||
268 | #define XPC_RP_PART_NASIDS(_rp) (u64 *) ((u8 *) _rp + XPC_RP_HEADER_SIZE) | ||
269 | #define XPC_RP_MACH_NASIDS(_rp) (XPC_RP_PART_NASIDS(_rp) + xp_nasid_mask_words) | ||
270 | #define XPC_RP_VARS(_rp) ((struct xpc_vars *) XPC_RP_MACH_NASIDS(_rp) + xp_nasid_mask_words) | ||
271 | #define XPC_RP_VARS_PART(_rp) (struct xpc_vars_part *) ((u8 *) XPC_RP_VARS(rp) + XPC_RP_VARS_SIZE) | ||
272 | |||
273 | |||
274 | /* | ||
275 | * Functions registered by add_timer() or called by kernel_thread() only | ||
276 | * allow for a single 64-bit argument. The following macros can be used to | ||
277 | * pack and unpack two (32-bit, 16-bit or 8-bit) arguments into or out from | ||
278 | * the passed argument. | ||
279 | */ | ||
280 | #define XPC_PACK_ARGS(_arg1, _arg2) \ | ||
281 | ((((u64) _arg1) & 0xffffffff) | \ | ||
282 | ((((u64) _arg2) & 0xffffffff) << 32)) | ||
283 | |||
284 | #define XPC_UNPACK_ARG1(_args) (((u64) _args) & 0xffffffff) | ||
285 | #define XPC_UNPACK_ARG2(_args) ((((u64) _args) >> 32) & 0xffffffff) | ||
286 | |||
287 | |||
288 | |||
289 | /* | ||
290 | * Define a Get/Put value pair (pointers) used with a message queue. | ||
291 | */ | ||
292 | struct xpc_gp { | ||
293 | volatile s64 get; /* Get value */ | ||
294 | volatile s64 put; /* Put value */ | ||
295 | }; | ||
296 | |||
297 | #define XPC_GP_SIZE \ | ||
298 | L1_CACHE_ALIGN(sizeof(struct xpc_gp) * XPC_NCHANNELS) | ||
299 | |||
300 | |||
301 | |||
302 | /* | ||
303 | * Define a structure that contains arguments associated with opening and | ||
304 | * closing a channel. | ||
305 | */ | ||
306 | struct xpc_openclose_args { | ||
307 | u16 reason; /* reason why channel is closing */ | ||
308 | u16 msg_size; /* sizeof each message entry */ | ||
309 | u16 remote_nentries; /* #of message entries in remote msg queue */ | ||
310 | u16 local_nentries; /* #of message entries in local msg queue */ | ||
311 | u64 local_msgqueue_pa; /* physical address of local message queue */ | ||
312 | }; | ||
313 | |||
314 | #define XPC_OPENCLOSE_ARGS_SIZE \ | ||
315 | L1_CACHE_ALIGN(sizeof(struct xpc_openclose_args) * XPC_NCHANNELS) | ||
316 | |||
317 | |||
318 | |||
319 | /* struct xpc_msg flags */ | ||
320 | |||
321 | #define XPC_M_DONE 0x01 /* msg has been received/consumed */ | ||
322 | #define XPC_M_READY 0x02 /* msg is ready to be sent */ | ||
323 | #define XPC_M_INTERRUPT 0x04 /* send interrupt when msg consumed */ | ||
324 | |||
325 | |||
326 | #define XPC_MSG_ADDRESS(_payload) \ | ||
327 | ((struct xpc_msg *)((u8 *)(_payload) - XPC_MSG_PAYLOAD_OFFSET)) | ||
328 | |||
329 | |||
330 | |||
331 | /* | ||
332 | * Defines notify entry. | ||
333 | * | ||
334 | * This is used to notify a message's sender that their message was received | ||
335 | * and consumed by the intended recipient. | ||
336 | */ | ||
337 | struct xpc_notify { | ||
338 | struct semaphore sema; /* notify semaphore */ | ||
339 | volatile u8 type; /* type of notification */ | ||
340 | |||
341 | /* the following two fields are only used if type == XPC_N_CALL */ | ||
342 | xpc_notify_func func; /* user's notify function */ | ||
343 | void *key; /* pointer to user's key */ | ||
344 | }; | ||
345 | |||
346 | /* struct xpc_notify type of notification */ | ||
347 | |||
348 | #define XPC_N_CALL 0x01 /* notify function provided by user */ | ||
349 | |||
350 | |||
351 | |||
352 | /* | ||
353 | * Define the structure that manages all the stuff required by a channel. In | ||
354 | * particular, they are used to manage the messages sent across the channel. | ||
355 | * | ||
356 | * This structure is private to a partition, and is NOT shared across the | ||
357 | * partition boundary. | ||
358 | * | ||
359 | * There is an array of these structures for each remote partition. It is | ||
360 | * allocated at the time a partition becomes active. The array contains one | ||
361 | * of these structures for each potential channel connection to that partition. | ||
362 | * | ||
363 | * Each of these structures manages two message queues (circular buffers). | ||
364 | * They are allocated at the time a channel connection is made. One of | ||
365 | * these message queues (local_msgqueue) holds the locally created messages | ||
366 | * that are destined for the remote partition. The other of these message | ||
367 | * queues (remote_msgqueue) is a locally cached copy of the remote partition's | ||
368 | * own local_msgqueue. | ||
369 | * | ||
370 | * The following is a description of the Get/Put pointers used to manage these | ||
371 | * two message queues. Consider the local_msgqueue to be on one partition | ||
372 | * and the remote_msgqueue to be its cached copy on another partition. A | ||
373 | * description of what each of the lettered areas contains is included. | ||
374 | * | ||
375 | * | ||
376 | * local_msgqueue remote_msgqueue | ||
377 | * | ||
378 | * |/////////| |/////////| | ||
379 | * w_remote_GP.get --> +---------+ |/////////| | ||
380 | * | F | |/////////| | ||
381 | * remote_GP.get --> +---------+ +---------+ <-- local_GP->get | ||
382 | * | | | | | ||
383 | * | | | E | | ||
384 | * | | | | | ||
385 | * | | +---------+ <-- w_local_GP.get | ||
386 | * | B | |/////////| | ||
387 | * | | |////D////| | ||
388 | * | | |/////////| | ||
389 | * | | +---------+ <-- w_remote_GP.put | ||
390 | * | | |////C////| | ||
391 | * local_GP->put --> +---------+ +---------+ <-- remote_GP.put | ||
392 | * | | |/////////| | ||
393 | * | A | |/////////| | ||
394 | * | | |/////////| | ||
395 | * w_local_GP.put --> +---------+ |/////////| | ||
396 | * |/////////| |/////////| | ||
397 | * | ||
398 | * | ||
399 | * ( remote_GP.[get|put] are cached copies of the remote | ||
400 | * partition's local_GP->[get|put], and thus their values can | ||
401 | * lag behind their counterparts on the remote partition. ) | ||
402 | * | ||
403 | * | ||
404 | * A - Messages that have been allocated, but have not yet been sent to the | ||
405 | * remote partition. | ||
406 | * | ||
407 | * B - Messages that have been sent, but have not yet been acknowledged by the | ||
408 | * remote partition as having been received. | ||
409 | * | ||
410 | * C - Area that needs to be prepared for the copying of sent messages, by | ||
411 | * the clearing of the message flags of any previously received messages. | ||
412 | * | ||
413 | * D - Area into which sent messages are to be copied from the remote | ||
414 | * partition's local_msgqueue and then delivered to their intended | ||
415 | * recipients. [ To allow for a multi-message copy, another pointer | ||
416 | * (next_msg_to_pull) has been added to keep track of the next message | ||
417 | * number needing to be copied (pulled). It chases after w_remote_GP.put. | ||
418 | * Any messages lying between w_local_GP.get and next_msg_to_pull have | ||
419 | * been copied and are ready to be delivered. ] | ||
420 | * | ||
421 | * E - Messages that have been copied and delivered, but have not yet been | ||
422 | * acknowledged by the recipient as having been received. | ||
423 | * | ||
424 | * F - Messages that have been acknowledged, but XPC has not yet notified the | ||
425 | * sender that the message was received by its intended recipient. | ||
426 | * This is also an area that needs to be prepared for the allocating of | ||
427 | * new messages, by the clearing of the message flags of the acknowledged | ||
428 | * messages. | ||
429 | */ | ||
430 | struct xpc_channel { | ||
431 | partid_t partid; /* ID of remote partition connected */ | ||
432 | spinlock_t lock; /* lock for updating this structure */ | ||
433 | u32 flags; /* general flags */ | ||
434 | |||
435 | enum xpc_retval reason; /* reason why channel is disconnect'g */ | ||
436 | int reason_line; /* line# disconnect initiated from */ | ||
437 | |||
438 | u16 number; /* channel # */ | ||
439 | |||
440 | u16 msg_size; /* sizeof each msg entry */ | ||
441 | u16 local_nentries; /* #of msg entries in local msg queue */ | ||
442 | u16 remote_nentries; /* #of msg entries in remote msg queue*/ | ||
443 | |||
444 | void *local_msgqueue_base; /* base address of kmalloc'd space */ | ||
445 | struct xpc_msg *local_msgqueue; /* local message queue */ | ||
446 | void *remote_msgqueue_base; /* base address of kmalloc'd space */ | ||
447 | struct xpc_msg *remote_msgqueue;/* cached copy of remote partition's */ | ||
448 | /* local message queue */ | ||
449 | u64 remote_msgqueue_pa; /* phys addr of remote partition's */ | ||
450 | /* local message queue */ | ||
451 | |||
452 | atomic_t references; /* #of external references to queues */ | ||
453 | |||
454 | atomic_t n_on_msg_allocate_wq; /* #on msg allocation wait queue */ | ||
455 | wait_queue_head_t msg_allocate_wq; /* msg allocation wait queue */ | ||
456 | |||
457 | u8 delayed_IPI_flags; /* IPI flags received, but delayed */ | ||
458 | /* action until channel disconnected */ | ||
459 | |||
460 | /* queue of msg senders who want to be notified when msg received */ | ||
461 | |||
462 | atomic_t n_to_notify; /* #of msg senders to notify */ | ||
463 | struct xpc_notify *notify_queue;/* notify queue for messages sent */ | ||
464 | |||
465 | xpc_channel_func func; /* user's channel function */ | ||
466 | void *key; /* pointer to user's key */ | ||
467 | |||
468 | struct semaphore msg_to_pull_sema; /* next msg to pull serialization */ | ||
469 | struct semaphore wdisconnect_sema; /* wait for channel disconnect */ | ||
470 | |||
471 | struct xpc_openclose_args *local_openclose_args; /* args passed on */ | ||
472 | /* opening or closing of channel */ | ||
473 | |||
474 | /* various flavors of local and remote Get/Put values */ | ||
475 | |||
476 | struct xpc_gp *local_GP; /* local Get/Put values */ | ||
477 | struct xpc_gp remote_GP; /* remote Get/Put values */ | ||
478 | struct xpc_gp w_local_GP; /* working local Get/Put values */ | ||
479 | struct xpc_gp w_remote_GP; /* working remote Get/Put values */ | ||
480 | s64 next_msg_to_pull; /* Put value of next msg to pull */ | ||
481 | |||
482 | /* kthread management related fields */ | ||
483 | |||
484 | // >>> rethink having kthreads_assigned_limit and kthreads_idle_limit; perhaps | ||
485 | // >>> allow the assigned limit be unbounded and let the idle limit be dynamic | ||
486 | // >>> dependent on activity over the last interval of time | ||
487 | atomic_t kthreads_assigned; /* #of kthreads assigned to channel */ | ||
488 | u32 kthreads_assigned_limit; /* limit on #of kthreads assigned */ | ||
489 | atomic_t kthreads_idle; /* #of kthreads idle waiting for work */ | ||
490 | u32 kthreads_idle_limit; /* limit on #of kthreads idle */ | ||
491 | atomic_t kthreads_active; /* #of kthreads actively working */ | ||
492 | // >>> following field is temporary | ||
493 | u32 kthreads_created; /* total #of kthreads created */ | ||
494 | |||
495 | wait_queue_head_t idle_wq; /* idle kthread wait queue */ | ||
496 | |||
497 | } ____cacheline_aligned; | ||
498 | |||
499 | |||
500 | /* struct xpc_channel flags */ | ||
501 | |||
502 | #define XPC_C_WASCONNECTED 0x00000001 /* channel was connected */ | ||
503 | |||
504 | #define XPC_C_ROPENREPLY 0x00000002 /* remote open channel reply */ | ||
505 | #define XPC_C_OPENREPLY 0x00000004 /* local open channel reply */ | ||
506 | #define XPC_C_ROPENREQUEST 0x00000008 /* remote open channel request */ | ||
507 | #define XPC_C_OPENREQUEST 0x00000010 /* local open channel request */ | ||
508 | |||
509 | #define XPC_C_SETUP 0x00000020 /* channel's msgqueues are alloc'd */ | ||
510 | #define XPC_C_CONNECTCALLOUT 0x00000040 /* channel connected callout made */ | ||
511 | #define XPC_C_CONNECTED 0x00000080 /* local channel is connected */ | ||
512 | #define XPC_C_CONNECTING 0x00000100 /* channel is being connected */ | ||
513 | |||
514 | #define XPC_C_RCLOSEREPLY 0x00000200 /* remote close channel reply */ | ||
515 | #define XPC_C_CLOSEREPLY 0x00000400 /* local close channel reply */ | ||
516 | #define XPC_C_RCLOSEREQUEST 0x00000800 /* remote close channel request */ | ||
517 | #define XPC_C_CLOSEREQUEST 0x00001000 /* local close channel request */ | ||
518 | |||
519 | #define XPC_C_DISCONNECTED 0x00002000 /* channel is disconnected */ | ||
520 | #define XPC_C_DISCONNECTING 0x00004000 /* channel is being disconnected */ | ||
521 | #define XPC_C_DISCONNECTCALLOUT 0x00008000 /* chan disconnected callout made */ | ||
522 | #define XPC_C_WDISCONNECT 0x00010000 /* waiting for channel disconnect */ | ||
523 | |||
524 | |||
525 | |||
526 | /* | ||
527 | * Manages channels on a partition basis. There is one of these structures | ||
528 | * for each partition (a partition will never utilize the structure that | ||
529 | * represents itself). | ||
530 | */ | ||
531 | struct xpc_partition { | ||
532 | |||
533 | /* XPC HB infrastructure */ | ||
534 | |||
535 | u8 remote_rp_version; /* version# of partition's rsvd pg */ | ||
536 | struct timespec remote_rp_stamp;/* time when rsvd pg was initialized */ | ||
537 | u64 remote_rp_pa; /* phys addr of partition's rsvd pg */ | ||
538 | u64 remote_vars_pa; /* phys addr of partition's vars */ | ||
539 | u64 remote_vars_part_pa; /* phys addr of partition's vars part */ | ||
540 | u64 last_heartbeat; /* HB at last read */ | ||
541 | u64 remote_amos_page_pa; /* phys addr of partition's amos page */ | ||
542 | int remote_act_nasid; /* active part's act/deact nasid */ | ||
543 | int remote_act_phys_cpuid; /* active part's act/deact phys cpuid */ | ||
544 | u32 act_IRQ_rcvd; /* IRQs since activation */ | ||
545 | spinlock_t act_lock; /* protect updating of act_state */ | ||
546 | u8 act_state; /* from XPC HB viewpoint */ | ||
547 | u8 remote_vars_version; /* version# of partition's vars */ | ||
548 | enum xpc_retval reason; /* reason partition is deactivating */ | ||
549 | int reason_line; /* line# deactivation initiated from */ | ||
550 | int reactivate_nasid; /* nasid in partition to reactivate */ | ||
551 | |||
552 | unsigned long disengage_request_timeout; /* timeout in jiffies */ | ||
553 | struct timer_list disengage_request_timer; | ||
554 | |||
555 | |||
556 | /* XPC infrastructure referencing and teardown control */ | ||
557 | |||
558 | volatile u8 setup_state; /* infrastructure setup state */ | ||
559 | wait_queue_head_t teardown_wq; /* kthread waiting to teardown infra */ | ||
560 | atomic_t references; /* #of references to infrastructure */ | ||
561 | |||
562 | |||
563 | /* | ||
564 | * NONE OF THE PRECEDING FIELDS OF THIS STRUCTURE WILL BE CLEARED WHEN | ||
565 | * XPC SETS UP THE NECESSARY INFRASTRUCTURE TO SUPPORT CROSS PARTITION | ||
566 | * COMMUNICATION. ALL OF THE FOLLOWING FIELDS WILL BE CLEARED. (THE | ||
567 | * 'nchannels' FIELD MUST BE THE FIRST OF THE FIELDS TO BE CLEARED.) | ||
568 | */ | ||
569 | |||
570 | |||
571 | u8 nchannels; /* #of defined channels supported */ | ||
572 | atomic_t nchannels_active; /* #of channels that are not DISCONNECTED */ | ||
573 | atomic_t nchannels_engaged;/* #of channels engaged with remote part */ | ||
574 | struct xpc_channel *channels;/* array of channel structures */ | ||
575 | |||
576 | void *local_GPs_base; /* base address of kmalloc'd space */ | ||
577 | struct xpc_gp *local_GPs; /* local Get/Put values */ | ||
578 | void *remote_GPs_base; /* base address of kmalloc'd space */ | ||
579 | struct xpc_gp *remote_GPs;/* copy of remote partition's local Get/Put */ | ||
580 | /* values */ | ||
581 | u64 remote_GPs_pa; /* phys address of remote partition's local */ | ||
582 | /* Get/Put values */ | ||
583 | |||
584 | |||
585 | /* fields used to pass args when opening or closing a channel */ | ||
586 | |||
587 | void *local_openclose_args_base; /* base address of kmalloc'd space */ | ||
588 | struct xpc_openclose_args *local_openclose_args; /* local's args */ | ||
589 | void *remote_openclose_args_base; /* base address of kmalloc'd space */ | ||
590 | struct xpc_openclose_args *remote_openclose_args; /* copy of remote's */ | ||
591 | /* args */ | ||
592 | u64 remote_openclose_args_pa; /* phys addr of remote's args */ | ||
593 | |||
594 | |||
595 | /* IPI sending, receiving and handling related fields */ | ||
596 | |||
597 | int remote_IPI_nasid; /* nasid of where to send IPIs */ | ||
598 | int remote_IPI_phys_cpuid; /* phys CPU ID of where to send IPIs */ | ||
599 | AMO_t *remote_IPI_amo_va; /* address of remote IPI AMO_t structure */ | ||
600 | |||
601 | AMO_t *local_IPI_amo_va; /* address of IPI AMO_t structure */ | ||
602 | u64 local_IPI_amo; /* IPI amo flags yet to be handled */ | ||
603 | char IPI_owner[8]; /* IPI owner's name */ | ||
604 | struct timer_list dropped_IPI_timer; /* dropped IPI timer */ | ||
605 | |||
606 | spinlock_t IPI_lock; /* IPI handler lock */ | ||
607 | |||
608 | |||
609 | /* channel manager related fields */ | ||
610 | |||
611 | atomic_t channel_mgr_requests; /* #of requests to activate chan mgr */ | ||
612 | wait_queue_head_t channel_mgr_wq; /* channel mgr's wait queue */ | ||
613 | |||
614 | } ____cacheline_aligned; | ||
615 | |||
616 | |||
617 | /* struct xpc_partition act_state values (for XPC HB) */ | ||
618 | |||
619 | #define XPC_P_INACTIVE 0x00 /* partition is not active */ | ||
620 | #define XPC_P_ACTIVATION_REQ 0x01 /* created thread to activate */ | ||
621 | #define XPC_P_ACTIVATING 0x02 /* activation thread started */ | ||
622 | #define XPC_P_ACTIVE 0x03 /* xpc_partition_up() was called */ | ||
623 | #define XPC_P_DEACTIVATING 0x04 /* partition deactivation initiated */ | ||
624 | |||
625 | |||
626 | #define XPC_DEACTIVATE_PARTITION(_p, _reason) \ | ||
627 | xpc_deactivate_partition(__LINE__, (_p), (_reason)) | ||
628 | |||
629 | |||
630 | /* struct xpc_partition setup_state values */ | ||
631 | |||
632 | #define XPC_P_UNSET 0x00 /* infrastructure was never setup */ | ||
633 | #define XPC_P_SETUP 0x01 /* infrastructure is setup */ | ||
634 | #define XPC_P_WTEARDOWN 0x02 /* waiting to teardown infrastructure */ | ||
635 | #define XPC_P_TORNDOWN 0x03 /* infrastructure is torndown */ | ||
636 | |||
637 | |||
638 | |||
639 | /* | ||
640 | * struct xpc_partition IPI_timer #of seconds to wait before checking for | ||
641 | * dropped IPIs. These occur whenever an IPI amo write doesn't complete until | ||
642 | * after the IPI was received. | ||
643 | */ | ||
644 | #define XPC_P_DROPPED_IPI_WAIT (0.25 * HZ) | ||
645 | |||
646 | |||
647 | /* number of seconds to wait for other partitions to disengage */ | ||
648 | #define XPC_DISENGAGE_REQUEST_DEFAULT_TIMELIMIT 90 | ||
649 | |||
650 | /* interval in seconds to print 'waiting disengagement' messages */ | ||
651 | #define XPC_DISENGAGE_PRINTMSG_INTERVAL 10 | ||
652 | |||
653 | |||
654 | #define XPC_PARTID(_p) ((partid_t) ((_p) - &xpc_partitions[0])) | ||
655 | |||
656 | |||
657 | |||
658 | /* found in xp_main.c */ | ||
659 | extern struct xpc_registration xpc_registrations[]; | ||
660 | |||
661 | |||
662 | /* found in xpc_main.c */ | ||
663 | extern struct device *xpc_part; | ||
664 | extern struct device *xpc_chan; | ||
665 | extern int xpc_disengage_request_timelimit; | ||
666 | extern int xpc_disengage_request_timedout; | ||
667 | extern irqreturn_t xpc_notify_IRQ_handler(int, void *, struct pt_regs *); | ||
668 | extern void xpc_dropped_IPI_check(struct xpc_partition *); | ||
669 | extern void xpc_activate_partition(struct xpc_partition *); | ||
670 | extern void xpc_activate_kthreads(struct xpc_channel *, int); | ||
671 | extern void xpc_create_kthreads(struct xpc_channel *, int); | ||
672 | extern void xpc_disconnect_wait(int); | ||
673 | |||
674 | |||
675 | /* found in xpc_partition.c */ | ||
676 | extern int xpc_exiting; | ||
677 | extern struct xpc_vars *xpc_vars; | ||
678 | extern struct xpc_rsvd_page *xpc_rsvd_page; | ||
679 | extern struct xpc_vars_part *xpc_vars_part; | ||
680 | extern struct xpc_partition xpc_partitions[XP_MAX_PARTITIONS + 1]; | ||
681 | extern char xpc_remote_copy_buffer[]; | ||
682 | extern struct xpc_rsvd_page *xpc_rsvd_page_init(void); | ||
683 | extern void xpc_allow_IPI_ops(void); | ||
684 | extern void xpc_restrict_IPI_ops(void); | ||
685 | extern int xpc_identify_act_IRQ_sender(void); | ||
686 | extern int xpc_partition_disengaged(struct xpc_partition *); | ||
687 | extern enum xpc_retval xpc_mark_partition_active(struct xpc_partition *); | ||
688 | extern void xpc_mark_partition_inactive(struct xpc_partition *); | ||
689 | extern void xpc_discovery(void); | ||
690 | extern void xpc_check_remote_hb(void); | ||
691 | extern void xpc_deactivate_partition(const int, struct xpc_partition *, | ||
692 | enum xpc_retval); | ||
693 | extern enum xpc_retval xpc_initiate_partid_to_nasids(partid_t, void *); | ||
694 | |||
695 | |||
696 | /* found in xpc_channel.c */ | ||
697 | extern void xpc_initiate_connect(int); | ||
698 | extern void xpc_initiate_disconnect(int); | ||
699 | extern enum xpc_retval xpc_initiate_allocate(partid_t, int, u32, void **); | ||
700 | extern enum xpc_retval xpc_initiate_send(partid_t, int, void *); | ||
701 | extern enum xpc_retval xpc_initiate_send_notify(partid_t, int, void *, | ||
702 | xpc_notify_func, void *); | ||
703 | extern void xpc_initiate_received(partid_t, int, void *); | ||
704 | extern enum xpc_retval xpc_setup_infrastructure(struct xpc_partition *); | ||
705 | extern enum xpc_retval xpc_pull_remote_vars_part(struct xpc_partition *); | ||
706 | extern void xpc_process_channel_activity(struct xpc_partition *); | ||
707 | extern void xpc_connected_callout(struct xpc_channel *); | ||
708 | extern void xpc_deliver_msg(struct xpc_channel *); | ||
709 | extern void xpc_disconnect_channel(const int, struct xpc_channel *, | ||
710 | enum xpc_retval, unsigned long *); | ||
711 | extern void xpc_disconnect_callout(struct xpc_channel *, enum xpc_retval); | ||
712 | extern void xpc_partition_going_down(struct xpc_partition *, enum xpc_retval); | ||
713 | extern void xpc_teardown_infrastructure(struct xpc_partition *); | ||
714 | |||
715 | |||
716 | |||
717 | static inline void | ||
718 | xpc_wakeup_channel_mgr(struct xpc_partition *part) | ||
719 | { | ||
720 | if (atomic_inc_return(&part->channel_mgr_requests) == 1) { | ||
721 | wake_up(&part->channel_mgr_wq); | ||
722 | } | ||
723 | } | ||
724 | |||
725 | |||
726 | |||
727 | /* | ||
728 | * These next two inlines are used to keep us from tearing down a channel's | ||
729 | * msg queues while a thread may be referencing them. | ||
730 | */ | ||
731 | static inline void | ||
732 | xpc_msgqueue_ref(struct xpc_channel *ch) | ||
733 | { | ||
734 | atomic_inc(&ch->references); | ||
735 | } | ||
736 | |||
737 | static inline void | ||
738 | xpc_msgqueue_deref(struct xpc_channel *ch) | ||
739 | { | ||
740 | s32 refs = atomic_dec_return(&ch->references); | ||
741 | |||
742 | DBUG_ON(refs < 0); | ||
743 | if (refs == 0) { | ||
744 | xpc_wakeup_channel_mgr(&xpc_partitions[ch->partid]); | ||
745 | } | ||
746 | } | ||
747 | |||
748 | |||
749 | |||
750 | #define XPC_DISCONNECT_CHANNEL(_ch, _reason, _irqflgs) \ | ||
751 | xpc_disconnect_channel(__LINE__, _ch, _reason, _irqflgs) | ||
752 | |||
753 | |||
754 | /* | ||
755 | * These two inlines are used to keep us from tearing down a partition's | ||
756 | * setup infrastructure while a thread may be referencing it. | ||
757 | */ | ||
758 | static inline void | ||
759 | xpc_part_deref(struct xpc_partition *part) | ||
760 | { | ||
761 | s32 refs = atomic_dec_return(&part->references); | ||
762 | |||
763 | |||
764 | DBUG_ON(refs < 0); | ||
765 | if (refs == 0 && part->setup_state == XPC_P_WTEARDOWN) { | ||
766 | wake_up(&part->teardown_wq); | ||
767 | } | ||
768 | } | ||
769 | |||
770 | static inline int | ||
771 | xpc_part_ref(struct xpc_partition *part) | ||
772 | { | ||
773 | int setup; | ||
774 | |||
775 | |||
776 | atomic_inc(&part->references); | ||
777 | setup = (part->setup_state == XPC_P_SETUP); | ||
778 | if (!setup) { | ||
779 | xpc_part_deref(part); | ||
780 | } | ||
781 | return setup; | ||
782 | } | ||
783 | |||
784 | |||
785 | |||
786 | /* | ||
787 | * The following macro is to be used for the setting of the reason and | ||
788 | * reason_line fields in both the struct xpc_channel and struct xpc_partition | ||
789 | * structures. | ||
790 | */ | ||
791 | #define XPC_SET_REASON(_p, _reason, _line) \ | ||
792 | { \ | ||
793 | (_p)->reason = _reason; \ | ||
794 | (_p)->reason_line = _line; \ | ||
795 | } | ||
796 | |||
797 | |||
798 | |||
799 | /* | ||
800 | * This next set of inlines are used to keep track of when a partition is | ||
801 | * potentially engaged in accessing memory belonging to another partition. | ||
802 | */ | ||
803 | |||
804 | static inline void | ||
805 | xpc_mark_partition_engaged(struct xpc_partition *part) | ||
806 | { | ||
807 | unsigned long irq_flags; | ||
808 | AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa + | ||
809 | (XPC_ENGAGED_PARTITIONS_AMO * sizeof(AMO_t))); | ||
810 | |||
811 | |||
812 | local_irq_save(irq_flags); | ||
813 | |||
814 | /* set bit corresponding to our partid in remote partition's AMO */ | ||
815 | FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR, | ||
816 | (1UL << sn_partition_id)); | ||
817 | /* | ||
818 | * We must always use the nofault function regardless of whether we | ||
819 | * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we | ||
820 | * didn't, we'd never know that the other partition is down and would | ||
821 | * keep sending IPIs and AMOs to it until the heartbeat times out. | ||
822 | */ | ||
823 | (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo-> | ||
824 | variable), xp_nofault_PIOR_target)); | ||
825 | |||
826 | local_irq_restore(irq_flags); | ||
827 | } | ||
828 | |||
829 | static inline void | ||
830 | xpc_mark_partition_disengaged(struct xpc_partition *part) | ||
831 | { | ||
832 | unsigned long irq_flags; | ||
833 | AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa + | ||
834 | (XPC_ENGAGED_PARTITIONS_AMO * sizeof(AMO_t))); | ||
835 | |||
836 | |||
837 | local_irq_save(irq_flags); | ||
838 | |||
839 | /* clear bit corresponding to our partid in remote partition's AMO */ | ||
840 | FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND, | ||
841 | ~(1UL << sn_partition_id)); | ||
842 | /* | ||
843 | * We must always use the nofault function regardless of whether we | ||
844 | * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we | ||
845 | * didn't, we'd never know that the other partition is down and would | ||
846 | * keep sending IPIs and AMOs to it until the heartbeat times out. | ||
847 | */ | ||
848 | (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo-> | ||
849 | variable), xp_nofault_PIOR_target)); | ||
850 | |||
851 | local_irq_restore(irq_flags); | ||
852 | } | ||
853 | |||
854 | static inline void | ||
855 | xpc_request_partition_disengage(struct xpc_partition *part) | ||
856 | { | ||
857 | unsigned long irq_flags; | ||
858 | AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa + | ||
859 | (XPC_DISENGAGE_REQUEST_AMO * sizeof(AMO_t))); | ||
860 | |||
861 | |||
862 | local_irq_save(irq_flags); | ||
863 | |||
864 | /* set bit corresponding to our partid in remote partition's AMO */ | ||
865 | FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR, | ||
866 | (1UL << sn_partition_id)); | ||
867 | /* | ||
868 | * We must always use the nofault function regardless of whether we | ||
869 | * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we | ||
870 | * didn't, we'd never know that the other partition is down and would | ||
871 | * keep sending IPIs and AMOs to it until the heartbeat times out. | ||
872 | */ | ||
873 | (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo-> | ||
874 | variable), xp_nofault_PIOR_target)); | ||
875 | |||
876 | local_irq_restore(irq_flags); | ||
877 | } | ||
878 | |||
879 | static inline void | ||
880 | xpc_cancel_partition_disengage_request(struct xpc_partition *part) | ||
881 | { | ||
882 | unsigned long irq_flags; | ||
883 | AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa + | ||
884 | (XPC_DISENGAGE_REQUEST_AMO * sizeof(AMO_t))); | ||
885 | |||
886 | |||
887 | local_irq_save(irq_flags); | ||
888 | |||
889 | /* clear bit corresponding to our partid in remote partition's AMO */ | ||
890 | FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND, | ||
891 | ~(1UL << sn_partition_id)); | ||
892 | /* | ||
893 | * We must always use the nofault function regardless of whether we | ||
894 | * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we | ||
895 | * didn't, we'd never know that the other partition is down and would | ||
896 | * keep sending IPIs and AMOs to it until the heartbeat times out. | ||
897 | */ | ||
898 | (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo-> | ||
899 | variable), xp_nofault_PIOR_target)); | ||
900 | |||
901 | local_irq_restore(irq_flags); | ||
902 | } | ||
903 | |||
904 | static inline u64 | ||
905 | xpc_partition_engaged(u64 partid_mask) | ||
906 | { | ||
907 | AMO_t *amo = xpc_vars->amos_page + XPC_ENGAGED_PARTITIONS_AMO; | ||
908 | |||
909 | |||
910 | /* return our partition's AMO variable ANDed with partid_mask */ | ||
911 | return (FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_LOAD) & | ||
912 | partid_mask); | ||
913 | } | ||
914 | |||
915 | static inline u64 | ||
916 | xpc_partition_disengage_requested(u64 partid_mask) | ||
917 | { | ||
918 | AMO_t *amo = xpc_vars->amos_page + XPC_DISENGAGE_REQUEST_AMO; | ||
919 | |||
920 | |||
921 | /* return our partition's AMO variable ANDed with partid_mask */ | ||
922 | return (FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_LOAD) & | ||
923 | partid_mask); | ||
924 | } | ||
925 | |||
926 | static inline void | ||
927 | xpc_clear_partition_engaged(u64 partid_mask) | ||
928 | { | ||
929 | AMO_t *amo = xpc_vars->amos_page + XPC_ENGAGED_PARTITIONS_AMO; | ||
930 | |||
931 | |||
932 | /* clear bit(s) based on partid_mask in our partition's AMO */ | ||
933 | FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND, | ||
934 | ~partid_mask); | ||
935 | } | ||
936 | |||
937 | static inline void | ||
938 | xpc_clear_partition_disengage_request(u64 partid_mask) | ||
939 | { | ||
940 | AMO_t *amo = xpc_vars->amos_page + XPC_DISENGAGE_REQUEST_AMO; | ||
941 | |||
942 | |||
943 | /* clear bit(s) based on partid_mask in our partition's AMO */ | ||
944 | FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND, | ||
945 | ~partid_mask); | ||
946 | } | ||
947 | |||
948 | |||
949 | |||
950 | /* | ||
951 | * The following set of macros and inlines are used for the sending and | ||
952 | * receiving of IPIs (also known as IRQs). There are two flavors of IPIs, | ||
953 | * one that is associated with partition activity (SGI_XPC_ACTIVATE) and | ||
954 | * the other that is associated with channel activity (SGI_XPC_NOTIFY). | ||
955 | */ | ||
956 | |||
957 | static inline u64 | ||
958 | xpc_IPI_receive(AMO_t *amo) | ||
959 | { | ||
960 | return FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_CLEAR); | ||
961 | } | ||
962 | |||
963 | |||
964 | static inline enum xpc_retval | ||
965 | xpc_IPI_send(AMO_t *amo, u64 flag, int nasid, int phys_cpuid, int vector) | ||
966 | { | ||
967 | int ret = 0; | ||
968 | unsigned long irq_flags; | ||
969 | |||
970 | |||
971 | local_irq_save(irq_flags); | ||
972 | |||
973 | FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR, flag); | ||
974 | sn_send_IPI_phys(nasid, phys_cpuid, vector, 0); | ||
975 | |||
976 | /* | ||
977 | * We must always use the nofault function regardless of whether we | ||
978 | * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we | ||
979 | * didn't, we'd never know that the other partition is down and would | ||
980 | * keep sending IPIs and AMOs to it until the heartbeat times out. | ||
981 | */ | ||
982 | ret = xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->variable), | ||
983 | xp_nofault_PIOR_target)); | ||
984 | |||
985 | local_irq_restore(irq_flags); | ||
986 | |||
987 | return ((ret == 0) ? xpcSuccess : xpcPioReadError); | ||
988 | } | ||
989 | |||
990 | |||
991 | /* | ||
992 | * IPIs associated with SGI_XPC_ACTIVATE IRQ. | ||
993 | */ | ||
994 | |||
995 | /* | ||
996 | * Flag the appropriate AMO variable and send an IPI to the specified node. | ||
997 | */ | ||
998 | static inline void | ||
999 | xpc_activate_IRQ_send(u64 amos_page_pa, int from_nasid, int to_nasid, | ||
1000 | int to_phys_cpuid) | ||
1001 | { | ||
1002 | int w_index = XPC_NASID_W_INDEX(from_nasid); | ||
1003 | int b_index = XPC_NASID_B_INDEX(from_nasid); | ||
1004 | AMO_t *amos = (AMO_t *) __va(amos_page_pa + | ||
1005 | (XPC_ACTIVATE_IRQ_AMOS * sizeof(AMO_t))); | ||
1006 | |||
1007 | |||
1008 | (void) xpc_IPI_send(&amos[w_index], (1UL << b_index), to_nasid, | ||
1009 | to_phys_cpuid, SGI_XPC_ACTIVATE); | ||
1010 | } | ||
1011 | |||
1012 | static inline void | ||
1013 | xpc_IPI_send_activate(struct xpc_vars *vars) | ||
1014 | { | ||
1015 | xpc_activate_IRQ_send(vars->amos_page_pa, cnodeid_to_nasid(0), | ||
1016 | vars->act_nasid, vars->act_phys_cpuid); | ||
1017 | } | ||
1018 | |||
1019 | static inline void | ||
1020 | xpc_IPI_send_activated(struct xpc_partition *part) | ||
1021 | { | ||
1022 | xpc_activate_IRQ_send(part->remote_amos_page_pa, cnodeid_to_nasid(0), | ||
1023 | part->remote_act_nasid, part->remote_act_phys_cpuid); | ||
1024 | } | ||
1025 | |||
1026 | static inline void | ||
1027 | xpc_IPI_send_reactivate(struct xpc_partition *part) | ||
1028 | { | ||
1029 | xpc_activate_IRQ_send(xpc_vars->amos_page_pa, part->reactivate_nasid, | ||
1030 | xpc_vars->act_nasid, xpc_vars->act_phys_cpuid); | ||
1031 | } | ||
1032 | |||
1033 | static inline void | ||
1034 | xpc_IPI_send_disengage(struct xpc_partition *part) | ||
1035 | { | ||
1036 | xpc_activate_IRQ_send(part->remote_amos_page_pa, cnodeid_to_nasid(0), | ||
1037 | part->remote_act_nasid, part->remote_act_phys_cpuid); | ||
1038 | } | ||
1039 | |||
1040 | |||
1041 | /* | ||
1042 | * IPIs associated with SGI_XPC_NOTIFY IRQ. | ||
1043 | */ | ||
1044 | |||
1045 | /* | ||
1046 | * Send an IPI to the remote partition that is associated with the | ||
1047 | * specified channel. | ||
1048 | */ | ||
1049 | #define XPC_NOTIFY_IRQ_SEND(_ch, _ipi_f, _irq_f) \ | ||
1050 | xpc_notify_IRQ_send(_ch, _ipi_f, #_ipi_f, _irq_f) | ||
1051 | |||
1052 | static inline void | ||
1053 | xpc_notify_IRQ_send(struct xpc_channel *ch, u8 ipi_flag, char *ipi_flag_string, | ||
1054 | unsigned long *irq_flags) | ||
1055 | { | ||
1056 | struct xpc_partition *part = &xpc_partitions[ch->partid]; | ||
1057 | enum xpc_retval ret; | ||
1058 | |||
1059 | |||
1060 | if (likely(part->act_state != XPC_P_DEACTIVATING)) { | ||
1061 | ret = xpc_IPI_send(part->remote_IPI_amo_va, | ||
1062 | (u64) ipi_flag << (ch->number * 8), | ||
1063 | part->remote_IPI_nasid, | ||
1064 | part->remote_IPI_phys_cpuid, | ||
1065 | SGI_XPC_NOTIFY); | ||
1066 | dev_dbg(xpc_chan, "%s sent to partid=%d, channel=%d, ret=%d\n", | ||
1067 | ipi_flag_string, ch->partid, ch->number, ret); | ||
1068 | if (unlikely(ret != xpcSuccess)) { | ||
1069 | if (irq_flags != NULL) { | ||
1070 | spin_unlock_irqrestore(&ch->lock, *irq_flags); | ||
1071 | } | ||
1072 | XPC_DEACTIVATE_PARTITION(part, ret); | ||
1073 | if (irq_flags != NULL) { | ||
1074 | spin_lock_irqsave(&ch->lock, *irq_flags); | ||
1075 | } | ||
1076 | } | ||
1077 | } | ||
1078 | } | ||
1079 | |||
1080 | |||
1081 | /* | ||
1082 | * Make it look like the remote partition, which is associated with the | ||
1083 | * specified channel, sent us an IPI. This faked IPI will be handled | ||
1084 | * by xpc_dropped_IPI_check(). | ||
1085 | */ | ||
1086 | #define XPC_NOTIFY_IRQ_SEND_LOCAL(_ch, _ipi_f) \ | ||
1087 | xpc_notify_IRQ_send_local(_ch, _ipi_f, #_ipi_f) | ||
1088 | |||
1089 | static inline void | ||
1090 | xpc_notify_IRQ_send_local(struct xpc_channel *ch, u8 ipi_flag, | ||
1091 | char *ipi_flag_string) | ||
1092 | { | ||
1093 | struct xpc_partition *part = &xpc_partitions[ch->partid]; | ||
1094 | |||
1095 | |||
1096 | FETCHOP_STORE_OP(TO_AMO((u64) &part->local_IPI_amo_va->variable), | ||
1097 | FETCHOP_OR, ((u64) ipi_flag << (ch->number * 8))); | ||
1098 | dev_dbg(xpc_chan, "%s sent local from partid=%d, channel=%d\n", | ||
1099 | ipi_flag_string, ch->partid, ch->number); | ||
1100 | } | ||
1101 | |||
1102 | |||
1103 | /* | ||
1104 | * The sending and receiving of IPIs includes the setting of an AMO variable | ||
1105 | * to indicate the reason the IPI was sent. The 64-bit variable is divided | ||
1106 | * up into eight bytes, ordered from right to left. Byte zero pertains to | ||
1107 | * channel 0, byte one to channel 1, and so on. Each byte is described by | ||
1108 | * the following IPI flags. | ||
1109 | */ | ||
1110 | |||
1111 | #define XPC_IPI_CLOSEREQUEST 0x01 | ||
1112 | #define XPC_IPI_CLOSEREPLY 0x02 | ||
1113 | #define XPC_IPI_OPENREQUEST 0x04 | ||
1114 | #define XPC_IPI_OPENREPLY 0x08 | ||
1115 | #define XPC_IPI_MSGREQUEST 0x10 | ||
1116 | |||
1117 | |||
1118 | /* given an AMO variable and a channel#, get its associated IPI flags */ | ||
1119 | #define XPC_GET_IPI_FLAGS(_amo, _c) ((u8) (((_amo) >> ((_c) * 8)) & 0xff)) | ||
1120 | #define XPC_SET_IPI_FLAGS(_amo, _c, _f) (_amo) |= ((u64) (_f) << ((_c) * 8)) | ||
1121 | |||
1122 | #define XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(_amo) ((_amo) & 0x0f0f0f0f0f0f0f0f) | ||
1123 | #define XPC_ANY_MSG_IPI_FLAGS_SET(_amo) ((_amo) & 0x1010101010101010) | ||
1124 | |||
1125 | |||
1126 | static inline void | ||
1127 | xpc_IPI_send_closerequest(struct xpc_channel *ch, unsigned long *irq_flags) | ||
1128 | { | ||
1129 | struct xpc_openclose_args *args = ch->local_openclose_args; | ||
1130 | |||
1131 | |||
1132 | args->reason = ch->reason; | ||
1133 | |||
1134 | XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_CLOSEREQUEST, irq_flags); | ||
1135 | } | ||
1136 | |||
1137 | static inline void | ||
1138 | xpc_IPI_send_closereply(struct xpc_channel *ch, unsigned long *irq_flags) | ||
1139 | { | ||
1140 | XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_CLOSEREPLY, irq_flags); | ||
1141 | } | ||
1142 | |||
1143 | static inline void | ||
1144 | xpc_IPI_send_openrequest(struct xpc_channel *ch, unsigned long *irq_flags) | ||
1145 | { | ||
1146 | struct xpc_openclose_args *args = ch->local_openclose_args; | ||
1147 | |||
1148 | |||
1149 | args->msg_size = ch->msg_size; | ||
1150 | args->local_nentries = ch->local_nentries; | ||
1151 | |||
1152 | XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_OPENREQUEST, irq_flags); | ||
1153 | } | ||
1154 | |||
1155 | static inline void | ||
1156 | xpc_IPI_send_openreply(struct xpc_channel *ch, unsigned long *irq_flags) | ||
1157 | { | ||
1158 | struct xpc_openclose_args *args = ch->local_openclose_args; | ||
1159 | |||
1160 | |||
1161 | args->remote_nentries = ch->remote_nentries; | ||
1162 | args->local_nentries = ch->local_nentries; | ||
1163 | args->local_msgqueue_pa = __pa(ch->local_msgqueue); | ||
1164 | |||
1165 | XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_OPENREPLY, irq_flags); | ||
1166 | } | ||
1167 | |||
1168 | static inline void | ||
1169 | xpc_IPI_send_msgrequest(struct xpc_channel *ch) | ||
1170 | { | ||
1171 | XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_MSGREQUEST, NULL); | ||
1172 | } | ||
1173 | |||
1174 | static inline void | ||
1175 | xpc_IPI_send_local_msgrequest(struct xpc_channel *ch) | ||
1176 | { | ||
1177 | XPC_NOTIFY_IRQ_SEND_LOCAL(ch, XPC_IPI_MSGREQUEST); | ||
1178 | } | ||
1179 | |||
1180 | |||
1181 | /* | ||
1182 | * Memory for XPC's AMO variables is allocated by the MSPEC driver. These | ||
1183 | * pages are located in the lowest granule. The lowest granule uses 4k pages | ||
1184 | * for cached references and an alternate TLB handler to never provide a | ||
1185 | * cacheable mapping for the entire region. This will prevent speculative | ||
1186 | * reading of cached copies of our lines from being issued which will cause | ||
1187 | * a PI FSB Protocol error to be generated by the SHUB. For XPC, we need 64 | ||
1188 | * AMO variables (based on XP_MAX_PARTITIONS) for message notification and an | ||
1189 | * additional 128 AMO variables (based on XP_NASID_MASK_WORDS) for partition | ||
1190 | * activation and 2 AMO variables for partition deactivation. | ||
1191 | */ | ||
1192 | static inline AMO_t * | ||
1193 | xpc_IPI_init(int index) | ||
1194 | { | ||
1195 | AMO_t *amo = xpc_vars->amos_page + index; | ||
1196 | |||
1197 | |||
1198 | (void) xpc_IPI_receive(amo); /* clear AMO variable */ | ||
1199 | return amo; | ||
1200 | } | ||
1201 | |||
1202 | |||
1203 | |||
1204 | static inline enum xpc_retval | ||
1205 | xpc_map_bte_errors(bte_result_t error) | ||
1206 | { | ||
1207 | switch (error) { | ||
1208 | case BTE_SUCCESS: return xpcSuccess; | ||
1209 | case BTEFAIL_DIR: return xpcBteDirectoryError; | ||
1210 | case BTEFAIL_POISON: return xpcBtePoisonError; | ||
1211 | case BTEFAIL_WERR: return xpcBteWriteError; | ||
1212 | case BTEFAIL_ACCESS: return xpcBteAccessError; | ||
1213 | case BTEFAIL_PWERR: return xpcBtePWriteError; | ||
1214 | case BTEFAIL_PRERR: return xpcBtePReadError; | ||
1215 | case BTEFAIL_TOUT: return xpcBteTimeOutError; | ||
1216 | case BTEFAIL_XTERR: return xpcBteXtalkError; | ||
1217 | case BTEFAIL_NOTAVAIL: return xpcBteNotAvailable; | ||
1218 | default: return xpcBteUnmappedError; | ||
1219 | } | ||
1220 | } | ||
1221 | |||
1222 | |||
1223 | |||
1224 | static inline void * | ||
1225 | xpc_kmalloc_cacheline_aligned(size_t size, gfp_t flags, void **base) | ||
1226 | { | ||
1227 | /* see if kmalloc will give us cachline aligned memory by default */ | ||
1228 | *base = kmalloc(size, flags); | ||
1229 | if (*base == NULL) { | ||
1230 | return NULL; | ||
1231 | } | ||
1232 | if ((u64) *base == L1_CACHE_ALIGN((u64) *base)) { | ||
1233 | return *base; | ||
1234 | } | ||
1235 | kfree(*base); | ||
1236 | |||
1237 | /* nope, we'll have to do it ourselves */ | ||
1238 | *base = kmalloc(size + L1_CACHE_BYTES, flags); | ||
1239 | if (*base == NULL) { | ||
1240 | return NULL; | ||
1241 | } | ||
1242 | return (void *) L1_CACHE_ALIGN((u64) *base); | ||
1243 | } | ||
1244 | |||
1245 | |||
1246 | /* | ||
1247 | * Check to see if there is any channel activity to/from the specified | ||
1248 | * partition. | ||
1249 | */ | ||
1250 | static inline void | ||
1251 | xpc_check_for_channel_activity(struct xpc_partition *part) | ||
1252 | { | ||
1253 | u64 IPI_amo; | ||
1254 | unsigned long irq_flags; | ||
1255 | |||
1256 | |||
1257 | IPI_amo = xpc_IPI_receive(part->local_IPI_amo_va); | ||
1258 | if (IPI_amo == 0) { | ||
1259 | return; | ||
1260 | } | ||
1261 | |||
1262 | spin_lock_irqsave(&part->IPI_lock, irq_flags); | ||
1263 | part->local_IPI_amo |= IPI_amo; | ||
1264 | spin_unlock_irqrestore(&part->IPI_lock, irq_flags); | ||
1265 | |||
1266 | dev_dbg(xpc_chan, "received IPI from partid=%d, IPI_amo=0x%lx\n", | ||
1267 | XPC_PARTID(part), IPI_amo); | ||
1268 | |||
1269 | xpc_wakeup_channel_mgr(part); | ||
1270 | } | ||
1271 | |||
1272 | |||
1273 | #endif /* _ASM_IA64_SN_XPC_H */ | ||
1274 | |||
diff --git a/include/asm-ia64/thread_info.h b/include/asm-ia64/thread_info.h index 653bb7f9a753..1d6518fe1f02 100644 --- a/include/asm-ia64/thread_info.h +++ b/include/asm-ia64/thread_info.h | |||
@@ -93,6 +93,7 @@ struct thread_info { | |||
93 | #define TIF_POLLING_NRFLAG 16 /* true if poll_idle() is polling TIF_NEED_RESCHED */ | 93 | #define TIF_POLLING_NRFLAG 16 /* true if poll_idle() is polling TIF_NEED_RESCHED */ |
94 | #define TIF_MEMDIE 17 | 94 | #define TIF_MEMDIE 17 |
95 | #define TIF_MCA_INIT 18 /* this task is processing MCA or INIT */ | 95 | #define TIF_MCA_INIT 18 /* this task is processing MCA or INIT */ |
96 | #define TIF_DB_DISABLED 19 /* debug trap disabled for fsyscall */ | ||
96 | 97 | ||
97 | #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) | 98 | #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) |
98 | #define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT) | 99 | #define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT) |
@@ -100,9 +101,10 @@ struct thread_info { | |||
100 | #define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME) | 101 | #define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME) |
101 | #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) | 102 | #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) |
102 | #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) | 103 | #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) |
103 | #define _TIF_SIGDELAYED (1 << TIF_SIGDELAYED) | 104 | #define _TIF_SIGDELAYED (1 << TIF_SIGDELAYED) |
104 | #define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) | 105 | #define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) |
105 | #define _TIF_MCA_INIT (1 << TIF_MCA_INIT) | 106 | #define _TIF_MCA_INIT (1 << TIF_MCA_INIT) |
107 | #define _TIF_DB_DISABLED (1 << TIF_DB_DISABLED) | ||
106 | 108 | ||
107 | /* "work to do on user-return" bits */ | 109 | /* "work to do on user-return" bits */ |
108 | #define TIF_ALLWORK_MASK (_TIF_NOTIFY_RESUME|_TIF_SIGPENDING|_TIF_NEED_RESCHED|_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SIGDELAYED) | 110 | #define TIF_ALLWORK_MASK (_TIF_NOTIFY_RESUME|_TIF_SIGPENDING|_TIF_NEED_RESCHED|_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SIGDELAYED) |