dep/ACE_wrappers/ace/POSIX_Proactor.cpp

   1 // $Id: POSIX_Proactor.cpp 81697 2008-05-14 18:33:11Z johnnyw $
   2
   3 #include "ace/POSIX_Proactor.h"
   4
   5 #if defined (ACE_HAS_AIO_CALLS)
   6
   7 #if !defined (__ACE_INLINE__)
   8 #include "ace/POSIX_Proactor.inl"
   9 #endif /* __ACE_INLINE__ */
  10
  11 # if defined (ACE_HAS_SYS_SYSTEMINFO_H)
  12 #   include /**/ <sys/systeminfo.h>
  13 # endif /* ACE_HAS_SYS_SYSTEMINFO_H */
  14
  15 #include "ace/ACE.h"
  16 #include "ace/Flag_Manip.h"
  17 #include "ace/Task_T.h"
  18 #include "ace/Log_Msg.h"
  19 #include "ace/Object_Manager.h"
  20 #include "ace/OS_NS_sys_socket.h"
  21 #include "ace/OS_NS_signal.h"
  22 #include "ace/OS_NS_unistd.h"
  23
  24 #if defined (sun)
  25 #  include "ace/OS_NS_strings.h"
  26 #endif /* sun */
  27
  28 // *********************************************************************
  29
  30 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  31
  32 /**
  33  * @class ACE_POSIX_Wakeup_Completion
  34  *
  35  * This result object is used by the <end_event_loop> of the
  36  * ACE_Proactor interface to wake up all the threads blocking
  37  * for completions.
  38  */
  39 class ACE_POSIX_Wakeup_Completion : public ACE_POSIX_Asynch_Result
  40 {
  41 public:
  42   /// Constructor.
  43   ACE_POSIX_Wakeup_Completion (const ACE_Handler::Proxy_Ptr &handler_proxy,
  44                                const void *act = 0,
  45                                ACE_HANDLE event = ACE_INVALID_HANDLE,
  46                                int priority = 0,
  47                                int signal_number = ACE_SIGRTMIN);
  48
  49   /// Destructor.
  50   virtual ~ACE_POSIX_Wakeup_Completion (void);
  51
  52
  53   /// This method calls the <handler>'s <handle_wakeup> method.
  54   virtual void complete (size_t bytes_transferred = 0,
  55                          int success = 1,
  56                          const void *completion_key = 0,
  57                          u_long error = 0);
  58 };
  59
  60 // *********************************************************************
  61 ACE_POSIX_Proactor::ACE_POSIX_Proactor (void)
  62   :  os_id_ (ACE_OS_UNDEFINED)
  63 {
  64 #if defined(sun)
  65
  66   os_id_ = ACE_OS_SUN; // set family
  67
  68   char Buf [32];
  69
  70   ::memset(Buf,0,sizeof(Buf));
  71
  72   ACE_OS::sysinfo (SI_RELEASE , Buf, sizeof(Buf)-1);
  73
  74   if (ACE_OS::strcasecmp (Buf , "5.6") == 0)
  75     os_id_ = ACE_OS_SUN_56;
  76   else if (ACE_OS::strcasecmp (Buf , "5.7") == 0)
  77     os_id_ = ACE_OS_SUN_57;
  78   else if (ACE_OS::strcasecmp (Buf , "5.8") == 0)
  79     os_id_ = ACE_OS_SUN_58;
  80
  81 #elif defined(HPUX)
  82
  83   os_id_ = ACE_OS_HPUX;   // set family
  84
  85 #elif defined(__sgi)
  86
  87   os_id_ = ACE_OS_IRIX;   // set family
  88
  89 #elif defined(__OpenBSD)
  90
  91   os_id_ = ACE_OS_OPENBSD; // set family
  92
  93   // do the same
  94
  95 //#else defined (LINUX, __FreeBSD__ ...)
  96 //setup here os_id_
  97 #endif
  98 }
  99
 100 ACE_POSIX_Proactor::~ACE_POSIX_Proactor (void)
 101 {
 102   this->close ();
 103 }
 104
 105 int
 106 ACE_POSIX_Proactor::close (void)
 107 {
 108   return 0;
 109 }
 110
 111 int
 112 ACE_POSIX_Proactor::register_handle (ACE_HANDLE handle,
 113                                      const void *completion_key)
 114 {
 115   ACE_UNUSED_ARG (handle);
 116   ACE_UNUSED_ARG (completion_key);
 117   return 0;
 118 }
 119
 120 int
 121 ACE_POSIX_Proactor::wake_up_dispatch_threads (void)
 122 {
 123   return 0;
 124 }
 125
 126 int
 127 ACE_POSIX_Proactor::close_dispatch_threads (int)
 128 {
 129   return 0;
 130 }
 131
 132 size_t
 133 ACE_POSIX_Proactor::number_of_threads (void) const
 134 {
 135   // @@ Implement it.
 136   ACE_NOTSUP_RETURN (0);
 137 }
 138
 139 void
 140 ACE_POSIX_Proactor::number_of_threads (size_t threads)
 141 {
 142   // @@ Implement it.
 143   ACE_UNUSED_ARG (threads);
 144 }
 145
 146 ACE_HANDLE
 147 ACE_POSIX_Proactor::get_handle (void) const
 148 {
 149   return ACE_INVALID_HANDLE;
 150 }
 151
 152 ACE_Asynch_Read_Stream_Impl *
 153 ACE_POSIX_Proactor::create_asynch_read_stream (void)
 154 {
 155   ACE_Asynch_Read_Stream_Impl *implementation = 0;
 156   ACE_NEW_RETURN (implementation,
 157                   ACE_POSIX_Asynch_Read_Stream (this),
 158                   0);
 159   return implementation;
 160 }
 161
 162 ACE_Asynch_Read_Stream_Result_Impl *
 163 ACE_POSIX_Proactor::create_asynch_read_stream_result
 164   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 165    ACE_HANDLE handle,
 166    ACE_Message_Block &message_block,
 167    size_t bytes_to_read,
 168    const void* act,
 169    ACE_HANDLE event,
 170    int priority,
 171    int signal_number)
 172 {
 173   ACE_Asynch_Read_Stream_Result_Impl *implementation;
 174   ACE_NEW_RETURN (implementation,
 175                   ACE_POSIX_Asynch_Read_Stream_Result (handler_proxy,
 176                                                        handle,
 177                                                        message_block,
 178                                                        bytes_to_read,
 179                                                        act,
 180                                                        event,
 181                                                        priority,
 182                                                        signal_number),
 183                   0);
 184   return implementation;
 185 }
 186
 187
 188 ACE_Asynch_Write_Stream_Impl *
 189 ACE_POSIX_Proactor::create_asynch_write_stream (void)
 190 {
 191   ACE_Asynch_Write_Stream_Impl *implementation = 0;
 192   ACE_NEW_RETURN (implementation,
 193                   ACE_POSIX_Asynch_Write_Stream (this),
 194                   0);
 195   return implementation;
 196 }
 197
 198 ACE_Asynch_Write_Stream_Result_Impl *
 199 ACE_POSIX_Proactor::create_asynch_write_stream_result
 200   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 201    ACE_HANDLE handle,
 202    ACE_Message_Block &message_block,
 203    size_t bytes_to_write,
 204    const void* act,
 205    ACE_HANDLE event,
 206    int priority,
 207    int signal_number)
 208 {
 209   ACE_Asynch_Write_Stream_Result_Impl *implementation;
 210   ACE_NEW_RETURN (implementation,
 211                   ACE_POSIX_Asynch_Write_Stream_Result (handler_proxy,
 212                                                         handle,
 213                                                         message_block,
 214                                                         bytes_to_write,
 215                                                         act,
 216                                                         event,
 217                                                         priority,
 218                                                         signal_number),
 219                   0);
 220   return implementation;
 221 }
 222
 223
 224 ACE_Asynch_Read_File_Impl *
 225 ACE_POSIX_Proactor::create_asynch_read_file (void)
 226 {
 227   ACE_Asynch_Read_File_Impl *implementation = 0;
 228   ACE_NEW_RETURN (implementation,
 229                   ACE_POSIX_Asynch_Read_File (this),
 230                   0);
 231   return  implementation;
 232 }
 233
 234 ACE_Asynch_Read_File_Result_Impl *
 235 ACE_POSIX_Proactor::create_asynch_read_file_result
 236   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 237    ACE_HANDLE handle,
 238    ACE_Message_Block &message_block,
 239    size_t bytes_to_read,
 240    const void* act,
 241    u_long offset,
 242    u_long offset_high,
 243    ACE_HANDLE event,
 244    int priority,
 245    int signal_number)
 246 {
 247   ACE_Asynch_Read_File_Result_Impl *implementation;
 248   ACE_NEW_RETURN (implementation,
 249                   ACE_POSIX_Asynch_Read_File_Result (handler_proxy,
 250                                                      handle,
 251                                                      message_block,
 252                                                      bytes_to_read,
 253                                                      act,
 254                                                      offset,
 255                                                      offset_high,
 256                                                      event,
 257                                                      priority,
 258                                                      signal_number),
 259                   0);
 260   return implementation;
 261 }
 262
 263
 264 ACE_Asynch_Write_File_Impl *
 265 ACE_POSIX_Proactor::create_asynch_write_file (void)
 266 {
 267   ACE_Asynch_Write_File_Impl *implementation = 0;
 268   ACE_NEW_RETURN (implementation,
 269                   ACE_POSIX_Asynch_Write_File (this),
 270                   0);
 271   return  implementation;
 272 }
 273
 274 ACE_Asynch_Write_File_Result_Impl *
 275 ACE_POSIX_Proactor::create_asynch_write_file_result
 276   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 277    ACE_HANDLE handle,
 278    ACE_Message_Block &message_block,
 279    size_t bytes_to_write,
 280    const void* act,
 281    u_long offset,
 282    u_long offset_high,
 283    ACE_HANDLE event,
 284    int priority,
 285    int signal_number)
 286 {
 287   ACE_Asynch_Write_File_Result_Impl *implementation;
 288   ACE_NEW_RETURN (implementation,
 289                   ACE_POSIX_Asynch_Write_File_Result (handler_proxy,
 290                                                       handle,
 291                                                       message_block,
 292                                                       bytes_to_write,
 293                                                       act,
 294                                                       offset,
 295                                                       offset_high,
 296                                                       event,
 297                                                       priority,
 298                                                       signal_number),
 299                   0);
 300   return implementation;
 301 }
 302
 303
 304 ACE_Asynch_Read_Dgram_Impl *
 305 ACE_POSIX_Proactor::create_asynch_read_dgram (void)
 306 {
 307     ACE_Asynch_Read_Dgram_Impl *implementation = 0;
 308     ACE_NEW_RETURN (implementation,
 309                     ACE_POSIX_Asynch_Read_Dgram (this),
 310                     0);
 311     return implementation;
 312 }
 313
 314 ACE_Asynch_Read_Dgram_Result_Impl *
 315 ACE_POSIX_Proactor::create_asynch_read_dgram_result
 316   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 317    ACE_HANDLE handle,
 318    ACE_Message_Block *message_block,
 319    size_t bytes_to_read,
 320    int flags,
 321    int protocol_family,
 322    const void* act,
 323    ACE_HANDLE event ,
 324    int priority ,
 325    int signal_number)
 326 {
 327   ACE_Asynch_Read_Dgram_Result_Impl *implementation=0;
 328   ACE_NEW_RETURN (implementation,
 329                   ACE_POSIX_Asynch_Read_Dgram_Result(handler_proxy,
 330                                                      handle,
 331                                                      message_block,
 332                                                      bytes_to_read,
 333                                                      flags,
 334                                                      protocol_family,
 335                                                      act,
 336                                                      event,
 337                                                      priority,
 338                                                      signal_number),
 339                   0);
 340
 341   return implementation;
 342 }
 343
 344
 345 ACE_Asynch_Write_Dgram_Impl *
 346 ACE_POSIX_Proactor::create_asynch_write_dgram (void)
 347 {
 348         ACE_Asynch_Write_Dgram_Impl *implementation = 0;
 349         ACE_NEW_RETURN (implementation,
 350                         ACE_POSIX_Asynch_Write_Dgram (this),
 351                         0);
 352
 353     return implementation;
 354 }
 355
 356 ACE_Asynch_Write_Dgram_Result_Impl *
 357 ACE_POSIX_Proactor::create_asynch_write_dgram_result
 358   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 359    ACE_HANDLE handle,
 360    ACE_Message_Block *message_block,
 361    size_t bytes_to_write,
 362    int flags,
 363    const void* act,
 364    ACE_HANDLE event,
 365    int priority ,
 366    int signal_number)
 367 {
 368   ACE_Asynch_Write_Dgram_Result_Impl *implementation=0;
 369   ACE_NEW_RETURN (implementation,
 370                   ACE_POSIX_Asynch_Write_Dgram_Result(handler_proxy,
 371                                                       handle,
 372                                                       message_block,
 373                                                       bytes_to_write,
 374                                                       flags,
 375                                                       act,
 376                                                       event,
 377                                                       priority,
 378                                                       signal_number),
 379                   0);
 380
 381   return implementation;
 382 }
 383
 384
 385 ACE_Asynch_Accept_Impl *
 386 ACE_POSIX_Proactor::create_asynch_accept (void)
 387 {
 388   ACE_Asynch_Accept_Impl *implementation = 0;
 389   ACE_NEW_RETURN (implementation,
 390                   ACE_POSIX_Asynch_Accept (this),
 391                   0);
 392
 393   return implementation;
 394 }
 395
 396 ACE_Asynch_Accept_Result_Impl *
 397 ACE_POSIX_Proactor::create_asynch_accept_result
 398   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 399    ACE_HANDLE listen_handle,
 400    ACE_HANDLE accept_handle,
 401    ACE_Message_Block &message_block,
 402    size_t bytes_to_read,
 403    const void* act,
 404    ACE_HANDLE event,
 405    int priority,
 406    int signal_number)
 407 {
 408   ACE_Asynch_Accept_Result_Impl *implementation;
 409   ACE_NEW_RETURN (implementation,
 410                   ACE_POSIX_Asynch_Accept_Result (handler_proxy,
 411                                                   listen_handle,
 412                                                   accept_handle,
 413                                                   message_block,
 414                                                   bytes_to_read,
 415                                                   act,
 416                                                   event,
 417                                                   priority,
 418                                                   signal_number),
 419                   0);
 420   return implementation;
 421 }
 422
 423
 424 ACE_Asynch_Connect_Impl *
 425 ACE_POSIX_Proactor::create_asynch_connect (void)
 426 {
 427   ACE_Asynch_Connect_Impl *implementation = 0;
 428   ACE_NEW_RETURN (implementation,
 429                   ACE_POSIX_Asynch_Connect (this),
 430                   0);
 431
 432   return implementation;
 433 }
 434
 435 ACE_Asynch_Connect_Result_Impl *
 436 ACE_POSIX_Proactor::create_asynch_connect_result
 437   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 438    ACE_HANDLE connect_handle,
 439    const void* act,
 440    ACE_HANDLE event,
 441    int priority,
 442    int signal_number)
 443 {
 444   ACE_Asynch_Connect_Result_Impl *implementation;
 445   ACE_NEW_RETURN (implementation,
 446                   ACE_POSIX_Asynch_Connect_Result (handler_proxy,
 447                                                    connect_handle,
 448                                                    act,
 449                                                    event,
 450                                                    priority,
 451                                                    signal_number),
 452                   0);
 453   return implementation;
 454 }
 455
 456
 457 ACE_Asynch_Transmit_File_Impl *
 458 ACE_POSIX_Proactor::create_asynch_transmit_file (void)
 459 {
 460   ACE_Asynch_Transmit_File_Impl *implementation = 0;
 461   ACE_NEW_RETURN (implementation,
 462                   ACE_POSIX_Asynch_Transmit_File (this),
 463                   0);
 464   return implementation;
 465 }
 466
 467 ACE_Asynch_Transmit_File_Result_Impl *
 468 ACE_POSIX_Proactor::create_asynch_transmit_file_result
 469   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 470    ACE_HANDLE socket,
 471    ACE_HANDLE file,
 472    ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
 473    size_t bytes_to_write,
 474    u_long offset,
 475    u_long offset_high,
 476    size_t bytes_per_send,
 477    u_long flags,
 478    const void *act,
 479    ACE_HANDLE event,
 480    int priority,
 481    int signal_number)
 482 {
 483   ACE_Asynch_Transmit_File_Result_Impl *implementation;
 484   ACE_NEW_RETURN (implementation,
 485                   ACE_POSIX_Asynch_Transmit_File_Result (handler_proxy,
 486                                                          socket,
 487                                                          file,
 488                                                          header_and_trailer,
 489                                                          bytes_to_write,
 490                                                          offset,
 491                                                          offset_high,
 492                                                          bytes_per_send,
 493                                                          flags,
 494                                                          act,
 495                                                          event,
 496                                                          priority,
 497                                                          signal_number),
 498                   0);
 499   return implementation;
 500 }
 501
 502 ACE_Asynch_Result_Impl *
 503 ACE_POSIX_Proactor::create_asynch_timer
 504   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 505    const void *act,
 506    const ACE_Time_Value &tv,
 507    ACE_HANDLE event,
 508    int priority,
 509    int signal_number)
 510 {
 511   ACE_POSIX_Asynch_Timer *implementation;
 512   ACE_NEW_RETURN (implementation,
 513                   ACE_POSIX_Asynch_Timer (handler_proxy,
 514                                           act,
 515                                           tv,
 516                                           event,
 517                                           priority,
 518                                           signal_number),
 519                   0);
 520   return implementation;
 521 }
 522
 523 #if 0
 524 int
 525 ACE_POSIX_Proactor::handle_signal (int, siginfo_t *, ucontext_t *)
 526 {
 527   // Perform a non-blocking "poll" for all the I/O events that have
 528   // completed in the I/O completion queue.
 529
 530   ACE_Time_Value timeout (0, 0);
 531   int result = 0;
 532
 533   for (;;)
 534     {
 535       result = this->handle_events (timeout);
 536       if (result != 0 || errno == ETIME)
 537         break;
 538     }
 539
 540   // If our handle_events failed, we'll report a failure to the
 541   // Reactor.
 542   return result == -1 ? -1 : 0;
 543 }
 544
 545 int
 546 ACE_POSIX_Proactor::handle_close (ACE_HANDLE handle,
 547                                   ACE_Reactor_Mask close_mask)
 548 {
 549   ACE_UNUSED_ARG (close_mask);
 550   ACE_UNUSED_ARG (handle);
 551
 552   return this->close ();
 553 }
 554 #endif /* 0 */
 555
 556 void
 557 ACE_POSIX_Proactor::application_specific_code (ACE_POSIX_Asynch_Result *asynch_result,
 558                                                size_t bytes_transferred,
 559                                                const void */* completion_key*/,
 560                                                u_long error)
 561 {
 562   ACE_SEH_TRY
 563     {
 564       // Call completion hook
 565       asynch_result->complete (bytes_transferred,
 566                                error ? 0 : 1,
 567                                0, // No completion key.
 568                                error);
 569     }
 570   ACE_SEH_FINALLY
 571     {
 572       // This is crucial to prevent memory leaks
 573       delete asynch_result;
 574     }
 575 }
 576
 577 int
 578 ACE_POSIX_Proactor::post_wakeup_completions (int how_many)
 579 {
 580   ACE_POSIX_Wakeup_Completion *wakeup_completion = 0;
 581
 582   for (int ci = 0; ci < how_many; ci++)
 583     {
 584       ACE_NEW_RETURN
 585         (wakeup_completion,
 586          ACE_POSIX_Wakeup_Completion (this->wakeup_handler_.proxy ()),
 587          -1);
 588       if (this->post_completion (wakeup_completion) == -1)
 589         return -1;
 590     }
 591
 592   return 0;
 593 }
 594
 595 ACE_POSIX_Proactor::Proactor_Type
 596 ACE_POSIX_Proactor::get_impl_type (void)
 597 {
 598   return PROACTOR_POSIX;
 599 }
 600
 601
 602 /**
 603  * @class ACE_AIOCB_Notify_Pipe_Manager
 604  *
 605  * @brief This class manages the notify pipe of the AIOCB Proactor.
 606  *
 607  * This class acts as the Handler for the
 608  * <Asynch_Read> operations issued on the notify pipe. This
 609  * class is very useful in implementing <Asynch_Accept> operation
 610  * class for the <AIOCB_Proactor>. This is also useful for
 611  * implementing <post_completion> for <AIOCB_Proactor>.
 612
 613  * <AIOCB_Proactor> class issues a <Asynch_Read> on
 614  * the pipe, using this class as the
 615  * Handler. <POSIX_Asynch_Result *>'s are sent through the
 616  * notify pipe. When <POSIX_Asynch_Result *>'s show up on the
 617  * notify pipe, the <POSIX_AIOCB_Proactor> dispatches the
 618  * completion of the <Asynch_Read_Stream> and calls the
 619  * <handle_read_stream> of this class. This class calls
 620  * <complete> on the <POSIX_Asynch_Result *> and thus calls the
 621  * application handler.
 622  * Handling the MessageBlock:
 623  * We give this message block to read the result pointer through
 624  * the notify pipe. We expect that to read 4 bytes from the
 625  * notify pipe, for each <accept> call. Before giving this
 626  * message block to another <accept>, we update <wr_ptr> and put
 627  * it in its initial position.
 628  */
 629 class ACE_AIOCB_Notify_Pipe_Manager : public ACE_Handler
 630 {
 631 public:
 632   /// Constructor. You need the posix proactor because you need to call
 633   /// <application_specific_code>
 634   ACE_AIOCB_Notify_Pipe_Manager (ACE_POSIX_AIOCB_Proactor *posix_aiocb_proactor);
 635
 636   /// Destructor.
 637   virtual ~ACE_AIOCB_Notify_Pipe_Manager (void);
 638
 639   /// Send the result pointer through the notification pipe.
 640   int notify ();
 641
 642   /// This is the call back method when <Asynch_Read> from the pipe is
 643   /// complete.
 644   virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
 645
 646 private:
 647   /// The implementation proactor class.
 648   ACE_POSIX_AIOCB_Proactor  *posix_aiocb_proactor_;
 649
 650   /// Message block to get ACE_POSIX_Asynch_Result pointer from the pipe.
 651   ACE_Message_Block message_block_;
 652
 653   /// Pipe for the communication between Proactor and the
 654   /// Asynch_Accept/Asynch_Connect and other post_completions
 655   ACE_Pipe pipe_;
 656
 657   /// To do asynch_read on the pipe.
 658   ACE_POSIX_Asynch_Read_Stream read_stream_;
 659
 660   /// Default constructor. Shouldnt be called.
 661   ACE_AIOCB_Notify_Pipe_Manager (void);
 662 };
 663
 664 ACE_AIOCB_Notify_Pipe_Manager::ACE_AIOCB_Notify_Pipe_Manager (ACE_POSIX_AIOCB_Proactor *posix_aiocb_proactor)
 665   : posix_aiocb_proactor_ (posix_aiocb_proactor),
 666     message_block_ (sizeof (2)),
 667     read_stream_ (posix_aiocb_proactor)
 668 {
 669   // Open the pipe.
 670   this->pipe_.open ();
 671
 672   // Set write side in NONBLOCK mode
 673   ACE::set_flags (this->pipe_.write_handle (), ACE_NONBLOCK);
 674
 675   // Set read side in BLOCK mode
 676   ACE::clr_flags (this->pipe_.read_handle (), ACE_NONBLOCK);
 677
 678   // Let AIOCB_Proactor know about our handle
 679   posix_aiocb_proactor_->set_notify_handle (this->pipe_.read_handle ());
 680
 681   // Open the read stream.
 682   if (this->read_stream_.open (this->proxy (),
 683                                this->pipe_.read_handle (),
 684                                0, // Completion Key
 685                                0) // Proactor
 686       == -1)
 687     ACE_ERROR ((LM_ERROR,
 688                 "%N:%l:%p\n",
 689                 "ACE_AIOCB_Notify_Pipe_Manager::ACE_AIOCB_Notify_Pipe_Manager:"
 690                 "Open on Read Stream failed"));
 691
 692   // Issue an asynch_read on the read_stream of the notify pipe.
 693   if (this->read_stream_.read (this->message_block_,
 694                                1, // enough to read 1 byte
 695                                0, // ACT
 696                                0) // Priority
 697       == -1)
 698     ACE_ERROR ((LM_ERROR,
 699                 "%N:%l:%p\n",
 700                 "ACE_AIOCB_Notify_Pipe_Manager::ACE_AIOCB_Notify_Pipe_Manager:"
 701                 "Read from pipe failed"));
 702 }
 703
 704 ACE_AIOCB_Notify_Pipe_Manager::~ACE_AIOCB_Notify_Pipe_Manager (void)
 705 {
 706   // 1. try to cancel pending aio
 707   this->read_stream_.cancel ();
 708
 709   // 2. close both handles
 710   // Destuctor of ACE_Pipe does not close handles.
 711   // We can not use ACE_Pipe::close() as it
 712   // closes  read_handle and than write_handle.
 713   // In some systems close() may wait for
 714   // completion for all asynch. pending requests.
 715   // So we should close write_handle firstly
 716   // to force read completion ( if 1. does not help )
 717   // and then read_handle and not vice versa
 718
 719   ACE_HANDLE h = this->pipe_.write_handle ();
 720   if (h != ACE_INVALID_HANDLE)
 721      ACE_OS::closesocket (h);
 722
 723   h = this->pipe_.read_handle ();
 724   if ( h != ACE_INVALID_HANDLE)
 725      ACE_OS::closesocket (h);
 726
 727 }
 728
 729
 730 int
 731 ACE_AIOCB_Notify_Pipe_Manager::notify ()
 732 {
 733   // Send the result pointer through the pipe.
 734   char char_send = 0;
 735   ssize_t ret_val = ACE::send (this->pipe_.write_handle (),
 736                                &char_send,
 737                                sizeof (char_send));
 738
 739   if (ret_val < 0)
 740     {
 741       if (errno != EWOULDBLOCK)
 742 #if 0
 743         ACE_ERROR ((LM_ERROR,
 744                     ACE_TEXT ("(%P %t):%p\n"),
 745                     ACE_TEXT ("ACE_AIOCB_Notify_Pipe_Manager::notify")
 746                     ACE_TEXT ("Error:Writing on to notify pipe failed")));
 747 #endif /* 0 */
 748       return -1;
 749     }
 750
 751   return 0;
 752 }
 753
 754 void
 755 ACE_AIOCB_Notify_Pipe_Manager::handle_read_stream
 756   (const ACE_Asynch_Read_Stream::Result & /*result*/)
 757 {
 758   // 1. Start new read to avoid pipe overflow
 759
 760   // Set the message block properly. Put the <wr_ptr> back in the
 761   // initial position.
 762   if (this->message_block_.length () > 0)
 763       this->message_block_.wr_ptr (this->message_block_.rd_ptr ());
 764
 765   // One accept has completed. Issue a read to handle any
 766   // <post_completion>s in the future.
 767   if (-1 == this->read_stream_.read (this->message_block_,
 768                                      1,   // enough to read 1 byte
 769                                      0,   // ACT
 770                                      0))  // Priority
 771     ACE_ERROR ((LM_ERROR,
 772                 ACE_TEXT ("%N:%l:(%P | %t):%p\n"),
 773                 ACE_TEXT ("ACE_AIOCB_Notify_Pipe_Manager::handle_read_stream:")
 774                 ACE_TEXT ("Read from pipe failed")));
 775
 776
 777   // 2. Do the upcalls
 778   // this->posix_aiocb_proactor_->process_result_queue ();
 779 }
 780
 781 // Public constructor for common use.
 782 ACE_POSIX_AIOCB_Proactor::ACE_POSIX_AIOCB_Proactor (size_t max_aio_operations)
 783   : aiocb_notify_pipe_manager_ (0),
 784     aiocb_list_ (0),
 785     result_list_ (0),
 786     aiocb_list_max_size_ (max_aio_operations),
 787     aiocb_list_cur_size_ (0),
 788     notify_pipe_read_handle_ (ACE_INVALID_HANDLE),
 789     num_deferred_aiocb_ (0),
 790     num_started_aio_ (0)
 791 {
 792   // Check for correct value for max_aio_operations
 793   check_max_aio_num ();
 794
 795   this->create_result_aiocb_list ();
 796
 797   this->create_notify_manager ();
 798
 799   // start pseudo-asynchronous accept task
 800   // one per all future acceptors
 801   this->get_asynch_pseudo_task().start ();
 802
 803 }
 804
 805 // Special protected constructor for ACE_SUN_Proactor
 806 ACE_POSIX_AIOCB_Proactor::ACE_POSIX_AIOCB_Proactor (size_t max_aio_operations,
 807                                                     ACE_POSIX_Proactor::Proactor_Type)
 808   : aiocb_notify_pipe_manager_ (0),
 809     aiocb_list_ (0),
 810     result_list_ (0),
 811     aiocb_list_max_size_ (max_aio_operations),
 812     aiocb_list_cur_size_ (0),
 813     notify_pipe_read_handle_ (ACE_INVALID_HANDLE),
 814     num_deferred_aiocb_ (0),
 815     num_started_aio_ (0)
 816 {
 817   //check for correct value for max_aio_operations
 818   this->check_max_aio_num ();
 819
 820   this->create_result_aiocb_list ();
 821
 822   // @@ We should create Notify_Pipe_Manager in the derived class to
 823   // provide correct calls for virtual functions !!!
 824 }
 825
 826 // Destructor.
 827 ACE_POSIX_AIOCB_Proactor::~ACE_POSIX_AIOCB_Proactor (void)
 828 {
 829   this->close();
 830 }
 831
 832 ACE_POSIX_Proactor::Proactor_Type
 833 ACE_POSIX_AIOCB_Proactor::get_impl_type (void)
 834 {
 835   return PROACTOR_AIOCB;
 836 }
 837
 838
 839 int
 840 ACE_POSIX_AIOCB_Proactor::close (void)
 841 {
 842   // stop asynch accept task
 843   this->get_asynch_pseudo_task().stop ();
 844
 845   this->delete_notify_manager ();
 846
 847   this->clear_result_queue ();
 848
 849   return this->delete_result_aiocb_list ();
 850 }
 851
 852 void ACE_POSIX_AIOCB_Proactor::set_notify_handle (ACE_HANDLE h)
 853 {
 854   notify_pipe_read_handle_ = h;
 855 }
 856
 857 int ACE_POSIX_AIOCB_Proactor::create_result_aiocb_list (void)
 858 {
 859   if (aiocb_list_ != 0)
 860     return 0;
 861
 862   ACE_NEW_RETURN (aiocb_list_, aiocb *[aiocb_list_max_size_], -1);
 863
 864   ACE_NEW_RETURN (result_list_,
 865                   ACE_POSIX_Asynch_Result *[aiocb_list_max_size_],
 866                   -1);
 867
 868   // Initialize the array.
 869   for (size_t ai = 0; ai < this->aiocb_list_max_size_; ai++)
 870     {
 871       aiocb_list_[ai] = 0;
 872       result_list_[ai] = 0;
 873     }
 874
 875   return 0;
 876 }
 877
 878 int ACE_POSIX_AIOCB_Proactor::delete_result_aiocb_list (void)
 879 {
 880   if (aiocb_list_ == 0)  // already deleted
 881     return 0;
 882
 883   size_t ai;
 884
 885   // Try to cancel all uncompleted operations; POSIX systems may have
 886   // hidden system threads that still can work with our aiocbs!
 887   for (ai = 0; ai < aiocb_list_max_size_; ai++)
 888     if (this->aiocb_list_[ai] != 0)  // active operation
 889       this->cancel_aiocb (result_list_[ai]);
 890
 891   int num_pending = 0;
 892
 893   for (ai = 0; ai < aiocb_list_max_size_; ai++)
 894     {
 895       if (this->aiocb_list_[ai] == 0 ) //  not active operation
 896         continue;
 897
 898       // Get the error and return status of the aio_ operation.
 899       int error_status  = 0;
 900       size_t transfer_count = 0;
 901       int flg_completed = this->get_result_status (result_list_[ai],
 902                                                    error_status,
 903                                                    transfer_count);
 904
 905       //don't delete uncompleted AIOCB's
 906       if (flg_completed == 0)  // not completed !!!
 907         {
 908           num_pending++;
 909 #if 0
 910           char * errtxt = ACE_OS::strerror (error_status);
 911           if (errtxt == 0)
 912               errtxt ="?????????";
 913
 914           char * op = (aiocb_list_[ai]->aio_lio_opcode == LIO_WRITE )?
 915             "WRITE":"READ" ;
 916
 917
 918           ACE_ERROR ((LM_ERROR,
 919                       ACE_TEXT("slot=%d op=%s status=%d xfercnt=%d %s\n"),
 920                       ai,
 921                       op,
 922                       error_status,
 923                       transfer_count,
 924                       errtxt));
 925 #endif /* 0 */
 926         }
 927       else // completed , OK
 928         {
 929           delete this->result_list_[ai];
 930           this->result_list_[ai] = 0;
 931           this->aiocb_list_[ai] = 0;
 932         }
 933     }
 934
 935   // If it is not possible cancel some operation (num_pending > 0 ),
 936   // we can do only one thing -report about this
 937   // and complain about POSIX implementation.
 938   // We know that we have memory leaks, but it is better than
 939   // segmentation fault!
 940   ACE_DEBUG
 941     ((LM_DEBUG,
 942       ACE_TEXT("ACE_POSIX_AIOCB_Proactor::delete_result_aiocb_list\n")
 943       ACE_TEXT(" number pending AIO=%d\n"),
 944       num_pending));
 945
 946   delete [] this->aiocb_list_;
 947   this->aiocb_list_ = 0;
 948
 949   delete [] this->result_list_;
 950   this->result_list_ = 0;
 951
 952   return (num_pending == 0 ? 0 : -1);
 953   // ?? or just always return 0;
 954 }
 955
 956 void ACE_POSIX_AIOCB_Proactor::check_max_aio_num ()
 957 {
 958   long max_os_aio_num = ACE_OS::sysconf (_SC_AIO_MAX);
 959
 960   // Define max limit AIO's for concrete OS
 961   // -1 means that there is no limit, but it is not true
 962   // (example, SunOS 5.6)
 963
 964   if (max_os_aio_num > 0 &&
 965       aiocb_list_max_size_ > (unsigned long) max_os_aio_num)
 966      aiocb_list_max_size_ = max_os_aio_num;
 967
 968 #if defined (HPUX) || defined (__FreeBSD__)
 969   // Although HPUX 11.00 allows to start 2048 AIO's for all process in
 970   // system it has a limit 256 max elements for aio_suspend () It is a
 971   // pity, but ...
 972
 973   long max_os_listio_num = ACE_OS::sysconf (_SC_AIO_LISTIO_MAX);
 974   if (max_os_listio_num > 0
 975       && aiocb_list_max_size_ > (unsigned long) max_os_listio_num)
 976     aiocb_list_max_size_ = max_os_listio_num;
 977 #endif /* HPUX || __FreeBSD__ */
 978
 979   // check for user-defined value
 980   // ACE_AIO_MAX_SIZE if defined in POSIX_Proactor.h
 981
 982   if (aiocb_list_max_size_ <= 0
 983      || aiocb_list_max_size_ > ACE_AIO_MAX_SIZE)
 984      aiocb_list_max_size_ = ACE_AIO_MAX_SIZE;
 985
 986   // check for max number files to open
 987
 988   int max_num_files = ACE::max_handles ();
 989
 990   if (max_num_files > 0
 991       && aiocb_list_max_size_ > (unsigned long) max_num_files)
 992     {
 993       ACE::set_handle_limit (aiocb_list_max_size_);
 994
 995       max_num_files = ACE::max_handles ();
 996     }
 997
 998   if (max_num_files > 0
 999       && aiocb_list_max_size_ > (unsigned long) max_num_files)
1000     aiocb_list_max_size_ = (unsigned long) max_num_files;
1001
1002   ACE_DEBUG ((LM_DEBUG,
1003              "(%P | %t) ACE_POSIX_AIOCB_Proactor::Max Number of AIOs=%d\n",
1004               aiocb_list_max_size_));
1005
1006 #if defined(__sgi)
1007
1008    ACE_DEBUG((LM_DEBUG,
1009               ACE_TEXT( "SGI IRIX specific: aio_init!\n")));
1010
1011 //typedef struct aioinit {
1012 //    int aio_threads;  /* The number of aio threads to start (5) */
1013 //    int aio_locks;    /* Initial number of preallocated locks (3) */
1014 //    int aio_num;      /* estimated total simultanious aiobc structs (1000) */
1015 //    int aio_usedba;   /* Try to use DBA for raw I/O in lio_listio (0) */
1016 //    int aio_debug;    /* turn on debugging (0) */
1017 //    int aio_numusers; /* max number of user sprocs making aio_* calls (5) */
1018 //    int aio_reserved[3];
1019 //} aioinit_t;
1020
1021     aioinit_t  aioinit;
1022
1023     aioinit.aio_threads = 10; /* The number of aio threads to start (5) */
1024     aioinit.aio_locks = 20;   /* Initial number of preallocated locks (3) */
1025                        /* estimated total simultaneous aiobc structs (1000) */
1026     aioinit.aio_num = aiocb_list_max_size_;
1027     aioinit.aio_usedba = 0;   /* Try to use DBA for raw IO in lio_listio (0) */
1028     aioinit.aio_debug = 0;    /* turn on debugging (0) */
1029     aioinit.aio_numusers = 100; /* max number of user sprocs making aio_* calls (5) */
1030     aioinit.aio_reserved[0] = 0;
1031     aioinit.aio_reserved[1] = 0;
1032     aioinit.aio_reserved[2] = 0;
1033
1034     aio_sgi_init (&aioinit);
1035
1036 #endif
1037
1038     return;
1039 }
1040
1041 void
1042 ACE_POSIX_AIOCB_Proactor::create_notify_manager (void)
1043 {
1044   // Remember! this issues a Asynch_Read
1045   // on the notify pipe for doing the Asynch_Accept/Connect.
1046
1047   if (aiocb_notify_pipe_manager_ == 0)
1048     ACE_NEW (aiocb_notify_pipe_manager_,
1049              ACE_AIOCB_Notify_Pipe_Manager (this));
1050 }
1051
1052 void
1053 ACE_POSIX_AIOCB_Proactor::delete_notify_manager (void)
1054 {
1055   // We are responsible for delete as all pointers set to 0 after
1056   // delete, it is save to delete twice
1057
1058   delete aiocb_notify_pipe_manager_;
1059   aiocb_notify_pipe_manager_ = 0;
1060 }
1061
1062 int
1063 ACE_POSIX_AIOCB_Proactor::handle_events (ACE_Time_Value &wait_time)
1064 {
1065   // Decrement <wait_time> with the amount of time spent in the method
1066   ACE_Countdown_Time countdown (&wait_time);
1067   return this->handle_events_i (wait_time.msec ());
1068 }
1069
1070 int
1071 ACE_POSIX_AIOCB_Proactor::handle_events (void)
1072 {
1073   return this->handle_events_i (ACE_INFINITE);
1074 }
1075
1076 int
1077 ACE_POSIX_AIOCB_Proactor::notify_completion(int  sig_num)
1078 {
1079   ACE_UNUSED_ARG (sig_num);
1080
1081   return this->aiocb_notify_pipe_manager_->notify ();
1082 }
1083
1084 int
1085 ACE_POSIX_AIOCB_Proactor::post_completion (ACE_POSIX_Asynch_Result *result)
1086 {
1087   ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1));
1088
1089   int ret_val = this->putq_result (result);
1090
1091   return ret_val;
1092 }
1093
1094 int
1095 ACE_POSIX_AIOCB_Proactor::putq_result (ACE_POSIX_Asynch_Result *result)
1096 {
1097   // this protected method should be called with locked mutex_
1098   // we can't use GUARD as Proactor uses non-recursive mutex
1099
1100   if (!result)
1101     return -1;
1102
1103   int sig_num = result->signal_number ();
1104   int ret_val = this->result_queue_.enqueue_tail (result);
1105
1106   if (ret_val == -1)
1107     ACE_ERROR_RETURN ((LM_ERROR,
1108                        "%N:%l:ACE_POSIX_AIOCB_Proactor::putq_result failed\n"),
1109                       -1);
1110
1111   this->notify_completion (sig_num);
1112
1113   return 0;
1114 }
1115
1116 ACE_POSIX_Asynch_Result * ACE_POSIX_AIOCB_Proactor::getq_result (void)
1117 {
1118   ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, 0));
1119
1120
1121   ACE_POSIX_Asynch_Result* result = 0;
1122
1123   if (this->result_queue_.dequeue_head (result) != 0)
1124     return 0;
1125
1126 //  don't waste time if queue is empty - it is normal
1127 //  or check queue size before dequeue_head
1128 //    ACE_ERROR_RETURN ((LM_ERROR,
1129 //                       "%N:%l:(%P | %t):%p\n",
1130 //                       "ACE_POSIX_AIOCB_Proactor::getq_result failed"),
1131 //                      0);
1132
1133   return result;
1134 }
1135
1136 int ACE_POSIX_AIOCB_Proactor::clear_result_queue (void)
1137 {
1138   int ret_val = 0;
1139   ACE_POSIX_Asynch_Result* result = 0;
1140
1141   while ((result = this->getq_result ()) != 0)
1142     {
1143       delete result;
1144       ret_val++;
1145     }
1146
1147   return ret_val;
1148 }
1149
1150 int ACE_POSIX_AIOCB_Proactor::process_result_queue (void)
1151 {
1152   int ret_val = 0;
1153   ACE_POSIX_Asynch_Result* result = 0;
1154
1155   while ((result = this->getq_result ()) != 0)
1156     {
1157       this->application_specific_code
1158             (result,
1159              result->bytes_transferred(), // 0, No bytes transferred.
1160              0,  // No completion key.
1161              result->error());   //0, No error.
1162
1163       ret_val++;
1164     }
1165
1166   return ret_val;
1167 }
1168
1169 int
1170 ACE_POSIX_AIOCB_Proactor::handle_events_i (u_long milli_seconds)
1171 {
1172   int result_suspend = 0;
1173   int retval= 0;
1174
1175   if (milli_seconds == ACE_INFINITE)
1176     // Indefinite blocking.
1177     result_suspend = aio_suspend (aiocb_list_,
1178                                   aiocb_list_max_size_,
1179                                   0);
1180   else
1181     {
1182       // Block on <aio_suspend> for <milli_seconds>
1183       timespec timeout;
1184       timeout.tv_sec = milli_seconds / 1000;
1185       timeout.tv_nsec = (milli_seconds - (timeout.tv_sec * 1000)) * 1000000;
1186       result_suspend = aio_suspend (aiocb_list_,
1187                                     aiocb_list_max_size_,
1188                                     &timeout);
1189     }
1190
1191   // Check for errors
1192   if (result_suspend == -1)
1193     {
1194       if (errno != EAGAIN &&   // Timeout
1195           errno != EINTR )    // Interrupted call
1196           ACE_ERROR ((LM_ERROR,
1197                       ACE_TEXT ("%N:%l:(%P|%t)::%p\n"),
1198                       ACE_TEXT ("handle_events: aio_suspend failed")));
1199       // let continue work
1200       // we should check "post_completed" queue
1201     }
1202   else
1203     {
1204       size_t index = 0;
1205       size_t count = aiocb_list_max_size_;  // max number to iterate
1206       int error_status = 0;
1207       size_t transfer_count = 0;
1208
1209       for (;; retval++)
1210         {
1211           ACE_POSIX_Asynch_Result *asynch_result =
1212             find_completed_aio (error_status,
1213                                 transfer_count,
1214                                 index,
1215                                 count);
1216
1217           if (asynch_result == 0)
1218             break;
1219
1220           // Call the application code.
1221           this->application_specific_code (asynch_result,
1222                                            transfer_count,
1223                                            0,             // No completion key.
1224                                            error_status);
1225         }
1226     }
1227
1228   // process post_completed results
1229   retval += this->process_result_queue ();
1230
1231   return retval > 0 ? 1 : 0;
1232 }
1233
1234 int
1235 ACE_POSIX_AIOCB_Proactor::get_result_status (ACE_POSIX_Asynch_Result *asynch_result,
1236                                              int &error_status,
1237                                              size_t &transfer_count)
1238 {
1239   transfer_count = 0;
1240
1241   // Get the error status of the aio_ operation.
1242   error_status  = aio_error (asynch_result);
1243   if (error_status == EINPROGRESS)
1244     return 0;  // not completed
1245
1246   ssize_t op_return = aio_return (asynch_result);
1247   if (op_return > 0)
1248     transfer_count = static_cast<size_t> (op_return);
1249   // else transfer_count is already 0, error_status reports the error.
1250   return 1; // completed
1251 }
1252
1253 ACE_POSIX_Asynch_Result *
1254 ACE_POSIX_AIOCB_Proactor::find_completed_aio (int &error_status,
1255                                               size_t &transfer_count,
1256                                               size_t &index,
1257                                               size_t &count)
1258 {
1259   // parameter index defines initial slot to scan
1260   // parameter count tells us how many slots should we scan
1261
1262   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->mutex_, 0));
1263
1264   ACE_POSIX_Asynch_Result *asynch_result = 0;
1265
1266   if (num_started_aio_ == 0)  // save time
1267     return 0;
1268
1269   for (; count > 0; index++ , count--)
1270     {
1271       if (index >= aiocb_list_max_size_) // like a wheel
1272         index = 0;
1273
1274       if (aiocb_list_[index] == 0) // Dont process null blocks.
1275         continue;
1276
1277       if (0 != this->get_result_status (result_list_[index],
1278                                         error_status,
1279                                         transfer_count))  // completed
1280         break;
1281
1282     } // end for
1283
1284   if (count == 0) // all processed , nothing found
1285     return 0;
1286   asynch_result = result_list_[index];
1287
1288   aiocb_list_[index] = 0;
1289   result_list_[index] = 0;
1290   aiocb_list_cur_size_--;
1291
1292   num_started_aio_--;  // decrement count active aios
1293   index++;             // for next iteration
1294   count--;             // for next iteration
1295
1296   this->start_deferred_aio ();
1297   //make attempt to start deferred AIO
1298   //It is safe as we are protected by mutex_
1299
1300   return asynch_result;
1301 }
1302
1303
1304 int
1305 ACE_POSIX_AIOCB_Proactor::start_aio (ACE_POSIX_Asynch_Result *result,
1306                                      ACE_POSIX_Proactor::Opcode op)
1307 {
1308   ACE_TRACE ("ACE_POSIX_AIOCB_Proactor::start_aio");
1309
1310   ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->mutex_, -1));
1311
1312   int ret_val = (aiocb_list_cur_size_ >= aiocb_list_max_size_) ? -1 : 0;
1313
1314   if (result == 0) // Just check the status of the list
1315     return ret_val;
1316
1317   // Save operation code in the aiocb
1318   switch (op)
1319     {
1320     case ACE_POSIX_Proactor::ACE_OPCODE_READ:
1321       result->aio_lio_opcode = LIO_READ;
1322       break;
1323
1324     case ACE_POSIX_Proactor::ACE_OPCODE_WRITE:
1325       result->aio_lio_opcode = LIO_WRITE;
1326       break;
1327
1328     default:
1329       ACE_ERROR_RETURN ((LM_ERROR,
1330                          ACE_TEXT ("%N:%l:(%P|%t)::")
1331                          ACE_TEXT ("start_aio: Invalid op code %d\n"),
1332                          op),
1333                         -1);
1334     }
1335
1336   if (ret_val != 0)   // No free slot
1337     {
1338       errno = EAGAIN;
1339       return -1;
1340     }
1341
1342   // Find a free slot and store.
1343
1344   ssize_t slot = allocate_aio_slot (result);
1345
1346   if (slot < 0)
1347     return -1;
1348
1349   size_t index = static_cast<size_t> (slot);
1350
1351   result_list_[index] = result;   //Store result ptr anyway
1352   aiocb_list_cur_size_++;
1353
1354   ret_val = start_aio_i (result);
1355   switch (ret_val)
1356     {
1357     case 0:     // started OK
1358       aiocb_list_[index] = result;
1359       return 0;
1360
1361     case 1:     // OS AIO queue overflow
1362       num_deferred_aiocb_ ++;
1363       return 0;
1364
1365     default:    // Invalid request, there is no point
1366       break;    // to start it later
1367     }
1368
1369   result_list_[index] = 0;
1370   aiocb_list_cur_size_--;
1371   return -1;
1372 }
1373
1374 ssize_t
1375 ACE_POSIX_AIOCB_Proactor::allocate_aio_slot (ACE_POSIX_Asynch_Result *result)
1376 {
1377   size_t i = 0;
1378
1379   // we reserve zero slot for ACE_AIOCB_Notify_Pipe_Manager
1380   // so make check for ACE_AIOCB_Notify_Pipe_Manager request
1381
1382   if (notify_pipe_read_handle_ == result->aio_fildes) // Notify_Pipe ?
1383     {                                       // should be free,
1384       if (result_list_[i] != 0)           // only 1 request
1385         {                                   // is allowed
1386           errno   = EAGAIN;
1387           ACE_ERROR_RETURN ((LM_ERROR,
1388                      "%N:%l:(%P | %t)::\n"
1389                      "ACE_POSIX_AIOCB_Proactor::allocate_aio_slot:"
1390                      "internal Proactor error 0\n"),
1391                      -1);
1392         }
1393     }
1394   else  //try to find free slot as usual, but starting from 1
1395     {
1396       for (i= 1; i < this->aiocb_list_max_size_; i++)
1397         if (result_list_[i] == 0)
1398           break;
1399     }
1400
1401   if (i >= this->aiocb_list_max_size_)
1402     ACE_ERROR_RETURN ((LM_ERROR,
1403               "%N:%l:(%P | %t)::\n"
1404               "ACE_POSIX_AIOCB_Proactor::allocate_aio_slot:"
1405               "internal Proactor error 1\n"),
1406               -1);
1407
1408   //setup OS notification methods for this aio
1409   result->aio_sigevent.sigev_notify = SIGEV_NONE;
1410
1411   return static_cast<ssize_t> (i);
1412 }
1413
1414 // start_aio_i  has new return codes
1415 //     0    AIO was started successfully
1416 //     1    AIO was not started, OS AIO queue overflow
1417 //     -1   AIO was not started, other errors
1418
1419 int
1420 ACE_POSIX_AIOCB_Proactor::start_aio_i (ACE_POSIX_Asynch_Result *result)
1421 {
1422   ACE_TRACE ("ACE_POSIX_AIOCB_Proactor::start_aio_i");
1423
1424   int ret_val;
1425   const ACE_TCHAR *ptype = 0;
1426
1427   // Start IO
1428
1429   switch (result->aio_lio_opcode )
1430     {
1431     case LIO_READ :
1432       ptype = ACE_TEXT ("read ");
1433       ret_val = aio_read (result);
1434       break;
1435     case LIO_WRITE :
1436       ptype = ACE_TEXT ("write");
1437       ret_val = aio_write (result);
1438       break;
1439     default:
1440       ptype = ACE_TEXT ("?????");
1441       ret_val = -1;
1442       break;
1443     }
1444
1445   if (ret_val == 0)
1446     {
1447       ++this->num_started_aio_;
1448     }
1449   else // if (ret_val == -1)
1450     {
1451       if (errno == EAGAIN || errno == ENOMEM)  //Ok, it will be deferred AIO
1452         ret_val = 1;
1453       else
1454         ACE_ERROR ((LM_ERROR,
1455                     ACE_TEXT ("%N:%l:(%P | %t)::start_aio_i: aio_%s %p\n"),
1456                     ptype,
1457                     ACE_TEXT ("queueing failed")));
1458     }
1459
1460   return ret_val;
1461 }
1462
1463
1464 int
1465 ACE_POSIX_AIOCB_Proactor::start_deferred_aio ()
1466 {
1467   ACE_TRACE ("ACE_POSIX_AIOCB_Proactor::start_deferred_aio");
1468
1469   // This protected method is called from
1470   // find_completed_aio after any AIO completion
1471   // We should call this method always with locked
1472   // ACE_POSIX_AIOCB_Proactor::mutex_
1473   //
1474   // It tries to start the first deferred AIO
1475   // if such exists
1476
1477   if (num_deferred_aiocb_ == 0)
1478     return 0;  //  nothing to do
1479
1480   size_t i = 0;
1481
1482   for (i= 0; i < this->aiocb_list_max_size_; i++)
1483     if (result_list_[i] !=0       // check for
1484        && aiocb_list_[i]  ==0)     // deferred AIO
1485       break;
1486
1487   if (i >= this->aiocb_list_max_size_)
1488     ACE_ERROR_RETURN ((LM_ERROR,
1489                  "%N:%l:(%P | %t)::\n"
1490                  "start_deferred_aio:"
1491                  "internal Proactor error 3\n"),
1492                  -1);
1493
1494   ACE_POSIX_Asynch_Result *result = result_list_[i];
1495
1496   int ret_val = start_aio_i (result);
1497
1498   switch (ret_val)
1499     {
1500     case 0 :    //started OK , decrement count of deferred AIOs
1501       aiocb_list_[i] = result;
1502       num_deferred_aiocb_ --;
1503       return 0;
1504
1505     case 1 :
1506       return 0;  //try again later
1507
1508     default :     // Invalid Parameters , should never be
1509       break;
1510     }
1511
1512   //AL notify  user
1513
1514   result_list_[i] = 0;
1515   --aiocb_list_cur_size_;
1516
1517   --num_deferred_aiocb_;
1518
1519   result->set_error (errno);
1520   result->set_bytes_transferred (0);
1521   this->putq_result (result);  // we are with locked mutex_ here !
1522
1523   return -1;
1524 }
1525
1526 int
1527 ACE_POSIX_AIOCB_Proactor::cancel_aio (ACE_HANDLE handle)
1528 {
1529   // This new method should be called from
1530   // ACE_POSIX_Asynch_Operation instead of usual ::aio_cancel
1531   // It scans the result_list_ and defines all AIO requests
1532   // that were issued for handle "handle"
1533   //
1534   // For all deferred AIO requests with handle "handle"
1535   // it removes its from the lists and notifies user
1536   //
1537   // For all running AIO requests with handle "handle"
1538   // it calls ::aio_cancel. According to the POSIX standards
1539   // we will receive ECANCELED  for all ::aio_canceled AIO requests
1540   // later on return from ::aio_suspend
1541
1542   ACE_TRACE ("ACE_POSIX_AIOCB_Proactor::cancel_aio");
1543
1544   int    num_total     = 0;
1545   int    num_cancelled = 0;
1546
1547   {
1548     ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->mutex_, -1));
1549
1550     size_t ai = 0;
1551
1552     for (ai = 0; ai < this->aiocb_list_max_size_; ai++)
1553       {
1554         if (this->result_list_[ai] == 0)    // Skip empty slot
1555           continue;
1556
1557         if (this->result_list_[ai]->aio_fildes != handle)  // Not ours
1558           continue;
1559
1560         ++num_total;
1561
1562         ACE_POSIX_Asynch_Result *asynch_result = this->result_list_[ai];
1563
1564         if (this->aiocb_list_[ai] == 0)  // Canceling a deferred operation
1565           {
1566             num_cancelled++;
1567             this->num_deferred_aiocb_--;
1568
1569             this->aiocb_list_[ai] = 0;
1570             this->result_list_[ai] = 0;
1571             this->aiocb_list_cur_size_--;
1572
1573             asynch_result->set_error (ECANCELED);
1574             asynch_result->set_bytes_transferred (0);
1575             this->putq_result (asynch_result);
1576             // we are with locked mutex_ here !
1577           }
1578         else      // Cancel started aio
1579           {
1580             int rc_cancel = this->cancel_aiocb (asynch_result);
1581
1582             if (rc_cancel == 0)    //notification in the future
1583               num_cancelled++;     //it is OS responsiblity
1584           }
1585       }
1586
1587   } // release mutex_
1588
1589   if (num_total == 0)
1590     return 1;  // ALLDONE
1591
1592   if (num_cancelled == num_total)
1593     return 0;  // CANCELLED
1594
1595   return 2; // NOT CANCELLED
1596 }
1597
1598 int
1599 ACE_POSIX_AIOCB_Proactor::cancel_aiocb (ACE_POSIX_Asynch_Result * result)
1600 {
1601   // This method is called from cancel_aio
1602   // to cancel a previously submitted AIO request
1603   int rc = ::aio_cancel (0, result);
1604
1605   // Check the return value and return 0/1/2 appropriately.
1606   if (rc == AIO_CANCELED)
1607     return 0;
1608   else if (rc == AIO_ALLDONE)
1609     return 1;
1610   else // (rc == AIO_NOTCANCELED)
1611     return 2;
1612 }
1613
1614
1615 // *********************************************************************
1616
1617 #if defined(ACE_HAS_POSIX_REALTIME_SIGNALS)
1618
1619 ACE_POSIX_SIG_Proactor::ACE_POSIX_SIG_Proactor (size_t max_aio_operations)
1620   :  ACE_POSIX_AIOCB_Proactor (max_aio_operations,
1621                                ACE_POSIX_Proactor::PROACTOR_SIG)
1622 {
1623   // = Set up the mask we'll use to block waiting for SIGRTMIN. Use that
1624   // to add it to the signal mask for this thread, and also set the process
1625   // signal action to pass signal information when we want it.
1626
1627   // Clear the signal set.
1628   ACE_OS::sigemptyset (&this->RT_completion_signals_);
1629
1630   // Add the signal number to the signal set.
1631   if (ACE_OS::sigaddset (&this->RT_completion_signals_, ACE_SIGRTMIN) == -1)
1632     ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_POSIX_SIG_Proactor: %p\n"),
1633                 ACE_TEXT ("sigaddset")));
1634   this->block_signals ();
1635   // Set up the signal action for SIGRTMIN.
1636   this->setup_signal_handler (ACE_SIGRTMIN);
1637
1638   // we do not have to create notify manager
1639   // but we should start pseudo-asynchronous accept task
1640   // one per all future acceptors
1641
1642   this->get_asynch_pseudo_task().start ();
1643   return;
1644 }
1645
1646 ACE_POSIX_SIG_Proactor::ACE_POSIX_SIG_Proactor (const sigset_t signal_set,
1647                                                 size_t max_aio_operations)
1648   :  ACE_POSIX_AIOCB_Proactor (max_aio_operations,
1649                                ACE_POSIX_Proactor::PROACTOR_SIG)
1650 {
1651   // = Keep <Signal_set> with the Proactor, mask all the signals and
1652   //   setup signal actions for the signals in the <signal_set>.
1653
1654   // = Keep <signal_set> with the Proactor.
1655
1656   // Empty the signal set first.
1657   if (sigemptyset (&this->RT_completion_signals_) == -1)
1658     ACE_ERROR ((LM_ERROR,
1659                 "Error:(%P | %t):%p\n",
1660                 "sigemptyset failed"));
1661
1662   // For each signal number present in the <signal_set>, add it to
1663   // the signal set we use, and also set up its process signal action
1664   // to allow signal info to be passed into sigwait/sigtimedwait.
1665   int member = 0;
1666   for (int si = ACE_SIGRTMIN; si <= ACE_SIGRTMAX; si++)
1667     {
1668       member = sigismember (&signal_set,
1669                             si);
1670       if (member == -1)
1671         ACE_ERROR ((LM_ERROR,
1672                     "%N:%l:(%P | %t)::%p\n",
1673                     "ACE_POSIX_SIG_Proactor::ACE_POSIX_SIG_Proactor:"
1674                     "sigismember failed"));
1675       else if (member == 1)
1676         {
1677           sigaddset (&this->RT_completion_signals_, si);
1678           this->setup_signal_handler (si);
1679         }
1680     }
1681
1682   // Mask all the signals.
1683   this->block_signals ();
1684
1685   // we do not have to create notify manager
1686   // but we should start pseudo-asynchronous accept task
1687   // one per all future acceptors
1688
1689   this->get_asynch_pseudo_task().start ();
1690   return;
1691 }
1692
1693 ACE_POSIX_SIG_Proactor::~ACE_POSIX_SIG_Proactor (void)
1694 {
1695   this->close ();
1696
1697   // @@ Enable the masked signals again.
1698 }
1699
1700 ACE_POSIX_Proactor::Proactor_Type
1701 ACE_POSIX_SIG_Proactor::get_impl_type (void)
1702 {
1703   return PROACTOR_SIG;
1704 }
1705
1706 int
1707 ACE_POSIX_SIG_Proactor::handle_events (ACE_Time_Value &wait_time)
1708 {
1709   // Decrement <wait_time> with the amount of time spent in the method
1710   ACE_Countdown_Time countdown (&wait_time);
1711   return this->handle_events_i (&wait_time);
1712 }
1713
1714 int
1715 ACE_POSIX_SIG_Proactor::handle_events (void)
1716 {
1717   return this->handle_events_i (0);
1718 }
1719
1720 int
1721 ACE_POSIX_SIG_Proactor::notify_completion (int sig_num)
1722 {
1723   // Get this process id.
1724   pid_t const pid = ACE_OS::getpid ();
1725   if (pid == (pid_t) -1)
1726     ACE_ERROR_RETURN ((LM_ERROR,
1727                        "Error:%N:%l(%P | %t):%p",
1728                        "<getpid> failed"),
1729                       -1);
1730
1731   // Set the signal information.
1732   sigval value;
1733 #if defined (ACE_HAS_SIGVAL_SIGVAL_INT)
1734   value.sigval_int = -1;
1735 #else
1736   value.sival_int = -1;
1737 #endif /* ACE_HAS_SIGVAL_SIGVAL_INT */
1738
1739   // Queue the signal.
1740   if (sigqueue (pid, sig_num, value) == 0)
1741     return 0;
1742
1743   if (errno != EAGAIN)
1744     ACE_ERROR_RETURN ((LM_ERROR,
1745                        "Error:%N:%l:(%P | %t):%p\n",
1746                        "<sigqueue> failed"),
1747                       -1);
1748   return -1;
1749 }
1750
1751 ACE_Asynch_Result_Impl *
1752 ACE_POSIX_SIG_Proactor::create_asynch_timer
1753   (const ACE_Handler::Proxy_Ptr &handler_proxy,
1754    const void *act,
1755    const ACE_Time_Value &tv,
1756    ACE_HANDLE event,
1757    int priority,
1758    int signal_number)
1759 {
1760   int is_member = 0;
1761
1762   // Fix the signal number.
1763   if (signal_number == -1)
1764     {
1765       int si;
1766       for (si = ACE_SIGRTMAX;
1767            (is_member == 0) && (si >= ACE_SIGRTMIN);
1768            si--)
1769         {
1770           is_member = sigismember (&this->RT_completion_signals_,
1771                                    si);
1772           if (is_member == -1)
1773             ACE_ERROR_RETURN ((LM_ERROR,
1774                                "%N:%l:(%P | %t)::%s\n",
1775                                "ACE_POSIX_SIG_Proactor::create_asynch_timer:"
1776                                "sigismember failed"),
1777                               0);
1778         }
1779
1780       if (is_member == 0)
1781         ACE_ERROR_RETURN ((LM_ERROR,
1782                            "Error:%N:%l:(%P | %t)::%s\n",
1783                            "ACE_POSIX_SIG_Proactor::ACE_POSIX_SIG_Proactor:"
1784                            "Signal mask set empty"),
1785                           0);
1786       else
1787         // + 1 to nullify loop increment.
1788         signal_number = si + 1;
1789     }
1790
1791   ACE_Asynch_Result_Impl *implementation;
1792   ACE_NEW_RETURN (implementation,
1793                   ACE_POSIX_Asynch_Timer (handler_proxy,
1794                                           act,
1795                                           tv,
1796                                           event,
1797                                           priority,
1798                                           signal_number),
1799                   0);
1800   return implementation;
1801 }
1802
1803 #if 0
1804 static void
1805 sig_handler (int sig_num, siginfo_t *, ucontext_t *)
1806 {
1807   // Should never be called
1808   ACE_DEBUG ((LM_DEBUG,
1809               "%N:%l:(%P | %t)::sig_handler received signal: %d\n",
1810                sig_num));
1811 }
1812 #endif /*if 0*/
1813
1814 int
1815 ACE_POSIX_SIG_Proactor::setup_signal_handler (int signal_number) const
1816 {
1817   // Set up the specified signal so that signal information will be
1818   // passed to sigwaitinfo/sigtimedwait. Don't change the default
1819   // signal handler - having a handler and waiting for the signal can
1820   // produce undefined behavior.
1821
1822   // But can not use SIG_DFL
1823   // With SIG_DFL after delivering the first signal
1824   // SIG_DFL handler resets  SA_SIGINFO flags
1825   // and we will lose all information sig_info
1826   // At least all SunOS have such behavior
1827 #if 0
1828   struct sigaction reaction;
1829   sigemptyset (&reaction.sa_mask);   // Nothing else to mask.
1830   reaction.sa_flags = SA_SIGINFO;    // Realtime flag.
1831   reaction.sa_sigaction = ACE_SIGNAL_C_FUNC (sig_handler); // (SIG_DFL);
1832   int sigaction_return = ACE_OS::sigaction (signal_number,
1833                                             &reaction,
1834                                             0);
1835   if (sigaction_return == -1)
1836     ACE_ERROR_RETURN ((LM_ERROR,
1837                        "Error:%p\n",
1838                        "Proactor couldnt do sigaction for the RT SIGNAL"),
1839                       -1);
1840 #else
1841   ACE_UNUSED_ARG(signal_number);
1842 #endif
1843   return 0;
1844 }
1845
1846
1847 int
1848 ACE_POSIX_SIG_Proactor::block_signals (void) const
1849 {
1850   return ACE_OS::pthread_sigmask (SIG_BLOCK, &this->RT_completion_signals_, 0);
1851 }
1852
1853 ssize_t
1854 ACE_POSIX_SIG_Proactor::allocate_aio_slot (ACE_POSIX_Asynch_Result *result)
1855 {
1856   size_t i = 0;
1857
1858   //try to find free slot as usual, starting from 0
1859   for (i = 0; i < this->aiocb_list_max_size_; i++)
1860     if (result_list_[i] == 0)
1861       break;
1862
1863   if (i >= this->aiocb_list_max_size_)
1864     ACE_ERROR_RETURN ((LM_ERROR,
1865               "%N:%l:(%P | %t)::\n"
1866               "ACE_POSIX_SIG_Proactor::allocate_aio_slot "
1867               "internal Proactor error 1\n"),
1868               -1);
1869
1870   // setup OS notification methods for this aio
1871   // store index!!, not pointer in signal info
1872   result->aio_sigevent.sigev_notify = SIGEV_SIGNAL;
1873   result->aio_sigevent.sigev_signo = result->signal_number ();
1874 #if defined (ACE_HAS_SIGVAL_SIGVAL_INT)
1875   result->aio_sigevent.sigev_value.sigval_int = static_cast<int> (i);
1876 #else
1877   result->aio_sigevent.sigev_value.sival_int = static_cast<int> (i);
1878 #endif /* ACE_HAS_SIGVAL_SIGVAL_INT */
1879
1880   return static_cast<ssize_t> (i);
1881 }
1882
1883 int
1884 ACE_POSIX_SIG_Proactor::handle_events_i (const ACE_Time_Value *timeout)
1885 {
1886   int result_sigwait = 0;
1887   siginfo_t sig_info;
1888
1889   do
1890     {
1891       // Wait for the signals.
1892       if (timeout == 0)
1893         {
1894           result_sigwait = ACE_OS::sigwaitinfo (&this->RT_completion_signals_,
1895                                                 &sig_info);
1896         }
1897       else
1898         {
1899           result_sigwait = ACE_OS::sigtimedwait (&this->RT_completion_signals_,
1900                                                  &sig_info,
1901                                                  timeout);
1902           if (result_sigwait == -1 && errno == EAGAIN)
1903             return 0;
1904         }
1905     }
1906   while (result_sigwait == -1 && errno == EINTR);
1907
1908   if (result_sigwait == -1)  // Not a timeout, not EINTR: tell caller of error
1909     return -1;
1910
1911   // Decide what to do. We always check the completion queue since it's an
1912   // easy, quick check. What is decided here is whether to check for
1913   // I/O completions and, if so, how completely to scan.
1914   int flg_aio = 0;           // 1 if AIO Completion possible
1915
1916   size_t index = 0;          // start index to scan aiocb list
1917   size_t count = 1;          // max number of aiocbs to scan
1918   int error_status = 0;
1919   size_t transfer_count = 0;
1920
1921   if (sig_info.si_code == SI_ASYNCIO || this->os_id_ == ACE_OS_SUN_56)
1922     {
1923       flg_aio = 1;  // AIO signal received
1924       // define index to start
1925       // nothing will happen if it contains garbage
1926 #if defined (ACE_HAS_SIGVAL_SIGVAL_INT)
1927       index = static_cast<size_t> (sig_info.si_value.sigval_int);
1928 #else
1929       index = static_cast<size_t> (sig_info.si_value.sival_int);
1930 #endif /* ACE_HAS_SIGVAL_SIGVAL_INT */
1931       // Assume we have a correctly-functioning implementation, and that
1932       // there is one I/O to process, and it's correctly specified in the
1933       // siginfo received. There are, however, some special situations
1934       // where this isn't true...
1935       if (os_id_ == ACE_OS_SUN_56) // Solaris 6
1936         {
1937           // 1. Solaris 6 always loses any RT signal,
1938           //    if it has more SIGQUEMAX=32 pending signals
1939           //    so we should scan the whole aiocb list
1940           // 2. Moreover,it has one more bad habit
1941           //    to notify aio completion
1942           //    with SI_QUEUE code instead of SI_ASYNCIO, hence the
1943           //    OS_SUN_56 addition to the si_code check, above.
1944           count = aiocb_list_max_size_;
1945         }
1946     }
1947   else if (sig_info.si_code != SI_QUEUE)
1948     {
1949       // Unknown signal code.
1950       // may some other third-party libraries could send it
1951       // or message queue could also generate it !
1952       // So print the message and check our completions
1953       ACE_ERROR ((LM_DEBUG,
1954                   ACE_TEXT ("%N:%l:(%P | %t): ")
1955                   ACE_TEXT ("ACE_POSIX_SIG_Proactor::handle_events: ")
1956                   ACE_TEXT ("Unexpected signal code (%d) returned ")
1957                   ACE_TEXT ("from sigwait; expecting %d\n"),
1958                   result_sigwait, sig_info.si_code));
1959       flg_aio = 1;
1960     }
1961
1962   int ret_aio = 0;
1963   int ret_que = 0;
1964
1965   if (flg_aio)
1966     for (;; ret_aio++)
1967       {
1968         ACE_POSIX_Asynch_Result *asynch_result =
1969           find_completed_aio (error_status,
1970                               transfer_count,
1971                               index,
1972                               count);
1973
1974         if (asynch_result == 0)
1975           break;
1976
1977         // Call the application code.
1978         this->application_specific_code (asynch_result,
1979                                          transfer_count,
1980                                          0,             // No completion key.
1981                                          error_status); // Error
1982       }
1983
1984   // process post_completed results
1985   ret_que = this->process_result_queue ();
1986
1987   // Uncomment this  if you want to test
1988   // and research the behavior of you system
1989 #if 0
1990   ACE_DEBUG ((LM_DEBUG,
1991               "(%t) NumAIO=%d NumQueue=%d\n",
1992               ret_aio, ret_que));
1993 #endif
1994
1995   return ret_aio + ret_que > 0 ? 1 : 0;
1996 }
1997
1998 #endif /* ACE_HAS_POSIX_REALTIME_SIGNALS */
1999
2000 // *********************************************************************
2001
2002 ACE_POSIX_Asynch_Timer::ACE_POSIX_Asynch_Timer
2003   (const ACE_Handler::Proxy_Ptr &handler_proxy,
2004    const void *act,
2005    const ACE_Time_Value &tv,
2006    ACE_HANDLE event,
2007    int priority,
2008    int signal_number)
2009   : ACE_POSIX_Asynch_Result
2010      (handler_proxy, act, event, 0, 0, priority, signal_number),
2011     time_ (tv)
2012 {
2013 }
2014
2015 void
2016 ACE_POSIX_Asynch_Timer::complete (size_t       /* bytes_transferred */,
2017                                   int          /* success */,
2018                                   const void * /* completion_key */,
2019                                   u_long       /* error */)
2020 {
2021   ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
2022   if (handler != 0)
2023     handler->handle_time_out (this->time_, this->act ());
2024 }
2025
2026
2027 // *********************************************************************
2028
2029 ACE_POSIX_Wakeup_Completion::ACE_POSIX_Wakeup_Completion
2030   (const ACE_Handler::Proxy_Ptr &handler_proxy,
2031    const void *act,
2032    ACE_HANDLE event,
2033    int priority,
2034    int signal_number)
2035   : ACE_Asynch_Result_Impl (),
2036     ACE_POSIX_Asynch_Result (handler_proxy,
2037                              act,
2038                              event,
2039                              0,
2040                              0,
2041                              priority,
2042                              signal_number)
2043 {
2044 }
2045
2046 ACE_POSIX_Wakeup_Completion::~ACE_POSIX_Wakeup_Completion (void)
2047 {
2048 }
2049
2050 void
2051 ACE_POSIX_Wakeup_Completion::complete (size_t       /* bytes_transferred */,
2052                                        int          /* success */,
2053                                        const void * /* completion_key */,
2054                                        u_long       /*  error */)
2055 {
2056
2057   ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
2058   if (handler != 0)
2059     handler->handle_wakeup ();
2060 }
2061
2062 ACE_END_VERSIONED_NAMESPACE_DECL
2063
2064 #endif /* ACE_HAS_AIO_CALLS */