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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
MEMMGR.C
资源名称：840.rar　[点击查看]
上传用户：dcs7469208
上传日期：2010-01-02
资源大小：443k
文件大小：16k
源码类别：

操作系统开发

开发平台：

DOS

MEMMGR.C：源码内容
  1. /****************************************************************/
  2. /*                                                              */
  3. /*                          memmgr.c                            */
  4. /*                                                              */
  5. /*               Memory Manager for Core Allocation             */
  6. /*                                                              */
  7. /*                      Copyright (c) 1995                      */
  8. /*                      Pasquale J. Villani                     */
  9. /*                      All Rights Reserved                     */
  10. /*                                                              */
  11. /* This file is part of DOS-C.                                  */
  12. /*                                                              */
  13. /* DOS-C is free software; you can redistribute it and/or       */
  14. /* modify it under the terms of the GNU General Public License  */
  15. /* as published by the Free Software Foundation; either version */
  16. /* 2, or (at your option) any later version.                    */
  17. /*                                                              */
  18. /* DOS-C is distributed in the hope that it will be useful, but */
  19. /* WITHOUT ANY WARRANTY; without even the implied warranty of   */
  20. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See    */
  21. /* the GNU General Public License for more details.             */
  22. /*                                                              */
  23. /* You should have received a copy of the GNU General Public    */
  24. /* License along with DOS-C; see the file COPYING.  If not,     */
  25. /* write to the Free Software Foundation, 675 Mass Ave,         */
  26. /* Cambridge, MA 02139, USA.                                    */
  27. /****************************************************************/
  29. #include "../../hdr/portab.h"
  30. #include "globals.h"
  33. /* $Logfile*/
  34. #ifdef VERSION_STRING
  35. static BYTE *memmgrRcsId = "$Header:   C:/dos-c/src/kernel/memmgr.c_v   1.6   04 Jan 1998 23:15:18   patv  $";
  36. #endif
  38. /* $Log:   C:/dos-c/src/kernel/memmgr.c_v  $
  39.  * 
  40.  *    Rev 1.6   04 Jan 1998 23:15:18   patv
  41.  * Changed Log for strip utility
  42.  * 
  43.  *    Rev 1.5   16 Jan 1997 12:47:00   patv
  44.  * pre-Release 0.92 feature additions
  45.  * 
  46.  *    Rev 1.4   29 May 1996 21:03:34   patv
  47.  * bug fixes for v0.91a
  48.  * 
  49.  *    Rev 1.3   19 Feb 1996  3:21:36   patv
  50.  * Added NLS, int2f and config.sys processing
  51.  * 
  52.  *    Rev 1.2   01 Sep 1995 17:54:20   patv
  53.  * First GPL release.
  54.  * 
  55.  *    Rev 1.1   30 Jul 1995 20:51:58   patv
  56.  * Eliminated version strings in ipl
  57.  * 
  58.  *    Rev 1.0   02 Jul 1995  8:33:08   patv
  59.  * Initial revision.
  60.  */
  61. /* $EndLog$ */
  63. VOID mcb_init();        
  64. VOID mcb_print();
  65. VOID show_chain();
  67. /* The following code is 8086 dependant                         */
  69. #ifdef KERNEL
  70. VOID 
  71. mcb_init (mcb FAR *mcbp, UWORD size)
  72. {
  73. COUNT i;
  75. mcbp -> m_type = MCB_LAST;
  76. mcbp -> m_psp = FREE_PSP;
  77. mcbp -> m_size = size;
  78. for(i = 0; i < 8; i++)
  79. mcbp -> m_name[i] = '';
  80. mem_access_mode = FIRST_FIT;
  81. }
  82. #endif
  84. seg 
  85. far2para (VOID FAR *p)
  86. {
  87. seg u1 = FP_SEG(p);
  88. offset u2 = FP_OFF(p);
  89. ULONG phy_addr;
  91. phy_addr = (((long)u1) << 4) + u2;
  92. return (phy_addr>>4);
  93. }
  96. seg 
  97. long2para (LONG size)
  98. {
  99. return ((size + 0x0f)>>4);
  100. }
  103. VOID FAR *
  104. add_far (VOID FAR *fp, ULONG off)
  105. {
  106. UWORD seg_val;
  107. UWORD off_val;
  109. /* Break far pointer into components                            */
  110. seg_val = FP_SEG(fp);
  111. off_val = FP_OFF(fp);
  113. /* add the offset  to the fp's offset part                      */
  114. off += off_val;
  116. /* make off_val equal to lower part of new value                */
  117. off_val = off & 0xffff;
  119. /* and add top part into seg                                    */
  120. seg_val += ((off & 0x000f0000l) / 0x10);
  122. /* and send back the new pointer                                */
  123. return (VOID FAR *)MK_FP(seg_val, off_val);
  124. }
  127. VOID FAR *
  128. adjust_far (VOID FAR *fp)
  129. {
  130. ULONG linear;
  131. UWORD seg_val;
  132. UWORD off_val;
  134. /* First, convert the segmented pointer to a linear address     */
  135. linear = (((ULONG)FP_SEG(fp)) << 4) + FP_OFF(fp);
  137. /* Break it into segments.                                      */
  138. seg_val = (UWORD)(linear >> 4);
  139. off_val = (UWORD)(linear & 0xf);
  141. /* and return an adddress adjusted to the nearest paragraph     */
  142. /* boundary.                                                    */
  143. return MK_FP(seg_val, off_val);
  144. }
  146. #undef REG
  147. #define REG 
  149. #ifdef KERNEL
  150. COUNT 
  151. DosMemAlloc (UWORD size, COUNT mode, seg FAR *para, UWORD FAR *asize)
  152. {
  153. REG mcb FAR *p;
  154. mcb FAR *q;
  155. COUNT i;
  156. BOOL found;
  158. /* Initialize                                           */
  159. p = (mcb FAR *)(MK_FP(first_mcb, 0));
  161. /* Search through memory blocks                         */
  162. for(q = (mcb FAR *)0, i = 0, found = FALSE; !found; )
  163. {
  164. /* check for corruption                         */
  165. if(p -> m_type != MCB_NORMAL && p -> m_type != MCB_LAST)
  166. return DE_MCBDESTRY;
  168. /* Test if free based on mode rules             */
  169. switch(mode)
  170. {
  171. case LAST_FIT:
  172. default:
  173. /* Check for a last fit candidate       */
  174. if(p -> m_size >= size && p -> m_psp == FREE_PSP)
  175. /* keep the last know fit       */
  176. q = p;
  177. /* not free - bump the pointer          */
  178. if(p -> m_type != MCB_LAST)
  179. p = MK_FP(far2para((VOID FAR *)p) + p -> m_size + 1, 0);
  180. /* was there no room (q == 0)?          */
  181. else if(p -> m_type == MCB_LAST && q == (mcb FAR *)0)
  182. return DE_NOMEM;
  183. /* something was found - continue       */
  184. else
  185. found = TRUE;
  186. break;
  188. case FIRST_FIT:
  189. /* Check for a first fit candidate      */
  190. if(p -> m_size >= size && p -> m_psp == FREE_PSP)
  191. {
  192. q = p;
  193. found = TRUE;
  194. break;
  195. }
  196. /* not free - bump the pointer          */
  197. if(p -> m_type != MCB_LAST)
  198. p = MK_FP(far2para((VOID FAR *)p) + p -> m_size + 1, 0);
  199. /* nothing found till end - no room     */
  200. else
  201. return DE_NOMEM;
  202. break;
  204. case BEST_FIT:
  205. /* Check for a best fit candidate       */
  206. if(p -> m_size >= size && p -> m_psp == FREE_PSP)
  207. {
  208. if(i == 0 || p -> m_size < i)
  209. {
  210. i = p -> m_size;
  211. q = p;
  212. }
  213. }
  214. /* not free - bump the pointer          */
  215. if(p -> m_type != MCB_LAST)
  216. p = MK_FP(far2para((VOID FAR *)p) + p -> m_size + 1, 0);
  217. /* was there no room (q == 0)?          */
  218. else if(p -> m_type == MCB_LAST && q == (mcb FAR *)0)
  219. return DE_NOMEM;
  220. /* something was found - continue       */
  221. else
  222. found = TRUE;
  223. break;
  225. case LARGEST:
  226. /* Check for a first fit candidate      */
  227. if((p -> m_psp == FREE_PSP) && (i == 0 || p -> m_size > i))
  228. {
  229. size = *asize = i = p -> m_size;
  230. q = p;
  231. }
  232. /* not free - bump the pointer          */
  233. if(p -> m_type != MCB_LAST)
  234. p = MK_FP(far2para((VOID FAR *)p) + p -> m_size + 1, 0);
  235. /* was there no room (q == 0)?          */
  236. else if(p -> m_type == MCB_LAST && q == (mcb FAR *)0)
  237. return DE_NOMEM;
  238. /* something was found - continue       */
  239. else
  240. found = TRUE;
  241. break;
  242. }
  243. }
  244. p = q;
  245. /* Larger fit case              */
  246. if(p -> m_size > size)
  247. {
  248. if(mode != LAST_FIT)
  249. {
  250. q = MK_FP(far2para((VOID FAR *)p) + size + 1, 0);
  251. /* Always flow m_type up */
  252. /* on alloc             */
  253. q -> m_type = p -> m_type;
  254. p -> m_type = MCB_NORMAL;
  255. p -> m_psp = cu_psp;
  256. q -> m_psp = FREE_PSP;
  257. q -> m_size = p -> m_size - size - 1;
  258. p -> m_size = size;
  259. for(i = 0; i < 8; i++)
  260. p -> m_name[i] = q -> m_name[i] = '';
  261. }
  262. else
  263. {
  264. q = MK_FP(far2para((VOID FAR *)p) + (p -> m_size - size), 0);
  265. /* Always flow m_type up */
  266. /* on alloc             */
  267. q -> m_type = p -> m_type;
  268. p -> m_type = MCB_NORMAL;
  269. q -> m_psp = cu_psp;
  270. p -> m_psp = FREE_PSP;
  271. p -> m_size = p -> m_size - size - 1;
  272. q -> m_size = size;
  273. for(i = 0; i < 8; i++)
  274. p -> m_name[i] = q -> m_name[i] = '';
  275. }
  276. /* Found - return good          */
  277. *para = far2para((VOID FAR *)(mode == LAST_FIT ? (VOID FAR *)q : (VOID FAR *)p));
  278. return SUCCESS;
  279. }
  280. /* Exact fit case               */
  281. else if(p -> m_size == size)
  282. {
  283. p -> m_psp = cu_psp;
  284. for(i = 0; i < 8; i++)
  285. p -> m_name[i] = '';
  286. /* Found - return good          */
  287. *para = far2para((VOID FAR *)(BYTE FAR *)p);
  288. return SUCCESS;
  289. }
  290. else
  291. return DE_MCBDESTRY;
  292. }
  295. seg 
  296. DosMemLargest (seg FAR *size)
  297. {
  298. REG mcb FAR *p;
  299. mcb FAR *q;
  300. COUNT found;
  302. /* Initialize                                           */
  303. p = (mcb FAR *)(MK_FP(first_mcb, 0));
  305. /* Search through memory blocks                         */
  306. for(q = (mcb FAR *)0, *size = 0, found = FALSE; !found; )
  307. {
  308. /* check for corruption                         */
  309. if(p -> m_type != MCB_NORMAL && p -> m_type != MCB_LAST)
  310. return DE_MCBDESTRY;
  312. /* Test for largest fit/available               */
  313. if((p -> m_psp == FREE_PSP) && (p -> m_size > *size))
  314. {
  315. *size = p -> m_size;
  316. q = p;
  317. }
  318. /* not free - bump the pointer          */
  319. if(p -> m_type != MCB_LAST)
  320. p = MK_FP(far2para((VOID FAR *)p) + p -> m_size + 1, 0);
  321. /* was there no room (q == 0)?          */
  322. else if(p -> m_type == MCB_LAST && q == (mcb FAR *)0)
  323. return DE_NOMEM;
  324. /* something was found - continue       */
  325. else
  326. found = TRUE;
  327. }
  328. if( q != 0)
  329. return SUCCESS;
  330. else
  331. return DE_NOMEM;
  332. }
  335. COUNT 
  336. DosMemFree (UWORD para)
  337. {
  338. REG mcb FAR *p, FAR *q;
  339. COUNT i;
  341. /* Initialize                                           */
  342. p = (mcb FAR *)(MK_FP(para, 0));
  344. /* check for corruption                         */
  345. if(p -> m_type != MCB_NORMAL && p -> m_type != MCB_LAST)
  346. return DE_INVLDMCB;
  348. /* Mark the mcb as free so that we can later    */
  349. /* merge with other surrounding free mcb's      */
  350. p -> m_psp = FREE_PSP;
  351. for(i = 0; i < 8; i++)
  352. p -> m_name[i] = '';
  354. /* Now merge free blocks                        */
  355. for(p = (mcb FAR *)(MK_FP(first_mcb, 0)); p -> m_type != MCB_LAST; p = q)
  356. {
  357. /* make q a pointer to the next block   */
  358. q = MK_FP(far2para((VOID FAR *)p) + p -> m_size + 1, 0);
  359. /* and test for corruption              */
  360. if(q -> m_type != MCB_NORMAL && q -> m_type != MCB_LAST)
  361. return DE_MCBDESTRY;
  362. if(p -> m_psp != FREE_PSP)
  363. continue;
  365. /* test if next is free - if so merge   */
  366. if(q -> m_psp == FREE_PSP)
  367. {
  368. /* Always flow type down on free */
  369. p -> m_type = q -> m_type;
  370. p -> m_size += q -> m_size + 1;
  371. /* and make pointers the same   */
  372. /* since the next free is now   */
  373. /* this block                   */
  374. q = p;
  375. }
  376. }
  377. return SUCCESS;
  378. }
  380. COUNT 
  381. DosMemChange (UWORD para, UWORD size, UWORD *maxSize)
  382. {
  383. REG mcb FAR *p, FAR *q;
  384. REG COUNT i;
  387. /* Initialize                                                   */
  388. p = (mcb FAR *)(MK_FP(--para, 0));
  390. /* check for corruption                                         */
  391. if(p -> m_type != MCB_NORMAL && p -> m_type != MCB_LAST)
  392. return DE_MCBDESTRY;
  394. /* check for wrong allocation                                   */
  395. if(size > p -> m_size)
  396. {
  397. REG UCOUNT delta;
  399. if (p -> m_type == MCB_LAST)
  400. {      
  401.     if (maxSize) *maxSize = p -> m_size + q -> m_size;
  402.     return DE_NOMEM;
  403. }
  405. /* make q a pointer to the next block                   */
  406. q = MK_FP(far2para((VOID FAR *)p) + p -> m_size + 1, 0);
  408. /* check for corruption                                         */
  409. if(q -> m_type != MCB_NORMAL && q -> m_type != MCB_LAST)
  410.     return DE_MCBDESTRY;
  412. /* if next mcb is not free, error no memory             */
  413. if(q -> m_psp != FREE_PSP)
  414. {        
  415. if (maxSize) *maxSize = p -> m_size;
  416. return DE_NOMEM;
  417. }
  418. /* reduce the size of q and add difference to p         */
  419. /* but check that q is big enough first                 */
  420. delta = size - p -> m_size;
  421.  
  422. if(q -> m_size < delta)
  423. {        
  425. if (maxSize) *maxSize = p -> m_size + q -> m_size;
  426. return DE_NOMEM;
  427. }
  429. q -> m_size -= delta;
  430. p -> m_size += delta;
  432. /* Now go back and adjust q, we'll make p new q         */
  433. p = MK_FP(far2para((VOID FAR *)q) + delta, 0);
  434. p -> m_type = q -> m_type;
  435. p -> m_psp  = q -> m_psp;
  436. p -> m_size = q -> m_size;
  438. for(i = 0; i < 8; i++)
  439.     p -> m_name[i] = q -> m_name[i];
  441. /* and finished                                         */
  442. return SUCCESS;
  443. }
  445. /* else, shrink it down                                         */
  446. else if(size < p -> m_size)
  447. {
  448. /* make q a pointer to the new next block               */
  449. q = MK_FP(far2para((VOID FAR *)p) + size + 1, 0);
  450. /* reduce the size of p and add difference to q         */
  451. q -> m_type = p -> m_type;
  452. q -> m_size = p -> m_size - size - 1;
  454. p -> m_size = size;
  456. /* Make certian the old psp is not last (if it was)     */
  457. p -> m_type = MCB_NORMAL;
  459. /* Mark the mcb as free so that we can later    */
  460. /* merge with other surrounding free mcb's      */
  461. q -> m_psp = FREE_PSP;
  462. for(i = 0; i < 8; i++)
  463. q -> m_name[i] = '';
  465. /* now free it so that we have a complete block */
  466. return DosMemFree(far2para((VOID FAR *)q));
  467. }
  469. /* otherwise, its a no-op                                       */
  470. else
  471. return SUCCESS;
  472. }
  474. COUNT 
  475. DosMemCheck (void)
  476. {
  477. REG mcb FAR *p;
  479. /* Initialize                                           */
  480. p = (mcb FAR *)(MK_FP(first_mcb, 0));
  482. /* Search through memory blocks                         */
  483. for( ; ; )
  484. {
  485. /* check for corruption                         */
  486. if(p -> m_type != MCB_NORMAL && p -> m_type != MCB_LAST)
  487. return DE_MCBDESTRY;
  489. /* not corrupted - if last we're OK!            */
  490. if(p -> m_type == MCB_LAST)
  491. return SUCCESS;
  493. /* not corrupted - but not end, bump the pointer */
  494. else if(p -> m_type != MCB_LAST)
  495. p = MK_FP(far2para((VOID FAR *)p) + p -> m_size + 1, 0);
  497. /* totally lost - bad exit                      */
  498. else
  499. return DE_MCBDESTRY;
  500. }
  501. }
  503. COUNT 
  504. FreeProcessMem (UWORD ps)
  505. {
  506. mcb FAR *p;
  508. /* Initialize                                           */
  509. p = (mcb FAR *)(MK_FP(first_mcb, 0));
  511. /* Search through memory blocks                         */
  512. for( ; ; )
  513. {
  514. /* check for corruption                         */
  515. if(p -> m_type != MCB_NORMAL && p -> m_type != MCB_LAST)
  516. return DE_MCBDESTRY;
  518. if(p -> m_psp == ps) 
  519. DosMemFree( FP_SEG(p) );
  521. /* not corrupted - if last we're OK!            */
  522. if(p -> m_type == MCB_LAST) break;
  523. p = MK_FP(far2para((VOID FAR *)p) + p -> m_size + 1, 0);
  525. }
  526. return SUCCESS;
  527. }
  529. COUNT
  530. DosGetLargestBlock(UWORD FAR *block)
  531. {
  532. UWORD sz = 0;
  533. mcb FAR *p;
  534. *block = sz;
  536. /* Initialize                                           */
  537. p = (mcb FAR *)(MK_FP(first_mcb, 0));
  539. /* Search through memory blocks                         */
  540. for( ; ; )
  541. {
  542. /* check for corruption                         */
  543. if(p -> m_type != MCB_NORMAL && p -> m_type != MCB_LAST)
  544. return DE_MCBDESTRY;
  546. if (p -> m_psp == FREE_PSP && p -> m_size > sz)
  547.     sz = p -> m_size;
  549. /* not corrupted - if last we're OK!            */
  550. if(p -> m_type == MCB_LAST) break;
  551. p = MK_FP(far2para((VOID FAR *)p) + p -> m_size + 1, 0);
  553. }
  554. *block = sz;
  555. return SUCCESS;
  556. }
  558. VOID 
  559. show_chain (void)
  560. {
  561. mcb FAR *p = (mcb FAR *)(MK_FP(first_mcb, 0));
  563. for(;;)
  564. {
  565. mcb_print(p);
  566. if(p -> m_type == MCB_LAST || p -> m_type != MCB_NORMAL)
  567. return;
  568. else
  569. p = (mcb FAR *)(MK_FP(far2para((VOID FAR *)p)+p -> m_size+1,0));
  570. }
  571. }
  574. VOID 
  575. mcb_print (mcb FAR *mcbp)
  576. {
  577. static BYTE buff[9];
  578. VOID _fmemcpy();
  580. _fmemcpy((BYTE FAR *)buff, (BYTE FAR *)(mcbp -> m_name), 8);
  581. buff[8] = '';
  582. printf("%04x:%04x -> |%s| m_type = 0x%02x; m_psp = 0x%04x; m_size = 0x%04xn",
  583. FP_SEG(mcbp),
  584. FP_OFF(mcbp),
  585. *buff == '' ? "*NO-ID*" : buff,
  586. mcbp -> m_type,
  587. mcbp -> m_psp,
  588. mcbp -> m_size);
  589. }
  592. VOID _fmemcpy(BYTE FAR *d, BYTE FAR *s, REG COUNT n)
  593. {
  594. while(n--)
  595.       *d++ = *s++;
  597. }
  598. #endif