arch/all-unix/hidd/unixio/unixio_class.c

   1 /*
   2     Copyright © 1995-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Unix filedescriptor/socket IO
   6     Lang: english
   7 */
   8
   9 #include <exec/types.h>
  10 #include <exec/lists.h>
  11 #include <exec/interrupts.h>
  12 #include <exec/execbase.h>
  13 #include <exec/semaphores.h>
  14 #include <exec/memory.h>
  15 #include <exec/resident.h>
  16 #include <exec/alerts.h>
  17 #include <exec/tasks.h>
  18 #include <exec/ports.h>
  19 #include <exec/nodes.h>
  20 #include <utility/tagitem.h>
  21 #include <utility/hooks.h>
  22 #include <hidd/unixio.h>
  23 #include <aros/asmcall.h>
  24 #include <aros/symbolsets.h>
  25 #include <hardware/intbits.h>
  26 #include <hardware/custom.h>
  27
  28 #include <oop/oop.h>
  29 #include <proto/exec.h>
  30 #include <proto/oop.h>
  31 #include <proto/utility.h>
  32 #include <proto/alib.h>
  33
  34 #include <devices/timer.h>
  35
  36 /* Unix includes */
  37 #define timeval sys_timeval /* We don't want the unix timeval to interfere with the AROS one */
  38 #include <sys/types.h>
  39 #include <fcntl.h>
  40 #include <unistd.h>
  41 #include <sys/stat.h>
  42 #include <sys/time.h>
  43 #include <sys/ioctl.h>
  44 #include <string.h>
  45 #include <errno.h>
  46 #undef timeval
  47
  48 #include "unixio.h"
  49
  50 #include LC_LIBDEFS_FILE
  51
  52 #ifdef __AROS__
  53 #include <aros/asmcall.h>
  54
  55 #define SDEBUG 0
  56 #define DEBUG 0
  57 #include <aros/debug.h>
  58 #endif /* __AROS__ */
  59
  60 struct newMemList
  61 {
  62   struct Node     nml_Node;
  63   UWORD           nml_NumEntries;
  64   struct MemEntry nml_ME[2];
  65 };
  66
  67 static const struct newMemList MemTemplate =
  68 {
  69     { 0, },
  70     2,
  71     {
  72         { { MEMF_CLEAR|MEMF_PUBLIC }, sizeof(struct Task) },
  73         { { MEMF_CLEAR             }, 0                   }
  74     }
  75 };
  76
  77
  78 /************************************************************************/
  79
  80 AROS_UFH5 (void, SigIO_IntServer,
  81     AROS_UFHA (ULONG             ,dummy,  D0),
  82     AROS_UFHA (struct Custom    *,custom, A0),
  83     AROS_UFHA (struct List      *,intList,A1),
  84     AROS_UFHA (APTR              ,ivCode, A5),
  85     AROS_UFHA (struct ExecBase  *,SysBase,A6)
  86 )
  87 {
  88     AROS_USERFUNC_INIT
  89
  90     struct uio_data * ud = (struct uio_data *) intList;
  91
  92     Signal (ud -> ud_WaitForIO, SIGBREAKF_CTRL_C);
  93
  94     AROS_USERFUNC_EXIT
  95 }
  96
  97
  98 #ifdef __linux__
  99 static int unixio_start_timer(struct timerequest * timerio)
 100 {
 101     int rc = FALSE;
 102
 103     if (NULL != timerio) {
 104         timerio->tr_node.io_Command = TR_ADDREQUEST;
 105         timerio->tr_time.tv_secs    = 0;
 106         timerio->tr_time.tv_micro   = 250000;
 107
 108         SendIO(&timerio->tr_node);
 109         rc = TRUE;
 110     }
 111     return rc;
 112 }
 113 #endif
 114
 115 /******************
 116 **  UnixIO task  **
 117 ******************/
 118 static void WaitForIO (void)
 119 {
 120     struct uio_data * ud = FindTask(NULL)->tc_UserData;
 121     int maxfd;
 122     int selecterr;
 123     int err;
 124     fd_set rfds, wfds, efds;
 125     fd_set * rp, * wp, * ep;
 126     struct sys_timeval tv;
 127     struct List waitList;
 128     struct uioMessage * msg, * nextmsg;
 129     ULONG rmask;
 130     int flags;
 131     pid_t my_pid = getpid();
 132 #ifdef __linux__
 133     int terminals_write_counter = 0;
 134     struct MsgPort * timer_port = NULL;
 135     struct timerequest * timerio = NULL;
 136 #endif
 137     /*
 138      * Since the signal was allocated by other task, but really is mine
 139      * I need to allocate it here 'manually'. Otherwise the CreateMsgPort()
 140      * would get the wrong signal.
 141      */
 142     AllocSignal(ud->ud_Port -> mp_SigBit);
 143
 144 #ifdef __linux__
 145     timer_port = CreateMsgPort();
 146     timerio = (struct timerequest *)CreateIORequest(timer_port, sizeof(struct timerequest));
 147     OpenDevice("timer.device", UNIT_VBLANK, &timerio->tr_node, 0);
 148 #endif
 149
 150     NEWLIST (&waitList);
 151
 152     D(bug("wfio: UnixIO.hidd ready ud=%08lx\n", ud));
 153
 154     for (;;)
 155     {
 156         if (IsListEmpty (&waitList))
 157         {
 158             D(bug("wfio: Waiting for message for task %s\n",ud->ud_WaitForIO->tc_Node.ln_Name));
 159             WaitPort (ud->ud_Port);
 160             D(bug("wfio: Got messages\n"));
 161         }
 162         else
 163         {
 164 #if 0
 165         kprintf("FLAGS FOR FDS: ");
 166         ForeachNode (&waitList, msg) {
 167             int flags;
 168
 169             flags = fcntl (msg->fd, F_GETFL);
 170             kprintf("fd %d: %d", msg->fd, flags);
 171             if (flags & FASYNC)
 172                 kprintf(" ASYNC SET, ");
 173             else
 174                 kprintf(" ASYNC NOT SET, ");
 175             }
 176
 177             kprintf("\n");
 178 #endif
 179
 180             D(bug("wfio: Waiting for message or signal for task %s\n",ud->ud_WaitForIO->tc_Node.ln_Name));
 181 #ifdef __linux__
 182             rmask =
 183                 Wait
 184                 (
 185                     (1UL << ud->ud_Port->mp_SigBit)
 186                     |
 187                     (1UL << timer_port->mp_SigBit)
 188                     |
 189                     SIGBREAKF_CTRL_C
 190                 );
 191
 192             if (rmask & 1 << timer_port -> mp_SigBit)
 193             {
 194                 /*
 195                  * Must take the message from the timer port.
 196                  * Will be sending it again.
 197                  */
 198                 GetMsg(timer_port);
 199
 200                 if (terminals_write_counter > 0) {
 201                   //kprintf("RE STARTING TIMER! (%d)\n",terminals_write_counter);
 202                   unixio_start_timer(timerio);
 203                 } else {
 204                   //kprintf("NOT RE STARTING TIMER!\n");
 205                 }
 206             }
 207             else
 208 #else
 209             rmask = Wait((1UL << ud->ud_Port->mp_SigBit) | SIGBREAKF_CTRL_C);
 210 #endif
 211
 212             if (rmask & 1 << ud->ud_Port -> mp_SigBit)
 213             {
 214                 D(bug("wfio: Got message\n"));
 215             }
 216             else if (rmask & SIGBREAKF_CTRL_C)
 217             {
 218                 D(bug("wfio: Got signal\n"));
 219             }
 220         }
 221
 222         while ((msg = (struct uioMessage *)GetMsg (ud->ud_Port)))
 223         {
 224             if (msg->mode != vHidd_UnixIO_Abort)
 225             {
 226
 227               D(bug("wfio: Got msg fd=%ld mode=%ld\n", msg->fd, msg->mode));
 228               AddTail (&waitList, (struct Node *)msg);
 229
 230               fcntl (msg->fd, F_SETOWN, my_pid);
 231               flags = fcntl (msg->fd, F_GETFL);
 232               fcntl (msg->fd, F_SETFL, flags | FASYNC | O_NONBLOCK);
 233 #ifdef __linux__
 234               if (msg->mode & vHidd_UnixIO_Write &&
 235                   msg->fd_type & vHidd_UnixIO_Terminal) {
 236                   terminals_write_counter++;
 237                   if (1 == terminals_write_counter) {
 238                       unixio_start_timer(timerio);
 239                   }
 240               }
 241 #endif
 242             }
 243             else
 244             {
 245               /*
 246               ** I must look for all messages that tell me to watch on this
 247               ** filedescriptor.
 248               */
 249               struct uioMessage * umsg,  *_umsg;
 250
 251               ForeachNodeSafe(&waitList, umsg, _umsg)
 252               {
 253                 if (umsg->fd == msg->fd)
 254                 {
 255 #ifdef __linux__
 256                   if (umsg->mode & vHidd_UnixIO_Write &&
 257                       umsg->fd_type & vHidd_UnixIO_Terminal) {
 258                       terminals_write_counter--;
 259 #if 1
 260                       if (0 == terminals_write_counter) {
 261                         if (!CheckIO(&timerio->tr_node))
 262                           AbortIO(&timerio->tr_node);
 263                         WaitIO(&timerio->tr_node);
 264                         SetSignal(0, 1L << timer_port->mp_SigBit);
 265                         //kprintf("KIIIIILLLED!\n");
 266                       }
 267 #endif
 268                   }
 269 #endif
 270
 271                   Remove((struct Node *)umsg);
 272                   FreeMem(umsg, sizeof(struct uioMessage));
 273                 }
 274               }
 275               ReplyMsg((struct Message *)msg);
 276             }
 277         } /* while (there are messages) */
 278
 279         FD_ZERO (&rfds);
 280         FD_ZERO (&wfds);
 281         FD_ZERO (&efds);
 282
 283         rp = wp = ep = NULL;
 284
 285         maxfd = 0;
 286
 287         D(bug("Waiting on fd "));
 288
 289         ForeachNode (&waitList, msg)
 290         {
 291             D(bug("%d, ", msg->fd));
 292             if (msg->mode & vHidd_UnixIO_Read)
 293             {
 294                 FD_SET (msg->fd, &rfds);
 295                 rp = &rfds;
 296             }
 297
 298             if (msg->mode & vHidd_UnixIO_Write)
 299             {
 300                 FD_SET (msg->fd, &wfds);
 301                 wp = &wfds;
 302             }
 303
 304             FD_SET (msg->fd, &efds);
 305             ep = &efds;
 306
 307             if (maxfd < msg->fd)
 308                 maxfd = msg->fd;
 309         }
 310         D(bug("\n"));
 311
 312         tv.tv_sec  = 0;
 313         tv.tv_usec = 0;
 314
 315         errno = 0; /* set errno to zero before select() call */
 316         selecterr = select (maxfd+1, rp, wp, ep, &tv);
 317         err = errno;
 318
 319 #if 1
 320         D(bug("wfio: got io sel=%ld err=%ld\n", selecterr, err));
 321 #endif
 322
 323         if (selecterr < 0 && err == EINTR)
 324             continue;
 325
 326         if (selecterr >= 0)
 327         {
 328             ForeachNodeSafe (&waitList, msg, nextmsg)
 329             {
 330                 if (FD_ISSET (msg->fd, &efds))
 331                 {
 332                     msg->result = err;
 333                     goto reply;
 334                 }
 335                 else if ((vHidd_UnixIO_Read & msg->mode) &&
 336                          FD_ISSET (msg->fd, &rfds))
 337                 {
 338                     if (msg->callback)
 339                     {
 340                         if ( ((int (*)(int, void *))msg->callback)(msg->fd, msg->callbackdata) )
 341                         {
 342                             msg->result = 0;
 343                             goto reply;
 344                         }
 345                     }
 346                     else
 347                     {
 348                         msg->result = 0;
 349                         goto reply;
 350                     }
 351                 }
 352                 else if ((vHidd_UnixIO_Write & msg->mode) &&
 353                          FD_ISSET (msg->fd, &wfds))
 354                 {
 355                     msg->result = 0;
 356 reply:
 357                     D(bug("wfio: Reply: fd=%ld res=%ld replying to task %s on port %x\n", msg->fd, msg->result, ((struct Task *)((struct Message *)msg)->mn_ReplyPort->mp_SigTask)->tc_Node.ln_Name,((struct Message *)msg)->mn_ReplyPort));
 358 /*
 359 kprintf("\tUnixIO task: Replying a message from task %s (%x) to port %x (flags : 0x%0x)\n",((struct Task *)((struct Message *)msg)->mn_ReplyPort->mp_SigTask)->tc_Node.ln_Name,((struct Message *)msg)->mn_ReplyPort->mp_SigTask,((struct Message *)msg)->mn_ReplyPort,((struct Message *)msg)->mn_ReplyPort->mp_Flags);
 360 */
 361                     if (0 == (msg->mode & vHidd_UnixIO_Keep)) {
 362                         Remove ((struct Node *)msg);
 363                         flags = fcntl (msg->fd, F_GETFL);
 364                         fcntl (msg->fd, F_SETFL, flags & ~FASYNC);
 365                         ReplyMsg ((struct Message *)msg);
 366 #ifdef __linux__
 367                         if ((msg->mode & vHidd_UnixIO_Write) &&
 368                             (msg->fd_type & vHidd_UnixIO_Terminal)) /* stegerg: CHECKME added vHidd_Unixio_terminal check */
 369                         {
 370                             terminals_write_counter--;
 371                       if (terminals_write_counter == 0) {
 372                         if (!CheckIO(&timerio->tr_node))
 373                           AbortIO(&timerio->tr_node);
 374                         WaitIO(&timerio->tr_node);
 375                         SetSignal(0, 1L << timer_port->mp_SigBit);
 376
 377                         }
 378                       }
 379 #endif
 380                     } else {
 381                         /*
 382                          * Since I am supposed to keep the message
 383                          * I cannot use ReplyMsg() on it, because that
 384                          * would put it on the reply port's message port.
 385                          * So I am doing things 'manually' here what
 386                          * ReplyMsg() does internally, except for putting
 387                          * the message onto the message port.
 388                          */
 389                         struct MsgPort *port;
 390                         Disable();
 391                         port=((struct Message *)msg)->mn_ReplyPort;
 392                         if(port->mp_SigTask)
 393                         {
 394                             /* And trigger the arrival action. */
 395                             switch(port->mp_Flags&PF_ACTION)
 396                             {
 397                                 case PA_SIGNAL:
 398                                     /* Send a signal */
 399                                     Signal((struct Task *)port->mp_SigTask,1<<port->mp_SigBit);
 400                                     break;
 401
 402                                 case PA_SOFTINT:
 403                                     /* Raise a software interrupt */
 404                                     Cause((struct Interrupt *)port->mp_SoftInt);
 405                                     break;
 406
 407                                 case PA_IGNORE:
 408                                     /* Do nothing */
 409                                     break;
 410                             }
 411                         }
 412                         Enable();
 413                     }
 414                 }
 415             }
 416         }
 417         else
 418         {
 419             D(bug("wfio: Timeout sel=%ld err=%ld\n", selecterr, err));
 420         }
 421     } /* Forever */
 422 }
 423
 424 /* This is the dispatcher for the UnixIO HIDD class. */
 425
 426
 427 /********************
 428 **  UnixIO::New()  **
 429 ********************/
 430 OOP_Object *UXIO__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
 431 {
 432     EnterFunc(bug("UnixIO::New(cl=%s)\n", cl->ClassNode.ln_Name));
 433     D(bug("DoSuperMethod:%p\n", cl->DoSuperMethod));
 434     o =(OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 435
 436     if (o)
 437     {
 438         struct UnixIOData *id;
 439         ULONG dispose_mid;
 440
 441         id = OOP_INST_DATA(cl, o);
 442         D(bug("inst: %p, o: %p\n", id, o));
 443
 444         id->uio_ReplyPort = CreatePort (NULL, 0);
 445         if (id->uio_ReplyPort)
 446         {
 447 /*
 448 kprintf("\tUnixIO::New(): Task %s (%x) Replyport: %x\n",FindTask(NULL)->tc_Node.ln_Name,FindTask(NULL),id->uio_ReplyPort);
 449 */
 450             D(bug("Port created at %x\n",id->uio_ReplyPort));
 451             ReturnPtr("UnixIO::New", Object *, o);
 452         }
 453
 454
 455         dispose_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
 456         OOP_CoerceMethod(cl, o, (OOP_Msg)&dispose_mid);
 457     }
 458     ReturnPtr("UnixIO::New", OOP_Object *, NULL);
 459 }
 460
 461 /***********************
 462 **  UnixIO::Dispose()  **
 463 ***********************/
 464 IPTR UXIO__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 465 {
 466     struct UnixIOData *id = OOP_INST_DATA(cl, o);
 467
 468     if (id -> uio_ReplyPort)
 469         DeletePort (id->uio_ReplyPort);
 470
 471     return OOP_DoSuperMethod(cl, o, msg);
 472 }
 473
 474 /*********************
 475 **  UnixIO::Wait()  **
 476 *********************/
 477 IPTR UXIO__Hidd_UnixIO__Wait(OOP_Class *cl, OOP_Object *o, struct uioMsg *msg)
 478 {
 479     IPTR retval = 0UL;
 480 //    struct UnixIOData *id = OOP_INST_DATA(cl, o);
 481     struct uioMessage * umsg = AllocMem (sizeof (struct uioMessage), MEMF_CLEAR|MEMF_PUBLIC);
 482     struct MsgPort  * port = CreatePort(NULL, 0);
 483     struct uio_data *ud = UD(cl);
 484
 485     if (umsg  && port)
 486     {
 487         port->mp_Flags = PA_SIGNAL;
 488         port->mp_SigTask = FindTask (NULL);
 489
 490         umsg->Message.mn_ReplyPort = port;
 491         umsg->fd   = ((struct uioMsg *)msg)->um_Filedesc;
 492         umsg->fd_type = vHidd_UnixIO_Socket;
 493         umsg->mode = ((struct uioMsg *)msg)->um_Mode;
 494         umsg->callback = ((struct uioMsg *)msg)->um_CallBack;
 495         umsg->callbackdata = ((struct uioMsg *)msg)->um_CallBackData;
 496
 497         D(bug("UnixIO::Wait() Sending msg fd=%ld mode=%ld to port %x\n", umsg->fd, umsg->mode, ud->ud_Port));
 498
 499 /*
 500 kprintf("\tUnixIO::Wait() Task %s (%x) waiting on port %x\n",FindTask(NULL)->tc_Node.ln_Name,FindTask(NULL),port);
 501 */
 502         PutMsg (ud->ud_Port, (struct Message *)umsg);
 503         WaitPort (port);
 504         GetMsg (port);
 505
 506         DeletePort(port);
 507
 508         D(bug("Get msg fd=%ld mode=%ld res=%ld\n", umsg->fd, umsg->mode, umsg->result));
 509         retval = umsg->result;
 510     }
 511     else
 512         retval = ENOMEM;
 513
 514     if (umsg)
 515         FreeMem (umsg, sizeof (struct uioMessage));
 516
 517     return retval;
 518 }
 519
 520 /************************
 521 **  UnixIO::AsyncIO()  **
 522 ************************/
 523 IPTR UXIO__Hidd_UnixIO__AsyncIO(OOP_Class *cl, OOP_Object *o, struct uioMsgAsyncIO *msg)
 524 {
 525     IPTR retval = 0UL;
 526     struct uioMessage * umsg = AllocMem (sizeof (struct uioMessage), MEMF_CLEAR|MEMF_PUBLIC);
 527     struct MsgPort  * port = msg->um_ReplyPort;
 528     struct uio_data *ud = UD(cl);
 529
 530     if (umsg)
 531     {
 532         /* nlorentz: What action should be taken on reply of this message
 533            should be the choice of the caller. (The caller might want
 534            a signal instead of a softint)
 535
 536         port->mp_Flags   = PA_SOFTINT;
 537
 538         */
 539
 540         umsg->Message.mn_ReplyPort = port;
 541         umsg->fd      = ((struct uioMsg *)msg)->um_Filedesc;
 542         umsg->fd_type = ((struct uioMsg *)msg)->um_Filedesc_Type;
 543         umsg->mode    = ((struct uioMsg *)msg)->um_Mode;
 544         umsg->callback = NULL;
 545         umsg->callbackdata = NULL;
 546
 547         D(bug("Sending msg fd=%ld mode=%ld to port %x\n", umsg->fd, umsg->mode, ud->ud_Port));
 548
 549         /*
 550         ** Just send the message and leave
 551         ** When the message arrives on the port the user must free
 552         ** the message!
 553         */
 554         PutMsg (ud->ud_Port, (struct Message *)umsg);
 555
 556     }
 557     else
 558         retval = ENOMEM;
 559
 560     return retval;
 561 }
 562
 563
 564 /*****************************
 565 **  UnixIO::AbortAsyncIO()  **
 566 *****************************/
 567 VOID UXIO__Hidd_UnixIO__AbortAsyncIO(OOP_Class *cl, OOP_Object *o, struct uioMsgAbortAsyncIO *msg)
 568 {
 569     struct uioMessage * umsg = AllocMem (sizeof (struct uioMessage), MEMF_CLEAR|MEMF_PUBLIC);
 570     struct uio_data *ud = UD(cl);
 571     struct MsgPort  * port = CreatePort(NULL, 0);
 572
 573     if (umsg  && port)
 574     {
 575         umsg->Message.mn_ReplyPort = port;
 576         umsg->fd   = ((struct uioMsg *)msg)->um_Filedesc;
 577         umsg->mode = vHidd_UnixIO_Abort;
 578
 579         PutMsg (ud->ud_Port, (struct Message *)umsg);
 580
 581         WaitPort (port);
 582         GetMsg (port);
 583
 584     }
 585
 586     if (umsg)
 587         FreeMem (umsg, sizeof (struct uioMessage));
 588
 589     if (port)
 590         DeletePort(port);
 591 }
 592
 593 /*****************************
 594 **  UnixIO::OpenFile()      **
 595 *****************************/
 596 APTR UXIO__Hidd_UnixIO__OpenFile(OOP_Class *cl, OOP_Object *o, struct uioMsgOpenFile *msg)
 597 {
 598     APTR retval = (APTR)open((const char *)msg->um_FileName, (int)msg->um_Flags, (int)msg->um_Mode);
 599
 600     if (msg->um_ErrNoPtr) *msg->um_ErrNoPtr = errno;
 601
 602     return retval;
 603 }
 604
 605 /*****************************
 606 **  UnixIO::CloseFile()      **
 607 *****************************/
 608 VOID UXIO__Hidd_UnixIO__CloseFile(OOP_Class *cl, OOP_Object *o, struct uioMsgCloseFile *msg)
 609 {
 610     if (msg->um_FD != (APTR)-1) close((int)msg->um_FD);
 611     if (msg->um_ErrNoPtr) *msg->um_ErrNoPtr = errno;
 612 }
 613
 614 /*****************************
 615 **  UnixIO::ReadFile()     **
 616 *****************************/
 617 IPTR UXIO__Hidd_UnixIO__ReadFile(OOP_Class *cl, OOP_Object *o, struct uioMsgReadFile *msg)
 618 {
 619     IPTR retval = (IPTR)-1;
 620
 621     if (msg->um_FD != (APTR)-1)
 622     {
 623         do
 624         {
 625             retval = (IPTR)read((int)msg->um_FD, (void *)msg->um_Buffer, (size_t)msg->um_Count);
 626             //kprintf(" UXIO__Hidd_UnixIO__ReadFile[%04ld]: retval %d errno %d  buff %x  count %d\n", count++, retval, errno, msg->um_Buffer, msg->um_Count);
 627
 628             if (msg->um_ErrNoPtr) break;
 629
 630         } while(((int)errno == EINTR) || ((int)errno == EAGAIN));
 631     }
 632
 633     if (msg->um_ErrNoPtr) *msg->um_ErrNoPtr = errno;
 634
 635     //if ((int)retval == -1) kprintf("UXIO__Hidd_UnixIO__ReadFile: errno %d  buff %x  count %d\n", errno, msg->um_Buffer, msg->um_Count);
 636
 637     return retval;
 638 }
 639
 640 /*****************************
 641 **  UnixIO::WriteFile()     **
 642 *****************************/
 643 IPTR UXIO__Hidd_UnixIO__WriteFile(OOP_Class *cl, OOP_Object *o, struct uioMsgWriteFile *msg)
 644 {
 645     IPTR retval = (IPTR)-1;
 646
 647     if (msg->um_FD != (APTR)-1)
 648     {
 649         do
 650         {
 651             retval = (IPTR)write((int)msg->um_FD, (const void *)msg->um_Buffer, (size_t)msg->um_Count);
 652             //kprintf(" UXIO__Hidd_UnixIO__WriteFile[%04ld]: retval %d errno %d  buff %x  count %d\n", count++, retval, errno, msg->um_Buffer, msg->um_Count);
 653
 654             if (msg->um_ErrNoPtr) break;
 655
 656         } while(((int)retval < 1) && (((int)errno == EINTR) || ((int)errno == EAGAIN) || (errno == 0)));
 657     }
 658
 659     if (msg->um_ErrNoPtr) *msg->um_ErrNoPtr = errno;
 660
 661     //if ((int)retval == -1) kprintf("UXIO__Hidd_UnixIO__WriteFile: errno %d  buff %x  count %d\n", errno, msg->um_Buffer, msg->um_Count);
 662
 663     return retval;
 664 }
 665
 666 /*****************************
 667 **  UnixIO::IOControlFile() **
 668 *****************************/
 669 IPTR UXIO__Hidd_UnixIO__IOControlFile(OOP_Class *cl, OOP_Object *o, struct uioMsgIOControlFile *msg)
 670 {
 671     IPTR retval = (IPTR)-1;
 672
 673     if (msg->um_FD != (APTR)-1)
 674     {
 675         retval = (IPTR)ioctl((int)msg->um_FD, (int)msg->um_Request, msg->um_Param);
 676     }
 677
 678     if (msg->um_ErrNoPtr) *msg->um_ErrNoPtr = errno;
 679
 680     return retval;
 681 }
 682
 683 /* This is the initialisation code for the HIDD class itself. */
 684
 685 static int UXIO_Init(LIBBASETYPEPTR LIBBASE)
 686 {
 687     struct Task     * newtask,
 688                     * task2 = NULL; /* keep compiler happy */
 689     struct newMemList nml;
 690     struct MemList  * ml;
 691     struct Interrupt * is;
 692
 693     LIBBASE->uio_csd.ud_Port = CreatePort (NULL, 0);
 694     if(LIBBASE->uio_csd.ud_Port == NULL)
 695     {
 696         /* If you are not running from ROM, don't use Alert() */
 697         Alert(AT_DeadEnd | AG_NoMemory | AN_Unknown);
 698         return FALSE;
 699     }
 700
 701     nml = MemTemplate;
 702
 703     /*
 704         The original stack size was 8192, however some emulated systems
 705         require a large stack during signal handlers. FreeBSD in fact
 706         says that it requires 8192 just FOR the signal handler. I have
 707         changed this to AROS_STACKSIZE for that reason.
 708     */
 709     nml.nml_ME[1].me_Length = AROS_STACKSIZE;
 710
 711     if (NewAllocEntry((struct MemList *)&nml, &ml, NULL))
 712     {
 713         newtask = ml->ml_ME[0].me_Addr;
 714
 715         newtask->tc_Node.ln_Type = NT_TASK;
 716         newtask->tc_Node.ln_Pri  = 30;
 717         newtask->tc_Node.ln_Name = "UnixIO.task";
 718
 719         newtask->tc_SPReg   = (APTR)((ULONG)ml->ml_ME[1].me_Addr + AROS_STACKSIZE);
 720         newtask->tc_SPLower = ml->ml_ME[1].me_Addr;
 721         newtask->tc_SPUpper = newtask->tc_SPReg;
 722
 723         newtask->tc_UserData = &LIBBASE->uio_csd;
 724
 725         NEWLIST (&newtask->tc_MemEntry);
 726         AddHead (&newtask->tc_MemEntry, (struct Node *)ml);
 727
 728         task2 = (struct Task *)AddTask (newtask, WaitForIO, 0);
 729
 730         if (SysBase->LibNode.lib_Version>36 && !task2)
 731         {
 732             FreeEntry (ml);
 733             newtask = NULL;
 734         }
 735     }
 736     else
 737         newtask = NULL;
 738
 739     if (!newtask)
 740     {
 741         /* If you are not running from ROM, don't use Alert() */
 742         Alert(AT_DeadEnd | AG_NoMemory | AN_Unknown);
 743         return FALSE;
 744     }
 745
 746     LIBBASE->uio_csd.ud_WaitForIO = task2;
 747
 748     LIBBASE->uio_csd.ud_Port->mp_Flags   = PA_SIGNAL;
 749     LIBBASE->uio_csd.ud_Port->mp_SigTask = task2;
 750
 751     is=(struct Interrupt *)AllocMem(sizeof(struct Interrupt),MEMF_PUBLIC);
 752     if (!is)
 753     {
 754         Alert(AT_DeadEnd | AG_NoMemory | AN_Unknown);
 755         return FALSE;
 756     }
 757     is->is_Code=(void (*)())&SigIO_IntServer;
 758     is->is_Data=(APTR)&LIBBASE->uio_csd;
 759     SetIntVector(INTB_DSKBLK,is);
 760
 761     return TRUE;
 762 }
 763
 764 ADD2INITLIB(UXIO_Init, 0)