home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / doc / ems / disk1 / memintrl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-12-03  |  123.2 KB  |  2,547 lines
  1. /**********************************************************************/
  2. /*                                                                    */
  3. /*     Module: MEMINTRL.INC                                           */
  4. /*                                                                    */
  5. /*     This module contains the internal routines used by MEMLIB.C.   */
  6. /*     These functions are designed to be called by the functions     */
  7. /*     contained in MEMLIB.C only and are not for use by an           */
  8. /*     application.                                                   */
  9. /*                                                                    */
  10. /**********************************************************************/
  11.  
  12. /*$PAGE*/
  13. /*====================================================================*/
  14. /*   INCLUDE FILES                                                    */
  15. /*====================================================================*/
  16.  
  17. #include <stddef.h>
  18. #include <malloc.h>
  19. #include <dos.h>
  20.  
  21. /*******************************************************************/
  22. /* Error code definitions for MEMLIB.  Since MEMLIB makes calls to */
  23. /* EMMLIB you may get EMM specific errors.  These errors can be    */
  24. /* found in table A-2 in the EMS manual.                           */
  25. /*******************************************************************/
  26.  
  27. #include "errors.h"
  28.  
  29. /********************************/
  30. /* External Function prototypes */
  31. /********************************/
  32.  
  33. #include "memlib.h"
  34. #include "emmlib.h"
  35.  
  36. /********************************/
  37. /* Internal Function prototypes */
  38. /********************************/
  39.  
  40. unsigned int init_exp_mem   (void);
  41. unsigned int break_overlap  (unsigned int *);
  42. unsigned int check_best_fit (unsigned int, unsigned int *, long *);
  43. unsigned int split_block    (unsigned int, unsigned int);
  44. unsigned int search_after   (unsigned int, unsigned int *, unsigned int *);
  45. unsigned int search_before  (unsigned int, unsigned int *, unsigned int *);
  46. unsigned int coalesce_block (unsigned int, unsigned int, unsigned int *);
  47. unsigned int map_dir_page   (unsigned int, unsigned int);
  48. unsigned int check_token    (unsigned int);
  49. unsigned int find_new_dir_start          (void);
  50. unsigned int restore_memlib_context      (unsigned int);
  51. unsigned int allocate_new_directory_page (void);
  52. unsigned int allocate_new_block          (unsigned int, unsigned int);
  53. unsigned int check_if_all_blocks_free    (unsigned int *);
  54. unsigned int prepare_dir_mapping         (unsigned int *);
  55.  
  56. /*$PAGE*/
  57. /*====================================================================*/
  58. /*   DEFINES                                                          */
  59. /*====================================================================*/
  60.  
  61. #define TRUE                       (unsigned int) 1
  62. #define FALSE                      (unsigned int) 0
  63. #define PASSED                     (unsigned int) 0
  64. #define K64K                       (unsigned long) (64L * 1024L)
  65. #define K16K                       (unsigned int) (16 * 1024)
  66.  
  67. #define PAGE_SIZE                  (unsigned int) K16K
  68. #define MAX_PAGE_FRAME_SIZE        (unsigned int) 24
  69. #define LARGEST_ALLOCATABLE_BLOCK  (unsigned int) (K64K - 1)
  70. #define MAX_ALLOCATABLE_PAGES      (unsigned int) 4
  71. #define MAX_CONTEXTS_AVAILABLE     (unsigned int) 10
  72. #define MAX_DIR_ENTRIES            (unsigned int) (K64K - 1)
  73.  
  74. #define FIRST_PHYS_PAGE            (unsigned int) 0
  75. #define SECOND_PHYS_PAGE           (unsigned int) 1
  76.  
  77. #define UNASSIGNED_TOKEN           (unsigned int) 0xFFFF
  78. #define OFFSET_SIZE                (unsigned int) 0x0400
  79. #define UNMAPPED                   (unsigned int) 0xFFFF
  80. #define NO_CONTEXTS                (unsigned int) 0xFFFF
  81.  
  82. #define EMM_NOT_ENOUGH_PAGES       (unsigned int) 0x88
  83.  
  84. #define DIR_ENTRIES_PER_PAGE       (PAGE_SIZE / sizeof(DIRECTORY_NODE))
  85.  
  86. /*$PAGE*/
  87. /*====================================================================*/
  88. /*   TYPEDEFS                                                         */
  89. /*====================================================================*/
  90.  
  91. /**********************************************************************/
  92. /* This structure stores the housekeeping information used to         */
  93. /* uniquely identify a block of memory and to do garbage collection.  */
  94. /* The directory is an array of these structures.                     */
  95. /*                                                                    */
  96. /*  token        - An identifier to a block of memory which is an     */
  97. /*                 index in the directory array.                      */
  98. /*  size         - The size of the memory block.                      */
  99. /*  logical_page - The array of logical pages that the block uses.    */
  100. /*  offset       - The offset into this block's first logical page.   */
  101. /*                 We only need to keep track of the offset since the */
  102. /*                 segment is set by seteptrs when access is desired. */
  103. /*                                                                    */
  104. /* We must keep track of the directory entries in two ways (an entry  */
  105. /* meaning the index into the directory array which gives us access   */
  106. /* to the structure above).  One is in which the token is used as an  */
  107. /* index into the directory array, giving us a range of 0 - 65535     */
  108. /* directory entries.  Second is when we actually want to access a    */
  109. /* directory entry.  Since we cannot map in the entire directory, due */
  110. /* to its size, we must find what logical page an entry belongs to,   */
  111. /* map that page in, and access that entry by using an index into     */
  112. /* that page.  This index has a range of 0 to the number of entries   */
  113. /* possible in a page.                                                */
  114. /*                                                                    */
  115. /* Note: The token has two uses -- one for identifying a block of     */
  116. /* memory and other as an index into the full directory array which   */
  117. /* gives us acces to a DIRECTORY_NODE structure.  The user of MEMLIB  */
  118. /* always keeps track of his blocks of memory with the token value    */
  119. /* and does not have to worry about the directory array.              */
  120. /*                                                                    */
  121. /* In order to know which logical page to map in we use the following */
  122. /* formula:                                                           */
  123. /*                                                                    */
  124. /* directory_log_page = token / DIR_ENTRIES_PER_PAGE                  */
  125. /*                                                                    */
  126. /* Token is the actual entry into the directory that identifies a     */
  127. /* block.  NUM_DIR_ENTRIES is a macro that returns the number of      */
  128. /* directory entries possible in a given number of pages -- in this   */
  129. /* case one page.  By performing an integer divide, we obtain the     */
  130. /* logical page number that this token's directory entry resides in.  */            
  131. /*                                                                    */
  132. /* In order to access a directory entry when it is mapped in we use   */
  133. /* this formula:                                                      */
  134. /*                                                                    */
  135. /* directory_index = token % DIR_ENTRIES_PER_PAGE                     */
  136. /*                                                                    */
  137. /* This number is used as an index into the page of the directory     */
  138. /* array that's mapped in.  This number is different than the token   */
  139. /* which identifies the entry into the full directory array.          */
  140. /**********************************************************************/
  141.  
  142. typedef struct 
  143. {
  144.    unsigned int token;
  145.    unsigned int size;
  146.    unsigned int logical_page [MAX_ALLOCATABLE_PAGES];
  147.    unsigned int offset;
  148.  
  149. } DIRECTORY_NODE;
  150.  
  151. /**********************************************************************/
  152. /* This structure is for holding the segment and page number of a     */
  153. /* mappable memory region.  This will be used in an array to hold the */
  154. /* entire list of mappable memory regions.                            */
  155. /**********************************************************************/
  156.  
  157. typedef struct 
  158. {
  159.    unsigned int phys_page_segment;
  160.    unsigned int phys_page_number;
  161.  
  162. } MAPPABLE_REGIONS;
  163.  
  164.  
  165. /*$PAGE*/
  166. /*====================================================================*/
  167. /*                 MACROS                                             */
  168. /*====================================================================*/
  169.  
  170. /**********************************************************************/
  171. /* This macro returns the number of PAGE_SIZE pages needed for a      */
  172. /* memory block of the given size.                                    */
  173. /**********************************************************************/
  174. #define NUM_PAGES(size) ((unsigned int) (((unsigned long) size + PAGE_SIZE - 1) / PAGE_SIZE))
  175.  
  176. /**********************************************************************/
  177. /* This macro returns the number of directory entries that fit within */
  178. /* the given amount of PAGES_SIZE pages.                              */
  179. /**********************************************************************/
  180. #define NUM_DIR_ENTRIES(num_pages) ((unsigned long) (PAGE_SIZE / sizeof (DIRECTORY_NODE)) * num_pages)
  181.  
  182. /*$PAGE*/
  183. /*====================================================================*/
  184. /*   GLOBAL VARIABLES                                                 */
  185. /*====================================================================*/
  186.  
  187. /**********************************************************************/
  188. /* Actual number of PAGE_SIZE pages available in the page frame       */
  189. /**********************************************************************/
  190.  
  191. unsigned int num_pages_in_page_frame;
  192.  
  193. /**********************************************************************/
  194. /* Store the page frame base address                                  */
  195. /**********************************************************************/
  196.  
  197. void far* page_frame_base_address;
  198.  
  199. /**********************************************************************/
  200. /* Store the EMM handle that the app will use                         */
  201. /* Store the EMM handle that the memory manager will use              */
  202. /**********************************************************************/
  203.  
  204. unsigned int app_handle;
  205. unsigned int man_handle;
  206.  
  207. /**********************************************************************/
  208. /* The first time that any of the external MEMLIB functions are       */
  209. /* called the initializing routine must be called.  This flag is set  */
  210. /* to TRUE once the call is made.                                     */
  211. /**********************************************************************/
  212.  
  213. unsigned int exp_initialized = FALSE;
  214.  
  215. /**********************************************************************/
  216. /* An array of pointers to each pysical page that the directory uses. */
  217. /* When we need to access two different entries on two separate pages */
  218. /* we can map both pages needed in.                                   */
  219. /**********************************************************************/
  220.  
  221. DIRECTORY_NODE far* directory[2];
  222.  
  223. /**********************************************************************/
  224. /* Number of pages for the directory (dynamically changes)            */
  225. /**********************************************************************/
  226.  
  227. unsigned int dir_page_count;
  228.  
  229. /**********************************************************************/
  230. /* Array tells which logical page is mapped at each physical page.    */
  231. /* UNMAPPED ==> no page is mapped.   Unmap 24 pages (A000 - EFFF).    */
  232. /**********************************************************************/
  233.  
  234. MAP_STRUCT pages_mapped[MAX_PAGE_FRAME_SIZE] =
  235. { 
  236.    UNMAPPED,0,  UNMAPPED,1,  UNMAPPED,2,  UNMAPPED,3,
  237.    UNMAPPED,4,  UNMAPPED,5,  UNMAPPED,6,  UNMAPPED,7,
  238.    UNMAPPED,8,  UNMAPPED,9,  UNMAPPED,10, UNMAPPED,11,
  239.    UNMAPPED,12, UNMAPPED,13, UNMAPPED,14, UNMAPPED,15,
  240.    UNMAPPED,16, UNMAPPED,17, UNMAPPED,18, UNMAPPED,19,
  241.    UNMAPPED,20, UNMAPPED,21, UNMAPPED,22, UNMAPPED,23 
  242. };
  243.  
  244. /**********************************************************************/
  245. /* number_pages_mapped stores the number actually mapped.             */
  246. /**********************************************************************/
  247.  
  248. unsigned int number_pages_mapped = 0;
  249.  
  250. /**********************************************************************/
  251. /* The total number of pages allocated to the application.            */
  252. /**********************************************************************/
  253.  
  254. unsigned int total_app_allocated_pages;
  255.  
  256. /**********************************************************************/
  257. /* Used to get and restore partial page maps for push_context() and   */
  258. /* pop_context().                                                     */
  259. /**********************************************************************/
  260.  
  261. PARTIAL_CONTEXT_LIST_STRUCT partial_page_map;
  262.  
  263. /**********************************************************************/
  264. /* An array of pointers to saved contexts used by the push_context()  */
  265. /* and pop_context() functions.                                       */
  266. /**********************************************************************/
  267.  
  268. CONTEXT_STRUCT* context_ptrs[MAX_CONTEXTS_AVAILABLE];
  269.  
  270. /**********************************************************************/
  271. /* This variable keeps track of the top of the context_ptrs array.    */
  272. /* This allows pop_context() to know whether there are any contexts   */
  273. /* left to remove or for push_context() to know whether there is      */
  274. /* enough room to store another context.                              */
  275. /**********************************************************************/
  276.  
  277. unsigned int context_top;     
  278.  
  279. /**********************************************************************/
  280. /* Size of each context - set in init_exp_mem().                      */
  281. /**********************************************************************/
  282.  
  283. unsigned int context_size;
  284.  
  285. /**********************************************************************/
  286. /* The index into the full directory array used as the starting       */
  287. /* location when searching through the directory for a viable entry   */
  288. /* to keep track of a new memory block.                               */
  289. /**********************************************************************/
  290.  
  291. unsigned int dir_start;
  292.  
  293. /**********************************************************************/
  294. /* The index into the full directory array used as the ending         */
  295. /* location when searching through the directory for a viable entry   */
  296. /* to keep track of a new memory block.                               */
  297. /**********************************************************************/
  298.  
  299. unsigned int dir_end;
  300.  
  301. /*$PAGE*/
  302. /*====================================================================*/
  303. /*              CODE                                                  */
  304. /*====================================================================*/
  305.  
  306. /**********************************************************************/
  307. /*     Name:  unsigned int prepare_dir_mapping (context_saved)        */
  308. /*            unsigned int *context_saved;                            */
  309. /*                                                                    */
  310. /*     Definition:                                                    */
  311. /*        To save the context before mapping in the directory.  This  */
  312. /*     function is called before a directory page will be mapped in.  */
  313. /*     It firsts checks to see if the expanded memory has been        */
  314. /*     initialized and then saves the current context.  The status    */
  315. /*     will be returned to the caller for error checking.             */
  316. /*     'context_saved' is set to TRUE if save_context() was           */
  317. /*     successful.                                                    */
  318. /*                                                                    */
  319. /*     The calling function can then call restore_memlib_context()    */
  320. /*     depending whether 'saved' is TRUE or not.  This allows the     */
  321. /*     caller to preserve the error status from save_context().       */
  322. /*                                                                    */
  323. /*     Parameters:                                                    */
  324. /*        output  context_saved  Whether the context was saved or not */
  325. /*                                                                    */
  326. /*     Results returned:                                              */
  327. /*        PASSED     Operation successful                             */
  328. /*        error      Non-zero value, see "ERRORS.H" or EMS table A-2  */
  329. /*                                                                    */
  330. /*     Calls: init_exp_mem()                                          */
  331. /*            save_context()                                          */
  332. /*                                                                    */
  333. /*     Called by: ememavl()                                           */
  334. /*                ememmax()                                           */
  335. /*                emsize()                                            */
  336. /*                efmalloc()                                          */
  337. /*                effree()                                            */
  338. /*                                                                    */
  339. /*     Globals referenced/modified: exp_initialized                   */
  340. /*                                  man_handle                        */
  341. /*                                                                    */
  342. /**********************************************************************/
  343.  
  344. unsigned int prepare_dir_mapping (context_saved)
  345. unsigned int *context_saved;
  346. {
  347.    unsigned int status;          /* The status of EMM and MEMLIB */
  348.                                                                   
  349.    *context_saved = FALSE;
  350.    status         = PASSED;
  351.  
  352.    /**********************************************/
  353.    /* If expanded memory hasn't been initialized */
  354.    /* then call init_exp_mem().                  */
  355.    /**********************************************/
  356.  
  357.    if (!exp_initialized)
  358.       status = init_exp_mem();
  359.  
  360.    if (status == PASSED)
  361.    {
  362.       /*****************************/
  363.       /* Save the current context. */
  364.       /*****************************/
  365.  
  366.       status = save_context (man_handle);
  367.       if (status == PASSED)
  368.       {
  369.          *context_saved = TRUE;
  370.       }
  371.    }
  372.    return (status);
  373.  
  374. } /** prepare_dir_mapping **/
  375.  
  376. /*$PAGE*/
  377. /**********************************************************************/
  378. /*     Name:  unsigned int map_dir_page (log_page, phys_page)         */
  379. /*            unsigned int log_page;                                  */
  380. /*            unsigned int phys_page;                                 */
  381. /*                                                                    */
  382. /*     Definition:                                                    */
  383. /*        Maps in the specified logical page for the directory into   */
  384. /*     the specified physical page.  For use by MEMLIB only (uses     */
  385. /*     MEMLIB handle -- man_handle).                                  */
  386. /*                                                                    */
  387. /*     Parameters:                                                    */
  388. /*        input   log_page    The logical directory page to map in    */
  389. /*        input   phys_page   Which physical page to map log_page in  */
  390. /*                                                                    */
  391. /*     Results returned:                                              */
  392. /*        PASSED     Operation successful                             */
  393. /*        error      Non-zero value, see "ERRORS.H" or EMS table A-2  */
  394. /*                                                                    */
  395. /*     Calls: map_unmap_pages()                                       */
  396. /*                                                                    */
  397. /*     Called by: ememavl()                                           */
  398. /*                ememmax()                                           */
  399. /*                emsize()                                            */
  400. /*                efmalloc()                                          */
  401. /*                effree()                                            */
  402. /*                seteptrs()                                          */
  403. /*                                                                    */
  404. /*     Globals referenced/modified: exp_intialized                    */
  405. /*                                  man_handle                        */
  406. /*                                                                    */
  407. /**********************************************************************/
  408.  
  409. unsigned int map_dir_page (log_page, phys_page)
  410. unsigned int log_page;
  411. unsigned int phys_page;
  412. {
  413.    MAP_STRUCT   directory_map[1];  /* Structure to use EMS map pages */
  414.    unsigned int status;            /* Status of EMM and MEMLIB       */
  415.  
  416.    directory_map[0].log_page         = log_page;
  417.    directory_map[0].phys_page_or_seg = phys_page;
  418.    status = map_unmap_pages (PHYS_PAGE_MODE, 1, directory_map, man_handle);
  419.  
  420.    return (status);
  421. } /** end map_dir_page **/
  422.  
  423. /*$PAGE*/
  424. /**********************************************************************/
  425. /*                                                                    */
  426. /*     Name:    unsigned int restore_memlib_context (status)          */
  427. /*              unsigned int status;                                  */
  428. /*                                                                    */
  429. /*     Description:                                                   */
  430. /*        Restores a context saved by prepare_dir_mapping() so that   */
  431. /*     memlib can access the directory.  If the status passed in is   */
  432. /*     an error, then that is the status returned regardless if       */
  433. /*     restore_context() generates an error.  If the status passed in */
  434. /*     is PASSED, we return the status generated by restore_context().*/
  435. /*        We do this so that in some recoverable errors we can        */
  436. /*     successfully restore the context and still return the correct  */
  437. /*     error code to the application.                                 */
  438. /*                                                                    */
  439. /*     Parameters:                                                    */
  440. /*        input   status     The status passed in                     */
  441. /*                                                                    */
  442. /*     Results returned:                                              */
  443. /*        PASSED     Operation successful                             */
  444. /*        error      Non-zero value, see "ERRORS.H" or EMS table A-2  */
  445. /*                                                                    */
  446. /*     Calls: restore_context()                                       */
  447. /*                                                                    */
  448. /*     Called by: ememavl()                                           */
  449. /*                ememmax()                                           */
  450. /*                emsize()                                            */
  451. /*                efmalloc()                                          */
  452. /*                effree()                                            */
  453. /*                                                                    */
  454. /*     Globals referenced/modified: man_handle                        */
  455. /*                                                                    */
  456. /**********************************************************************/
  457.  
  458. unsigned int restore_memlib_context (status)
  459. unsigned int status;
  460. {
  461.    unsigned int restore_status;  /* Status returned from restore_context */
  462.  
  463.    restore_status = restore_context (man_handle);
  464.    if (status == PASSED)
  465.       return (restore_status);
  466.    else
  467.       return (status);
  468.  
  469. } /** end restore_memlib_context **/
  470.      
  471. /*$PAGE*/
  472. /**********************************************************************/
  473. /*                                                                    */
  474. /*     Name:  unsigned int check_token (token)                        */
  475. /*            unsigned int token;                                     */
  476. /*                                                                    */
  477. /*     Description:                                                   */
  478. /*        This function check's a token to see if it is valid.  It    */
  479. /*     is valid if it is within the directory boundries.  A token is  */
  480. /*     valid when it is set by efmalloc().                            */
  481. /*                                                                    */
  482. /*     Parameters:                                                    */
  483. /*        input    token   The token to be validated.                 */
  484. /*                                                                    */
  485. /*     Results returned:                                              */
  486. /*        PASSED     Operation successful                             */
  487. /*        error      Non-zero value, see "ERRORS.H" or EMS table A-2  */
  488. /*                                                                    */
  489. /*     Calls: None                                                    */
  490. /*                                                                    */
  491. /*     Called by: effree()                                            */
  492. /*                emsize()                                            */
  493. /*                                                                    */
  494. /*     Globals referenced/modified: dir_page_count                    */
  495. /*                                  exp_initialized                   */
  496. /*                                                                    */
  497. /**********************************************************************/
  498.  
  499. unsigned int check_token (token)
  500. unsigned int token;
  501. {
  502.    unsigned int status;          /* The status of EMM and MEMLIB */
  503.  
  504.    /******************/
  505.    /* Assume PASSED. */
  506.    /******************/
  507.  
  508.    status = PASSED;
  509.  
  510.    /****************************************************************/
  511.    /* If the manager is not initialized then the token is invalid. */
  512.    /****************************************************************/
  513.  
  514.    if (!exp_initialized)
  515.       status = INVALID_TOKEN;
  516.  
  517.    /***************************************************************/
  518.    /* First make sure the token isn't greater than the number of  */
  519.    /* entries possible for the current number of directory pages. */
  520.    /* Then check for a valid token.                               */
  521.    /***************************************************************/
  522.  
  523.    if (status == PASSED)
  524.    {
  525.       if ((token > (unsigned int) (NUM_DIR_ENTRIES (dir_page_count) - 1)) ||
  526.           (token == UNASSIGNED_TOKEN))
  527.          status = INVALID_TOKEN;
  528.    }
  529.  
  530.    return(status);
  531.  
  532. } /** end check_token **/
  533.  
  534. /*$PAGE*/
  535. /**********************************************************************/
  536. /*                                                                    */
  537. /*     Name:     unsigned int init_exp_mem (void)                     */
  538. /*                                                                    */
  539. /*     Description:                                                   */
  540. /*        This routine initializes the housekeeping variables needed  */
  541. /*     to keep track of expanded memory.  It tests for the presence   */
  542. /*     of EMM 4.0 and initializes the directory.                      */
  543. /*                                                                    */
  544. /*     Parameters: None                                               */
  545. /*                                                                    */
  546. /*     Results returned:                                              */
  547. /*        PASSED     Operation successful                             */
  548. /*        error      Non-zero value, see "ERRORS.H" or EMS table A-2  */
  549. /*                                                                    */
  550. /*     Calls: alloc_pages()                                           */
  551. /*            EMM_installed()                                         */
  552. /*            get_page_frame_seg()                                    */
  553. /*            get_partial_context_size()                              */
  554. /*            get_unalloc_page_count()                                */
  555. /*            realloc_pages()                                         */
  556. /*            map_dir_page()                                          */
  557. /*            get_page_frame_count()                                  */
  558. /*                                                                    */
  559. /*     Called by: prepare_dir_mapping()                               */
  560. /*                push_context()                                      */
  561. /*                pop_context()                                       */
  562. /*                                                                    */
  563. /*     Globals referenced/modified: directory                         */  
  564. /*                                  app_handle                        */
  565. /*                                  context_size                      */
  566. /*                                  dir_page_count                    */
  567. /*                                  exp_intialized                    */
  568. /*                                  man_handle                        */
  569. /*                                  number_pages_mapped               */
  570. /*                                  page_frame_base_address           */
  571. /*                                  num_pages_in_page_frame           */
  572. /*                                  pages_mapped                      */
  573. /*                                  context_top                       */
  574. /*                                  total_app_allocated_pages         */
  575. /*                                  dir_start                         */
  576. /*                                  dir_end                           */
  577. /*                                  exp_initialized                   */
  578. /*                                  partial_page_map                  */
  579. /*                                                                    */
  580. /**********************************************************************/
  581.  
  582. unsigned int init_exp_mem (void)
  583. {
  584.  
  585.    unsigned int status;            /* The status of EMM and MEMLIB */
  586.    unsigned int num_unalloc_pages; /* Number of unallocated pages  */
  587.    unsigned int page_frame_seg;    /* Page frame segment           */
  588.    unsigned int i;                 /* Looping variable             */
  589.    unsigned int zero_pages;        /* To call realloc for 0 pages  */
  590.  
  591.    /********************************************************/
  592.    /* Test for EMM presence and enough pages -- need at    */
  593.    /* least 1 for the directory and 1 for the application. */
  594.    /********************************************************/
  595.  
  596.    status = EMM_installed();
  597.    if (status == PASSED)
  598.    {
  599.       status = get_unalloc_page_count (&num_unalloc_pages);
  600.       if (status == PASSED)
  601.          if (num_unalloc_pages <= 1)
  602.             status = NOT_ENOUGH_UNALLOCATED_PAGES;
  603.    }
  604.  
  605.    if (status == PASSED)
  606.    {
  607.       /*****************************************/
  608.       /* Allocate 0 pages for the application. */
  609.       /* We need to first alloc 1 page to get  */
  610.       /* a handle then realloc to reduce the   */
  611.       /* number of pages used to 0.            */
  612.       /*****************************************/
  613.  
  614.       status = alloc_pages (1, &app_handle);
  615.       if (status == PASSED)
  616.          {
  617.          zero_pages = 0;
  618.          status = realloc_pages (&zero_pages, app_handle);
  619.          if ((zero_pages != 0) ||
  620.              (status == EMM_NOT_ENOUGH_PAGES))
  621.             status = NOT_ENOUGH_UNALLOCATED_PAGES;
  622.          }
  623.  
  624.       /*********************************************/
  625.       /* Allocate 1 page for the manager (memlib). */
  626.       /*********************************************/
  627.  
  628.       if (status == PASSED)
  629.          status = alloc_pages (1, &man_handle);
  630.  
  631.       if (status == PASSED)
  632.       {
  633.          /****************************/
  634.          /* Map this directory page. */
  635.          /****************************/
  636.  
  637.          status = map_dir_page (0, FIRST_PHYS_PAGE);
  638.       }
  639.  
  640.       if (status == PASSED)
  641.       {
  642.          /*********************************************************/
  643.          /* Get the base address of the start of expanded memory. */
  644.          /*********************************************************/
  645.  
  646.          status = get_page_frame_seg (&page_frame_seg);
  647.          if (status == PASSED)
  648.          {
  649.             /***************************************************/
  650.             /* Convert the page frame segment to a far pointer */
  651.             /* and point directory[0] to it.                   */
  652.             /***************************************************/
  653.  
  654.             page_frame_base_address = FP (page_frame_seg);
  655.             directory[0] = (DIRECTORY_NODE far *) page_frame_base_address;
  656.  
  657.             /****************************************************/
  658.             /* Point directory[1] to the address of the second  */
  659.             /* physical page in the page frame.                 */
  660.             /****************************************************/
  661.             FP_SEG(directory[1]) = page_frame_seg + OFFSET_SIZE;
  662.             FP_OFF(directory[1]) = 0;
  663.          }
  664.       }
  665.    }
  666.  
  667.    if (status == PASSED)
  668.    {
  669.       /************************************************/
  670.       /* Set the variable that keeps track of the how */
  671.       /* many pages the directory is using to 1.      */
  672.       /************************************************/
  673.  
  674.       dir_page_count = 1;
  675.  
  676.       /**************************************************************/
  677.       /* Initialize all the directory entries so that the token     */
  678.       /* identifiers are set UNASSIGNED_TOKEN (entry is available)  */
  679.       /* and their size to 0.                                       */
  680.       /**************************************************************/
  681.  
  682.       for (i = 0; i < DIR_ENTRIES_PER_PAGE; i++)
  683.       {
  684.          directory[0][i].token = UNASSIGNED_TOKEN;
  685.          directory[0][i].size = 0;
  686.       }
  687.  
  688.       /********************************************************/
  689.       /* Set the starting and ending entries in the directory */
  690.       /* when doing free memory block searches.               */
  691.       /********************************************************/
  692.  
  693.       dir_start = 0;
  694.       dir_end   = 0;
  695.  
  696.       /****************************************************************/
  697.       /* Set the total number of pages the application is using to 0. */
  698.       /****************************************************************/
  699.  
  700.       total_app_allocated_pages = 0;
  701.  
  702.       /**********************************************/
  703.       /* Get the number of pages in the page frame. */
  704.       /**********************************************/
  705.  
  706.       status = get_page_frame_count (&num_pages_in_page_frame);
  707.  
  708.       if (status == PASSED)
  709.       {
  710.          /*************************************************/
  711.          /* Set the partial page map for pushes and pops. */
  712.          /*************************************************/
  713.  
  714.          partial_page_map.mappable_region_count = num_pages_in_page_frame;
  715.          partial_page_map.mappable_region_seg[0] = FP_SEG (page_frame_base_address);
  716.  
  717.          /*************************************************************/
  718.          /* Set the segment value for each 16K page in the page frame */
  719.          /* that push_context() & pop_context() will be storing.      */
  720.          /*************************************************************/
  721.  
  722.          for (i = 1; i < num_pages_in_page_frame; i++)
  723.          {
  724.             partial_page_map.mappable_region_seg[i] =
  725.                partial_page_map.mappable_region_seg[i - 1] + OFFSET_SIZE;
  726.          }
  727.  
  728.          /***************************************************/
  729.          /* Set the context push and pop stack to be empty. */
  730.          /***************************************************/
  731.  
  732.          context_top = NO_CONTEXTS;
  733.  
  734.          /************************************************************/
  735.          /* Get the number of bytes needed to save (push) a context. */
  736.          /************************************************************/
  737.  
  738.          status = get_partial_context_size (num_pages_in_page_frame, &context_size);
  739.          if (status == PASSED)
  740.          {
  741.             /********************/
  742.             /* Unmap all pages. */
  743.             /********************/
  744.  
  745.             for (i = 0; i < num_pages_in_page_frame; i++)
  746.             {
  747.                pages_mapped[i].log_page = UNMAPPED;
  748.             }
  749.          }
  750.          number_pages_mapped = 0;
  751.       }
  752.    }
  753.    /***************************************************************/
  754.    /* If status is good then update the already-initialized flag. */
  755.    /***************************************************************/
  756.  
  757.    if (status == PASSED)
  758.       exp_initialized = TRUE;
  759.  
  760.    return (status);
  761.  
  762. } /** end init_exp_mem **/
  763.  
  764. /*$PAGE*/
  765. /**********************************************************************/
  766. /*                                                                    */
  767. /*     Name: unsigned int allocate_new_directory_page (void)          */
  768. /*                                                                    */
  769. /*     Description:                                                   */
  770. /*        This routine attempts to allocate a new page for the        */
  771. /*     directory.                                                     */
  772. /*                                                                    */
  773. /*     Parameters:  None                                              */
  774. /*                                                                    */
  775. /*     Results returned:                                              */
  776. /*        PASSED    Operation successful                              */
  777. /*        error     Non-zero value, see "ERRORS.H" or EMS table A-2   */
  778. /*                                                                    */
  779. /*     Calls: map_dir_page()                                          */
  780. /*            realloc_pages()                                         */
  781. /*                                                                    */
  782. /*     Called by: allocate_new_block()                                */
  783. /*                check_best_fit()                                    */
  784. /*                                                                    */
  785. /*     Globals referenced/modified: directory                         */
  786. /*                                  dir_page_count                    */
  787. /*                                  man_handle                        */
  788. /*                                                                    */
  789. /**********************************************************************/
  790.  
  791. unsigned int allocate_new_directory_page (void)
  792. {
  793.    unsigned int status;            /* The status of EMM and MEMLIB  */
  794.    unsigned int index;             /* Index into a directory page   */
  795.    unsigned int new_num_dir_pages; /* New number of directory pages */
  796.  
  797.    /*****************************/
  798.    /* Assume status will be ok. */
  799.    /*****************************/
  800.  
  801.    status = PASSED;
  802.  
  803.    /******************************************/
  804.    /* Set the new number of directory pages. */
  805.    /******************************************/
  806.  
  807.    new_num_dir_pages = dir_page_count + 1;
  808.  
  809.    /***************************************************/
  810.    /* Make sure we don't allocate beyond the maximum  */
  811.    /* number of directory entries allowable.          */
  812.    /***************************************************/
  813.  
  814.    if ((unsigned long) NUM_DIR_ENTRIES (new_num_dir_pages) > MAX_DIR_ENTRIES)
  815.       status = TOO_MANY_DIRECTORY_ENTRIES;
  816.  
  817.    if (status == PASSED)
  818.    {
  819.       /************************************************/
  820.       /* Attempt to add a new page for the directory. */
  821.       /************************************************/
  822.  
  823.       status = realloc_pages (&new_num_dir_pages, man_handle);
  824.  
  825.       /******************************************/
  826.       /* Make sure the number of pages returned */
  827.       /* is equal to the number we wanted.      */
  828.       /******************************************/
  829.  
  830.       if ((status == EMM_NOT_ENOUGH_PAGES) ||
  831.           (new_num_dir_pages != dir_page_count + 1))
  832.          status = NOT_ENOUGH_UNALLOCATED_PAGES;
  833.  
  834.       if (status == PASSED)
  835.       {
  836.          /************************************************/
  837.          /* Allocate succeeded, update the directory map */
  838.          /************************************************/
  839.  
  840.          dir_page_count++;
  841.  
  842.          status = map_dir_page (dir_page_count - 1, FIRST_PHYS_PAGE);
  843.          if (status == PASSED)
  844.          {
  845.             /*****************************************/
  846.             /* Initialize the new directory entries. */
  847.             /*****************************************/
  848.  
  849.             for (index = 0; index < DIR_ENTRIES_PER_PAGE; index++)
  850.             {
  851.                directory[0][index].token = UNASSIGNED_TOKEN;
  852.                directory[0][index].size = 0;
  853.             }
  854.          }
  855.       }
  856.    }
  857.    return (status);
  858.  
  859. }  /** end allocate_new_directory_page **/
  860.  
  861. /*$PAGE*/
  862. /**********************************************************************/
  863. /*                                                                    */
  864. /*     Name: unsigned int allocate_new_block (size, token)            */                                   
  865. /*           unsigned int size;                                       */
  866. /*           unsigned int token;                                      */   
  867. /*                                                                    */
  868. /*     Description:                                                   */
  869. /*        This routine attempts to allocate a block of size 'size',   */
  870. /*     in bytes, and set the fields in directory[token] appropriately.*/
  871. /*                                                                    */
  872. /*     Parameters:                                                    */
  873. /*        input size     the size, in bytes, to allocate              */
  874. /*        input token    index into directory for this block          */
  875. /*                                                                    */
  876. /*     Results returned:                                              */
  877. /*        PASSED    Operation successful                              */
  878. /*        error     Non-zero value, see "ERRORS.H" or EMS table A-2   */
  879. /*                                                                    */
  880. /*     Calls: allocate_new_directory_page()                           */
  881. /*            realloc_pages()                                         */
  882. /*            map_dir_page()                                          */
  883. /*                                                                    */
  884. /*     Called by: efmalloc()                                          */
  885. /*                                                                    */
  886. /*     Globals referenced/modified: directory                         */
  887. /*                                  app_handle                        */
  888. /*                                  dir_page_count                    */
  889. /*                                  total_app_allocated_pages         */
  890. /*                                  dir_start                         */
  891. /*                                  dir_end                           */
  892. /*                                                                    */
  893. /**********************************************************************/
  894.  
  895. unsigned int allocate_new_block (size, token)
  896. unsigned int size;
  897. unsigned int token;
  898. {
  899.    unsigned int i;                  /* Looping variable                    */
  900.    unsigned int page;               /* Current directory page mapped in    */
  901.    unsigned int status;             /* Status of EMM and MEMLIB            */
  902.    unsigned int num_pages_needed;   /* Number of pages needed              */
  903.    unsigned int size_mod_page_size; /* Size in bytes MOD PAGE_SIZE         */
  904.    unsigned int new_total_pages;    /* New number of pages for the         */
  905.                                     /* application's handle                */
  906.    unsigned int tokens_page;        /* Token's dir entry's logical page    */
  907.    unsigned int tokens_index;       /* Token's index into its page         */
  908.    unsigned int i_dir_entry;        /* Translate i to an entry into the    */
  909.                                     /* full directory array                */
  910.    unsigned int dir_starts_page;    /* Dir_start's dir entry's log page    */
  911.    unsigned int dir_starts_index;   /* Dir_start's index into its page     */
  912.    unsigned int found_block;        /* Whether a block was found or not    */
  913.    unsigned int remainders_logical_page; /* The remaining portion's first  */
  914.                                          /* logical page                   */
  915.    
  916.    status = PASSED;
  917.  
  918.    /****************************************************************/
  919.    /* Check if we need to allocate another page for the directory. */
  920.    /****************************************************************/
  921.  
  922.    if (dir_end >= (unsigned int) (NUM_DIR_ENTRIES (dir_page_count) - 2))
  923.       status = allocate_new_directory_page();
  924.  
  925.    if (status == PASSED)
  926.    {
  927.       /********************************************/
  928.       /* Allocate enough new pages for this block */
  929.       /********************************************/
  930.  
  931.       num_pages_needed = NUM_PAGES (size);
  932.       new_total_pages = total_app_allocated_pages + num_pages_needed;
  933.  
  934.       /*************************************************************/
  935.       /* Assign the new number of pages to the application handle. */
  936.       /*************************************************************/
  937.  
  938.       status = realloc_pages (&new_total_pages, app_handle);
  939.  
  940.       /******************************************/
  941.       /* Make sure the number of pages returned */
  942.       /* is equal to the number we wanted.      */
  943.       /******************************************/
  944.  
  945.       if ((new_total_pages != (total_app_allocated_pages + num_pages_needed)) 
  946.           || (status == EMM_NOT_ENOUGH_PAGES))
  947.          status = NOT_ENOUGH_UNALLOCATED_PAGES;
  948.    }
  949.  
  950.    /****************************************************/
  951.    /* If allocate succeeded, set the directory entries */
  952.    /****************************************************/
  953.  
  954.    if (status == PASSED)
  955.    {
  956.       /*******************************************************/
  957.       /* Convert 'token' to its respective directory entry's */
  958.       /* logical page and its index into that page.          */
  959.       /*******************************************************/
  960.  
  961.       tokens_page  = token / DIR_ENTRIES_PER_PAGE;
  962.       tokens_index = token % DIR_ENTRIES_PER_PAGE;
  963.  
  964.       /**************************************/
  965.       /* Map in the token's directory page. */
  966.       /**************************************/
  967.  
  968.       status = map_dir_page (tokens_page, FIRST_PHYS_PAGE);
  969.       if (status == PASSED)
  970.       {
  971.          /**************************************/
  972.          /* Set the entry in the directory for */
  973.          /* the newly allocated block.         */
  974.          /**************************************/
  975.  
  976.          directory[0][tokens_index].token  = token;
  977.          directory[0][tokens_index].size   = size;
  978.          directory[0][tokens_index].offset = 0;
  979.  
  980.          /*********************************************/
  981.          /* Set the logical pages for this block to   */
  982.          /* the logical pages that we just allocated. */
  983.          /*********************************************/
  984.  
  985.          for (i = 0; i < num_pages_needed; i++)
  986.          {
  987.             directory[0][tokens_index].logical_page[i] = 
  988.                total_app_allocated_pages + i;
  989.          }
  990.  
  991.          /**************************************************/
  992.          /* If this block size is NOT a multiple of 16K,   */
  993.          /* find an unused directory entry and have it     */
  994.          /* point to the remaining part of the page.       */
  995.          /**************************************************/
  996.      
  997.          size_mod_page_size = size % PAGE_SIZE;
  998.    
  999.          if (size_mod_page_size != 0)
  1000.          {
  1001.             /********************************************************/
  1002.             /* We have a remainder on the last logical page for the */
  1003.             /* new block.  Keep track of this page so that when we  */
  1004.             /* set a free directory entry to point to the remainder */
  1005.             /* we already know what logical page it uses.           */
  1006.             /********************************************************/
  1007.  
  1008.             remainders_logical_page = 
  1009.                directory[0][tokens_index].logical_page[num_pages_needed - 1];
  1010.  
  1011.             dir_starts_page  = dir_start / DIR_ENTRIES_PER_PAGE;
  1012.             dir_starts_index = dir_start % DIR_ENTRIES_PER_PAGE;
  1013.             found_block = FALSE;
  1014.  
  1015.             /****************************************/
  1016.             /* Go through the directory, page by    */
  1017.             /* page, until we find an usable entry. */
  1018.             /****************************************/
  1019.  
  1020.             for (page = dir_starts_page; ((status == PASSED) &&
  1021.                                           (page < dir_page_count) &&
  1022.                                           (!found_block)); page++)
  1023.             {
  1024.                /***********************************/
  1025.                /* Map in the this directory page. */
  1026.                /***********************************/
  1027.  
  1028.                status = map_dir_page (page, FIRST_PHYS_PAGE);
  1029.  
  1030.                /*********************************************************/
  1031.                /* Go through each entry for the mapped in page until we */
  1032.                /* find a usable entry or until we run out of entries.   */
  1033.                /*********************************************************/
  1034.  
  1035.                for (i = dir_starts_index; ((i < DIR_ENTRIES_PER_PAGE) &&
  1036.                                             (!found_block) &&
  1037.                                             (status == PASSED)); i++)
  1038.                {
  1039.                   if ((directory[0][i].token == UNASSIGNED_TOKEN) && 
  1040.                       (directory[0][i].size == 0))
  1041.                   {
  1042.                      /*******************************************/
  1043.                      /* We found an unused directory entry, set */
  1044.                      /* it to point to the leftover piece.      */
  1045.                      /*******************************************/
  1046.  
  1047.                      directory[0][i].offset = size_mod_page_size;
  1048.                      directory[0][i].size = PAGE_SIZE - size_mod_page_size;
  1049.                      directory[0][i].logical_page[0] = remainders_logical_page;
  1050.  
  1051.                      i_dir_entry = page * DIR_ENTRIES_PER_PAGE + i;
  1052.                      if (i_dir_entry >= dir_end)
  1053.                         dir_end = i_dir_entry + 1;
  1054.  
  1055.                      found_block = TRUE;
  1056.                   }
  1057.                } /** end for i **/
  1058.  
  1059.                dir_starts_index = 0;
  1060.  
  1061.             } /** end for page **/
  1062.  
  1063.          } /** end if page_mod_page_size **/
  1064.  
  1065.          /***********************************/
  1066.          /* Update the toal allocated pages */
  1067.          /***********************************/
  1068.  
  1069.          total_app_allocated_pages += num_pages_needed;
  1070.  
  1071.       }  /** end if status PASSED **/
  1072.  
  1073.    } /** end if status PASSED **/
  1074.    return (status);
  1075.  
  1076. }  /** end allocate_new_block **/
  1077.  
  1078.  
  1079. /*$PAGE*/
  1080. /**********************************************************************/
  1081. /*                                                                    */
  1082. /*     Name: unsigned int split_block (best_index, size)              */
  1083. /*           unsigned int best_index;                                 */
  1084. /*           unsigned int size;                                       */
  1085. /*                                                                    */
  1086. /*     Description:                                                   */
  1087. /*        This routine splits a block into allocated and unallocated  */
  1088. /*     portions.  The size is assigned to the allocated portion and   */
  1089. /*     the left over portion is set up as a free block.               */
  1090. /*                                                                    */
  1091. /*     Parms Passed:                                                  */
  1092. /*        input best_index   The directory entry to be broken up.     */
  1093. /*                           It will be the entry that will point to  */
  1094. /*                           the allocated portion after it is broken */
  1095. /*                           into its allocated/free portions.        */
  1096. /*              size         The size of the block to be allocated.   */
  1097. /*                                                                    */
  1098. /*     Results returned:                                              */
  1099. /*        PASSED    Operation successful                              */
  1100. /*        error     Non-zero value, see "ERRORS.H" or EMS table A-2   */
  1101. /*                                                                    */
  1102. /*     Calls: map_dir_page()                                          */
  1103. /*            break_overlap()                                         */
  1104. /*                                                                    */
  1105. /*     Called by:  efmalloc()                                         */
  1106. /*                                                                    */
  1107. /*     Globals referenced/modified: directory                         */
  1108. /*                                  dir_page_count                    */
  1109. /*                                  dir_end                           */
  1110. /*                                  dir_start                         */
  1111. /*                                                                    */
  1112. /**********************************************************************/
  1113.  
  1114. unsigned int split_block (best_index, size)
  1115. unsigned int best_index;
  1116. unsigned int size;
  1117. {
  1118.    unsigned int num_pages_for_size; /* The num of logical pages for size  */
  1119.    unsigned int size_mod_page_size; /* The size modulo the PAGE_SIZE      */
  1120.    unsigned int dir_starts_page;    /* Dir_start's dir entry's log page   */
  1121.    unsigned int best_indexs_page;   /* Best_index's dir entry's log page  */               
  1122.    unsigned int best_indexs_index;  /* Best_index's index into its page   */
  1123.    unsigned int best_index_offset;  /* Best_index's logical page offset   */
  1124.    unsigned int best_index_size;    /* Best_index's memory block's size   */
  1125.    unsigned int index;              /* Current index into a logical page  */
  1126.    unsigned int page;               /* Current directory page mapped in   */
  1127.    unsigned int remainder;          /* The index into a dir page that     */
  1128.                                     /* will point to the leftover portion */
  1129.                                     /* in a logical page after allocated  */
  1130.                                     /* block is set                       */
  1131.    unsigned int remainders_entry;   /* Remainder converted to a full      */
  1132.                                     /* directory entry                    */
  1133.    unsigned int status;             /* Status of EMM and MEMLIB           */
  1134.    unsigned int j;                  /* Looping variable                   */
  1135.    unsigned int avail_entry_found;  /* An available entry has been found  */
  1136.    unsigned int start_page_for_remainder; /* The starting logical page    */
  1137.                                           /* for the remainder            */
  1138.  
  1139.    /*******************************/
  1140.    /* Initialize local variables. */
  1141.    /*******************************/
  1142.  
  1143.    avail_entry_found = FALSE;
  1144.    status            = PASSED;
  1145.  
  1146.    /*************************************************/
  1147.    /* Convert dir_start to its respective directory */
  1148.    /* entry's logcal page.                          */
  1149.    /*************************************************/
  1150.  
  1151.    dir_starts_page  = dir_start / DIR_ENTRIES_PER_PAGE;
  1152.  
  1153.    /**************************************************/
  1154.    /* Convert dir_start to its respective entry's    */
  1155.    /* page index.  We want to start the first        */
  1156.    /* page's index at the current starting location. */                                 
  1157.    /**************************************************/
  1158.  
  1159.    index = dir_start % DIR_ENTRIES_PER_PAGE;
  1160.  
  1161.    /****************************************************************/
  1162.    /* Check if we need to allocate another page for the directory. */
  1163.    /****************************************************************/
  1164.  
  1165.    if (dir_end >= (unsigned int) (NUM_DIR_ENTRIES (dir_page_count) - 2))
  1166.       status = allocate_new_directory_page();
  1167.  
  1168.    /****************************************************************/
  1169.    /* Go through all the directory pages starting with dir_start's */
  1170.    /* page until we find an usable entry.                          */
  1171.    /****************************************************************/
  1172.  
  1173.    for (page = dir_starts_page; ((page < dir_page_count) && 
  1174.                                  (!avail_entry_found) && 
  1175.                                  (status == PASSED)); page++)
  1176.    {
  1177.       /*******************************/
  1178.       /* Map in this directory page. */
  1179.       /*******************************/
  1180.  
  1181.       status = map_dir_page (page, FIRST_PHYS_PAGE);
  1182.       /************************************************************/
  1183.       /* Go through this page's indexes looking for the first     */
  1184.       /* available directory entry to keep track of the remainder */
  1185.       /* portion.  The first time we enter this loop we start     */
  1186.       /* with the current starting location (dir_start converted  */
  1187.       /* to a page's index) from above.  All other index's after  */
  1188.       /* the first page will start with 0.                        */
  1189.       /************************************************************/
  1190.  
  1191.       for (remainder = index; ((remainder < DIR_ENTRIES_PER_PAGE) && 
  1192.                                (!avail_entry_found) &&
  1193.                                (status == PASSED)); remainder++)
  1194.       {
  1195.          if ((directory[0][remainder].size == 0) &&
  1196.              (directory[0][remainder].token == UNASSIGNED_TOKEN))
  1197.          {
  1198.             /**********************************************/
  1199.             /* We've found an available directory entry   */
  1200.             /* to keep track of the left-over portion.    */
  1201.             /* Time to map in the block we want to split. */
  1202.             /**********************************************/
  1203.  
  1204.             avail_entry_found = TRUE;
  1205.  
  1206.             /*******************************************************/
  1207.             /* We're going to map in two different directory pages */
  1208.             /* so that we can reference best_index's and           */
  1209.             /* remainder's directory entry at once.  Since we are  */
  1210.             /* using two different logical pages we need to use    */
  1211.             /* directory[1] to access the second page's entries.   */
  1212.             /*******************************************************/
  1213.  
  1214.             best_indexs_page  = best_index / DIR_ENTRIES_PER_PAGE;
  1215.             best_indexs_index = best_index % DIR_ENTRIES_PER_PAGE;
  1216.  
  1217.             /************************************************/
  1218.             /* Map in the best_index's directory page in at */
  1219.             /* physical page one while keeping  remainder's */
  1220.             /* directory page at physical page zero.        */
  1221.             /************************************************/
  1222.  
  1223.             status = map_dir_page (best_indexs_page, SECOND_PHYS_PAGE);
  1224.             if (status == PASSED)
  1225.             {
  1226.                /*****************************/
  1227.                /* Set some local variables. */
  1228.                /*****************************/
  1229.  
  1230.                best_index_offset  = directory[1][best_indexs_index].offset;
  1231.                best_index_size    = directory[1][best_indexs_index].size;
  1232.                num_pages_for_size = NUM_PAGES (size);
  1233.  
  1234.                /*************************************************/
  1235.                /* Split this block into used and free portions. */
  1236.                /*************************************************/
  1237.  
  1238.                directory[0][remainder].size = best_index_size - size;
  1239.  
  1240.                /***********************************************************/
  1241.                /* Find the starting logical page for the remainder block. */
  1242.                /***********************************************************/
  1243.  
  1244.                if (((best_index_offset + size) % (PAGE_SIZE)) == 0)
  1245.                   start_page_for_remainder = num_pages_for_size;
  1246.                else
  1247.                   start_page_for_remainder = num_pages_for_size - 1;
  1248.      
  1249.                /********************************************************/
  1250.                /* Set the logical pages for the newly allocated block. */
  1251.                /********************************************************/
  1252.  
  1253.                for (j = start_page_for_remainder; 
  1254.                    (j < NUM_PAGES (best_index_size)); j++)
  1255.                {
  1256.                   directory[0][remainder].
  1257.                      logical_page[j - start_page_for_remainder] =
  1258.                         directory[1][best_indexs_index].logical_page[j];
  1259.                }
  1260.  
  1261.                /*************************************************************/
  1262.                /* Set remainder's index to point to the new leftover piece. */
  1263.                /*************************************************************/
  1264.  
  1265.                directory[0][remainder].offset = 
  1266.                   (best_index_offset + size) % PAGE_SIZE;
  1267.  
  1268.                /*******************/
  1269.                /* Update dir_end. */
  1270.                /*******************/
  1271.  
  1272.                remainders_entry = remainder + page * DIR_ENTRIES_PER_PAGE;
  1273.                if (remainders_entry >= dir_end)
  1274.                   dir_end = remainders_entry + 1;
  1275.  
  1276.                /********************************************************/
  1277.                /* If the leftover piece takes more logical pages than  */
  1278.                /* it should (1 page / PAGE_SIZE) then we need to break */
  1279.                /* the remainder piece into two free blocks.            */
  1280.                /********************************************************/
  1281.  
  1282.                size_mod_page_size = directory[0][remainder].size % PAGE_SIZE;
  1283.                if (size_mod_page_size >
  1284.                       PAGE_SIZE - directory[0][remainder].offset)
  1285.                   status = break_overlap (&remainders_entry); 
  1286.  
  1287.             } /** if status PASSED **/
  1288.  
  1289.          } /** end if directory **/
  1290.  
  1291.       } /** end for remainder = dir_start **/
  1292.  
  1293.       index = 0;
  1294.  
  1295.    } /** end for page **/
  1296.  
  1297.    return (status);
  1298.  
  1299. } /** end split_block() **/
  1300.  
  1301.  
  1302. /*$PAGE*/
  1303. /**********************************************************************/
  1304. /*                                                                    */
  1305. /*     Name:    unsigned int find_new_dir_start (void)                */
  1306. /*                                                                    */
  1307. /*     Description:                                                   */
  1308. /*        This function finds a new starting location in the          */
  1309. /*     directory.  This starting entry is used when looking for a     */
  1310. /*     new block of memory.                                           */
  1311. /*                                                                    */
  1312. /*     Note: We know the new starting location will always start      */
  1313. /*     after the present one except when we free a block.  In this    */
  1314. /*     case, if the freed block's directory entry is before the       */
  1315. /*     current starting entry, we set the starting location to that   */
  1316. /*     of the newly freed block's directory entry.  This is done in   */
  1317. /*     effree().                                                      */
  1318. /*                                                                    */
  1319. /*     Parameters: None                                               */
  1320. /*                                                                    */
  1321. /*     Results returned:                                              */
  1322. /*        PASSED     Operation successful                             */
  1323. /*        error      Non-zero value, see "ERRORS.H" or EMS table A-2  */
  1324. /*                                                                    */
  1325. /*     Calls: map_dir_page()                                          */
  1326. /*                                                                    */
  1327. /*     Called by:  check_best_fit()                                   */
  1328. /*                                                                    */
  1329. /*     Globals referenced/modified: directory                         */
  1330. /*                                  directory_map                     */
  1331. /*                                  dir_page_count                    */
  1332. /*                                  dir_start                         */
  1333. /*                                  dir_end                           */
  1334. /*                                                                    */
  1335. /**********************************************************************/
  1336.  
  1337. unsigned int find_new_dir_start()
  1338. {
  1339.    unsigned int i;                 /* Looping variable                  */
  1340.    unsigned int avail_entry_found; /* An available entry has been found */
  1341.    unsigned int dir_starts_page;   /* Dir_start's dir entry's log page  */
  1342.    unsigned int index;             /* The current index into a page     */
  1343.    unsigned int page;              /* The current dir page mapped in    */
  1344.    unsigned int status;            /* Status of EMM and MEMLIB          */
  1345.  
  1346.    /*******************************/
  1347.    /* Initialize local variables. */
  1348.    /*******************************/
  1349.  
  1350.    avail_entry_found  = FALSE;
  1351.    status = PASSED;
  1352.  
  1353.    /***********************************************************/
  1354.    /* Convert dir_start + 1 to its respective directory page. */
  1355.    /***********************************************************/
  1356.  
  1357.    dir_starts_page = (dir_start + 1) / DIR_ENTRIES_PER_PAGE;
  1358.  
  1359.    /***************************************************************/
  1360.    /* Convert dir_start + 1 to its respective entry's page index. */
  1361.    /* We want to start the first page's index from one after the  */
  1362.    /* current starting location.                                  */
  1363.    /***************************************************************/
  1364.  
  1365.    index = (dir_start + 1) % DIR_ENTRIES_PER_PAGE;
  1366.    
  1367.    /****************************************************************/
  1368.    /* Go through all the directory pages starting with dir_start's */
  1369.    /* page until we find an usable entry.                          */
  1370.    /****************************************************************/
  1371.  
  1372.    for (page = dir_starts_page; ((page < dir_page_count) && 
  1373.                                  (!avail_entry_found) &&
  1374.                                  (status == PASSED)); page++)
  1375.    {
  1376.       /************************************************/
  1377.       /* Map in the directory page specified by page. */
  1378.       /************************************************/
  1379.  
  1380.       status = map_dir_page (page, FIRST_PHYS_PAGE);
  1381.       if (status == PASSED)
  1382.       {
  1383.          /*****************************************************************/
  1384.          /* Go through this page's entries looking for to first available */
  1385.          /* entry.  The first time we enter this loop we start with the   */
  1386.          /* current starting location + 1 (converted to a page's index)   */
  1387.          /* from above.  All other index's after the first page will      */
  1388.          /* start with 0.                                                 */
  1389.          /*****************************************************************/
  1390.  
  1391.          for (i = index; ((i < DIR_ENTRIES_PER_PAGE) && 
  1392.                           (!avail_entry_found)); i++)
  1393.          {
  1394.             if (directory[0][i].token == UNASSIGNED_TOKEN)
  1395.             {
  1396.                /*****************************************/
  1397.                /* Translate the i index into an entry   */
  1398.                /* into the full directory array for the */
  1399.                /* new starting location for dir_start.  */
  1400.                /*****************************************/
  1401.                
  1402.                dir_start = i + page * DIR_ENTRIES_PER_PAGE;
  1403.  
  1404.                /***************************************/
  1405.                /* Make sure the new starting location */
  1406.                /* isn't greater than the end.  If so, */
  1407.                /* than reset dir_end.                 */
  1408.                /***************************************/
  1409.  
  1410.                if (dir_start > dir_end)
  1411.                   dir_end = dir_start + 1;
  1412.                avail_entry_found = TRUE;
  1413.             }
  1414.          } /** end for i **/
  1415.  
  1416.       } /** end if status PASSED **/
  1417.  
  1418.       index = 0;
  1419.  
  1420.    } /** end for page **/
  1421.  
  1422.    return (status);
  1423.  
  1424. } /** end find_new_dir_start() **/
  1425.  
  1426. /*$PAGE*/
  1427. /**********************************************************************/
  1428. /*                                                                    */
  1429. /*     Name:    unsigned int break_overlap (best_index)               */
  1430. /*              unsigned int *best_index;                             */
  1431. /*                                                                    */
  1432. /*     Description:                                                   */
  1433. /*        This function breaks a free block into two parts at a page  */
  1434. /*     boundry.  This is done because check_best_fit() determined     */
  1435. /*     that the requested block would overlap a page boundry          */
  1436. /*     unnecessarily.  For example, we don't want an 8K block using   */
  1437. /*     two logical pages (part of it on one page and the rest on      */
  1438. /*     another).  Suppose we want to allocate a 9K block and          */
  1439. /*     check_best_fit() determined that a 22K block (6K on one page,  */
  1440. /*     16K on the another) was the best fit.  We want to start the 9K */
  1441. /*     block on a page boundry so that it will fit in one logical     */
  1442. /*     page.  This means that we eventually need to split the 22K     */
  1443. /*     block into three pieces:                                       */
  1444. /*                                                                    */
  1445. /*              6K first free piece on the first logical page.        */
  1446. /*              9K allocated piece on the second logical page.        */
  1447. /*              7K free space on the second logical page.             */
  1448. /*                                                                    */
  1449. /*     This routine will do the first split of 6K and 16K.  The       */
  1450. /*     function split_block(), called from efmalloc(), (which does    */
  1451. /*     all the normal splitting) will split the 16K block into its 9K */
  1452. /*     allocated and 7K free pieces.                                  */
  1453. /*                                                                    */
  1454. /*     Parameters:                                                    */
  1455. /*        output  best_index The directory entry of the best fit loc  */
  1456. /*                                                                    */
  1457. /*     Results returned:                                              */
  1458. /*        PASSED     Operation successful                             */
  1459. /*        error      Non-zero value, see "ERRORS.H" or EMS table A-2  */
  1460. /*                                                                    */
  1461. /*     Calls: map_dir_page()                                          */
  1462. /*                                                                    */
  1463. /*     Called by:  efmalloc()                                         */
  1464. /*                 split_block()                                      */
  1465. /*                                                                    */
  1466. /*     Globals referenced/modified: dir_page_count                    */
  1467. /*                                  directory                         */
  1468. /*                                  directory_map                     */
  1469. /*                                  dir_end                           */
  1470. /*                                                                    */
  1471. /**********************************************************************/
  1472.  
  1473. unsigned int break_overlap (best_index)
  1474. unsigned int *best_index;
  1475. {
  1476.    unsigned int i;                 /* Looping variable                  */
  1477.    unsigned int entry_found;       /* Whether an entry was found        */
  1478.    unsigned int free_space;        /* The free space before a page      */
  1479.                                    /* boundry in an overlaping block    */
  1480.    unsigned int new_size;          /* The free space starting on a page */
  1481.                                    /* boundry in an overlaping block    */
  1482.    unsigned int status;            /* Status of EMM and MEMLIB          */
  1483.    unsigned int best_indexs_page;  /* Best_index's dir entry's log page */
  1484.    unsigned int best_indexs_index; /* Best_index's index into its page  */
  1485.    unsigned int page;              /* Current directory page mapped in  */
  1486.    unsigned int index;             /* Index into a directory page       */
  1487.    unsigned int j;                 /* Loop variable                     */
  1488.  
  1489.    status = PASSED;
  1490.  
  1491.    /****************************************************************/
  1492.    /* Check if we need to allocate another page for the directory. */
  1493.    /****************************************************************/
  1494.  
  1495.    if (dir_end >= (unsigned int) (NUM_DIR_ENTRIES (dir_page_count) - 2))
  1496.       status = allocate_new_directory_page();
  1497.  
  1498.    /******************************************************************/
  1499.    /* Convert best_index to its respective directory page and index. */
  1500.    /******************************************************************/
  1501.  
  1502.    best_indexs_page  = *best_index / DIR_ENTRIES_PER_PAGE;
  1503.    best_indexs_index = *best_index % DIR_ENTRIES_PER_PAGE;
  1504.  
  1505.    /*******************************************/
  1506.    /* Map in the best_index's directory page. */
  1507.    /*******************************************/
  1508.  
  1509.    status = map_dir_page (best_indexs_page, FIRST_PHYS_PAGE);
  1510.    if (status == PASSED)
  1511.    {
  1512.       /***************************************/
  1513.       /* Set sizes for breaking the overlap. */
  1514.       /***************************************/
  1515.  
  1516.       free_space = PAGE_SIZE - directory[0][best_indexs_index].offset;
  1517.       new_size   = directory[0][best_indexs_index].size - free_space;
  1518.  
  1519.       /**********************************/
  1520.       /* Initialize variables for loop. */
  1521.       /**********************************/
  1522.  
  1523.       entry_found = FALSE;
  1524.       index       = best_indexs_index;
  1525.  
  1526.       /****************************************************/
  1527.       /* Go through all the directory pages starting with */
  1528.       /* best_index's page until we find an usable entry. */
  1529.       /****************************************************/
  1530.      
  1531.       for (page = best_indexs_page; ((page < dir_page_count) && 
  1532.                                      (!entry_found) &&
  1533.                                      (status == PASSED)); page++)
  1534.       {
  1535.          /************************************************/
  1536.          /* Map in the directory page specified by page. */
  1537.          /************************************************/
  1538.  
  1539.          status = map_dir_page (page, SECOND_PHYS_PAGE);
  1540.          if (status == PASSED)
  1541.          {
  1542.             /********************************************************/
  1543.             /* Go through this page's entries looking for the first */
  1544.             /* available entry.  The first time we enter this loop  */
  1545.             /* we start with best_index's entry (converted to a     */
  1546.             /* page's index from above).  All other index's after   */
  1547.             /* the first page will start with 0.                    */
  1548.             /********************************************************/
  1549.  
  1550.             for (i = index; ((i < DIR_ENTRIES_PER_PAGE) &&
  1551.                                  (!entry_found) &&
  1552.                                  (status == PASSED)); i++)
  1553.             {
  1554.                if ((directory[1][i].token == UNASSIGNED_TOKEN) && 
  1555.                    (directory[1][i].size == 0))
  1556.                {
  1557.                   /********************************************/
  1558.                   /* We found a usable entry.  Convert i to   */ 
  1559.                   /* a full directory entry for best_index.   */
  1560.                   /* Best_index will now point to this        */
  1561.                   /* directory entry though best_indexs_index */
  1562.                   /* and best_indexs_page will still refer to */
  1563.                   /* the original best_index.  Set this       */
  1564.                   /* directory entry to point to the          */
  1565.                   /* allocated block.                         */
  1566.                   /********************************************/
  1567.  
  1568.                   *best_index            = i + (page * DIR_ENTRIES_PER_PAGE);
  1569.                   directory[1][i].token  = *best_index;
  1570.                   directory[1][i].size   = new_size;
  1571.                   directory[1][i].offset = 0;
  1572.  
  1573.                   /*************************************/
  1574.                   /* Set logical pages for this block. */
  1575.                   /*************************************/
  1576.  
  1577.                   for (j = 0; j < NUM_PAGES (new_size); j++)
  1578.                   {
  1579.                      directory[1][i].logical_page[j] =
  1580.                         directory[0][best_indexs_index].logical_page[j + 1];
  1581.                   }
  1582.  
  1583.                   /***********************************/
  1584.                   /* Update size for original block. */
  1585.                   /***********************************/
  1586.  
  1587.                   directory[0][best_indexs_index].size = free_space;
  1588.  
  1589.                   /*****************************/
  1590.                   /* Update dir_end if needed. */
  1591.                   /*****************************/
  1592.  
  1593.                   if (*best_index >= dir_end)
  1594.                      dir_end = *best_index + 1;
  1595.  
  1596.                   entry_found = TRUE;
  1597.  
  1598.                } /** end if directory[1][i] **/
  1599.  
  1600.             } /** end for i **/
  1601.             
  1602.             index = 0;
  1603.  
  1604.          } /** end if status PASSED **/
  1605.  
  1606.       } /** end for page **/
  1607.  
  1608.    } /** end if status PASSED **/
  1609.  
  1610.    return (status);
  1611.  
  1612. } /** done break_overlap() **/
  1613.  
  1614. /*$PAGE*/
  1615. /**********************************************************************/
  1616. /*                                                                    */
  1617. /*     Name:  unsigned int check_best_fit (size, best_index,          */
  1618. /*                                           min_difference)          */
  1619. /*            unsigned int size;                                      */
  1620. /*            unsigned int *best_index;                               */
  1621. /*            long         *min_difference;                           */
  1622. /*                                                                    */
  1623. /*     Description:                                                   */
  1624. /*        This function finds the best fit for a block of memory      */
  1625. /*     asked for in efmalloc().                                       */
  1626. /*                                                                    */
  1627. /*     Parameters:                                                    */
  1628. /*        input    size           The desired size of the block of    */
  1629. /*                                memory.                             */
  1630. /*        output   best_index     The directory entry of the best fit */
  1631. /*        output   min_difference The remainder from best_fit()       */
  1632. /*                                                                    */
  1633. /*     Results returned:                                              */
  1634. /*        PASSED     Operation successful                             */
  1635. /*        error      Non-zero value, see "ERRORS.H" or EMS table A-2  */
  1636. /*                                                                    */
  1637. /*     Calls: allocate_new_directory_page()                           */
  1638. /*            map_dir_page()                                          */
  1639. /*            break_overlap()                                         */
  1640. /*            find_new_dir_start()                                    */
  1641. /*                                                                    */
  1642. /*     Called by: efmalloc()                                          */
  1643. /*                                                                    */
  1644. /*     Globals referenced/modified: dir_page_count                    */
  1645. /*                                  directory                         */
  1646. /*                                  directory_map                     */
  1647. /*                                  dir_start                         */
  1648. /*                                  dir_end                           */
  1649. /*                                                                    */
  1650. /**********************************************************************/
  1651.  
  1652. unsigned int check_best_fit (size, best_index, min_difference)
  1653. unsigned int size;
  1654. unsigned int *best_index;
  1655. long         *min_difference;
  1656. {
  1657.    unsigned int index;                  /* Index into a directory page      */
  1658.    unsigned int status;                 /* Status of EMM and MEMLIB         */
  1659.    unsigned int page;                   /* Directory page to map in         */
  1660.    unsigned int size_mod_page_size;     /* Size of block MOD PAGE_SIZE      */
  1661.    unsigned int free_space;             /* The free space before a page     */
  1662.                                         /* boundry in a free block          */
  1663.    unsigned int dir_starts_page;        /* Dir_start's dir entry's log page */
  1664.    long         this_ones_min_diff;     /* Current block's min difference   */
  1665.    unsigned int this_ones_offset;       /* Current block's offset into a    */
  1666.                                         /* logical page                     */
  1667.    long         new_size;               /* Free space after page boundry    */
  1668.    unsigned int found_exact_fit;        /* Whether we found an exact fit    */
  1669.    unsigned int overlap;                /* Whether we have an overlapping   */
  1670.                                         /* block                            */
  1671.    long         overlap_min_difference; /* Minimum difference for the       */
  1672.                                         /* overlapping block                */
  1673.  
  1674.    /************************************************/
  1675.    /* Initialize variables for best fit algorithm. */
  1676.    /************************************************/
  1677.  
  1678.    index                  = dir_start % DIR_ENTRIES_PER_PAGE;
  1679.    *best_index            = UNASSIGNED_TOKEN;
  1680.    found_exact_fit        = FALSE;
  1681.    overlap                = FALSE;
  1682.    *min_difference        = LARGEST_ALLOCATABLE_BLOCK;
  1683.    status                 = PASSED;
  1684.    overlap_min_difference = LARGEST_ALLOCATABLE_BLOCK;
  1685.    size_mod_page_size     = size % PAGE_SIZE;
  1686.  
  1687.    if (size_mod_page_size == 0)
  1688.       size_mod_page_size = PAGE_SIZE;
  1689.  
  1690.    /**************************************************/
  1691.    /* Make sure a new directory page is allocated    */
  1692.    /* before it is needed.  This done so the a block */
  1693.    /* that has free mem will not be lost to the      */
  1694.    /* the purple zone before a new directory page    */
  1695.    /* is allocated in allocate_new_block().            */
  1696.    /* Allocate_new_directory_page() is called when   */
  1697.    /* the current directory entries is two from      */
  1698.    /* being filled up.                               */
  1699.    /**************************************************/
  1700.  
  1701.    if (dir_end >= (unsigned int) (NUM_DIR_ENTRIES (dir_page_count) - 2))
  1702.       status = allocate_new_directory_page();
  1703.  
  1704.    if (status == PASSED)
  1705.    {
  1706.       dir_starts_page = dir_start / DIR_ENTRIES_PER_PAGE;
  1707.  
  1708.       /*****************************************/
  1709.       /* Go through all of the directory pages */
  1710.       /* until we find an exact fit.           */
  1711.       /*****************************************/
  1712.  
  1713.       for (page = dir_starts_page; ((page < dir_page_count) && 
  1714.                                     (!found_exact_fit) &&
  1715.                                     (status == PASSED)); page++)
  1716.       {
  1717.          /**********************************/
  1718.          /* Map in the this directory page */
  1719.          /**********************************/
  1720.  
  1721.          status = map_dir_page (page, FIRST_PHYS_PAGE);
  1722.          if (status == PASSED)
  1723.          {
  1724.             /*********************************************************/
  1725.             /* Go through the current page looking for the best fit. */
  1726.             /*********************************************************/
  1727.  
  1728.             while ((index < DIR_ENTRIES_PER_PAGE) &&
  1729.                   ((index + page * DIR_ENTRIES_PER_PAGE) <= dir_end) && 
  1730.                   (!found_exact_fit))
  1731.             {  
  1732.                /*****************************************/
  1733.                /* If this block of memory is available. */
  1734.                /*****************************************/
  1735.  
  1736.                if (directory[0][index].token == UNASSIGNED_TOKEN)
  1737.                {
  1738.                   /************************************************/
  1739.                   /* If size is 0 then this block is unallocated. */
  1740.                   /************************************************/
  1741.           
  1742.                   if (directory[0][index].size == 0)
  1743.                   {
  1744.                      /*********************************************/
  1745.                      /* If best_index = UNASSIGNED_TOKEN we       */
  1746.                      /* haven't found any previous blocks to use. */    
  1747.                      /*********************************************/
  1748.               
  1749.                      if (*best_index == UNASSIGNED_TOKEN)
  1750.                          *best_index = index + (page * DIR_ENTRIES_PER_PAGE);
  1751.                   }
  1752.                   else
  1753.                   {
  1754.                      /************************************************/
  1755.                      /* This is a previously freed block and we need */
  1756.                      /* to check how close of a fit it is.           */                          
  1757.                      /************************************************/
  1758.                   
  1759.                      this_ones_min_diff = (long) directory[0][index].size - size;
  1760.                      if ((this_ones_min_diff >= 0) &&
  1761.                         (this_ones_min_diff < *min_difference))
  1762.                      {
  1763.                         /**************************************/
  1764.                         /* If exact fit then take this block. */
  1765.                         /**************************************/
  1766.    
  1767.                         if (this_ones_min_diff == 0)
  1768.                         {
  1769.                            found_exact_fit = TRUE;
  1770.                            *best_index     = index + (page * DIR_ENTRIES_PER_PAGE);
  1771.                            *min_difference = 0;
  1772.                            overlap         = FALSE;
  1773.                         }
  1774.                         else
  1775.                         {
  1776.                            /***********************************************/
  1777.                            /* Make sure that putting the newly allocated  */
  1778.                            /* block at the beginning of the free block    */
  1779.                            /* won't cause the new block to overlap more   */
  1780.                            /* logical pages than it needs.                */
  1781.                            /*                                             */
  1782.                            /* If the remainder of the requested block     */
  1783.                            /* size MOD PAGE_SIZE will fit in the first    */
  1784.                            /* logical page of the freed block, then the   */
  1785.                            /* requested block will fit correctly.         */
  1786.                            /***********************************************/
  1787.    
  1788.                            /*******************************************/
  1789.                            /* Where this free block starts within its */
  1790.                            /* first logical page.                     */
  1791.                            /*******************************************/
  1792.  
  1793.                            this_ones_offset = directory[0][index].offset;
  1794.  
  1795.                            /********************************************/
  1796.                            /* The room left on the first logical page. */
  1797.                            /********************************************/
  1798.  
  1799.                            free_space = PAGE_SIZE - this_ones_offset;
  1800.  
  1801.                            if (free_space >= size_mod_page_size)
  1802.                            {
  1803.                               /******************************************/
  1804.                               /* The block will fit just fine.  We will */
  1805.                               /* have the block itself and a remainder. */
  1806.                               /******************************************/
  1807.  
  1808.                               *best_index     = index + (page * DIR_ENTRIES_PER_PAGE);
  1809.                               *min_difference = this_ones_min_diff;
  1810.                               overlap         = FALSE;
  1811.                            }
  1812.                            else        
  1813.                            {
  1814.                               /********************************************/
  1815.                               /* The new block will fit but we have to    */
  1816.                               /* start it on this free block's first page */
  1817.                               /* boundry.  We will need to keep track of  */
  1818.                               /* the space before the page boundry, the   */
  1819.                               /* new block, and any remainder from the    */
  1820.                               /* new block.  We will have an overlap to   */
  1821.                               /* break.                                   */
  1822.                               /********************************************/
  1823.  
  1824.                               new_size = (long) directory[0][index].size - free_space;
  1825.                               if (new_size >= size)
  1826.                               {
  1827.                                  overlap = TRUE;
  1828.                                  this_ones_min_diff = new_size - size;
  1829.                                  if (this_ones_min_diff < overlap_min_difference)
  1830.                                  {
  1831.                                     overlap_min_difference = new_size - size;
  1832.                                     *best_index = index + (page * DIR_ENTRIES_PER_PAGE);
  1833.                                  }
  1834.                               }
  1835.                            } /** end else **/
  1836.  
  1837.                         } /** end else **/ 
  1838.  
  1839.                      } /** end if temp_difference ... **/
  1840.  
  1841.                   } /** end else **/
  1842.  
  1843.                } /** end if directory **/
  1844.  
  1845.                index++;
  1846.  
  1847.             } /** end while **/
  1848.  
  1849.          } /** end if passed **/
  1850.          index = 0;
  1851.  
  1852.       } /** end if page **/
  1853.  
  1854.       /**********************************************/
  1855.       /* If we have an overlap we need to break it. */
  1856.       /**********************************************/
  1857.  
  1858.       if ((overlap) && 
  1859.           (status == PASSED))
  1860.       {
  1861.          *min_difference = overlap_min_difference;
  1862.          status = break_overlap (best_index);
  1863.       }
  1864.  
  1865.       /****************************************************/
  1866.       /* Update our starting entry if the current one ==  */
  1867.       /* to best_index and we don't have an overlap.      */
  1868.       /****************************************************/
  1869.  
  1870.       if ((dir_start == *best_index) && 
  1871.           (!overlap) && 
  1872.           (status == PASSED))
  1873.          status = find_new_dir_start();
  1874.  
  1875.       /**************************************/
  1876.       /* Update our ending entry if needed. */
  1877.       /**************************************/
  1878.  
  1879.       if ((*best_index >= dir_end) && 
  1880.           (status == PASSED))
  1881.          dir_end = *best_index + 1;
  1882.  
  1883.    } /** end if passed **/
  1884.  
  1885.    return (status);
  1886.  
  1887. } /* end check_best_fit() */
  1888.  
  1889. /*$PAGE*/
  1890. /**********************************************************************/
  1891. /*                                                                    */
  1892. /*     Name: unsigned int check_if_all_blocks_free (all_blocks_free)  */
  1893. /*           unsigned int *all_blocks_free;                           */
  1894. /*                                                                    */
  1895. /*     Description:                                                   */
  1896. /*        If the block being freed by effree() is the last one to be  */
  1897. /*     freed then we need to deallocate all the pages allocated to    */
  1898. /*     this application.  This tells us that the program using MEMLIB */
  1899. /*     may be terminating and we want to be sure that all pages for   */
  1900. /*     this application have been deallocated.  This function will    */
  1901. /*     see if there are any blocks left in the directory that are     */
  1902. /*     allocated and if not, will deallocate all pages that this      */
  1903. /*     application owns.                                              */
  1904. /*                                                                    */
  1905. /*     Parameters:                                                    */
  1906. /*        output  free_status     TRUE - all blocks are free          */
  1907. /*                                FALSE - there are some blocks used  */
  1908. /*                                                                    */
  1909. /*     Results returned:                                              */
  1910. /*        PASSED    Operation successful                              */
  1911. /*        error     Non-zero value, see "ERRORS.H" or EMS table A-2   */
  1912. /*                                                                    */
  1913. /*     Calls: map_dir_page()                                          */
  1914. /*                                                                    */
  1915. /*     Called by: effree()                                            */
  1916. /*                                                                    */
  1917. /*     Globals referenced/modified: dir_page_count                    */
  1918. /*                                  directory                         */
  1919. /*                                  directory_map                     */
  1920. /*                                                                    */
  1921. /**********************************************************************/
  1922.  
  1923. unsigned int check_if_all_blocks_free (all_blocks_free)
  1924. unsigned int *all_blocks_free;
  1925. {
  1926.    unsigned int status;       /* Status of EMM and MEMLIB          */
  1927.    unsigned int page;         /* Current directory page mapped in  */
  1928.    unsigned int index;        /* Current index into a logical page */
  1929.  
  1930.    /******************************/
  1931.    /* Assume all blocks are free */
  1932.    /* and status OK.             */
  1933.    /******************************/
  1934.  
  1935.    *all_blocks_free = TRUE;
  1936.    status           = PASSED;
  1937.  
  1938.    /**************************************************************/
  1939.    /* Loop through the directory, checking for non-freed blocks. */
  1940.    /**************************************************************/
  1941.  
  1942.    for (page = 0; ((page < dir_page_count) &&
  1943.                    (*all_blocks_free) &&
  1944.                    (status == PASSED)); page++)
  1945.    {
  1946.       /*******************************/
  1947.       /* Map in this directory page. */
  1948.       /*******************************/
  1949.  
  1950.       status = map_dir_page (page, FIRST_PHYS_PAGE);
  1951.       if (status == PASSED)
  1952.       {
  1953.          /************************************/
  1954.          /* Check all index's for this page. */
  1955.          /************************************/
  1956.  
  1957.          for (index = 0; ((index < DIR_ENTRIES_PER_PAGE) &&
  1958.                           (*all_blocks_free)); index++)
  1959.          {
  1960.             if (directory[0][index].token != UNASSIGNED_TOKEN)
  1961.             {
  1962.                /**********************************************/
  1963.                /* If we find a block that's being used, set  */
  1964.                /* all_block_free to FALSE and stop checking. */
  1965.                /**********************************************/
  1966.  
  1967.                *all_blocks_free = FALSE;
  1968.             }
  1969.          } /** end for index **/
  1970.  
  1971.       } /** end if status PASSED **/
  1972.  
  1973.    } /** end for page **/
  1974.  
  1975.    return (status);
  1976.  
  1977. }  /** end if_all_blocks_free **/
  1978.  
  1979.  
  1980. /*$PAGE*/
  1981. /**********************************************************************/
  1982. /*                                                                    */
  1983. /*     Name:  unsigned int coalesce_block (block1, block2, coalasce)  */
  1984. /*            unsigned int block1;                                    */
  1985. /*            unsigned int block2;                                    */
  1986. /*            unsigned int *coalesce;                                 */
  1987. /*                                                                    */
  1988. /*     Description:                                                   */
  1989. /*        This coalesces one block of free expanded memory (block1)   */
  1990. /*     to another (block2).                                           */
  1991. /*                                                                    */
  1992. /*     Parameters:                                                    */
  1993. /*        input    block1      The identifier for the first block.    */
  1994. /*                 block2      The identifier for the second block.   */
  1995. /*         output  coalesce    Whether we really coalesced or not.    */
  1996. /*                                                                    */
  1997. /*     Results returned:                                              */
  1998. /*        PASSED     Coalescing successful or not needed              */
  1999. /*        error      Non-zero value, see "ERRORS.H" or EMS table A-2  */
  2000. /*                                                                    */
  2001. /*     Calls: map_dir_page()                                          */
  2002. /*            get_context()                                           */
  2003. /*            set_context()                                           */
  2004. /*                                                                    */
  2005. /*     Called by:  search_before()                                    */
  2006. /*                 search_after()                                     */
  2007. /*                                                                    */
  2008. /*     Globals referenced/modified: directory                         */
  2009. /*                                  directory_map                     */
  2010. /*                                                                    */
  2011. /**********************************************************************/
  2012.  
  2013. unsigned int coalesce_block (block1, block2, coalesce)
  2014. unsigned int block1;
  2015. unsigned int block2;
  2016. unsigned int *coalesce;
  2017. {
  2018.    unsigned int   j;              /* Looping variable                     */
  2019.    unsigned int   block1s_page;   /* Block1's directory entry's log page  */
  2020.    unsigned int   block1s_index;  /* Block1's index into its logical page */
  2021.    unsigned int   block2s_page;   /* Block2's directory entry's log page  */
  2022.    unsigned int   block2s_index;  /* Block2's index into its logical page */
  2023.    unsigned int   end_of_block2;  /* End of block2 (size+offset)          */
  2024.    unsigned int   start_page;     /* Starting logical page for coalescing */
  2025.    unsigned int   status;         /* Status of EMM and MEMLIB             */
  2026.    CONTEXT_STRUCT context;        /* For storing the current context      */
  2027.  
  2028.    /******************************************************************/
  2029.    /* We need to continue where we left off from when we return      */
  2030.    /* to search_before() or search_after(), so we need to save       */
  2031.    /* the pages they had mapped in before they called this function. */
  2032.    /******************************************************************/
  2033.  
  2034.    status = get_context (&context);
  2035.    if (status == PASSED)
  2036.    {
  2037.       /**************************************************************/
  2038.       /* Convert block1 to its respective directory page and index. */
  2039.       /**************************************************************/
  2040.  
  2041.       block1s_page  = block1 / DIR_ENTRIES_PER_PAGE;
  2042.       block1s_index = block1 % DIR_ENTRIES_PER_PAGE;
  2043.  
  2044.       /***********************************/
  2045.       /* Map in block1's directory page. */
  2046.       /***********************************/
  2047.  
  2048.       status = map_dir_page (block1s_page, FIRST_PHYS_PAGE);
  2049.    }
  2050.  
  2051.    if (status == PASSED)
  2052.    {
  2053.       /*********************************************************/
  2054.       /* Convert block1 to its respective directory page and   */
  2055.       /* index.  We're going to map this page into the second  */
  2056.       /* physical page.  In order to access this pages entries */
  2057.       /* we need to offset its indexes by DIR_ENTRIES_PER_PAGE */
  2058.       /* from the beginning of the first physical page.        */
  2059.       /*********************************************************/
  2060.  
  2061.       block2s_page  = block2 / DIR_ENTRIES_PER_PAGE;
  2062.       block2s_index = block2 % DIR_ENTRIES_PER_PAGE;
  2063.  
  2064.       /*****************************************************/
  2065.       /* Map in block2's directory page using the          */
  2066.       /* directory_map's second array element to map this  */
  2067.       /* page in at physical page one while keeping        */
  2068.       /* block1's  directory page at physical page zero.   */
  2069.       /*****************************************************/
  2070.  
  2071.       status = map_dir_page (block2s_page, SECOND_PHYS_PAGE);
  2072.  
  2073.       /****************************/
  2074.       /* Coalesce the two blocks. */
  2075.       /****************************/
  2076.  
  2077.       if (status == PASSED)
  2078.       {
  2079.          /****************************************/
  2080.          /* Assume we will coalesce these blocks */
  2081.          /****************************************/
  2082.  
  2083.          *coalesce = TRUE;
  2084.  
  2085.          /*********************************************/
  2086.          /* Set the starting logical page for block2. */
  2087.          /*********************************************/
  2088.  
  2089.          end_of_block2 = (directory[1][block2s_index].offset +
  2090.                           directory[1][block2s_index].size) % PAGE_SIZE;
  2091.  
  2092.          if (end_of_block2 == 0)
  2093.             start_page = NUM_PAGES (directory[1][block2s_index].size);
  2094.          else
  2095.             start_page = NUM_PAGES (directory[1][block2s_index].size) - 1;
  2096.  
  2097.          /********************************************************/
  2098.          /* If combining the blocks would cause too many logical */
  2099.          /* pages to be used, DON'T coalesce them.               */
  2100.          /********************************************************/
  2101.  
  2102.          if ((start_page + NUM_PAGES (directory[0][block1s_index].size))
  2103.              >= MAX_ALLOCATABLE_PAGES)
  2104.             *coalesce = FALSE;
  2105.  
  2106.          if (*coalesce)
  2107.          {
  2108.  
  2109.             /*****************************************************/
  2110.             /* Combine the logical pages for block1 into block2. */
  2111.             /*****************************************************/
  2112.  
  2113.             for (j = 0; j < NUM_PAGES (directory[0][block1s_index].size); j++)
  2114.             {
  2115.                directory[1][block2s_index].logical_page[start_page + j] =
  2116.                   directory[0][block1s_index].logical_page[j];
  2117.             }
  2118.  
  2119.             /******************************************/
  2120.             /* Set block2's size to the combined size */
  2121.             /* and zero out block 1.                  */
  2122.             /******************************************/
  2123.  
  2124.             directory[1][block2s_index].size += directory[0][block1s_index].size;
  2125.             directory[0][block1s_index].size = 0;
  2126.  
  2127.          }
  2128.       }
  2129.    }
  2130.  
  2131.    /************************************/
  2132.    /* Restore the pages that were here */
  2133.    /* before this function was called. */
  2134.    /************************************/
  2135.  
  2136.    if (status == PASSED)
  2137.       status = set_context (&context);
  2138.  
  2139.    return (status);
  2140.  
  2141. } /** end coalesce_block() **/
  2142.  
  2143. /*$PAGE*/
  2144. /**********************************************************************/
  2145. /*                                                                    */
  2146. /*     Name:  unsigned int search_after (token, final_entry,          */
  2147. /*                                         usable_entry)              */
  2148. /*            unsigned int token;                                     */
  2149. /*            unsigned int *final_entry;                              */
  2150. /*            unsigned int *usable_entry;                             */
  2151. /*                                                                    */
  2152. /*     Description:                                                   */
  2153. /*        This function searches for a free block of memory after the */
  2154. /*     block of memory we just freed.  This is done in order to       */
  2155. /*     coalesce the two blocks.                                       */
  2156. /*                                                                    */
  2157. /*     Parameters:                                                    */
  2158. /*        input   token        The token of the block of memory       */
  2159. /*                             that's been freed                      */
  2160. /*        output  final_entry  The directory entry of the final       */
  2161. /*                             coalesced block or unassigned if no    */
  2162. /*                             blocks were found.                     */
  2163. /*                usable_entry The directory entry of a usable block  */
  2164. /*                                                                    */
  2165. /*     Results returned:                                              */
  2166. /*        PASSED     Operation successful                             */
  2167. /*        error      Non-zero value, see "ERRORS.H" or EMS table A-2  */
  2168. /*                                                                    */
  2169. /*     Calls: coalesce_block()                                        */
  2170. /*            map_dir_page()                                          */
  2171. /*                                                                    */
  2172. /*     Called by: effree()                                            */
  2173. /*                                                                    */
  2174. /*     Globals referenced/modified: directory                         */
  2175. /*                                  directory_map                     */
  2176. /*                                  dir_page_count                    */
  2177. /*                                                                    */
  2178. /**********************************************************************/
  2179.  
  2180. unsigned int search_after (token, final_entry, usable_entry)
  2181. unsigned int token;
  2182. unsigned int *final_entry;
  2183. unsigned int *usable_entry;
  2184. {
  2185.    unsigned int index;              /* Index into a directory page         */
  2186.    unsigned int indexs_entry;       /* Index translated to a full dir entry*/
  2187.    unsigned int coalesce;           /* Whether we should coalesce or not   */
  2188.    unsigned int tokens_last_page;   /* Last logical page for token's block */
  2189.    unsigned int end_of_tokens_block;/* The end of token's block            */
  2190.    unsigned int page;               /* Directory pages to loop through     */
  2191.    unsigned int tokens_page;        /* Token's directory entry's log page  */
  2192.    unsigned int tokens_index;       /* Token's index into its logical page */
  2193.    unsigned int status;             /* Status of EMM and MEMLIB            */
  2194.  
  2195.    /****************************************************************/
  2196.    /* Convert the token passed in to its respective directory page */
  2197.    /* and index.  We're going to map this page into the second     */
  2198.    /* physical page.  In order to access this pages entries we     */
  2199.    /* need to use second_dir_page.                                 */    
  2200.    /****************************************************************/
  2201.  
  2202.    tokens_page  = token / DIR_ENTRIES_PER_PAGE;
  2203.    tokens_index = token % DIR_ENTRIES_PER_PAGE;
  2204.  
  2205.    /*********************************************************/
  2206.    /* Map in the token's directory page using the           */
  2207.    /* directory_map's second array element to map this page */
  2208.    /* in at physical page one while keeping the block to be */
  2209.    /* coalesced's directory page at physical page zero.     */
  2210.    /*********************************************************/
  2211.  
  2212.    status = map_dir_page (tokens_page, SECOND_PHYS_PAGE);
  2213.    if (status == PASSED)
  2214.    {
  2215.       /**********************************/
  2216.       /* Find the end of token's block. */
  2217.       /**********************************/
  2218.  
  2219.       end_of_tokens_block = (directory[1][tokens_index].size + 
  2220.                              directory[1][tokens_index].offset) % PAGE_SIZE;
  2221.  
  2222.       /**************************/
  2223.       /* Set variables for loop */
  2224.       /**************************/
  2225.  
  2226.       *final_entry     = UNASSIGNED_TOKEN;
  2227.       tokens_last_page = NUM_PAGES (directory[1][tokens_index].size) - 1;
  2228.       coalesce         = FALSE;
  2229.  
  2230.       /******************************************************/
  2231.       /* Search for a free block of memory after this block */
  2232.       /* to coalesce into one free block.                   */
  2233.       /******************************************************/
  2234.  
  2235.       for (page = 0; ((page < dir_page_count) &&
  2236.                       (status == PASSED) && 
  2237.                       (!coalesce)); page++)
  2238.       {
  2239.          /*******************************/
  2240.          /* Map in this directory page. */
  2241.          /*******************************/
  2242.  
  2243.          status = map_dir_page (page, FIRST_PHYS_PAGE);
  2244.          /*********************************************/
  2245.          /* Go through all the indexes for this page. */
  2246.          /*********************************************/
  2247.  
  2248.          for (index = 0; ((index < DIR_ENTRIES_PER_PAGE) &&
  2249.                           (status == PASSED) && 
  2250.                           (!coalesce)); index++)
  2251.          {
  2252.             /********************************************/
  2253.             /* Convert index to a full directory entry. */
  2254.             /********************************************/
  2255.  
  2256.             indexs_entry = index + page * DIR_ENTRIES_PER_PAGE;
  2257.  
  2258.             /*********************************************************/
  2259.             /* For index's block test:                               */
  2260.             /* Is it free?                                           */
  2261.             /* Is it > 0?                                            */
  2262.             /* Is it different than the block we called effree with? */
  2263.             /* Would its size make a coalesced block > 64K?          */
  2264.             /*********************************************************/
  2265.             
  2266.             if ((directory[0][index].token == UNASSIGNED_TOKEN) && 
  2267.                 (directory[0][index].size > 0) &&
  2268.                 (indexs_entry != token) && 
  2269.                 ((unsigned long) directory[0][index].size + 
  2270.                  directory[1][tokens_index].size < K64K))
  2271.             {
  2272.                /****************************************************/
  2273.                /* If the end of token's block equals the beginning */
  2274.                /* of index's block then index's block could lie    */
  2275.                /* AFTER our block.                                 */
  2276.                /****************************************************/
  2277.  
  2278.                if (end_of_tokens_block == directory[0][index].offset)
  2279.                {
  2280.                   /******************************************************/
  2281.                   /* Test the logical pages for these two blocks to     */
  2282.                   /* see if we want to coalesce them.  We will coalesce */
  2283.                   /* if either of the following is true:                */
  2284.                   /*                                                    */
  2285.                   /* 1. If the token's block ends on an exact page      */
  2286.                   /*    boundry (end_of_tokens_block == 0) then we do   */
  2287.                   /*    NOT want the last logical page of token's block */
  2288.                   /*    to match the first logical page of index's      */
  2289.                   /*    block.                                          */
  2290.                   /*                                                    */
  2291.                   /* 2. If token's block ends in the middle of a        */
  2292.                   /*    logical page (end_of_tokens_block != 0) the we  */
  2293.                   /*    DO want token's block's last logical page to    */
  2294.                   /*    match index's block's first logical page.       */
  2295.                   /******************************************************/
  2296.  
  2297.                   if (end_of_tokens_block == 0)
  2298.                   {
  2299.                      if (directory[1][tokens_index].logical_page[tokens_last_page] 
  2300.                           != directory[0][index].logical_page[0])
  2301.                      {
  2302.                         coalesce = TRUE;
  2303.                      }
  2304.                   }
  2305.                   else 
  2306.                   {
  2307.                      if (directory[1][tokens_index].logical_page[tokens_last_page] 
  2308.                           == directory[0][index].logical_page[0])
  2309.                      {
  2310.                         coalesce = TRUE;
  2311.                      }
  2312.                   }
  2313.                   if (coalesce)
  2314.                   {
  2315.                      /************************************/
  2316.                      /* We've got a winner! Coalesce the */
  2317.                      /* i'th block into our block.       */
  2318.                      /************************************/
  2319.  
  2320.                      status = coalesce_block (indexs_entry, token, &coalesce);
  2321.  
  2322.                      if ((status == PASSED) && coalesce)
  2323.                      {
  2324.                         *final_entry  = token;
  2325.                         *usable_entry = indexs_entry;
  2326.                      }
  2327.  
  2328.                   } /** end if coalesce **/
  2329.  
  2330.                } /** end if end_of_tokens_block **/
  2331.  
  2332.             }  /** end if directory **/
  2333.  
  2334.          }  /** end for index **/
  2335.  
  2336.       }  /** end for page **/
  2337.  
  2338.    } /** end if PASSED **/
  2339.    
  2340.    return (status);
  2341.  
  2342. } /** end search_after() **/
  2343.  
  2344. /*$PAGE*/
  2345. /**********************************************************************/
  2346. /*                                                                    */
  2347. /*     Name:  unsigned int search_before (token, final_entry,         */
  2348. /*                                          usable_entry)             */
  2349. /*            unsigned int token;                                     */
  2350. /*            unsigned int *final_entry;                              */
  2351. /*            unsigned int *usable_entry;                             */
  2352. /*                                                                    */
  2353. /*     Description:                                                   */
  2354. /*        This function searches for a free block of memory before    */
  2355. /*     the block of memory we just freed.  This is done in order to   */
  2356. /*     coalesce the two blocks.                                       */
  2357. /*                                                                    */
  2358. /*     Parameters:                                                    */
  2359. /*        input   token        The token of the block of memory       */
  2360. /*                             that's been freed                      */
  2361. /*        output  final_entry  The directory entry of the final       */
  2362. /*                             coalesced block or unassigned if no    */
  2363. /*                             blocks were found.                     */
  2364. /*                temp_entry   The directory entry of a usable block  */
  2365. /*                                                                    */
  2366. /*     Results returned:                                              */
  2367. /*        PASSED     Operation successful                             */
  2368. /*        error      Non-zero value, see "ERRORS.H" or EMS table A-2  */
  2369. /*                                                                    */
  2370. /*     Calls: coalesce_block()                                        */
  2371. /*            map_dir_page()                                          */
  2372. /*                                                                    */
  2373. /*     Called by: effree()                                            */
  2374. /*                                                                    */
  2375. /*     Globals referenced/modified: directory                         */
  2376. /*                                  directory_map                     */
  2377. /*                                  dir_page_count                    */
  2378. /*                                                                    */
  2379. /**********************************************************************/
  2380.  
  2381. unsigned int search_before (token, final_entry, usable_entry)
  2382. unsigned int token;
  2383. unsigned int *final_entry;
  2384. unsigned int *usable_entry;
  2385. {
  2386.    unsigned int index;              /* Index into a directory page          */
  2387.    unsigned int indexs_entry;       /* Index translated to a full dir entry */
  2388.    unsigned int indexs_last_page;   /* Last logical page for index's block  */
  2389.    unsigned int coalesce;           /* Whether we should coalesce or not    */
  2390.    unsigned int end_of_indexs_block;/* The end of token's block             */
  2391.    unsigned int page;               /* Directory pages to loop through      */
  2392.    unsigned int tokens_page;        /* Token's directory entry's log page   */
  2393.    unsigned int tokens_index;       /* Token's index into its logical page  */
  2394.    unsigned int status;             /* Status of EMM and MEMLIB             */
  2395.  
  2396.    /****************************************************************/
  2397.    /* Convert the token passed in to its respective directory page */
  2398.    /* and index.  We're going to map this page into the second     */
  2399.    /* physical page.  In order to access this page's entries we    */
  2400.    /* need to use directory[1].                                    */
  2401.    /****************************************************************/
  2402.  
  2403.    tokens_page  = token / DIR_ENTRIES_PER_PAGE;
  2404.    tokens_index = token % DIR_ENTRIES_PER_PAGE;
  2405.  
  2406.    /*********************************************************/
  2407.    /* Map in the token's directory page using the           */
  2408.    /* directory_map's second array element to map this page */
  2409.    /* in at physical page one while keeping the block to be */
  2410.    /* coalesced's directory page at physical page zero.     */
  2411.    /*********************************************************/
  2412.  
  2413.    status = map_dir_page (tokens_page, SECOND_PHYS_PAGE);
  2414.    if (status == PASSED)
  2415.    {
  2416.       /***************************/
  2417.       /* Set variables for loop. */
  2418.       /***************************/
  2419.  
  2420.       coalesce = FALSE;
  2421.  
  2422.       /*************************************************/
  2423.       /* Search for a free block of memory before this */
  2424.       /* block to coalesce into one free block.        */
  2425.       /*************************************************/
  2426.  
  2427.       for (page = 0; ((page < dir_page_count) &&
  2428.                       (status == PASSED) && 
  2429.                       (!coalesce)); page++)
  2430.       {
  2431.          /*******************************/
  2432.          /* Map in this directory page. */
  2433.          /*******************************/
  2434.  
  2435.          status = map_dir_page (page, FIRST_PHYS_PAGE);
  2436.  
  2437.          /*********************************************/
  2438.          /* Go through all the indexes for this page. */
  2439.          /*********************************************/
  2440.  
  2441.          for (index = 0; ((index < DIR_ENTRIES_PER_PAGE) &&
  2442.                        (status == PASSED) &&
  2443.                        (!coalesce)); index++)
  2444.          {
  2445.             /********************************************/
  2446.             /* Convert index to a full directory entry. */
  2447.             /********************************************/
  2448.  
  2449.             indexs_entry = index + page * DIR_ENTRIES_PER_PAGE;
  2450.  
  2451.             /*********************************************************/
  2452.             /* For index's block test:                               */
  2453.             /* Is it free?                                           */
  2454.             /* Is it > 0?                                            */
  2455.             /* Is it different than the block we called effree with? */
  2456.             /* Would its size make a coalesced block > 64K?          */
  2457.             /*********************************************************/
  2458.             
  2459.             if ((directory[0][index].token == UNASSIGNED_TOKEN) && 
  2460.                 (directory[0][index].size > 0) &&
  2461.                 (indexs_entry != token) && 
  2462.                 ((unsigned long) directory[0][index].size + 
  2463.                  directory[1][tokens_index].size < K64K))
  2464.             {
  2465.                end_of_indexs_block = (directory[0][index].offset +
  2466.                                       directory[0][index].size) % PAGE_SIZE;
  2467.  
  2468.                indexs_last_page = NUM_PAGES (directory[0][index].size) - 1;
  2469.  
  2470.  
  2471.                /*********************************************/
  2472.                /* If the beginning of token's block exactly */
  2473.                /* matches the end of index's block then     */
  2474.                /* index's block could lie BEFORE our block. */
  2475.                /*********************************************/
  2476.  
  2477.                if (directory[1][tokens_index].offset == end_of_indexs_block)
  2478.                {
  2479.                   /******************************************************/
  2480.                   /* Test the logical pages for these two blocks to     */
  2481.                   /* see if we want to coalesce them.  We will coalesce */
  2482.                   /* if either of the following is true:                */
  2483.                   /*                                                    */
  2484.                   /* 1. If the token's block ends on an exact page      */
  2485.                   /*    boundry (end_of_indexs_block == 0) then we do   */
  2486.                   /*    NOT want the first logical page of token's      */
  2487.                   /*    block to match the last logical page of index's */
  2488.                   /*    block.                                          */
  2489.                   /*                                                    */
  2490.                   /* 2. If token's block ends in the middle of a        */
  2491.                   /*    logical page (end_of_indexs_block != 0) the we  */
  2492.                   /*    DO want token's block's first logical page to   */
  2493.                   /*    match index's block's last logical page.        */
  2494.                   /******************************************************/
  2495.  
  2496.                   if (end_of_indexs_block == 0)
  2497.                   {
  2498.                      if (directory[0][index].logical_page[indexs_last_page] !=
  2499.                          directory[1][tokens_index].logical_page[0])
  2500.                      {
  2501.                         coalesce   = TRUE;
  2502.                      }
  2503.                   }
  2504.                   else 
  2505.                   {
  2506.                      if (directory[0][index].logical_page[indexs_last_page] ==
  2507.                             directory[1][tokens_index].logical_page[0])
  2508.                      {
  2509.                         coalesce   = TRUE;
  2510.                      }
  2511.                   }
  2512.                   if (coalesce)
  2513.                   {
  2514.                      /************************************/
  2515.                      /* We've got a winner! Coalesce the */
  2516.                      /* i'th block into our block.       */
  2517.                      /************************************/
  2518.  
  2519.                      status = coalesce_block (token, indexs_entry, &coalesce);
  2520.  
  2521.                      if ((status == PASSED) && 
  2522.                          coalesce)
  2523.                      {
  2524.                         *final_entry  = indexs_entry;
  2525.                         *usable_entry = token;
  2526.                      }
  2527.  
  2528.                   } /** end if coalesce **/
  2529.  
  2530.                } /** end if directory **/
  2531.  
  2532.             }  /** end if directory **/
  2533.  
  2534.          }  /** end for index = 0 **/
  2535.  
  2536.       }  /** end for page **/
  2537.  
  2538.    } /** end if PASSED **/
  2539.  
  2540.    return (status);
  2541. }  /** end search_before() **/
  2542.  
  2543.  
  2544.  
  2545.  
  2546.  
  2547.