开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 查看源码
iosLib.c
资源名称：vxWorks_src.rar　[点击查看]
上传用户：baixin
上传日期：2008-03-13
资源大小：4795k
文件大小：28k
源码类别：

嵌入式/单片机编程

开发平台：

MultiPlatform

iosLib.c：源码内容
  1. /* iosLib.c - I/O system library */
  3. /* Copyright 1984-2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 04n,03oct01,dcb  Fix SPR 20033.  iosFdSet uses malloc without checking return
  10.                  code.
  11. 04m,31aug98,ms   add _func_ioTaskStdSet initialization.
  12. 04l,24aug96,sgv  fix for spr 6802. Modified iosFdNew to check for maxFiles
  13.  after a fd value is chosen.
  14. 04k,23aug96,ms   writing to null device no longer an error (SPR 7076)
  15. 04k,11jan95,rhp  explain "default device" in iosDevFind() man page (SPR#2462)
  16. 04j,17oct94,rhp  removed obsolete reference to pathLib in doc (SPR#3712).
  17. 04i,26jul94,dvs  made iosWrite/iosRead consistant so they both return ERROR 
  18.  if no driver routine - also changed doc (SPR #2019 and 2020).
  19. 04h,14jul94,dvs  made write return 0 if no driver routine (SPR #2020).
  20. 04g,07dec93,elh  added asynchronous I/O support for Posix.
  21. 04f,21jan93,jdi  documentation cleanup for 5.1.
  22. 04e,13nov92,dnw  added include of semLibP.h
  23. 04d,23aug92,jcf  split show routines into iosShow.c. 
  24.  moved typedefs/defines to private/iosLibP.h.
  25.  changed semMInit->semBInit.  changed lst* to dll*.
  26. 04c,18jul92,smb  Changed errno.h to errnoLib.h.
  27. 04b,26may92,rrr  the tree shuffle
  28. 04a,25nov91,rrr  cleanup of some ansi warnings.
  29. 03z,04oct91,rrr  passed through the ansification filter
  30.                   -changed functions to ansi style
  31.   -changed includes to have absolute path from h/
  32.   -changed VOID to void
  33.   -changed copyright notice
  34. 03y,30apr91,jdi  documentation tweaks.
  35. 03x,26apr91,shl  fixed potential race in iosFdFree() (spr 997).
  36. 03w,05apr91,jdi  documentation -- removed header parens and x-ref numbers;
  37.  moved position of iosDrvShow(); doc review by dnw.
  38. 03v,08feb92,jaa  documentation cleanup.
  39. 03u,05oct90,dnw  made iosNextDevGet() be NOMANUAL
  40. 03t,10aug90,kdl  added forward declarations for functions returning void.
  41. 03s,26jun90,jcf  changed iosSemaphore to mutex.
  42. 03r,29may90,dnw  fixed iosDevDelete to free memory allocated for name string.
  43.  tweaked documentation for iosDevAdd & iosDevDelete.
  44. 03q,25may90,dnw  fixed printf format in ios{Dev,Fd}Show to show entire name
  45.    instead of just 1st 20 chars.
  46.  changed iosFdSet to malloc space for filename, unless filename
  47.    is same as device name.  Note that callers should NOT
  48.    malloc the name before calling iosFdSet anymore.
  49.    See doc in iosFdSet.
  50.  made several obscure iosFd... routines be "no manual".
  51. 03p,11may90,yao  added missing modification history (03o) for the last checkin.
  52. 03o,09may90,yao  typecasted malloc to (char *).
  53. 03n,07may90,hjb  added iosFdDevFind routine.
  54. 03m,14mar90,jdi  documentation cleanup.
  55. 03l,14nov88,dnw  changed ioTaskStdGet to take taskId arg.
  56. 03i,08oct88,gae  fixed checking for task specific std. input/output/error fd's.
  57. 03h,15aug88,jcf  lint.
  58. 03g,15jul88,llk  changed iosFdSet.  fd names are now allocated before iosFdSet
  59.    is called.
  60. 03f,30jun88,llk  added iosNextDevGet().
  61.  changed iosDevAdd() so that it will not add devices with
  62.    duplicate names.
  63. 03e,04jun88,llk  replaced ioDefDev with ioDefPath.
  64. 03d,30may88,dnw  changed to v4 names.
  65. 03c,28may88,dnw  made ios{Create,Delete,Open,Close,Read,Write,Ioctl} LOCAL.
  66. 03b,23apr88,jcf  fixed semaphore calls for new semLib.
  67. 03a,30mar88,gae  made drvTable & fdTable definition local.
  68.  made fd's 0, 1, & 2 be standard in/out/err a la UNIX.
  69.  added ios{Creat,Delete,Open,Read,Write,Ioctl,Close}() for use
  70.  by ioLib.c.  Got rid of iosFdGetFree() and added iosFdNew()
  71.  to simplify setting up of new file descriptor.
  72.  iosFdCheck() turned into a macro for speed/jsr overhead.
  73.  iosDevList() shows driver number.
  74.  iosFdList() shows driver number and indicates std. in/out/err.
  75. 02b,20feb88,dnw  fixed missing return value in iosDrvRemove().
  76. 02a,16dec87,jlf  added iosDevDelete (), iosDrvRemove (), and iosDrvList ().
  77.  changed iosDrvInstall to look for an unused entry, instead
  78.     of just adding new drivers at the end.
  79. 01p,05nov87,rdc  fixed documentation for iosDevFind.
  80. 01o,30sep87,gae  made fdTable LOCAL; added iosFdSet() to set values in
  81.    fdTable; now keep file name in table; added iosFdList().
  82. 01n,28apr87,gae  made iosLock() and iosUnlock() LOCAL.
  83. 01m,24mar87,jlf  documentation.
  84. 01l,20dec86,dnw  changed iosDevMatch() to find longest (instead of just first)
  85.    device name that is initial substring of file name.
  86.  changed to not get include files from default directories.
  87. 01k,01dec86,dnw  changed iosDevAdd() to put device name in allocated memory,
  88.    instead of in fixed length array.
  89. 01j,14apr86,rdc  changed memAllocates to mallocs.
  90. 01i,11oct85,dnw  de-linted.
  91. 01h,20jul85,jlf  documentation.
  92. 01g,19sep84,jlf  worked on the comments a little.
  93. 01f,05sep84,jlf  fixed iosDevMatch to work properly.  Added copyright.  Added
  94.  comments.
  95. 01e,04sep84,dnw  added iosDevList.
  96. 01d,10aug84,dnw  changed ioDevFind to include "default device" search
  97.    if device name not explicitly specified.
  98. 01c,07aug84,ecs  added calls to setStatus to iosDevFind, iosDrvInstall,
  99.    iosFdCheck, and iosFdGetFree
  100. 01b,29jun84,ecs  changed iosDevFind to use new version of cmpbuf
  101. 01a,11jun84,dnw  culled from old drvLib and ioLib
  102. */
  104. /*
  105. This library is the driver-level interface to the I/O system.  Its
  106. primary purpose is to route user I/O requests to the proper drivers, using
  107. the proper parameters.  To do this, iosLib keeps tables describing the
  108. available drivers (e.g., names, open files).
  110. The I/O system should be initialized by calling iosInit(), before calling
  111. any other routines in iosLib.  Each driver then installs itself by calling
  112. iosDrvInstall().  The devices serviced by each driver are added to the I/O
  113. system with iosDevAdd().
  115. The I/O system is described more fully in the 
  116. .I "I/O System"
  117. chapter of the
  118. .I "Programmer's Guide."
  120. INCLUDE FILES: iosLib.h
  122. SEE ALSO: intLib, ioLib,
  123. .pG "I/O System"
  124. */
  126. #include "vxWorks.h"
  127. #include "dllLib.h"
  128. #include "stdlib.h"
  129. #include "semLib.h"
  130. #include "ioLib.h"
  131. #include "string.h"
  132. #include "errnoLib.h"
  133. #include "stdio.h"
  134. #include "private/iosLibP.h"
  135. #include "private/semLibP.h"
  136. #include "private/funcBindP.h"
  138. /* globals */
  140. DL_LIST  iosDvList; /* list of I/O device headers */
  141. DRV_ENTRY * drvTable; /* driver entry point table */
  142. FD_ENTRY * fdTable; /* table of fd entries */
  143. int  maxDrivers; /* max installed drivers */
  144. int  maxFiles; /* max open files */
  145. char ioDefPath[MAX_FILENAME_LENGTH]; /* default I/O prefix */
  146. int mutexOptionsIosLib = SEM_Q_FIFO | SEM_DELETE_SAFE;
  147. BOOL iosLibInitialized = FALSE;
  149. VOIDFUNCPTR iosFdNewHookRtn = NULL;
  150. VOIDFUNCPTR iosFdFreeHookRtn = NULL;
  152. /* forward static functions */
  154. static DEV_HDR *iosDevMatch (char *name);
  155. static void  iosLock (void);
  156. static void  iosUnlock (void);
  158. /* locals */
  160. LOCAL SEMAPHORE iosSemaphore; /* semaphore to interlock access to io tables */
  161. LOCAL DEV_HDR nullDevHdr; /* device header for null device */
  163. /******************************************************************************
  164. *
  165. * nullWrite - NULL device write routine
  166. */ 
  168. static STATUS nullWrite
  169.     (
  170.     int    dummy,
  171.     char * pBuf,
  172.     int    nBytes
  173.     )
  174.     {
  175.     return (nBytes);
  176.     }
  178. /*******************************************************************************
  179. *
  180. * iosInit - initialize the I/O system
  181. *
  182. * This routine initializes the I/O system.
  183. * It must be called before any other I/O system routine.
  184. *
  185. * RETURNS: OK, or ERROR if memory is insufficient.
  186. */
  188. STATUS iosInit
  189.     (
  190.     int max_drivers,            /* maximum number of drivers allowed */
  191.     int max_files,              /* max number of files allowed open at once */
  192.     char *nullDevName           /* name of the null device (bit bucket) */
  193.     )
  194.     {
  195.     int i;
  196.     int size;
  198.     maxDrivers = max_drivers;
  199.     maxFiles = max_files;
  201.     ioDefPath [0] = EOS;
  203.     /* allocate file table and make all entries free */
  205.     size = maxFiles * sizeof (FD_ENTRY);
  206.     fdTable = (FD_ENTRY *) malloc ((unsigned) size);
  208.     if (fdTable == NULL)
  209. return (ERROR);
  211.     bzero ((char *)fdTable, size);
  213.     for (i = 0; i < maxFiles; i++)
  214. iosFdFree (STD_FIX(i));
  216.     /* allocate driver table and make all entries null */
  218.     size = maxDrivers * sizeof (DRV_ENTRY);
  219.     drvTable = (DRV_ENTRY *) malloc ((unsigned) size);
  221.     if (drvTable == NULL)
  222. return (ERROR);
  224.     bzero ((char *) drvTable, size);
  225.     for (i = 0; i < maxDrivers; i++)
  226. drvTable [i].de_inuse = FALSE;
  228.     /* initialize the device list and data structure semaphore;
  229.      * add the null device to the system 
  230.      */
  232.     semBInit (&iosSemaphore, SEM_Q_PRIORITY, SEM_FULL);
  234.     dllInit (&iosDvList);
  236.     drvTable [0].de_write = nullWrite;
  237.     iosDevAdd (&nullDevHdr, nullDevName, 0);
  238.     iosLibInitialized = TRUE;
  240.     _func_ioTaskStdSet = (FUNCPTR)ioTaskStdSet;
  242.     return (OK);
  243.     }
  244. /*******************************************************************************
  245. *
  246. * iosDrvInstall - install an I/O driver
  247. *
  248. * This routine should be called once by each I/O driver.  It hooks up the
  249. * various I/O service calls to the driver service routines, assigns
  250. * the driver a number, and adds the driver to the driver table.
  251. *
  252. * RETURNS:
  253. * The driver number of the new driver, or ERROR if there is no room for the
  254. * driver.
  255. */
  257. int iosDrvInstall
  258.     (
  259.     FUNCPTR pCreate,    /* pointer to driver create function */
  260.     FUNCPTR pDelete,    /* pointer to driver delete function */
  261.     FUNCPTR pOpen,      /* pointer to driver open function */
  262.     FUNCPTR pClose,     /* pointer to driver close function */
  263.     FUNCPTR pRead,      /* pointer to driver read function */
  264.     FUNCPTR pWrite,     /* pointer to driver write function */
  265.     FUNCPTR pIoctl      /* pointer to driver ioctl function */
  266.     )
  267.     {
  268.     FAST DRV_ENTRY *pDrvEntry = NULL;
  269.     FAST int drvnum;
  271.     iosLock ();
  273.     /* Find a free driver table entry.  Never assign driver number 0. */
  275.     for (drvnum = 1; drvnum < maxDrivers; drvnum++)
  276. if (! drvTable [drvnum].de_inuse)
  277.     {
  278.     /* We've got a free entry */
  280.     pDrvEntry = &drvTable [drvnum];
  281.     break;
  282.     }
  284.     if (pDrvEntry == NULL)
  285. {
  286. /* we couldn't find a free driver table entry */
  288. errnoSet (S_iosLib_DRIVER_GLUT);
  289. iosUnlock ();
  290. return (ERROR);
  291. }
  294.     pDrvEntry->de_inuse = TRUE;
  295.     pDrvEntry->de_create= pCreate;
  296.     pDrvEntry->de_delete= pDelete;
  297.     pDrvEntry->de_open = pOpen;
  298.     pDrvEntry->de_close = pClose;
  299.     pDrvEntry->de_read = pRead;
  300.     pDrvEntry->de_write = pWrite;
  301.     pDrvEntry->de_ioctl = pIoctl;
  303.     iosUnlock ();
  305.     return (drvnum);
  306.     }
  307. /*******************************************************************************
  308. *
  309. * iosDrvRemove - remove an I/O driver
  310. *
  311. * This routine removes an I/O driver (added by iosDrvInstall()) from 
  312. * the driver table.
  313. * 
  314. *
  315. * RETURNS: OK, or ERROR if the driver has open files.
  316. *
  317. * SEE ALSO: iosDrvInstall()
  318. */
  320. STATUS iosDrvRemove
  321.     (
  322.     int drvnum,       /* no. of driver to remove,             */
  323.       /* returned by iosDrvInstall()          */
  324.     BOOL forceClose   /* if TRUE, force closure of open files */
  325.     )
  326.     {
  327.     DEV_HDR *pDevHdr;
  328.     FAST int fd;
  329.     FAST FD_ENTRY *pFdEntry;
  330.     FAST DRV_ENTRY *pDrvEntry = &drvTable [drvnum];
  331.     FUNCPTR drvClose = pDrvEntry->de_close;
  333.     iosLock ();
  335.     /* See if there are any open fd's for this driver */
  337.     for (fd = 0; fd < maxFiles; fd++)
  338. {
  339. pFdEntry = &fdTable [fd];
  340. if (pFdEntry->inuse && pFdEntry->pDevHdr->drvNum == drvnum)
  341.     {
  342.     if (! forceClose)
  343. {
  344. iosUnlock ();
  345. return (ERROR);
  346. }
  347.     else
  348. {
  349. if (drvClose != NULL)
  350.     (* drvClose) (pFdEntry->value);
  352. iosFdFree (STD_FIX(fd));
  353. }
  354.     }
  355. }
  357.     /* remove any devices for this driver */
  359.     for (pDevHdr = (DEV_HDR *) DLL_FIRST (&iosDvList); pDevHdr != NULL;
  360. pDevHdr = (DEV_HDR *) DLL_NEXT (&pDevHdr->node))
  361. {
  362. if (pDevHdr->drvNum == drvnum)
  363.     {
  364.     free (pDevHdr->name);
  365.     dllRemove (&iosDvList, &pDevHdr->node);
  366.     }
  367. }
  370.     pDrvEntry->de_inuse = FALSE;
  371.     pDrvEntry->de_create= NULL;
  372.     pDrvEntry->de_delete= NULL;
  373.     pDrvEntry->de_open = NULL;
  374.     pDrvEntry->de_close = NULL;
  375.     pDrvEntry->de_read = NULL;
  376.     pDrvEntry->de_write = NULL;
  377.     pDrvEntry->de_ioctl = NULL;
  379.     iosUnlock ();
  381.     return (OK);
  382.     }
  383. /*******************************************************************************
  384. *
  385. * iosDevAdd - add a device to the I/O system
  386. *
  387. * This routine adds a device to the I/O system device list, making the
  388. * device available for subsequent open() and creat() calls.
  389. *
  390. * The parameter <pDevHdr> is a pointer to a device header, DEV_HDR (defined
  391. * in iosLib.h), which is used as the node in the device list.  Usually this
  392. * is the first item in a larger device structure for the specific device
  393. * type.  The parameters <name> and <drvnum> are entered in <pDevHdr>.
  394. *
  395. * RETURNS: OK, or ERROR if there is already a device with the specified name.
  396. */
  398. STATUS iosDevAdd
  399.     (
  400.     DEV_HDR *pDevHdr, /* pointer to device's structure */
  401.     char *name,       /* name of device */
  402.     int drvnum        /* no. of servicing driver, */
  403.       /* returned by iosDrvInstall() */
  404.     )
  405.     {
  406.     DEV_HDR *pDevMatch = iosDevMatch (name);
  408.     /* don't add a device with a name that already exists in the device list.
  409.      * iosDevMatch will return NULL if a device name is a substring of the
  410.      * named argument, so check that the two names really are identical.
  411.      */
  413.     if ((pDevMatch != NULL) && (strcmp (pDevMatch->name, name) == 0))
  414. {
  415. errnoSet (S_iosLib_DUPLICATE_DEVICE_NAME);
  416. return (ERROR);
  417. }
  419.     pDevHdr->name   = (char *) malloc ((unsigned) (strlen (name) + 1));
  420.     pDevHdr->drvNum = drvnum;
  422.     if (pDevHdr->name == NULL)
  423. return (ERROR);
  425.     strcpy (pDevHdr->name, name);
  427.     iosLock ();
  429.     dllAdd (&iosDvList, &pDevHdr->node);
  431.     iosUnlock ();
  433.     return (OK);
  434.     }
  435. /*******************************************************************************
  436. *
  437. * iosDevDelete - delete a device from the I/O system
  438. *
  439. * This routine deletes a device from the I/O system device list, making it
  440. * unavailable to subsequent open() or creat() calls.  No interaction with
  441. * the driver occurs, and any file descriptors open on the device or pending
  442. * operations are unaffected.
  443. *
  444. * If the device was never added to the device list, unpredictable results
  445. * may occur.
  446. *
  447. * RETURNS: N/A
  448. */
  450. void iosDevDelete
  451.     (
  452.     DEV_HDR *pDevHdr            /* pointer to device's structure */
  453.     )
  454.     {
  455.     iosLock ();
  456.     dllRemove (&iosDvList, &pDevHdr->node);
  457.     iosUnlock ();
  459.     free (pDevHdr->name);
  460.     }
  461. /*******************************************************************************
  462. *
  463. * iosDevFind - find an I/O device in the device list
  464. *
  465. * This routine searches the device list for a device whose name matches the
  466. * first portion of <name>.  If a device is found, iosDevFind() sets the
  467. * character pointer pointed to by <pNameTail> to point to the first
  468. * character in <name>, following the portion which matched the device name.
  469. * It then returns a pointer to the device.  If the routine fails, it returns
  470. * a pointer to the default device (that is, the device where the current
  471. * working directory is mounted) and sets <pNameTail> to point to the
  472. * beginning of <name>.  If there is no default device, iosDevFind() 
  473. * returns NULL.
  474. *
  475. * RETURNS:
  476. * A pointer to the device header, or NULL if the device is not found.
  477. *
  478. */
  480. DEV_HDR *iosDevFind
  481.     (
  482.     char *name,                 /* name of the device */
  483.     char **pNameTail            /* where to put ptr to tail of name */
  484.     )
  485.     {
  486.     FAST DEV_HDR *pDevHdr = iosDevMatch (name);
  488.     if (pDevHdr != NULL)
  489. *pNameTail = name + strlen (pDevHdr->name);
  490.     else
  491. {
  492. pDevHdr = iosDevMatch (ioDefPath);
  493. *pNameTail = name;
  494. }
  496.     if (pDevHdr == NULL)
  497. errnoSet (S_iosLib_DEVICE_NOT_FOUND);
  499.     return (pDevHdr);
  500.     }
  501. /**********************************************************************
  502. *
  503. * iosDevMatch - find device whose name matches specified string
  504. *
  505. * RETURNS: Pointer to device header, or NULL if device not found.
  506. */
  508. LOCAL DEV_HDR *iosDevMatch
  509.     (
  510.     char *name
  511.     )
  512.     {
  513.     FAST DEV_HDR *pDevHdr;
  514.     FAST int len;
  515.     DEV_HDR *pBestDevHdr = NULL;
  516.     int maxLen = 0;
  518.     iosLock ();
  520.     for (pDevHdr = (DEV_HDR *) DLL_FIRST (&iosDvList); pDevHdr != NULL;
  521. pDevHdr = (DEV_HDR *) DLL_NEXT (&pDevHdr->node))
  522. {
  523. len = strlen (pDevHdr->name);
  525. if (strncmp (pDevHdr->name, name, len) == 0)
  526.     {
  527.     /* this device name is initial substring of name;
  528.      *   if it is longer than any other such device name so far,
  529.      *   remember it.
  530.      */
  532.     if (len > maxLen)
  533. {
  534. pBestDevHdr = pDevHdr;
  535. maxLen = len;
  536. }
  537.     }
  538. }
  540.     iosUnlock ();
  542.     return (pBestDevHdr);
  543.     }
  544. /*******************************************************************************
  545. *
  546. * iosNextDevGet - get the next device in the device list
  547. *
  548. * This routine gets the next device in the device list.
  549. * If the passed pointer is NULL, it starts at the top of the list.
  550. *
  551. * RETURNS:  Pointer to a device, or NULL if <pDev> is
  552. * the last device in the device list.
  553. *
  554. * NOTE: This routine was public in 4.0.2 but is obsolete.  It is made
  555. * no-manual in 5.0 and should be removed in the next major release.
  556. *
  557. * NOMANUAL
  558. */
  560. DEV_HDR *iosNextDevGet
  561.     (
  562.     DEV_HDR *pDev
  563.     )
  564.     {
  565.     if (pDev == NULL)
  566. return ((DEV_HDR *) DLL_FIRST (&iosDvList));
  567.     else
  568. return ((DEV_HDR *) DLL_NEXT (&pDev->node));
  569.     }
  570. /*******************************************************************************
  571. *
  572. * iosFdValue - validate an open file descriptor and return the driver-specific value
  573. *
  574. * This routine checks to see if a file descriptor is valid and
  575. * returns the driver-specific value.
  576. *
  577. * RETURNS: The driver-specific value, or ERROR if the file descriptor is 
  578. * invalid.
  579. */
  581. int iosFdValue
  582.     (
  583.     FAST int fd         /* file descriptor to check */
  584.     )
  585.     {
  586.     int xfd = STD_MAP (fd);
  588.     if (xfd >= 0 && xfd < maxFiles && fdTable[xfd].inuse)
  589. return (fdTable[xfd].value);
  590.     else
  591. {
  592. errnoSet (S_iosLib_INVALID_FILE_DESCRIPTOR);
  593. return (ERROR);
  594. }
  595.     }
  596. /*******************************************************************************
  597. *
  598. * iosFdDevFind - verify if open file descriptor is valid and return a pointer to DEV_HDR
  599. *
  600. * NOMANUAL
  601. */
  603. DEV_HDR *iosFdDevFind
  604.     (
  605.     FAST int fd
  606.     )
  607.     {
  608.     int xfd = STD_MAP (fd);
  610.     if (xfd >= 0 && xfd < maxFiles && fdTable[xfd].inuse)
  611. return (fdTable[xfd].pDevHdr);
  612.     else
  613. {
  614. errnoSet (S_iosLib_INVALID_FILE_DESCRIPTOR);
  615. return (NULL);
  616. }
  617.     }
  618. /*******************************************************************************
  619. *
  620. * iosFdFree - free an file descriptor entry in the file descriptor table
  621. *
  622. * This routine frees a file descriptor table entry.
  623. *
  624. * NOMANUAL
  625. */
  627. void iosFdFree
  628.     (
  629.     int fd              /* fd to free up */
  630.     )
  631.     {
  632.     FAST FD_ENTRY *pFdEntry;
  633.     FAST int xfd = STD_MAP(fd);
  635.     if ((pFdEntry = FD_CHECK (xfd)) != NULL)
  636. {
  638. if (pFdEntry->name != NULL)
  639.     {
  640.     /* free name unless it is just the device name */
  642.     if (pFdEntry->name != pFdEntry->pDevHdr->name)
  643. free (pFdEntry->name);
  645.     pFdEntry->name = NULL;
  646.     }
  648. if (iosFdFreeHookRtn != NULL)
  649.     (* iosFdFreeHookRtn) (fd);
  651. pFdEntry->inuse = FALSE;
  652. }
  653.     }
  654. /*******************************************************************************
  655. *
  656. * iosFdSet - record file descriptor specifics in file descriptor table
  657. *
  658. * This routine records the passed information about an file descriptor 
  659. * into the file descriptor table.
  660. *
  661. * The file name should NOT have been malloc'd prior to calling this routine.
  662. * The file name is now treated as follows:
  663. *   if no file name is specified (NULL),
  664. * then the name pointer in the file descriptor entry is left NULL.
  665. *   if the file name is the same as the device name,
  666. * then the name pointer in the file descriptor entry is set to point 
  667. *       to the device name
  668. *   otherwise
  669. * space is malloc'd for the file name and it is copied to that space
  670. *
  671. * This routine and iosFdFree ensure that the proper free'ing is done in each
  672. * of the cases.
  673. *
  674. * This name handling eliminates the malloc/free in cases where the file name
  675. * is the device name (i.e. sockets, pipes, serial devices, etc).
  676. *
  677. * NOMANUAL
  678. */
  680. STATUS iosFdSet
  681.     (
  682.     int fd,             /* file descriptor */
  683.     DEV_HDR *pDevHdr,   /* associated driver header */
  684.     char *name,         /* name of file */
  685.     int value           /* arbitrary driver info */
  686.     )
  687.     {
  688.     FAST FD_ENTRY *pFdEntry = &fdTable [STD_UNFIX(fd)];
  689.     STATUS        returnVal = OK;
  690.     int           error = 0;
  692.     /* free name unless it is just the device name */
  694.     if ((pFdEntry->name != NULL) && (pFdEntry->name != pDevHdr->name))
  695. free (pFdEntry->name);
  697.     /* if no name specified, set it NULL;
  698.      * if name is same as device name, make fd name point to device name;
  699.      * otherwise malloc and copy file name
  700.      */
  701.     if (name == NULL)
  702. pFdEntry->name = NULL;
  703.     else if (strcmp (name, pDevHdr->name) == 0)
  704. pFdEntry->name = pDevHdr->name;
  705.     else
  706. {
  707. if ((pFdEntry->name = (char *) malloc ((unsigned) (strlen (name) + 1)))
  708.     == NULL)
  709.     {
  710.     error = 1;
  711.     goto handleError;
  712.     }
  713. strcpy (pFdEntry->name, name);
  714. }
  716.     pFdEntry->pDevHdr = pDevHdr;
  717.     pFdEntry->value   = value;
  720.     return returnVal;
  722.     
  723. handleError:
  724.     if (error > 0)
  725. {
  726. returnVal = ERROR;
  727. }
  729.     
  730.     return returnVal;
  731.     }
  732. /*******************************************************************************
  733. *
  734. * iosFdNew - allocate and initialize a new fd
  735. *
  736. * This routine gets the index of a free entry in the file descriptor table.  
  737. * The entry is marked as reserved and will not be available again until it is
  738. * explicitly freed with iosFdFree().
  739. *
  740. * RETURNS: The file descriptor or ERROR.
  741. *
  742. * NOMANUAL
  743. */
  745. int iosFdNew
  746.     (
  747.     DEV_HDR *pDevHdr,   /* associated driver header */
  748.     char *name,         /* name of file */
  749.     int value           /* arbitrary driver info */
  750.     )
  751.     {
  752.     FAST int      fd;
  753.     FAST FD_ENTRY *pFdEntry = NULL;
  754.     FAST int      error = 0;
  756.     iosLock ();
  758.     for (fd = 0; fd < maxFiles; fd++)
  759. {
  760. if (!fdTable[fd].inuse)
  761.     {
  762.     pFdEntry = &fdTable[fd];
  763.     pFdEntry->inuse  = TRUE; /* reserve this entry */
  764.     pFdEntry->name   = NULL;
  765.     break;
  766.     }
  767. }
  769.     iosUnlock ();
  771.     fd = STD_FIX(fd);
  773.     if (fd >= maxFiles)
  774. {
  775. errnoSet (S_iosLib_TOO_MANY_OPEN_FILES);
  776. error = 1;
  777. goto handleError;
  778. }
  780.     if ((iosFdSet (fd, pDevHdr, name, value)) == ERROR)
  781. {
  782. error = 1;
  783. goto handleError;
  784. }
  787.     if (iosFdNewHookRtn != NULL)
  788. {
  789. (* iosFdNewHookRtn) (fd);
  790. }
  793.     return fd;
  794.     
  796. handleError:
  797.     if (error > 0)
  798. {
  799. if (pFdEntry != NULL)
  800.     {
  801.     pFdEntry->inuse = FALSE;
  802.     pFdEntry->name  = NULL;
  803.     }
  804. fd = (int)ERROR;
  805. }
  806.     
  807.     
  808.     return (fd);
  809.     }
  810. /*******************************************************************************
  811. *
  812. * iosCreat - invoke driver to open file
  813. *
  814. * RETURNS: OK if there is no create routine, or a driver-specific value.
  815. *
  816. * NOMANUAL
  817. */
  819. int iosCreate
  820.     (
  821.     DEV_HDR *pDevHdr,
  822.     char *fileName,
  823.     int mode
  824.     )
  825.     {
  826.     FUNCPTR drvCreate = drvTable [pDevHdr->drvNum].de_create;
  828.     if (drvCreate != NULL)
  829. return ((*drvCreate)(pDevHdr, fileName, mode));
  830.     else
  831. return (OK);
  832.     }
  833. /*******************************************************************************
  834. *
  835. * iosDelete - invoke driver to delete file
  836. *
  837. * RETURNS: OK if there is no delete routine, or a driver-specific value.
  838. *
  839. * NOMANUAL
  840. */
  842. int iosDelete
  843.     (
  844.     DEV_HDR *pDevHdr,
  845.     char *fileName
  846.     )
  847.     {
  848.     FUNCPTR drvDelete = drvTable [pDevHdr->drvNum].de_delete;
  850.     if (drvDelete != NULL)
  851. return ((*drvDelete)(pDevHdr, fileName));
  852.     else
  853. return (OK);
  854.     }
  855. /*******************************************************************************
  856. *
  857. * iosOpen - invoke driver to open file
  858. *
  859. * RETURNS:
  860. * OK if the driver has no open routine, or
  861. * whatever the driver's open routine returns.
  862. *
  863. * NOMANUAL
  864. */
  866. int iosOpen
  867.     (
  868.     DEV_HDR *pDevHdr,
  869.     char *fileName,
  870.     int flags,
  871.     int mode
  872.     )
  873.     {
  874.     FUNCPTR drvOpen = drvTable [pDevHdr->drvNum].de_open;
  876.     if (drvOpen != NULL)
  877. return ((*drvOpen)(pDevHdr, fileName, flags, mode));
  878.     else
  879. return (OK);
  880.     }
  881. /*******************************************************************************
  882. *
  883. * iosClose - invoke driver to close file
  884. *
  885. * RETURNS:
  886. * OK if the driver has no close routine, or
  887. * whatever the driver's close routine returns, or
  888. * ERROR if the file descriptor is invalid.
  889. *
  890. * NOMANUAL
  891. */
  893. STATUS iosClose
  894.     (
  895.     int fd
  896.     )
  897.     {
  898.     STATUS status;
  899.     FUNCPTR drvClose;
  900.     FD_ENTRY *pFdEntry;
  901.     FAST int xfd = STD_MAP(fd);
  903.     if ((pFdEntry = FD_CHECK (xfd)) == NULL)
  904. status = ERROR; /* status set when bad fd */
  905.     else
  906. {
  907. drvClose = drvTable [pFdEntry->pDevHdr->drvNum].de_close;
  909. if (drvClose != NULL)
  910.     status = (*drvClose)(pFdEntry->value);
  911. else
  912.     status = OK;
  914. iosFdFree (STD_FIX(xfd));
  915. }
  917.     return (status);
  918.     }
  919. /*******************************************************************************
  920. *
  921. * iosRead - invoke driver read routine
  922. *
  923. * RETURNS:
  924. * Whatever the driver's read routine returns (number of bytes read), or
  925. * ERROR if the file descriptor is invalid or if the driver has no read 
  926. * routine.  If the driver has no read routine, errno is set to ENOTSUP.
  927. *
  928. * NOMANUAL
  929. */
  931. int iosRead
  932.     (
  933.     int fd,
  934.     char *buffer,
  935.     int maxbytes
  936.     )
  937.     {
  938.     FUNCPTR drvRead;
  939.     FAST FD_ENTRY *pFdEntry;
  940.     FAST int xfd = STD_MAP(fd);
  942.     if ((pFdEntry = FD_CHECK (xfd)) == NULL)
  943. return (ERROR);
  945.     drvRead = drvTable [pFdEntry->pDevHdr->drvNum].de_read;
  947.     if (drvRead == NULL)
  948. {
  949. errno = ENOTSUP;
  950. return (ERROR);
  951. }
  952.     else
  953. return ((* drvRead) (pFdEntry->value, buffer, maxbytes));
  954.     }
  955. /*******************************************************************************
  956. *
  957. * iosWrite - invoke driver write routine
  958. *
  959. * RETURNS:
  960. * Whatever the driver's write routine returns (number of bytes written), or
  961. * ERROR if the file descriptor is invalid or if the driver has no write
  962. * routine. If the driver has no write routine, errno is set to ENOTSUP.
  963. *
  964. * NOMANUAL
  965. */
  967. int iosWrite
  968.     (
  969.     int fd,
  970.     char *buffer,
  971.     int nbytes
  972.     )
  973.     {
  974.     FUNCPTR drvWrite;
  975.     FAST FD_ENTRY *pFdEntry;
  976.     FAST int xfd = STD_MAP(fd);
  978.     if ((pFdEntry = FD_CHECK (xfd)) == NULL)
  979. return (ERROR);
  981.     drvWrite = drvTable [pFdEntry->pDevHdr->drvNum].de_write;
  983.     if (drvWrite == NULL)
  984. {
  985. errno = ENOTSUP;
  986. return (ERROR);
  987. }
  988.     else
  989. return ((* drvWrite) (pFdEntry->value, buffer, nbytes));
  990.     }
  991. /*******************************************************************************
  992. *
  993. * iosIoctl - invoke driver ioctl routine
  994. *
  995. * RETURNS:
  996. * OK if the function is FIOGETNAME (and arg set to name), or
  997. * if driver has no ioctl routine and
  998. * function is FIONREAD then 0 otherwise ERROR, or
  999. * whatever driver ioctl routine returns, or
  1000. * ERROR if invalid file descriptor
  1001. *
  1002. * NOMANUAL
  1003. */
  1005. int iosIoctl
  1006.     (
  1007.     int fd,
  1008.     int function,
  1009.     int arg
  1010.     )
  1011.     {
  1012.     FUNCPTR drvIoctl;
  1013.     FAST FD_ENTRY *pFdEntry;
  1014.     FAST int xfd = STD_MAP(fd);
  1016.     if ((pFdEntry = FD_CHECK (xfd)) == NULL)
  1017. return (ERROR);
  1019.     if (function == FIOGETNAME)
  1020. {
  1021. strcpy ((char *) arg, pFdEntry->name);
  1022. return (OK);
  1023. }
  1025.     drvIoctl = drvTable [pFdEntry->pDevHdr->drvNum].de_ioctl;
  1027.     if (drvIoctl == NULL)
  1028. {
  1029. if (function == FIONREAD)
  1030.     {
  1031.     * (char *) arg = 0;
  1032.     return (OK);
  1033.     }
  1034. else
  1035.     {
  1036.     errnoSet (S_ioLib_UNKNOWN_REQUEST);
  1037.     return (ERROR);
  1038.     }
  1039. }
  1040.     else
  1041. {
  1042. return ((* drvIoctl) (pFdEntry->value, function, arg));
  1043. }
  1044.     }
  1046. /*******************************************************************************
  1047. *
  1048. * iosLock - get exclusive use of I/O data structures
  1049. *
  1050. * This routine takes exclusive use of the I/O system's data structures,
  1051. * by taking the semaphore used for that purpose.  If the semaphore
  1052. * is already taken, the calling task will suspend until the
  1053. * semaphore is available.
  1054. */
  1056. LOCAL void iosLock (void)
  1057.     {
  1058.     semTake (&iosSemaphore, WAIT_FOREVER);
  1059.     }
  1060. /*******************************************************************************
  1061. *
  1062. * iosUnlock - release exclusive use of I/O data structures
  1063. *
  1064. * This routine releases the semaphore which had been checked out by iosLock.
  1065. * This routine should only be called by a task which currently has the
  1066. * semaphore.
  1067. */
  1069. LOCAL void iosUnlock (void)
  1070.     {
  1071.     semGive (&iosSemaphore);
  1072.     }