Subversion Repositories openrisc_2011-10-31

------------------------------------------------------------------------------

--                                                                          --

--                GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS                  --

--                                                                          --

--                SYSTEM.TASKING.PROTECTED_OBJECTS.ENTRIES                  --

--                                                                          --

--                               B o d y                                    --

--                                                                          --

--          Copyright (C) 1998-2010, Free Software Foundation, Inc.         --

--                                                                          --

-- GNARL is free software; you can  redistribute it  and/or modify it under --

-- terms of the  GNU General Public License as published  by the Free Soft- --

-- ware  Foundation;  either version 3,  or (at your option) any later ver- --

-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --

-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --

-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --

--                                                                          --

-- As a special exception under Section 7 of GPL version 3, you are granted --

-- additional permissions described in the GCC Runtime Library Exception,   --

-- version 3.1, as published by the Free Software Foundation.               --

--                                                                          --

-- You should have received a copy of the GNU General Public License and    --

-- a copy of the GCC Runtime Library Exception along with this program;     --

-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --

-- <http://www.gnu.org/licenses/>.                                          --

--                                                                          --

-- GNARL was developed by the GNARL team at Florida State University.       --

-- Extensive contributions were provided by Ada Core Technologies, Inc.     --

--                                                                          --

------------------------------------------------------------------------------

--  This package contains all the simple primitives related to protected

--  objects with entries (i.e init, lock, unlock).

--  The handling of protected objects with no entries is done in

--  System.Tasking.Protected_Objects, the complex routines for protected

--  objects with entries in System.Tasking.Protected_Objects.Operations.

--  The split between Entries and Operations is needed to break circular

--  dependencies inside the run time.

--  Note: the compiler generates direct calls to this interface, via Rtsfind

with Ada.Unchecked_Deallocation;

with System.Task_Primitives.Operations;

with System.Restrictions;

with System.Parameters;

with System.Tasking.Initialization;

pragma Elaborate_All (System.Tasking.Initialization);

--  To insure that tasking is initialized if any protected objects are created

package body System.Tasking.Protected_Objects.Entries is

   package STPO renames System.Task_Primitives.Operations;

   use Parameters;

   use Task_Primitives.Operations;

   -----------------------

   -- Local Subprograms --

   -----------------------

   procedure Free_Entry_Names (Object : Protection_Entries);

   --  Deallocate all string names associated with protected entries

   ----------------

   -- Local Data --

   ----------------

   Locking_Policy : Character;

   pragma Import (C, Locking_Policy, "__gl_locking_policy");

   --------------

   -- Finalize --

   --------------

   overriding procedure Finalize (Object : in out Protection_Entries) is

      Entry_Call        : Entry_Call_Link;

      Caller            : Task_Id;

      Ceiling_Violation : Boolean;

      Self_ID           : constant Task_Id := STPO.Self;

      Old_Base_Priority : System.Any_Priority;

   begin

      if Object.Finalized then

         return;

      end if;

      STPO.Write_Lock (Object.L'Unrestricted_Access, Ceiling_Violation);

      if Single_Lock then

         Lock_RTS;

      end if;

      if Ceiling_Violation then

         --  Dip our own priority down to ceiling of lock. See similar code in

         --  Tasking.Entry_Calls.Lock_Server.

         STPO.Write_Lock (Self_ID);

         Old_Base_Priority := Self_ID.Common.Base_Priority;

         Self_ID.New_Base_Priority := Object.Ceiling;

         Initialization.Change_Base_Priority (Self_ID);

         STPO.Unlock (Self_ID);

         if Single_Lock then

            Unlock_RTS;

         end if;

         STPO.Write_Lock (Object.L'Unrestricted_Access, Ceiling_Violation);

         if Ceiling_Violation then

            raise Program_Error with "Ceiling Violation";

         end if;

         if Single_Lock then

            Lock_RTS;

         end if;

         Object.Old_Base_Priority := Old_Base_Priority;

         Object.Pending_Action := True;

      end if;

      --  Send program_error to all tasks still queued on this object

      for E in Object.Entry_Queues'Range loop

         Entry_Call := Object.Entry_Queues (E).Head;

         while Entry_Call /= null loop

            Caller := Entry_Call.Self;

            Entry_Call.Exception_To_Raise := Program_Error'Identity;

            STPO.Write_Lock (Caller);

            Initialization.Wakeup_Entry_Caller (Self_ID, Entry_Call, Done);

            STPO.Unlock (Caller);

            exit when Entry_Call = Object.Entry_Queues (E).Tail;

            Entry_Call := Entry_Call.Next;

         end loop;

      end loop;

      Free_Entry_Names (Object);

      Object.Finalized := True;

      if Single_Lock then

         Unlock_RTS;

      end if;

      STPO.Unlock (Object.L'Unrestricted_Access);

      STPO.Finalize_Lock (Object.L'Unrestricted_Access);

   end Finalize;

   ----------------------

   -- Free_Entry_Names --

   ----------------------

   procedure Free_Entry_Names (Object : Protection_Entries) is

      Names : Entry_Names_Array_Access := Object.Entry_Names;

      procedure Free_Entry_Names_Array_Access is new

        Ada.Unchecked_Deallocation

          (Entry_Names_Array, Entry_Names_Array_Access);

   begin

      if Names = null then

         return;

      end if;

      Free_Entry_Names_Array (Names.all);

      Free_Entry_Names_Array_Access (Names);

   end Free_Entry_Names;

   -----------------

   -- Get_Ceiling --

   -----------------

   function Get_Ceiling

     (Object : Protection_Entries_Access) return System.Any_Priority is

   begin

      return Object.New_Ceiling;

   end Get_Ceiling;

   -------------------------------------

   -- Has_Interrupt_Or_Attach_Handler --

   -------------------------------------

   function Has_Interrupt_Or_Attach_Handler

     (Object : Protection_Entries_Access)

      return   Boolean

   is

      pragma Warnings (Off, Object);

   begin

      return False;

   end Has_Interrupt_Or_Attach_Handler;

   -----------------------------------

   -- Initialize_Protection_Entries --

   -----------------------------------

   procedure Initialize_Protection_Entries

     (Object            : Protection_Entries_Access;

      Ceiling_Priority  : Integer;

      Compiler_Info     : System.Address;

      Entry_Bodies      : Protected_Entry_Body_Access;

      Find_Body_Index   : Find_Body_Index_Access;

      Build_Entry_Names : Boolean)

   is

      Init_Priority : Integer := Ceiling_Priority;

      Self_ID       : constant Task_Id := STPO.Self;

   begin

      if Init_Priority = Unspecified_Priority then

         Init_Priority := System.Priority'Last;

      end if;

      if Locking_Policy = 'C'

        and then Has_Interrupt_Or_Attach_Handler (Object)

        and then Init_Priority not in System.Interrupt_Priority

      then

         --  Required by C.3.1(11)

         raise Program_Error;

      end if;

      --  pragma Assert (Self_Id.Deferral_Level = 0);

      --  If a PO is created from a controlled operation, abort is already

      --  deferred at this point, so we need to use Defer_Abort_Nestable

      --  In some cases, the above assertion can be useful to spot

      --  inconsistencies, outside the above scenario involving controlled

      --  types.

      Initialization.Defer_Abort_Nestable (Self_ID);

      Initialize_Lock (Init_Priority, Object.L'Access);

      Initialization.Undefer_Abort_Nestable (Self_ID);

      Object.Ceiling          := System.Any_Priority (Init_Priority);

      Object.New_Ceiling      := System.Any_Priority (Init_Priority);

      Object.Owner            := Null_Task;

      Object.Compiler_Info    := Compiler_Info;

      Object.Pending_Action   := False;

      Object.Call_In_Progress := null;

      Object.Entry_Bodies     := Entry_Bodies;

      Object.Find_Body_Index  := Find_Body_Index;

      for E in Object.Entry_Queues'Range loop

         Object.Entry_Queues (E).Head := null;

         Object.Entry_Queues (E).Tail := null;

      end loop;

      if Build_Entry_Names then

         Object.Entry_Names :=

           new Entry_Names_Array (1 .. Entry_Index (Object.Num_Entries));

      end if;

   end Initialize_Protection_Entries;

   ------------------

   -- Lock_Entries --

   ------------------

   procedure Lock_Entries

     (Object            : Protection_Entries_Access;

      Ceiling_Violation : out Boolean)

   is

   begin

      if Object.Finalized then

         raise Program_Error with "Protected Object is finalized";

      end if;

      --  If pragma Detect_Blocking is active then, as described in the ARM

      --  9.5.1, par. 15, we must check whether this is an external call on a

      --  protected subprogram with the same target object as that of the

      --  protected action that is currently in progress (i.e., if the caller

      --  is already the protected object's owner). If this is the case hence

      --  Program_Error must be raised.

      if Detect_Blocking and then Object.Owner = Self then

         raise Program_Error;

      end if;

      --  The lock is made without deferring abort

      --  Therefore the abort has to be deferred before calling this routine.

      --  This means that the compiler has to generate a Defer_Abort call

      --  before the call to Lock.

      --  The caller is responsible for undeferring abort, and compiler

      --  generated calls must be protected with cleanup handlers to ensure

      --  that abort is undeferred in all cases.

      pragma Assert

        (STPO.Self.Deferral_Level > 0

          or else not Restrictions.Abort_Allowed);

      Write_Lock (Object.L'Access, Ceiling_Violation);

      --  We are entering in a protected action, so that we increase the

      --  protected object nesting level (if pragma Detect_Blocking is

      --  active), and update the protected object's owner.

      if Detect_Blocking then

         declare

            Self_Id : constant Task_Id := Self;

         begin

            --  Update the protected object's owner

            Object.Owner := Self_Id;

            --  Increase protected object nesting level

            Self_Id.Common.Protected_Action_Nesting :=

              Self_Id.Common.Protected_Action_Nesting + 1;

         end;

      end if;

   end Lock_Entries;

   procedure Lock_Entries (Object : Protection_Entries_Access) is

      Ceiling_Violation : Boolean;

   begin

      Lock_Entries (Object, Ceiling_Violation);

      if Ceiling_Violation then

         raise Program_Error with "Ceiling Violation";

      end if;

   end Lock_Entries;

   ----------------------------

   -- Lock_Read_Only_Entries --

   ----------------------------

   procedure Lock_Read_Only_Entries (Object : Protection_Entries_Access) is

      Ceiling_Violation : Boolean;

   begin

      if Object.Finalized then

         raise Program_Error with "Protected Object is finalized";

      end if;

      --  If pragma Detect_Blocking is active then, as described in the ARM

      --  9.5.1, par. 15, we must check whether this is an external call on a

      --  protected subprogram with the same target object as that of the

      --  protected action that is currently in progress (i.e., if the caller

      --  is already the protected object's owner). If this is the case hence

      --  Program_Error must be raised.

      --  Note that in this case (getting read access), several tasks may

      --  have read ownership of the protected object, so that this method of

      --  storing the (single) protected object's owner does not work

      --  reliably for read locks. However, this is the approach taken for two

      --  major reasons: first, this function is not currently being used (it

      --  is provided for possible future use), and second, it largely

      --  simplifies the implementation.

      if Detect_Blocking and then Object.Owner = Self then

         raise Program_Error;

      end if;

      Read_Lock (Object.L'Access, Ceiling_Violation);

      if Ceiling_Violation then

         raise Program_Error with "Ceiling Violation";

      end if;

      --  We are entering in a protected action, so that we increase the

      --  protected object nesting level (if pragma Detect_Blocking is

      --  active), and update the protected object's owner.

      if Detect_Blocking then

         declare

            Self_Id : constant Task_Id := Self;

         begin

            --  Update the protected object's owner

            Object.Owner := Self_Id;

            --  Increase protected object nesting level

            Self_Id.Common.Protected_Action_Nesting :=

              Self_Id.Common.Protected_Action_Nesting + 1;

         end;

      end if;

   end Lock_Read_Only_Entries;

   -----------------

   -- Set_Ceiling --

   -----------------

   procedure Set_Ceiling

     (Object : Protection_Entries_Access;

      Prio   : System.Any_Priority) is

   begin

      Object.New_Ceiling := Prio;

   end Set_Ceiling;

   --------------------

   -- Set_Entry_Name --

   --------------------

   procedure Set_Entry_Name

     (Object : Protection_Entries'Class;

      Pos    : Protected_Entry_Index;

      Val    : String_Access)

   is

   begin

      pragma Assert (Object.Entry_Names /= null);

      Object.Entry_Names (Entry_Index (Pos)) := Val;

   end Set_Entry_Name;

   --------------------

   -- Unlock_Entries --

   --------------------

   procedure Unlock_Entries (Object : Protection_Entries_Access) is

   begin

      --  We are exiting from a protected action, so that we decrease the

      --  protected object nesting level (if pragma Detect_Blocking is

      --  active), and remove ownership of the protected object.

      if Detect_Blocking then

         declare

            Self_Id : constant Task_Id := Self;

         begin

            --  Calls to this procedure can only take place when being within

            --  a protected action and when the caller is the protected

            --  object's owner.

            pragma Assert (Self_Id.Common.Protected_Action_Nesting > 0

                             and then Object.Owner = Self_Id);

            --  Remove ownership of the protected object

            Object.Owner := Null_Task;

            Self_Id.Common.Protected_Action_Nesting :=

              Self_Id.Common.Protected_Action_Nesting - 1;

         end;

      end if;

      --  Before releasing the mutex we must actually update its ceiling

      --  priority if it has been changed.

      if Object.New_Ceiling /= Object.Ceiling then

         if Locking_Policy = 'C' then

            System.Task_Primitives.Operations.Set_Ceiling

              (Object.L'Access, Object.New_Ceiling);

         end if;

         Object.Ceiling := Object.New_Ceiling;

      end if;

      Unlock (Object.L'Access);

   end Unlock_Entries;

end System.Tasking.Protected_Objects.Entries;