home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / lxapi32.zip / Lib32 / lxmemory.cpp < prev    next >
C/C++ Source or Header  |  2002-04-26  |  5KB  |  237 lines
  1. /* $Id: lxmemory.cpp,v 1.2 2002/04/26 23:09:24 smilcke Exp $ */
  2.  
  3. /*
  4.  * memory.cpp
  5.  * Autor:               Stefan Milcke
  6.  * Erstellt am:         26.10.2001
  7.  * Letzte Aenderung am: 25.04.2002
  8.  *
  9. */
  10. extern "C" {
  11. #define INCL_NOPMAPI
  12. #define INCL_DOSERRORS           // for ERROR_INVALID_FUNCTION
  13. #include <os2.h>
  14. }
  15. #include <devhelp.h>
  16. #include <ldefos2.h>
  17. #include <string.h>
  18. #ifdef KEE
  19. #include <kee.h>
  20. #endif
  21.  
  22. #include "lxmalloc.hpp"
  23.  
  24. #pragma off (unreferenced)
  25.  
  26. #define PAGE_SIZE 4096
  27.  
  28. extern "C" {
  29.  
  30. //-------------------------------- virt_to_phys --------------------------------
  31. unsigned long virt_to_phys(void * address)
  32. {
  33. #ifdef KEE
  34.  KEEVMPageList pagelist;
  35.  ULONG         nrpages;
  36.  
  37.     if(KernLinToPageList(address, PAGE_SIZE, &pagelist, &nrpages)) {
  38.         DebugInt3();
  39.         return 0;
  40.     }
  41.     return pagelist.addr;
  42. #else
  43.  LINEAR addr = (LINEAR)address;
  44.  PAGELIST pagelist;
  45.  
  46.     if(DevLinToPageList(addr, PAGE_SIZE, (PAGELIST near *)__StackToFlat((ULONG)&pagelist))) {
  47.         DebugInt3();
  48.         return 0;
  49.     }
  50.     return pagelist.physaddr;
  51. #endif
  52. }
  53.  
  54. //-------------------------------- phys_to_virt --------------------------------
  55. void * phys_to_virt(unsigned long address)
  56. {
  57.     DebugInt3();
  58.     return 0;
  59. }
  60.  
  61. //------------------------------ __get_free_pages ------------------------------
  62. void *__get_free_pages(int gfp_mask, unsigned long order)
  63. {
  64.  ULONG addr;
  65.  
  66.     order = (1 << order); //TODO: Is this correct???
  67. #ifdef KEE
  68.  SHORT sel;
  69.  
  70.         if(KernVMAlloc(order*PAGE_SIZE, VMDHA_FIXED|VMDHA_CONTIG,
  71.                        (PVOID*)&addr, (PVOID*)-1, &sel)) {
  72. #else
  73.         if(DevVMAlloc(VMDHA_FIXED|VMDHA_CONTIG, order*PAGE_SIZE, (LINEAR)-1, __StackToFlat((ULONG)&addr))) {
  74. #endif
  75.         DebugInt3();
  76.         return 0;
  77.     }
  78. ////    dprintf(("__get_free_pages %d returned %x", order*PAGE_SIZE, addr));
  79.     return (void *)addr;
  80. }
  81.  
  82. //--------------------------------- free_pages ---------------------------------
  83. int free_pages(unsigned long addr, unsigned long order)
  84. {
  85. #ifdef KEE
  86.     KernVMFree((PVOID)addr);
  87. #else
  88.     DevVMFree((LINEAR)addr);
  89. #endif
  90. ////    dprintf(("free_pages %x", addr));
  91.     return 0;
  92. }
  93.  
  94. //-------------------------------- alloc_pages ---------------------------------
  95. struct page * alloc_pages(int gfp_mask, unsigned long order)
  96. {
  97.     DebugInt3();
  98.     return 0;
  99. }
  100.  
  101. //------------------------------ remap_page_range ------------------------------
  102. int remap_page_range(unsigned long from, unsigned long to, unsigned long size, unsigned long prot)
  103. {
  104.     DebugInt3();
  105.     return 0;
  106. }
  107.  
  108. //-------------------------------- is_access_ok --------------------------------
  109. int is_access_ok(int type, void *addr, unsigned long size)
  110. {
  111.     return 1;
  112. }
  113.  
  114. //-------------------------------- __copy_user ---------------------------------
  115. void __copy_user(void *to, const void *from, unsigned long n)
  116. {
  117.     if(to == NULL || from == NULL) {
  118.         DebugInt3();
  119.         return;
  120.     }
  121.         if(n == 0) return;
  122. #ifdef KEE
  123.     memcpy(to, from, n);
  124. #else
  125.     _fmemcpy(to, from, n);
  126. #endif
  127. }
  128.  
  129. //-------------------------------- copy_to_user --------------------------------
  130. unsigned long copy_to_user(void *to, const void *from, unsigned long n)
  131. {
  132.     if(to == NULL || from == NULL) {
  133.         DebugInt3();
  134.         return 0;
  135.     }
  136.         if(n == 0) return 0;
  137. #ifdef KEE
  138.     memcpy(to, from, n);
  139. #else
  140.     _fmemcpy(to, from, n);
  141. #endif
  142.     return 0;
  143. }
  144.  
  145. //---------------------------- __copy_user_zeroing -----------------------------
  146. void __copy_user_zeroing(void *to, const void *from, unsigned long n)
  147. {
  148.     if(to == NULL || from == NULL) {
  149.         DebugInt3();
  150.         return;
  151.     }
  152.         if(n == 0) return;
  153.     copy_to_user(to, from, n);
  154. }
  155.  
  156. //------------------------------- copy_from_user -------------------------------
  157. unsigned long copy_from_user(void *to, const void *from, unsigned long n)
  158. {
  159.     if(to == NULL || from == NULL) {
  160.         DebugInt3();
  161.         return 0;
  162.     }
  163.         if(n == 0) return 0;
  164. #ifdef KEE
  165.     memcpy(to, from, n);
  166. #else
  167.     _fmemcpy(to, from, n);
  168. #endif
  169.     return 0;
  170. }
  171.  
  172. //---------------------------------- get_user ----------------------------------
  173. int get_user(int size, void *dest, void *src)
  174. {
  175.     if(size == 0)    return 0;
  176.  
  177.     if(dest == NULL || src == NULL) {
  178.         DebugInt3();
  179.         return 0;
  180.     }
  181. #ifdef KEE
  182.     memcpy(dest, src, size);
  183. #else
  184.     _fmemcpy(dest, src, size);
  185. #endif
  186.     return 0;
  187. }
  188.  
  189. //---------------------------------- put_user ----------------------------------
  190. int put_user(int x, void *ptr)
  191. {
  192.     if(ptr == NULL) {
  193.         DebugInt3();
  194.         return 0;
  195.     }
  196.  
  197.     *(int *)ptr = x;
  198.     return 0;
  199. }
  200.  
  201. //--------------------------------- __put_user ---------------------------------
  202. #if 0
  203. int __put_user(int size, int x, void *ptr)
  204. {
  205. #ifdef KEE
  206.     memcpy(ptr,
  207. #else
  208.     _fmemcpy(ptr,
  209. #endif
  210.     return 0;
  211. }
  212. #endif
  213.  
  214. //---------------------------------- kmalloc -----------------------------------
  215. void *kmalloc(int size, int flags)
  216. {
  217.  return malloc(size);
  218. }
  219.  
  220. //----------------------------------- kfree ------------------------------------
  221. void kfree(const void *ptr)
  222. {
  223.  free((void *)(ULONG)ptr);
  224. }
  225.  
  226. //---------------------------------- kfree_s -----------------------------------
  227. void kfree_s(const void *ptr,int size)
  228. {
  229.  kfree(ptr);
  230. }
  231.  
  232. //---------------------------------- vmalloc -----------------------------------
  233. void *vmalloc(unsigned long size)
  234. {
  235.  return kmalloc(size,0);
  236. }
  237. }