home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume26 / maint / part02 / pool.c < prev    next >
C/C++ Source or Header  |  1992-05-13  |  13KB  |  405 lines
  1. /******************************************************************************
  2. *******************************************************************************
  3.  
  4.    Site:    Western Michigan University Academic Computer Center
  5.  
  6.    System:    Directory/File System Maintenance
  7.   
  8.    Program:    maint
  9.  
  10.    Version=01    Level=00    01/24/92    Leonard J. Peirce
  11.  
  12.    Purpose:    Routines for handling memory pools.
  13.  
  14.    Arguments:    See individual routines.
  15.  
  16.    External variables:    See individual routines.
  17.  
  18.    External functions:
  19.  
  20.     Defined:    free_pool, get_pool_mem, init_pool, new_pool, put_pool,
  21.             reset_pool
  22.  
  23.     Called:        None
  24.  
  25.    Files accessed:    None
  26.  
  27.    Return codes:    See individual routines
  28.  
  29.    Compiling instructions:    See Makefile
  30.  
  31.    Linking instructions:    See Makefile
  32.  
  33.    Other information:    Copyright (C) 1992, Leonard J. Peirce
  34.  
  35. ********************************************************************************
  36. *******************************************************************************/
  37.  
  38. /******************************************************************************/
  39. /*                                                                            */
  40. /*                        # I N C L U D E   F I L E S                         */
  41. /*                                                                            */
  42. /******************************************************************************/
  43.  
  44. #include <stdio.h>
  45. #include <malloc.h>
  46. #include "maint.h"
  47. #include <string.h>
  48.  
  49. /******************************************************************************/
  50. /*                                                                            */
  51. /*                             # D E F I N E S                                */
  52. /*                                                                            */
  53. /******************************************************************************/
  54.  
  55. /******************************************************************************/
  56. /*                                                                            */
  57. /*          S T R U C T U R E S ,   U N I O N S ,   T Y P E D E F S           */
  58. /*                                                                            */
  59. /******************************************************************************/
  60.  
  61. /******************************************************************************/
  62. /*                                                                            */
  63. /*   E X T E R N A L   D E F I N I T I O N S   &   D E C L A R A T I O N S    */
  64. /*                                                                            */
  65. /******************************************************************************/
  66.  
  67.      char      *get_pool_mem();
  68.  
  69.      POOL_DEF *new_pool();
  70.  
  71.      void      init_pool(),
  72.           put_pool(),
  73.           free_pool(),
  74.           reset_pool();
  75.  
  76. /******************************************************************************/
  77. /*                                                                            */
  78. /*     S T A T I C   D E F I N I T I O N S   &   D E C L A R A T I O N S      */
  79. /*                                                                            */
  80. /******************************************************************************/
  81.  
  82. /*******************************************************************************
  83. ********************************************************************************
  84.  
  85.   Function:    init_pool
  86.  
  87.   Purpose:    Allocate the first memory pool for the current directory,
  88.         initializing the pool structure node and initialize all of
  89.         the other structures to point to null pools.  The remaining
  90.         pool node structures are linked together in a linked list.
  91.  
  92.   Global variables:
  93.  
  94.     Name            Examine/Modify/Use/Read/Write
  95.     ----            -----------------------------
  96.     none
  97.  
  98.   Return Codes:
  99.                  
  100.     Code            Reason
  101.     ----            ------
  102.     none
  103.  
  104.   Termination Codes:
  105.  
  106.     Code            Reason
  107.     ----            ------
  108.     CANT_ALLOC        cannot allocate memory
  109.  
  110. ********************************************************************************
  111. *******************************************************************************/
  112.  
  113. void init_pool(pool,pool_length)
  114.                     /*******   FORMAL  PARAMETERS   *******/
  115.      POOL_DEF **pool;        /* array of pool node structures      */
  116.      size_t      pool_length;        /* length of pool to allocate          */
  117.  
  118. {    /*** init_pool ***/
  119.                     /********   LOCAL  VARIABLES   ********/
  120. register POOL_DEF *tptr;        /* temporary pool node structure ptr  */
  121.  
  122.  
  123.    /* allocate memory for the pool node structure first */
  124.  
  125.    tptr = (POOL_DEF *) malloc(sizeof(POOL_DEF));
  126.  
  127.    if(tptr == NULL)
  128.    {
  129.       puts("*ERROR*  Cannot allocate memory in init_pool #1");
  130.       exit(CANT_ALLOCATE);
  131.    }
  132.  
  133.    /* allocate memory for the first pool and initialize all of the other
  134.     * accounting stuff associated with it
  135.     */
  136.  
  137.    tptr->first = (char *) malloc((u_int) pool_length);
  138.  
  139.    if(tptr == NULL)
  140.    {
  141.       puts("*ERROR*  Cannot allocate memory in init_pool #2");
  142.       exit(CANT_ALLOCATE);
  143.    }
  144.  
  145.    /* set up the other stuff for the first memory pool */
  146.  
  147.    tptr->ptr = tptr->first;        /* set pointer to available memory    */
  148.    tptr->remaining = pool_length;    /* all bytes in pool available          */
  149.    tptr->next_pool = NULL;        /* terminate the linked list....      */
  150.    tptr->length = pool_length;        /* save original length of pool          */
  151.    *pool = tptr;            /* start everything....              */
  152.  
  153.    return;
  154.  
  155. }    /*** init_pool ***/
  156.  
  157. /*******************************************************************************
  158. ********************************************************************************
  159.  
  160.   Function:    reset_pool
  161.  
  162.   Purpose:    Reset the pool pointers so that the memory allocated for them
  163.         can be used again without reallocating the memory.
  164.  
  165.   Global variables:
  166.  
  167.     Name            Examine/Modify/Use/Read/Write
  168.     ----            -----------------------------
  169.     none
  170.  
  171.   Return Codes:
  172.  
  173.     Code            Reason
  174.     ----            ------
  175.     none
  176.  
  177. ********************************************************************************
  178. *******************************************************************************/
  179.  
  180. void reset_pool(pool)
  181.                     /*******   FORMAL  PARAMETERS   *******/
  182. register POOL_DEF *pool;        /* memory pool node structures          */
  183.  
  184. {    /*** reset_pool ***/                 
  185.  
  186.    while(pool != NULL)
  187.    {
  188.       pool->ptr = pool->first;        /* reset available byte pointer          */
  189.       pool->remaining = pool->length;    /* reset number of bytes available    */
  190.       pool = pool->next_pool;        /* go to next pool node structure     */
  191.    }
  192.  
  193.    return;
  194.  
  195. }    /*** reset_pool ***/
  196.  
  197. /*******************************************************************************
  198. ********************************************************************************
  199.  
  200.   Function:    new_pool
  201.  
  202.   Purpose:    allocate memory for a pool node structure and the actual
  203.         memory for the pool; also link the pool to the pool list.
  204.  
  205.   Global variables:
  206.  
  207.     Name            Examine/Modify/Use/Read/Write
  208.     ----            -----------------------------
  209.     none
  210.  
  211.   Return Codes:
  212.  
  213.     Code            Reason
  214.     ----            ------
  215.     none
  216.  
  217. ********************************************************************************
  218. *******************************************************************************/
  219.  
  220. POOL_DEF *new_pool(pool,pool_length)
  221.                     /*******   FORMAL  PARAMETERS   *******/
  222. register POOL_DEF *pool;        /* pointer to current memory pool     */
  223.      size_t      pool_length;        /* length of pool to allocate          */
  224.  
  225. {    /*** new_pool ***/
  226.                     /********   LOCAL  VARIABLES   ********/
  227.      POOL_DEF *tptr;        /* temporary pool pointer          */
  228.  
  229.  
  230.    /* first see if there is a pool already out there; if there is,
  231.     * just return so that we don't have to reuse the memory
  232.     */
  233.  
  234.    if(pool->next_pool != NULL)        /* is there a pool out there?          */
  235.       return(pool->next_pool);        /* yes, just return a pointer to it   */
  236.  
  237.    /* at this point we have conceded that a new memory pool is needed; allocate
  238.     * the structure to hold the new pool's accounting information
  239.     */
  240.  
  241.    init_pool(&tptr,pool_length);
  242.  
  243.    pool->next_pool = tptr;        /* link to current pool              */
  244.    pool = pool->next_pool;        /* move to new pool structure          */
  245.  
  246.    return(tptr);            /* return pointer to new pool struct. */
  247.  
  248. }    /*** new_pool ***/
  249.  
  250. /*******************************************************************************
  251. ********************************************************************************
  252.  
  253.   Function:    put_pool
  254.  
  255.   Purpose:    Copy a string to a memory pool.  If the current pool does not
  256.         have enough memory to accomodate the string, allocate a new
  257.         pool first and then copy the string to the new pool.
  258.  
  259.   Global variables:
  260.  
  261.     Name            Examine/Modify/Use/Read/Write
  262.     ----            -----------------------------
  263.     none
  264.  
  265.   Return Codes:
  266.  
  267.     Code            Reason
  268.     ----            ------
  269.     none
  270.  
  271. ********************************************************************************
  272. *******************************************************************************/
  273.  
  274. void put_pool(dest,pool,str,length,pool_length)
  275.                     /*******   FORMAL  PARAMETERS   *******/
  276.      char      **dest;        /* where to store pointer to str      */
  277.      POOL_DEF **pool;        /* current memory pool structure      */
  278.      char      *str;            /* string to be stored in memory pool */
  279.      size_t      length;        /* length of string to be stored      */
  280.      size_t      pool_length;        /* length of pool if we need another  */
  281.                 
  282. {    /*** put_pool ***/
  283.                     /********   LOCAL  VARIABLES   ********/
  284. register POOL_DEF *tptr;        /* temporary pool structure pointer   */
  285.  
  286.  
  287.    if((*pool)->remaining < (length + 1)) /* has the pool run dry....?          */
  288.    {
  289.       *pool = new_pool(*pool,pool_length); /* yes, get another pool          */
  290.    }
  291.  
  292.    tptr = *pool;            /* set up temporary pool struct. ptr. */
  293.    strcpy(tptr->ptr,str);        /* copy the string to the pool          */
  294.    *dest = tptr->ptr;            /* set the pointer to the string      */
  295.    tptr->ptr = tptr->ptr + length + 1;    /* update available memory pointer    */
  296.    tptr->remaining = tptr->remaining - (length + 1);
  297.  
  298.    return;
  299.  
  300. }    /*** put_pool ***/
  301.  
  302. /*******************************************************************************
  303. ********************************************************************************
  304.  
  305.   Function:    get_pool_mem
  306.  
  307.   Purpose:    Return a pointer to a memory slot that will satisfy the request.
  308.  
  309.   Global variables:
  310.  
  311.     Name            Examine/Modify/Use/Read/Write
  312.     ----            -----------------------------
  313.     none
  314.  
  315.   Return Codes:
  316.  
  317.     Code            Reason
  318.     ----            ------
  319.     retptr            pointer to memory slot
  320.  
  321. ********************************************************************************
  322. *******************************************************************************/
  323.  
  324. char *get_pool_mem(pool,pool_length,length)
  325.                     /*******   FORMAL  PARAMETERS   *******/
  326. register POOL_DEF **pool;        /* current memory pool              */
  327.      size_t      pool_length,        /* length of pool to request          */
  328.           length;        /* length of memory slot needed          */
  329.  
  330. {    /*** get_pool_mem ***/
  331.                     /********   LOCAL  VARIABLES   ********/
  332. register char      *retptr;        /* pointer to return              */
  333. register POOL_DEF *tptr;        /* used to speed things up a bit....  */
  334.  
  335.  
  336.    /* is there enough room in the current memory pool?  If not, allocate
  337.     * another one and get the memory from there
  338.     */
  339.  
  340.    if((*pool)->remaining < (length + 1))
  341.       *pool = new_pool(*pool,pool_length);
  342.  
  343.    tptr = *pool;            /* make a pointer              */
  344.  
  345.    /* we have the memory, whether it is in a new pool or the one we had on
  346.     * entry; update the pool structure to reflect the memory that we need
  347.     * to take from it
  348.     */
  349.  
  350.    retptr = tptr->ptr;            /* save pointer to memory slot          */
  351.    tptr->ptr = tptr->ptr + length + 1L;
  352.    tptr->remaining = tptr->remaining - (length + 1);
  353.    
  354.    return(retptr);            /* return pointer to slot          */
  355.  
  356. }    /*** get_pool_mem ***/
  357.  
  358. /*******************************************************************************
  359. ********************************************************************************
  360.  
  361.   Function:    free_pool
  362.  
  363.   Purpose:    Free the memory of all of the memory pools for a directory,
  364.         including the node structures for all of the nodes.  This
  365.         routine will be called when exiting a directory.
  366.  
  367.   Global variables:
  368.  
  369.     Name            Examine/Modify/Use/Read/Write
  370.     ----            -----------------------------
  371.     none
  372.  
  373.   Return Codes:
  374.  
  375.     Code             Reason
  376.     ----            ------
  377.     none
  378.  
  379. ********************************************************************************
  380. *******************************************************************************/
  381.  
  382. void free_pool(pool)
  383.                     /*******   FORMAL  PARAMETERS   *******/
  384. register POOL_DEF *pool;        /* first pool in pool node list          */
  385.  
  386. {    /*** free_pool ***/
  387.                     /********   LOCAL  VARIABLES   ********/
  388. register POOL_DEF *tpool;        /* temporary pool node pointer          */
  389.  
  390.  
  391.  
  392.    while(pool != NULL)
  393.    {
  394.       /* free the memory for the pool first */
  395.  
  396.       tpool = pool->next_pool;        /* save pointer to next pool node     */
  397.       free(pool->first);        /* free the memory              */
  398.       free((char *) pool);        /* free memory for pool node struct.  */
  399.       pool = tpool;            /* move to next pool in list          */
  400.    }
  401.  
  402.    return;
  403.  
  404. }    /*** free_pool ***/
  405.