1 ------------------------------------------------------------------------------
3 -- GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS --
5 -- S Y S T E M . I N T E R R U P T S --
9 -- Copyright (C) 1998-2007, Free Software Foundation, Inc. --
11 -- GNARL is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 2, or (at your option) any later ver- --
14 -- sion. GNARL is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNARL; see file COPYING. If not, write --
19 -- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
20 -- Boston, MA 02110-1301, USA. --
22 -- As a special exception, if other files instantiate generics from this --
23 -- unit, or you link this unit with other files to produce an executable, --
24 -- this unit does not by itself cause the resulting executable to be --
25 -- covered by the GNU General Public License. This exception does not --
26 -- however invalidate any other reasons why the executable file might be --
27 -- covered by the GNU Public License. --
29 -- GNARL was developed by the GNARL team at Florida State University. --
30 -- Extensive contributions were provided by Ada Core Technologies, Inc. --
32 ------------------------------------------------------------------------------
34 -- This is the IRIX & NT version of this package
36 with Ada.Task_Identification;
40 -- used for Raise_Exception
42 with System.Storage_Elements;
43 -- used for To_Address
46 with System.Task_Primitives.Operations;
53 with System.Tasking.Utilities;
54 -- used for Make_Independent
56 with System.Tasking.Rendezvous;
57 -- used for Call_Simple
59 with System.Tasking.Initialization;
60 -- used for Defer_Abort
63 with System.Interrupt_Management;
65 with System.Parameters;
66 -- used for Single_Lock
71 with Ada.Unchecked_Conversion;
73 package body System.Interrupts is
78 use System.OS_Interface;
81 package STPO renames System.Task_Primitives.Operations;
82 package IMNG renames System.Interrupt_Management;
84 subtype int is Interfaces.C.int;
86 function To_System is new Ada.Unchecked_Conversion
87 (Ada.Task_Identification.Task_Id, Task_Id);
89 type Handler_Kind is (Unknown, Task_Entry, Protected_Procedure);
91 type Handler_Desc is record
92 Kind : Handler_Kind := Unknown;
95 H : Parameterless_Handler;
96 Static : Boolean := False;
99 task type Server_Task (Interrupt : Interrupt_ID) is
100 pragma Interrupt_Priority (System.Interrupt_Priority'Last);
103 type Server_Task_Access is access Server_Task;
105 Handlers : array (Interrupt_ID) of Task_Id;
106 Descriptors : array (Interrupt_ID) of Handler_Desc;
107 Interrupt_Count : array (Interrupt_ID) of Integer := (others => 0);
109 pragma Volatile_Components (Interrupt_Count);
111 procedure Attach_Handler
112 (New_Handler : Parameterless_Handler;
113 Interrupt : Interrupt_ID;
115 Restoration : Boolean);
116 -- This internal procedure is needed to finalize protected objects
117 -- that contain interrupt handlers.
119 procedure Signal_Handler (Sig : Interrupt_ID);
120 -- This procedure is used to handle all the signals
122 -- Type and Head, Tail of the list containing Registered Interrupt
123 -- Handlers. These definitions are used to register the handlers
124 -- specified by the pragma Interrupt_Handler.
126 --------------------------
127 -- Handler Registration --
128 --------------------------
130 type Registered_Handler;
131 type R_Link is access all Registered_Handler;
133 type Registered_Handler is record
134 H : System.Address := System.Null_Address;
135 Next : R_Link := null;
138 Registered_Handlers : R_Link := null;
140 function Is_Registered (Handler : Parameterless_Handler) return Boolean;
141 -- See if the Handler has been "pragma"ed using Interrupt_Handler.
142 -- Always consider a null handler as registered.
144 type Handler_Ptr is access procedure (Sig : Interrupt_ID);
146 function TISR is new Ada.Unchecked_Conversion (Handler_Ptr, isr_address);
152 procedure Signal_Handler (Sig : Interrupt_ID) is
153 Handler : Task_Id renames Handlers (Sig);
156 if Intr_Attach_Reset and then
157 intr_attach (int (Sig), TISR (Signal_Handler'Access)) = FUNC_ERR
162 if Handler /= null then
163 Interrupt_Count (Sig) := Interrupt_Count (Sig) + 1;
164 STPO.Wakeup (Handler, Interrupt_Server_Idle_Sleep);
172 function Is_Reserved (Interrupt : Interrupt_ID) return Boolean is
174 return IMNG.Reserve (IMNG.Interrupt_ID (Interrupt));
177 -----------------------
178 -- Is_Entry_Attached --
179 -----------------------
181 function Is_Entry_Attached (Interrupt : Interrupt_ID) return Boolean is
183 if Is_Reserved (Interrupt) then
184 Raise_Exception (Program_Error'Identity, "Interrupt" &
185 Interrupt_ID'Image (Interrupt) & " is reserved");
188 return Descriptors (Interrupt).T /= Null_Task;
189 end Is_Entry_Attached;
191 -------------------------
192 -- Is_Handler_Attached --
193 -------------------------
195 function Is_Handler_Attached (Interrupt : Interrupt_ID) return Boolean is
197 if Is_Reserved (Interrupt) then
198 Raise_Exception (Program_Error'Identity, "Interrupt" &
199 Interrupt_ID'Image (Interrupt) & " is reserved");
202 return Descriptors (Interrupt).Kind /= Unknown;
203 end Is_Handler_Attached;
209 function Is_Ignored (Interrupt : Interrupt_ID) return Boolean is
219 function Unblocked_By (Interrupt : Interrupt_ID) return Task_Id is
225 ----------------------
226 -- Ignore_Interrupt --
227 ----------------------
229 procedure Ignore_Interrupt (Interrupt : Interrupt_ID) is
232 end Ignore_Interrupt;
234 ------------------------
235 -- Unignore_Interrupt --
236 ------------------------
238 procedure Unignore_Interrupt (Interrupt : Interrupt_ID) is
241 end Unignore_Interrupt;
243 -------------------------------------
244 -- Has_Interrupt_Or_Attach_Handler --
245 -------------------------------------
247 function Has_Interrupt_Or_Attach_Handler
248 (Object : access Dynamic_Interrupt_Protection) return Boolean
250 pragma Unreferenced (Object);
253 end Has_Interrupt_Or_Attach_Handler;
259 procedure Finalize (Object : in out Static_Interrupt_Protection) is
261 -- ??? loop to be executed only when we're not doing library level
262 -- finalization, since in this case all interrupt tasks are gone.
264 for N in reverse Object.Previous_Handlers'Range loop
266 (New_Handler => Object.Previous_Handlers (N).Handler,
267 Interrupt => Object.Previous_Handlers (N).Interrupt,
268 Static => Object.Previous_Handlers (N).Static,
269 Restoration => True);
272 Tasking.Protected_Objects.Entries.Finalize
273 (Tasking.Protected_Objects.Entries.Protection_Entries (Object));
276 -------------------------------------
277 -- Has_Interrupt_Or_Attach_Handler --
278 -------------------------------------
280 function Has_Interrupt_Or_Attach_Handler
281 (Object : access Static_Interrupt_Protection) return Boolean
283 pragma Unreferenced (Object);
286 end Has_Interrupt_Or_Attach_Handler;
288 ----------------------
289 -- Install_Handlers --
290 ----------------------
292 procedure Install_Handlers
293 (Object : access Static_Interrupt_Protection;
294 New_Handlers : New_Handler_Array)
297 for N in New_Handlers'Range loop
299 -- We need a lock around this ???
301 Object.Previous_Handlers (N).Interrupt := New_Handlers (N).Interrupt;
302 Object.Previous_Handlers (N).Static := Descriptors
303 (New_Handlers (N).Interrupt).Static;
305 -- We call Exchange_Handler and not directly Interrupt_Manager.
306 -- Exchange_Handler so we get the Is_Reserved check.
309 (Old_Handler => Object.Previous_Handlers (N).Handler,
310 New_Handler => New_Handlers (N).Handler,
311 Interrupt => New_Handlers (N).Interrupt,
314 end Install_Handlers;
316 ---------------------
317 -- Current_Handler --
318 ---------------------
320 function Current_Handler
321 (Interrupt : Interrupt_ID) return Parameterless_Handler
324 if Is_Reserved (Interrupt) then
328 if Descriptors (Interrupt).Kind = Protected_Procedure then
329 return Descriptors (Interrupt).H;
339 procedure Attach_Handler
340 (New_Handler : Parameterless_Handler;
341 Interrupt : Interrupt_ID;
342 Static : Boolean := False) is
344 Attach_Handler (New_Handler, Interrupt, Static, False);
347 procedure Attach_Handler
348 (New_Handler : Parameterless_Handler;
349 Interrupt : Interrupt_ID;
351 Restoration : Boolean)
353 New_Task : Server_Task_Access;
356 if Is_Reserved (Interrupt) then
360 if not Restoration and then not Static
362 -- Tries to overwrite a static Interrupt Handler with dynamic handle
365 (Descriptors (Interrupt).Static
367 -- New handler not specified as an Interrupt Handler by a pragma
369 or else not Is_Registered (New_Handler))
371 Raise_Exception (Program_Error'Identity,
372 "Trying to overwrite a static Interrupt Handler with a " &
376 if Handlers (Interrupt) = null then
377 New_Task := new Server_Task (Interrupt);
378 Handlers (Interrupt) := To_System (New_Task.all'Identity);
381 if intr_attach (int (Interrupt),
382 TISR (Signal_Handler'Access)) = FUNC_ERR
387 if New_Handler = null then
389 -- The null handler means we are detaching the handler
391 Descriptors (Interrupt) :=
392 (Kind => Unknown, T => null, E => 0, H => null, Static => False);
395 Descriptors (Interrupt).Kind := Protected_Procedure;
396 Descriptors (Interrupt).H := New_Handler;
397 Descriptors (Interrupt).Static := Static;
401 ----------------------
402 -- Exchange_Handler --
403 ----------------------
405 procedure Exchange_Handler
406 (Old_Handler : out Parameterless_Handler;
407 New_Handler : Parameterless_Handler;
408 Interrupt : Interrupt_ID;
409 Static : Boolean := False)
412 if Is_Reserved (Interrupt) then
416 if Descriptors (Interrupt).Kind = Task_Entry then
418 -- In case we have an Interrupt Entry already installed.
419 -- raise a program error. (propagate it to the caller).
421 Raise_Exception (Program_Error'Identity,
422 "An interrupt is already installed");
425 Old_Handler := Current_Handler (Interrupt);
426 Attach_Handler (New_Handler, Interrupt, Static);
427 end Exchange_Handler;
433 procedure Detach_Handler
434 (Interrupt : Interrupt_ID;
435 Static : Boolean := False)
438 if Is_Reserved (Interrupt) then
442 if Descriptors (Interrupt).Kind = Task_Entry then
443 Raise_Exception (Program_Error'Identity,
444 "Trying to detach an Interrupt Entry");
447 if not Static and then Descriptors (Interrupt).Static then
448 Raise_Exception (Program_Error'Identity,
449 "Trying to detach a static Interrupt Handler");
452 Descriptors (Interrupt) :=
453 (Kind => Unknown, T => null, E => 0, H => null, Static => False);
455 if intr_attach (int (Interrupt), null) = FUNC_ERR then
464 function Reference (Interrupt : Interrupt_ID) return System.Address is
465 Signal : constant System.Address :=
466 System.Storage_Elements.To_Address
467 (System.Storage_Elements.Integer_Address (Interrupt));
470 if Is_Reserved (Interrupt) then
472 -- Only usable Interrupts can be used for binding it to an Entry
480 --------------------------------
481 -- Register_Interrupt_Handler --
482 --------------------------------
484 procedure Register_Interrupt_Handler (Handler_Addr : System.Address) is
486 Registered_Handlers :=
487 new Registered_Handler'(H => Handler_Addr, Next => Registered_Handlers);
488 end Register_Interrupt_Handler;
494 -- See if the Handler has been "pragma"ed using Interrupt_Handler.
495 -- Always consider a null handler as registered.
497 function Is_Registered (Handler : Parameterless_Handler) return Boolean is
498 Ptr : R_Link := Registered_Handlers;
500 type Fat_Ptr is record
501 Object_Addr : System.Address;
502 Handler_Addr : System.Address;
505 function To_Fat_Ptr is new Ada.Unchecked_Conversion
506 (Parameterless_Handler, Fat_Ptr);
511 if Handler = null then
515 Fat := To_Fat_Ptr (Handler);
517 while Ptr /= null loop
519 if Ptr.H = Fat.Handler_Addr then
529 -----------------------------
530 -- Bind_Interrupt_To_Entry --
531 -----------------------------
533 procedure Bind_Interrupt_To_Entry
535 E : Task_Entry_Index;
536 Int_Ref : System.Address)
538 Interrupt : constant Interrupt_ID :=
539 Interrupt_ID (Storage_Elements.To_Integer (Int_Ref));
541 New_Task : Server_Task_Access;
544 if Is_Reserved (Interrupt) then
548 if Descriptors (Interrupt).Kind /= Unknown then
549 Raise_Exception (Program_Error'Identity,
550 "A binding for this interrupt is already present");
553 if Handlers (Interrupt) = null then
554 New_Task := new Server_Task (Interrupt);
555 Handlers (Interrupt) := To_System (New_Task.all'Identity);
558 if intr_attach (int (Interrupt),
559 TISR (Signal_Handler'Access)) = FUNC_ERR
564 Descriptors (Interrupt).Kind := Task_Entry;
565 Descriptors (Interrupt).T := T;
566 Descriptors (Interrupt).E := E;
568 -- Indicate the attachment of Interrupt Entry in ATCB. This is needed so
569 -- that when an Interrupt Entry task terminates the binding can be
570 -- cleaned up. The call to unbinding must be make by the task before it
573 T.Interrupt_Entry := True;
574 end Bind_Interrupt_To_Entry;
576 ------------------------------
577 -- Detach_Interrupt_Entries --
578 ------------------------------
580 procedure Detach_Interrupt_Entries (T : Task_Id) is
582 for J in Interrupt_ID loop
583 if not Is_Reserved (J) then
584 if Descriptors (J).Kind = Task_Entry
585 and then Descriptors (J).T = T
587 Descriptors (J).Kind := Unknown;
589 if intr_attach (int (J), null) = FUNC_ERR then
596 -- Indicate in ATCB that no Interrupt Entries are attached
598 T.Interrupt_Entry := True;
599 end Detach_Interrupt_Entries;
601 ---------------------
602 -- Block_Interrupt --
603 ---------------------
605 procedure Block_Interrupt (Interrupt : Interrupt_ID) is
610 -----------------------
611 -- Unblock_Interrupt --
612 -----------------------
614 procedure Unblock_Interrupt (Interrupt : Interrupt_ID) is
617 end Unblock_Interrupt;
623 function Is_Blocked (Interrupt : Interrupt_ID) return Boolean is
629 task body Server_Task is
630 Desc : Handler_Desc renames Descriptors (Interrupt);
631 Self_Id : constant Task_Id := STPO.Self;
632 Temp : Parameterless_Handler;
635 Utilities.Make_Independent;
638 while Interrupt_Count (Interrupt) > 0 loop
639 Interrupt_Count (Interrupt) := Interrupt_Count (Interrupt) - 1;
645 Rendezvous.Call_Simple (Desc.T, Desc.E, Null_Address);
646 when Protected_Procedure =>
655 Initialization.Defer_Abort (Self_Id);
661 STPO.Write_Lock (Self_Id);
662 Self_Id.Common.State := Interrupt_Server_Idle_Sleep;
663 STPO.Sleep (Self_Id, Interrupt_Server_Idle_Sleep);
664 Self_Id.Common.State := Runnable;
665 STPO.Unlock (Self_Id);
671 Initialization.Undefer_Abort (Self_Id);
673 -- Undefer abort here to allow a window for this task to be aborted
674 -- at the time of system shutdown.
679 end System.Interrupts;