home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / tt / vmem11 / vmem_prg / vmem.h < prev    next >
Text File  |  1991-06-08  |  10KB  |  366 lines
  1. #define    VERSION            0x102        /* Versionsnummer */
  2. #define    START_BLOCK        1
  3. #define    MAX_BLOCKS        256
  4.  
  5. #undef    STAT            /* print CACHE-Statistics */
  6.  
  7. #define    TMP_FILE        "C:\\VMEM_TMP.$$$"
  8. #define    DIR_FILE        "VMEM_TMP$$$"
  9.  
  10. #define    EMPTY_ENTRY        0xffff        /* illegale Seiten-Nr. */
  11. #define    CACHE_EMPTY        0
  12. #define    _NULL            (0L)        /* für V_ADR */
  13. #define    NIL                (-1)        /* für Memory Deskriptor */
  14. #define    FREE_MD            0            /* freier MD */
  15.  
  16. typedef int                MD;            /* Memory Deskriptor */
  17. typedef unsigned char    BYTE;
  18. typedef unsigned int    WORD;
  19. typedef unsigned int    VPAGE;
  20. typedef unsigned int    CPAGE;
  21. typedef unsigned int    SECTOR;
  22. typedef unsigned long    ULONG;
  23. typedef unsigned long    V_ADR;
  24.  
  25. #define    MEMORY    struct memory
  26. #define    V_INFO    struct v_info
  27. #define    TAB        struct tab
  28. #define    SEQ        struct seq
  29.  
  30. #define    SIZE_1024        0    /* Page-Types */
  31. #define    SIZE_2048        1
  32. #define    SIZE_4096        2
  33. #define    SIZE_8192        3
  34. #define    SIZE_16384        4
  35. #define    SIZE_32768        5
  36.  
  37. #define    NEW                0    /* Flags */
  38. #define    OLD                1
  39. #define    FILE            0
  40. #define    CACHE            2
  41. #define    FREE            0
  42. #define    USED            4
  43.  
  44. #define    CACHE_FREE        0    /* Cache-Flags */
  45. #define    CACHE_READ        2
  46. #define    CACHE_WRITE        4
  47.  
  48. /*************************/
  49. /* Include-Definitionen: */
  50. /*************************/
  51.  
  52. /**********************/
  53. /* #include <stdio.h> */
  54. /**********************/
  55.  
  56. typedef unsigned long   size_t;
  57. #define   NULL   ( (void*) 0L )
  58. int     printf (const char *format, ...);
  59.  
  60. /***********************/
  61. /* #include <stdlib.h> */
  62. /***********************/
  63.  
  64. void    exit (int status);
  65.  
  66. /***********************/
  67. /* #include <string.h> */
  68. /***********************/
  69.  
  70. typedef unsigned long    size_t;
  71. void    *memcpy (void *dest, const void *src, size_t len);
  72. void    *memset (void *ptr, int val, size_t len);
  73. int        strncmp (char *s1, char *s2, size_t maxlen);
  74.  
  75. /********************/
  76. /* #include <tos.h> */
  77. /********************/
  78.  
  79. typedef struct
  80. {
  81.     unsigned long   b_free;
  82.     unsigned long   b_total;
  83.     unsigned long   b_secsiz;
  84.     unsigned long   b_clsiz;
  85. } DISKINFO;
  86.  
  87. typedef struct
  88. {
  89.     int recsiz;        /* Bytes pro Sektor */
  90.     int clsiz;        /* Sektoren pro Cluster */
  91.     int clsizb;        /* Bytes pro Cluster */
  92.     int rdlen;        /* Verzeichnislänge */
  93.     int fsiz;        /* Länge der FAT */
  94.     int fatrec;        /* Start der 2. FAT */
  95.     int datrec;        /* 1. freier Sektor */
  96.     int numcl;        /* Gesamtzahl an Cluster */
  97.     int bflags;        /* Flags */
  98. } BPB ;
  99.  
  100. #define Malloc malloc
  101. #define Mfree free
  102.  
  103. void    *Malloc (long number);
  104. int     Mfree (void *block);
  105. int     Fopen (const char *filename, int mode);
  106. int     Fcreate (const char *filename, int attr);
  107. int     Fclose (int handle);
  108. int     Fdelete (const char *filename);
  109. long    Fread (int handle, long count, void *buf);
  110. long    Fwrite (int handle, long count, void *buf);
  111. long    Fseek (long offset, int handle, int seekmode);
  112. int     Dfree (DISKINFO *buf, int driveno);
  113. long    Drvmap (void);
  114. BPB        *Getbpb (int dev);
  115. long    Rwabs (int rwflag, void *buff, int cnt, int recnr, int dev);
  116.  
  117. /***********************/
  118. /* Makro-Definitionen: */
  119. /***********************/
  120.  
  121. #define    DO_NOTHING
  122. #define    MIN(a,b)        (((a) < (b)) ? (a) : (b))
  123. #define    MAX(a,b)        (((a) > (b)) ? (a) : (b))
  124.  
  125. #define    MD_START(a)        md_array [(a)].start
  126. #define    MD_COUNT(a)        md_array [(a)].count
  127. #define    MD_NEXT(a)        md_array [(a)].next
  128. #define    INSERT_MD(a,b,c,d)    { MD_START (a) = b; \
  129.                             MD_COUNT (a) = c;   \
  130.                             MD_NEXT (a) = d; }
  131. #define    DELETE_MD(a)        { MD_START (a) = FREE_MD; \
  132.                             MD_COUNT (a) = 0;         \
  133.                             MD_NEXT (a) = NIL; }
  134.  
  135. #define    NEW_FLAG(a)        (flags [a] & 1)
  136. #define    WHERE_FLAG(a)    (flags [a] & 2)
  137.  
  138. #define    INSIDE(a,b,c)    (((a) >= (b)) && ((a) <= (c)))
  139. #define    OUTSIDE(a,b,c)    (((a) < (b)) || ((a) > (c)))
  140.  
  141. #define    MALLOC(a,b,c)    { if (((a) = (b *) Malloc (sizeof(b) * (long) (c))) == NULL) \
  142.                             return (OUT_OF_MEMORY); }
  143.  
  144. #define    PAGE(a)            ((a) >> offset_bits)
  145. #define    OFFSET(a)        ((a) & offset_mask)
  146. #define    GET_PAGE(a)        ((WORD) (PAGE (a)))
  147. #define    GET_OFFSET(a)    ((WORD) (OFFSET (a)))
  148. #define    GET_COUNT(a)    ((WORD) ((OFFSET (a)) ? (PAGE (a) + 1) : PAGE (a)))
  149. #define    PAGE_TO_ADDR(a)    (((long) (a)) << offset_bits)
  150.  
  151. #define    ACCESSED(a)        { cache_age [a] = lru_count++; }
  152.  
  153. #define    CACHE_ADDRESS(a)    ((BYTE *) (cache + PAGE_TO_ADDR (a)))
  154.  
  155. #define    CACHE_TO_FILE(a)    flags [a] &= (~CACHE)
  156. #define    FILE_TO_CACHE(a)    flags [a] |= CACHE
  157. #define    MAKE_OLD(a)            flags [a] |= OLD
  158. #define    UPDATE_FLAG(a,b)    { if (b > cache_flags [a])       \
  159.                                 { MAKE_OLD (cache_page [a]); \
  160.                                 cache_flags [a] = b; } }
  161. #define    SET_FLAG(a,b)        cache_flags [a] = b
  162.  
  163. #define    INIT_CACHE(a)        memset ((a), info.fill_value, info.page_size)
  164. #define    FILL_CACHE(a,b)        memset ((a), (b), info.page_size)
  165. #define    COPY_CACHE(a,b)        memcopy ((a), (b), info.page_size)
  166. #define    SWAP_CACHE(a,b)        memswap ((a), (b), info.page_size)
  167.  
  168. #define    ALLOC_CACHE(a,b,c)    { cache_flags [a] = b; cache_page [a] = c; }
  169. #define    FREE_CACHE(a)        { cache_flags [a] = CACHE_FREE; \
  170.                             cache_page [a] = CACHE_EMPTY; }
  171.  
  172. #define    FSEEK(a)            Fseek (PAGE_TO_ADDR ((a)-1), tmp_handle, 0)
  173. #define    FREAD(a,b)            Fread (tmp_handle, (a), (b))
  174. #define    FWRITE(a,b)            Fwrite (tmp_handle, (a), (b))
  175.  
  176. #define    READ_SECTOR(a,b,c)    { if (Rwabs (0, (a), (b), (c), drive) < 0) \
  177.                             { printf ("READ-Error $%lx $%x $%x!!\n", (a), (b), (c)); vm_close (); exit (5); } }
  178. #define    WRITE_SECTOR(a,b,c)    { if (Rwabs (1, (a), (b), (c), drive) < 0) \
  179.                             { printf ("WRITE-Error $%lx $%x $%x!!\n", (a), (b), (c)); vm_close (); exit (6); } }
  180.  
  181. /************************/
  182. /* Funktions-Meldungen: */
  183. /************************/
  184.  
  185. /* vm_config: */
  186.  
  187. #define    OK                    0
  188. #define    WRONG_CACHE_SIZE    -256
  189. #define    WRONG_PAGE_TYPE        -257
  190. #define    OUT_OF_MEMORY        -258
  191. #define    FILE_ERROR            -259
  192. #define    ILLEGAL_DRIVE        -260
  193. #define    ILLEGAL_FATSIZE        -265
  194.  
  195. /* vm_free: */
  196.  
  197. #define    NOT_OK                -261
  198.  
  199. /* vm_fill / vm_copy / vm_load / vm_save / vm_read / vm_write: */
  200.  
  201. #define    ILLEGAL_ADDRESS        -262
  202. #define    ILLEGAL_COUNT        -263
  203. #define    ILLEGAL_MODE        -264
  204.  
  205. /************************/
  206. /* Funktions-Parameter: */
  207. /************************/
  208.  
  209. #define    DRIVE_C                3    /* vm_config */
  210. #define    DRIVE_D                4
  211. #define    DRIVE_E                5
  212.  
  213. #define    NORMAL_MODE            0    /* vm_read / vm_write */
  214. #define    BURST_MODE            1
  215.  
  216. #define    READ_MODE            CACHE_READ    /* vm_address */
  217. #define    WRITE_MODE            CACHE_WRITE
  218.  
  219. /***************/
  220. /* Strukturen: */
  221. /***************/
  222.  
  223. V_INFO
  224. {
  225.     WORD    version;        /* Versionsnummer */
  226.  
  227.     WORD    count_page;        /* Maximalanzahl an Seiten */
  228.  
  229.     WORD    count_blocks;    /* Maximale Anzahl an Blöcken */
  230.     WORD    free_blocks;    /* Anzahl der noch verfügbaren Blöcke */
  231.  
  232.     int        fill_value;        /* Füllwert */
  233.  
  234.     long    cache_size;        /* Größe des Caches in Bytes */
  235.     WORD    cache_count;    /* Größe des Caches in Seiten */
  236.  
  237.     long    page_size;        /* Größe einer Seite in Bytes */
  238.  
  239.     long    max_size;        /* Maximalgröße des virtuellen Speichers */
  240.     long    max_alloc;        /* Maximalgröße eines einzelnen Blocks */
  241.  
  242.     int        drive_no;        /* TMP-Laufwerk (A=1, B=2, C=3, ...) */
  243.     long    drive_free;        /* freier Speicher auf dem TMP-Laufwerk */
  244. };
  245.  
  246. TAB
  247. {
  248.     WORD    version;
  249.     WORD    count_page;
  250.     WORD    cache_size;
  251.     WORD    page_type;
  252.     int        fill_value;
  253.     int        drive_no;
  254. };
  255.  
  256. MEMORY
  257. {
  258.     WORD    start;            /* Nr. der ersten Seite */
  259.     WORD    count;            /* Anzahl der belegten Seiten */
  260.     MD        next;            /* Index des Nachfolgers bzw. -1 */
  261. };
  262.  
  263. SEQ
  264. {
  265.     WORD    count;            /* Anzahl der aufeinanderfolgenden Seiten */
  266.     WORD    cachepage;        /* Position der ersten Seite im Cache */
  267.     WORD    vmempage;        /* erste Seite dieser Sequenz */
  268. };
  269.  
  270. /***************/
  271. /* Prototypen: */
  272. /***************/
  273.  
  274. /* VMEM.C: */
  275.  
  276. int        vm_config    (TAB *parameter);
  277. void    vm_close    (void);
  278. V_INFO    *vm_info    (void);
  279. void    vm_clrcache    (void);
  280.  
  281. /* VM_ADDRE.C: */
  282.  
  283. char    *vm_address        (V_ADR address, long *window_size, int mode);
  284. WORD    search_sequence    (VPAGE vmempage, VPAGE lastpage);
  285.  
  286. /* VM_FILL.C: */
  287.  
  288. long    vm_fill        (V_ADR address, long count, int value);
  289.  
  290. /* VM_COPY.C: */
  291.  
  292. long    vm_copy        (V_ADR source, V_ADR destination, long count);
  293.  
  294. /* VM_LOAD.C: */
  295.  
  296. long    vm_load        (V_ADR source, char *destination, long count);
  297.  
  298. /* VM_SAVE.C: */
  299.  
  300. long    vm_save        (char *source, V_ADR destination, long count);
  301.  
  302. /* VM_WRITE.C: */
  303.  
  304. long    vm_write    (int handle, long count, V_ADR source);
  305.  
  306. /* VM_READ.C: */
  307.  
  308. long    vm_read        (int handle, long count, V_ADR destination);
  309.  
  310. /* VM_ALLOC.C: */
  311.  
  312. V_ADR    vm_alloc    (long size);
  313. int        vm_free        (V_ADR address);
  314. void    md_delete    (MD before, MD pointer);
  315. void    md_merge    (MD before, MD current, MD next);
  316. MD        md_find        (VPAGE vmempage);
  317.  
  318. /* VSUBROUT.C: */
  319.  
  320. BYTE    *load_page        (VPAGE page, int flag);
  321. void    save_page        (BYTE *block, VPAGE vmempage);
  322. CPAGE    find_cache        (void);
  323. void    read_page        (BYTE *buff, VPAGE vmempage);
  324. void    write_page        (BYTE *buff, VPAGE vmempage);
  325. int        init_pages        (VPAGE vmempage, WORD count);
  326. void    cache_clr        (CPAGE cachepage, WORD count);
  327. void    write_sequence    (CPAGE cachepage, WORD count, VPAGE vmempage);
  328. void    read_sequence    (CPAGE cachepage, WORD count, VPAGE vmempage);
  329. MD        get_free_md        (void);
  330. int        alloc_sector    (VPAGE vmempage, WORD count);
  331. void    free_sector        (VPAGE vmempage, WORD count);
  332.  
  333. /* VMEM_ASS.S: */
  334.  
  335. void    aging            (void);
  336. CPAGE    get_oldest        (void);
  337. CPAGE    search_cache    (VPAGE vmempage);
  338. WORD    read_test        (VPAGE vmempage, WORD count);
  339. WORD    write_test        (VPAGE vmempage, WORD count);
  340. void    memcopy            (void *destination, void *source, long count);
  341. /*void    memfill            (void *destination, int value, long count);*/
  342. /*void    memswap            (void *destination, void *source, long count);*/
  343.  
  344. /**********************/
  345. /* Externe Variablen: */
  346. /**********************/
  347.  
  348. extern ULONG    *cache_age;
  349. extern VPAGE    *cache_page;
  350. extern SECTOR    *sector_no;
  351. extern BYTE        *cache_flags, *flags;
  352. extern BYTE        *cache, *buffer;
  353. extern BPB        *bpb_block;
  354. extern WORD        offset_bits, offset_mask, free_mem, age_count,
  355.                 max_page, record_bits, cluster_bits, sector_mask,
  356.                 size_bits, cluster_size, sectors, drive;
  357. extern ULONG    lru_count;
  358. extern V_INFO    info;
  359. extern MD        used_list, free_list;
  360. extern MEMORY    md_array [];
  361. extern int        tmp_handle, sector_flag;
  362.  
  363. #ifdef STAT
  364. extern WORD        stat_access, stat_read, stat_write;
  365. #endif
  366.