Ros-diffs January 2008

ros-diffs@reactos.org

24 participants
539 discussions

[cwittich] 31760: don't corrupt the image path

by cwittich＠svn.reactos.org

Author: cwittich Date: Sun Jan 13 16:44:14 2008 New Revision: 31760 URL: http://svn.reactos.org/svn/reactos?rev=31760&view=rev Log: don't corrupt the image path Modified: trunk/reactos/base/system/services/rpcserver.c Modified: trunk/reactos/base/system/services/rpcserver.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/system/services/rpcse… ============================================================================== --- trunk/reactos/base/system/services/rpcserver.c (original) +++ trunk/reactos/base/system/services/rpcserver.c Sun Jan 13 16:44:14 2008 @@ -1058,10 +1058,7 @@ if (dwServiceType & SERVICE_DRIVER) { - /* FIXME: Adjust the image path - * Following line is VERY BAD, because it assumes that the - * first part of full file name is the OS directory */ - if (lpBinaryPathName[1] == ':') lpBinaryPathName += GetWindowsDirectoryW(NULL, 0); + /* FIXME: Adjust the image path */ lpImagePath = (WCHAR*) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, @@ -1185,7 +1182,7 @@ 0, REG_EXPAND_SZ, (LPBYTE)lpImagePath, - (wcslen(lpImagePath) + 1) *sizeof(WCHAR)); + (wcslen(lpImagePath) + 1) * sizeof(WCHAR)); if (dwError != ERROR_SUCCESS) goto done; }

16 years, 8 months

[dchapyshev] 31759: - Add more languages

by dchapyshev＠svn.reactos.org

Author: dchapyshev Date: Sun Jan 13 16:39:36 2008 New Revision: 31759 URL: http://svn.reactos.org/svn/reactos?rev=31759&view=rev Log: - Add more languages Modified: trunk/reactos/boot/bootdata/txtsetup.sif Modified: trunk/reactos/boot/bootdata/txtsetup.sif URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/bootdata/txtsetup.sif… ============================================================================== --- trunk/reactos/boot/bootdata/txtsetup.sif (original) +++ trunk/reactos/boot/bootdata/txtsetup.sif Sun Jan 13 16:39:36 2008 @@ -101,6 +101,7 @@ [Language] 00000402 = "Bulgarian" 00000403 = "Catalan" +00000804 = "Chinese (PRC)" 00000406 = "Danish" 00000413 = "Dutch" 00000409 = "English" @@ -112,6 +113,7 @@ 0000040E = "Hungarian" 00000410 = "Italian" 00000411 = "Japanese" +00000412 = "Korean" 00000414 = "Norwegian" 00000415 = "Polish" 00000816 = "Portuguese" @@ -119,6 +121,8 @@ 0000041B = "Slovak" 0000040A = "Spanish" 0000041D = "Swedish" +0000041E = "Thai" +0000041F = "Turkish" 00000422 = "Ukrainian"

16 years, 8 months

[dchapyshev] 31758: - Add more languages (not translated)

by dchapyshev＠svn.reactos.org

Author: dchapyshev Date: Sun Jan 13 16:37:35 2008 New Revision: 31758 URL: http://svn.reactos.org/svn/reactos?rev=31758&view=rev Log: - Add more languages (not translated) Added: trunk/reactos/base/setup/usetup/lang/ko-KR.h (with props) trunk/reactos/base/setup/usetup/lang/th-TH.h (with props) trunk/reactos/base/setup/usetup/lang/tr-TR.h (with props) trunk/reactos/base/setup/usetup/lang/zh-CN.h (with props) Modified: trunk/reactos/base/setup/usetup/mui.c [This mail would be too long, it was shortened to contain the URLs only.] Added: trunk/reactos/base/setup/usetup/lang/ko-KR.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/setup/usetup/lang/ko-… Added: trunk/reactos/base/setup/usetup/lang/th-TH.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/setup/usetup/lang/th-… Added: trunk/reactos/base/setup/usetup/lang/tr-TR.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/setup/usetup/lang/tr-… Added: trunk/reactos/base/setup/usetup/lang/zh-CN.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/setup/usetup/lang/zh-… Modified: trunk/reactos/base/setup/usetup/mui.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/setup/usetup/mui.c?re…

16 years, 8 months

[cwittich] 31757: fix a bug in CreateServiceA

by cwittich＠svn.reactos.org

Author: cwittich Date: Sun Jan 13 16:33:28 2008 New Revision: 31757 URL: http://svn.reactos.org/svn/reactos?rev=31757&view=rev Log: fix a bug in CreateServiceA Modified: trunk/reactos/dll/win32/advapi32/service/scm.c Modified: trunk/reactos/dll/win32/advapi32/service/scm.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/advapi32/service… ============================================================================== --- trunk/reactos/dll/win32/advapi32/service/scm.c (original) +++ trunk/reactos/dll/win32/advapi32/service/scm.c Sun Jan 13 16:33:28 2008 @@ -496,7 +496,7 @@ SetLastError(ERROR_NOT_ENOUGH_MEMORY); goto cleanup; } - MultiByteToWideChar(CP_ACP, 0, lpDisplayName, -1, lpBinaryPathNameW, len); + MultiByteToWideChar(CP_ACP, 0, lpBinaryPathName, -1, lpBinaryPathNameW, len); } if (lpLoadOrderGroup)

16 years, 8 months

[fireball] 31756: - Add BGET (public domain heap implementation).

by fireball＠svn.reactos.org

Author: fireball Date: Sun Jan 13 16:03:42 2008 New Revision: 31756 URL: http://svn.reactos.org/svn/reactos?rev=31756&view=rev Log: - Add BGET (public domain heap implementation). Added: trunk/reactos/boot/freeldr/freeldr/include/bget.h (with props) trunk/reactos/boot/freeldr/freeldr/rtl/bget.c (with props) Modified: trunk/reactos/boot/freeldr/freeldr/freeldr_base.rbuild Modified: trunk/reactos/boot/freeldr/freeldr/freeldr_base.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/freel… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/freeldr_base.rbuild (original) +++ trunk/reactos/boot/freeldr/freeldr/freeldr_base.rbuild Sun Jan 13 16:03:42 2008 @@ -51,6 +51,7 @@ <file>reactos.c</file> </directory> <directory name="rtl"> + <file>bget.c</file> <file>libsupp.c</file> </directory> <directory name="ui"> Added: trunk/reactos/boot/freeldr/freeldr/include/bget.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/inclu… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/include/bget.h (added) +++ trunk/reactos/boot/freeldr/freeldr/include/bget.h Sun Jan 13 16:03:42 2008 @@ -1,0 +1,30 @@ +/* + + Interface definitions for bget.c, the memory management package. + +*/ + +#ifndef _ +#ifdef PROTOTYPES +#define _(x) x /* If compiler knows prototypes */ +#else +#define _(x) () /* It it doesn't */ +#endif /* PROTOTYPES */ +#endif + +typedef long bufsize; +void bpool _((void *buffer, bufsize len)); +void *bget _((bufsize size)); +void *bgetz _((bufsize size)); +void *bgetr _((void *buffer, bufsize newsize)); +void brel _((void *buf)); +void bectl _((int (*compact)(bufsize sizereq, int sequence), + void *(*acquire)(bufsize size), + void (*release)(void *buf), bufsize pool_incr)); +void bstats _((bufsize *curalloc, bufsize *totfree, bufsize *maxfree, + long *nget, long *nrel)); +void bstatse _((bufsize *pool_incr, long *npool, long *npget, + long *nprel, long *ndget, long *ndrel)); +void bufdump _((void *buf)); +void bpoold _((void *pool, int dumpalloc, int dumpfree)); +int bpoolv _((void *pool)); Propchange: trunk/reactos/boot/freeldr/freeldr/include/bget.h ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/boot/freeldr/freeldr/rtl/bget.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/rtl/b… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/rtl/bget.c (added) +++ trunk/reactos/boot/freeldr/freeldr/rtl/bget.c Sun Jan 13 16:03:42 2008 @@ -1,0 +1,1593 @@ +/* + + B G E T + + Buffer allocator + + Designed and implemented in April of 1972 by John Walker, based on the + Case Algol OPRO$ algorithm implemented in 1966. + + Reimplemented in 1975 by John Walker for the Interdata 70. + Reimplemented in 1977 by John Walker for the Marinchip 9900. + Reimplemented in 1982 by Duff Kurland for the Intel 8080. + + Portable C version implemented in September of 1990 by an older, wiser + instance of the original implementor. + + Souped up and/or weighed down slightly shortly thereafter by Greg + Lutz. + + AMIX edition, including the new compaction call-back option, prepared + by John Walker in July of 1992. + + Bug in built-in test program fixed, ANSI compiler warnings eradicated, + buffer pool validator implemented, and guaranteed repeatable test + added by John Walker in October of 1995. + + This program is in the public domain. + + 1. This is the book of the generations of Adam. In the day that God + created man, in the likeness of God made he him; + 2. Male and female created he them; and blessed them, and called + their name Adam, in the day when they were created. + 3. And Adam lived an hundred and thirty years, and begat a son in + his own likeness, and after his image; and called his name Seth: + 4. And the days of Adam after he had begotten Seth were eight + hundred years: and he begat sons and daughters: + 5. And all the days that Adam lived were nine hundred and thirty + years: and he died. + 6. And Seth lived an hundred and five years, and begat Enos: + 7. And Seth lived after he begat Enos eight hundred and seven years, + and begat sons and daughters: + 8. And all the days of Seth were nine hundred and twelve years: and + he died. + 9. And Enos lived ninety years, and begat Cainan: + 10. And Enos lived after he begat Cainan eight hundred and fifteen + years, and begat sons and daughters: + 11. And all the days of Enos were nine hundred and five years: and + he died. + 12. And Cainan lived seventy years and begat Mahalaleel: + 13. And Cainan lived after he begat Mahalaleel eight hundred and + forty years, and begat sons and daughters: + 14. And all the days of Cainan were nine hundred and ten years: and + he died. + 15. And Mahalaleel lived sixty and five years, and begat Jared: + 16. And Mahalaleel lived after he begat Jared eight hundred and + thirty years, and begat sons and daughters: + 17. And all the days of Mahalaleel were eight hundred ninety and + five years: and he died. + 18. And Jared lived an hundred sixty and two years, and he begat + Enoch: + 19. And Jared lived after he begat Enoch eight hundred years, and + begat sons and daughters: + 20. And all the days of Jared were nine hundred sixty and two years: + and he died. + 21. And Enoch lived sixty and five years, and begat Methuselah: + 22. And Enoch walked with God after he begat Methuselah three + hundred years, and begat sons and daughters: + 23. And all the days of Enoch were three hundred sixty and five + years: + 24. And Enoch walked with God: and he was not; for God took him. + 25. And Methuselah lived an hundred eighty and seven years, and + begat Lamech. + 26. And Methuselah lived after he begat Lamech seven hundred eighty + and two years, and begat sons and daughters: + 27. And all the days of Methuselah were nine hundred sixty and nine + years: and he died. + 28. And Lamech lived an hundred eighty and two years, and begat a + son: + 29. And he called his name Noah, saying, This same shall comfort us + concerning our work and toil of our hands, because of the ground + which the LORD hath cursed. + 30. And Lamech lived after he begat Noah five hundred ninety and + five years, and begat sons and daughters: + 31. And all the days of Lamech were seven hundred seventy and seven + years: and he died. + 32. And Noah was five hundred years old: and Noah begat Shem, Ham, + and Japheth. + + And buffers begat buffers, and links begat links, and buffer pools + begat links to chains of buffer pools containing buffers, and lo the + buffers and links and pools of buffers and pools of links to chains of + pools of buffers were fruitful and they multiplied and the Operating + System looked down upon them and said that it was Good. + + + INTRODUCTION + ============ + + BGET is a comprehensive memory allocation package which is easily + configured to the needs of an application. BGET is efficient in + both the time needed to allocate and release buffers and in the + memory overhead required for buffer pool management. It + automatically consolidates contiguous space to minimise + fragmentation. BGET is configured by compile-time definitions, + Major options include: + + * A built-in test program to exercise BGET and + demonstrate how the various functions are used. + + * Allocation by either the "first fit" or "best fit" + method. + + * Wiping buffers at release time to catch code which + references previously released storage. + + * Built-in routines to dump individual buffers or the + entire buffer pool. + + * Retrieval of allocation and pool size statistics. + + * Quantisation of buffer sizes to a power of two to + satisfy hardware alignment constraints. + + * Automatic pool compaction, growth, and shrinkage by + means of call-backs to user defined functions. + + Applications of BGET can range from storage management in + ROM-based embedded programs to providing the framework upon which + a multitasking system incorporating garbage collection is + constructed. BGET incorporates extensive internal consistency + checking using the <assert.h> mechanism; all these checks can be + turned off by compiling with NDEBUG defined, yielding a version of + BGET with minimal size and maximum speed. + + The basic algorithm underlying BGET has withstood the test of + time; more than 25 years have passed since the first + implementation of this code. And yet, it is substantially more + efficient than the native allocation schemes of many operating + systems: the Macintosh and Microsoft Windows to name two, on which + programs have obtained substantial speed-ups by layering BGET as + an application level memory manager atop the underlying system's. + + BGET has been implemented on the largest mainframes and the lowest + of microprocessors. It has served as the core for multitasking + operating systems, multi-thread applications, embedded software in + data network switching processors, and a host of C programs. And + while it has accreted flexibility and additional options over the + years, it remains fast, memory efficient, portable, and easy to + integrate into your program. + + + BGET IMPLEMENTATION ASSUMPTIONS + =============================== + + BGET is written in as portable a dialect of C as possible. The + only fundamental assumption about the underlying hardware + architecture is that memory is allocated is a linear array which + can be addressed as a vector of C "char" objects. On segmented + address space architectures, this generally means that BGET should + be used to allocate storage within a single segment (although some + compilers simulate linear address spaces on segmented + architectures). On segmented architectures, then, BGET buffer + pools may not be larger than a segment, but since BGET allows any + number of separate buffer pools, there is no limit on the total + storage which can be managed, only on the largest individual + object which can be allocated. Machines with a linear address + architecture, such as the VAX, 680x0, Sparc, MIPS, or the Intel + 80386 and above in native mode, may use BGET without restriction. + + + GETTING STARTED WITH BGET + ========================= + + Although BGET can be configured in a multitude of fashions, there + are three basic ways of working with BGET. The functions + mentioned below are documented in the following section. Please + excuse the forward references which are made in the interest of + providing a roadmap to guide you to the BGET functions you're + likely to need. + + Embedded Applications + --------------------- + + Embedded applications typically have a fixed area of memory + dedicated to buffer allocation (often in a separate RAM address + space distinct from the ROM that contains the executable code). + To use BGET in such an environment, simply call bpool() with the + start address and length of the buffer pool area in RAM, then + allocate buffers with bget() and release them with brel(). + Embedded applications with very limited RAM but abundant CPU speed + may benefit by configuring BGET for BestFit allocation (which is + usually not worth it in other environments). + + Malloc() Emulation + ------------------ + + If the C library malloc() function is too slow, not present in + your development environment (for example, an a native Windows or + Macintosh program), or otherwise unsuitable, you can replace it + with BGET. Initially define a buffer pool of an appropriate size + with bpool()--usually obtained by making a call to the operating + system's low-level memory allocator. Then allocate buffers with + bget(), bgetz(), and bgetr() (the last two permit the allocation + of buffers initialised to zero and [inefficient] re-allocation of + existing buffers for compatibility with C library functions). + Release buffers by calling brel(). If a buffer allocation request + fails, obtain more storage from the underlying operating system, + add it to the buffer pool by another call to bpool(), and continue + execution. + + Automatic Storage Management + ---------------------------- + + You can use BGET as your application's native memory manager and + implement automatic storage pool expansion, contraction, and + optionally application-specific memory compaction by compiling + BGET with the BECtl variable defined, then calling bectl() and + supplying functions for storage compaction, acquisition, and + release, as well as a standard pool expansion increment. All of + these functions are optional (although it doesn't make much sense + to provide a release function without an acquisition function, + does it?). Once the call-back functions have been defined with + bectl(), you simply use bget() and brel() to allocate and release + storage as before. You can supply an initial buffer pool with + bpool() or rely on automatic allocation to acquire the entire + pool. When a call on bget() cannot be satisfied, BGET first + checks if a compaction function has been supplied. If so, it is + called (with the space required to satisfy the allocation request + and a sequence number to allow the compaction routine to be called + successively without looping). If the compaction function is able + to free any storage (it needn't know whether the storage it freed + was adequate) it should return a nonzero value, whereupon BGET + will retry the allocation request and, if it fails again, call the + compaction function again with the next-higher sequence number. + + If the compaction function returns zero, indicating failure to + free space, or no compaction function is defined, BGET next tests + whether a non-NULL allocation function was supplied to bectl(). + If so, that function is called with an argument indicating how + many bytes of additional space are required. This will be the + standard pool expansion increment supplied in the call to bectl() + unless the original bget() call requested a buffer larger than + this; buffers larger than the standard pool block can be managed + "off the books" by BGET in this mode. If the allocation function + succeeds in obtaining the storage, it returns a pointer to the new + block and BGET expands the buffer pool; if it fails, the + allocation request fails and returns NULL to the caller. If a + non-NULL release function is supplied, expansion blocks which + become totally empty are released to the global free pool by + passing their addresses to the release function. + + Equipped with appropriate allocation, release, and compaction + functions, BGET can be used as part of very sophisticated memory + management strategies, including garbage collection. (Note, + however, that BGET is *not* a garbage collector by itself, and + that developing such a system requires much additional logic and + careful design of the application's memory allocation strategy.) + + + BGET FUNCTION DESCRIPTIONS + ========================== + + Functions implemented in this file (some are enabled by certain of + the optional settings below): + + void bpool(void *buffer, bufsize len); + + Create a buffer pool of <len> bytes, using the storage starting at + <buffer>. You can call bpool() subsequently to contribute + additional storage to the overall buffer pool. + + void *bget(bufsize size); + + Allocate a buffer of <size> bytes. The address of the buffer is + returned, or NULL if insufficient memory was available to allocate + the buffer. + + void *bgetz(bufsize size); + + Allocate a buffer of <size> bytes and clear it to all zeroes. The + address of the buffer is returned, or NULL if insufficient memory + was available to allocate the buffer. + + void *bgetr(void *buffer, bufsize newsize); + + Reallocate a buffer previously allocated by bget(), changing its + size to <newsize> and preserving all existing data. NULL is + returned if insufficient memory is available to reallocate the + buffer, in which case the original buffer remains intact. + + void brel(void *buf); + + Return the buffer <buf>, previously allocated by bget(), to the + free space pool. + + void bectl(int (*compact)(bufsize sizereq, int sequence), + void *(*acquire)(bufsize size), + void (*release)(void *buf), + bufsize pool_incr); + + Expansion control: specify functions through which the package may + compact storage (or take other appropriate action) when an + allocation request fails, and optionally automatically acquire + storage for expansion blocks when necessary, and release such + blocks when they become empty. If <compact> is non-NULL, whenever + a buffer allocation request fails, the <compact> function will be + called with arguments specifying the number of bytes (total buffer + size, including header overhead) required to satisfy the + allocation request, and a sequence number indicating the number of + consecutive calls on <compact> attempting to satisfy this + allocation request. The sequence number is 1 for the first call + on <compact> for a given allocation request, and increments on + subsequent calls, permitting the <compact> function to take + increasingly dire measures in an attempt to free up storage. If + the <compact> function returns a nonzero value, the allocation + attempt is re-tried. If <compact> returns 0 (as it must if it + isn't able to release any space or add storage to the buffer + pool), the allocation request fails, which can trigger automatic + pool expansion if the <acquire> argument is non-NULL. At the time + the <compact> function is called, the state of the buffer + allocator is identical to that at the moment the allocation + request was made; consequently, the <compact> function may call + brel(), bpool(), bstats(), and/or directly manipulate the buffer + pool in any manner which would be valid were the application in + control. This does not, however, relieve the <compact> function + of the need to ensure that whatever actions it takes do not change + things underneath the application that made the allocation + request. For example, a <compact> function that released a buffer + in the process of being reallocated with bgetr() would lead to + disaster. Implementing a safe and effective <compact> mechanism + requires careful design of an application's memory architecture, + and cannot generally be easily retrofitted into existing code. + + If <acquire> is non-NULL, that function will be called whenever an + allocation request fails. If the <acquire> function succeeds in + allocating the requested space and returns a pointer to the new + area, allocation will proceed using the expanded buffer pool. If + <acquire> cannot obtain the requested space, it should return NULL + and the entire allocation process will fail. <pool_incr> + specifies the normal expansion block size. Providing an <acquire> + function will cause subsequent bget() requests for buffers too + large to be managed in the linked-block scheme (in other words, + larger than <pool_incr> minus the buffer overhead) to be satisfied + directly by calls to the <acquire> function. Automatic release of + empty pool blocks will occur only if all pool blocks in the system + are the size given by <pool_incr>. + + void bstats(bufsize *curalloc, bufsize *totfree, + bufsize *maxfree, long *nget, long *nrel); + + The amount of space currently allocated is stored into the + variable pointed to by <curalloc>. The total free space (sum of + all free blocks in the pool) is stored into the variable pointed + to by <totfree>, and the size of the largest single block in the + free space pool is stored into the variable pointed to by + <maxfree>. The variables pointed to by <nget> and <nrel> are + filled, respectively, with the number of successful (non-NULL + return) bget() calls and the number of brel() calls. + + void bstatse(bufsize *pool_incr, long *npool, + long *npget, long *nprel, + long *ndget, long *ndrel); + + Extended statistics: The expansion block size will be stored into + the variable pointed to by <pool_incr>, or the negative thereof if + automatic expansion block releases are disabled. The number of + currently active pool blocks will be stored into the variable + pointed to by <npool>. The variables pointed to by <npget> and + <nprel> will be filled with, respectively, the number of expansion + block acquisitions and releases which have occurred. The + variables pointed to by <ndget> and <ndrel> will be filled with + the number of bget() and brel() calls, respectively, managed + through blocks directly allocated by the acquisition and release + functions. + + void bufdump(void *buf); + + The buffer pointed to by <buf> is dumped on standard output. + + void bpoold(void *pool, int dumpalloc, int dumpfree); + + All buffers in the buffer pool <pool>, previously initialised by a + call on bpool(), are listed in ascending memory address order. If + <dumpalloc> is nonzero, the contents of allocated buffers are + dumped; if <dumpfree> is nonzero, the contents of free blocks are + dumped. + + int bpoolv(void *pool); + + The named buffer pool, previously initialised by a call on + bpool(), is validated for bad pointers, overwritten data, etc. If + compiled with NDEBUG not defined, any error generates an assertion + failure. Otherwise 1 is returned if the pool is valid, 0 if an + error is found. + + + BGET CONFIGURATION + ================== +*/ + +/*#define TestProg 20000*/ /* Generate built-in test program + if defined. The value specifies + how many buffer allocation attempts + the test program should make. */ + +#define SizeQuant 4 /* Buffer allocation size quantum: + all buffers allocated are a + multiple of this size. This + MUST be a power of two. */ + +#define BufDump 1 /* Define this symbol to enable the + bpoold() function which dumps the + buffers in a buffer pool. */ + +#define BufValid 1 /* Define this symbol to enable the + bpoolv() function for validating + a buffer pool. */ + +#define DumpData 1 /* Define this symbol to enable the + bufdump() function which allows + dumping the contents of an allocated + or free buffer. */ + +#define BufStats 1 /* Define this symbol to enable the + bstats() function which calculates + the total free space in the buffer + pool, the largest available + buffer, and the total space + currently allocated. */ + +#define FreeWipe 1 /* Wipe free buffers to a guaranteed + pattern of garbage to trip up + miscreants who attempt to use + pointers into released buffers. */ + +#define BestFit 1 /* Use a best fit algorithm when + searching for space for an + allocation request. This uses + memory more efficiently, but + allocation will be much slower. */ + +#define BECtl 1 /* Define this symbol to enable the + bectl() function for automatic + pool space control. */ + +#include <stdio.h> + +#ifdef lint +#define NDEBUG /* Exits in asserts confuse lint */ +/* LINTLIBRARY */ /* Don't complain about def, no ref */ +extern char *sprintf(); /* Sun includes don't define sprintf */ +#endif + +#define NDEBUG + +#include <assert.h> +#include <memory.h> + +#ifdef BufDump /* BufDump implies DumpData */ +#ifndef DumpData +#define DumpData 1 +#endif +#endif + +#ifdef DumpData +#include <ctype.h> +#endif + +/* Declare the interface, including the requested buffer size type, + bufsize. */ + +#include "bget.h" + +#define MemSize int /* Type for size arguments to memxxx() + functions such as memcmp(). */ + +/* Queue links */ + +struct qlinks { + struct bfhead *flink; /* Forward link */ + struct bfhead *blink; /* Backward link */ +}; + +/* Header in allocated and free buffers */ + +struct bhead { + bufsize prevfree; /* Relative link back to previous + free buffer in memory or 0 if + previous buffer is allocated. */ + bufsize bsize; /* Buffer size: positive if free, + negative if allocated. */ +}; +#define BH(p) ((struct bhead *) (p)) + +/* Header in directly allocated buffers (by acqfcn) */ + +struct bdhead { + bufsize tsize; /* Total size, including overhead */ + struct bhead bh; /* Common header */ +}; +#define BDH(p) ((struct bdhead *) (p)) + +/* Header in free buffers */ + +struct bfhead { + struct bhead bh; /* Common allocated/free header */ + struct qlinks ql; /* Links on free list */ +}; +#define BFH(p) ((struct bfhead *) (p)) + +static struct bfhead freelist = { /* List of free buffers */ + {0, 0}, + {&freelist, &freelist} +}; + + +#ifdef BufStats +static bufsize totalloc = 0; /* Total space currently allocated */ +static long numget = 0, numrel = 0; /* Number of bget() and brel() calls */ +#ifdef BECtl +static long numpblk = 0; /* Number of pool blocks */ +static long numpget = 0, numprel = 0; /* Number of block gets and rels */ +static long numdget = 0, numdrel = 0; /* Number of direct gets and rels */ +#endif /* BECtl */ +#endif /* BufStats */ + +#ifdef BECtl + +/* Automatic expansion block management functions */ + +static int (*compfcn) _((bufsize sizereq, int sequence)) = NULL; +static void *(*acqfcn) _((bufsize size)) = NULL; +static void (*relfcn) _((void *buf)) = NULL; + +static bufsize exp_incr = 0; /* Expansion block size */ +static bufsize pool_len = 0; /* 0: no bpool calls have been made + -1: not all pool blocks are + the same size + >0: (common) block size for all + bpool calls made so far + */ +#endif + +/* Minimum allocation quantum: */ + +#define QLSize (sizeof(struct qlinks)) +#define SizeQ ((SizeQuant > QLSize) ? SizeQuant : QLSize) + +#define V (void) /* To denote unwanted returned values */ + +/* End sentinel: value placed in bsize field of dummy block delimiting + end of pool block. The most negative number which will fit in a + bufsize, defined in a way that the compiler will accept. */ + +#define ESent ((bufsize) (-(((1L << (sizeof(bufsize) * 8 - 2)) - 1) * 2) - 2)) + +/* BGET -- Allocate a buffer. */ + +void *bget(requested_size) + bufsize requested_size; +{ + bufsize size = requested_size; + struct bfhead *b; +#ifdef BestFit + struct bfhead *best; +#endif + void *buf; +#ifdef BECtl + int compactseq = 0; +#endif + + assert(size > 0); + + if (size < SizeQ) { /* Need at least room for the */ + size = SizeQ; /* queue links. */ + } +#ifdef SizeQuant +#if SizeQuant > 1 + size = (size + (SizeQuant - 1)) & (~(SizeQuant - 1)); +#endif +#endif + + size += sizeof(struct bhead); /* Add overhead in allocated buffer + to size required. */ + +#ifdef BECtl + /* If a compact function was provided in the call to bectl(), wrap + a loop around the allocation process to allow compaction to + intervene in case we don't find a suitable buffer in the chain. */ + + while (1) { +#endif + b = freelist.ql.flink; +#ifdef BestFit + best = &freelist; +#endif + + + /* Scan the free list searching for the first buffer big enough + to hold the requested size buffer. */ + +#ifdef BestFit + while (b != &freelist) { + if (b->bh.bsize >= size) { + if ((best == &freelist) || (b->bh.bsize < best->bh.bsize)) { + best = b; + } + } + b = b->ql.flink; /* Link to next buffer */ + } + b = best; +#endif /* BestFit */ + + while (b != &freelist) { + if ((bufsize) b->bh.bsize >= size) { + + /* Buffer is big enough to satisfy the request. Allocate it + to the caller. We must decide whether the buffer is large + enough to split into the part given to the caller and a + free buffer that remains on the free list, or whether the + entire buffer should be removed from the free list and + given to the caller in its entirety. We only split the + buffer if enough room remains for a header plus the minimum + quantum of allocation. */ + + if ((b->bh.bsize - size) > (SizeQ + (sizeof(struct bhead)))) { + struct bhead *ba, *bn; + + ba = BH(((char *) b) + (b->bh.bsize - size)); + bn = BH(((char *) ba) + size); + assert(bn->prevfree == b->bh.bsize); + /* Subtract size from length of free block. */ + b->bh.bsize -= size; + /* Link allocated buffer to the previous free buffer. */ + ba->prevfree = b->bh.bsize; + /* Plug negative size into user buffer. */ + ba->bsize = -(bufsize) size; + /* Mark buffer after this one not preceded by free block. */ + bn->prevfree = 0; + +#ifdef BufStats + totalloc += size; + numget++; /* Increment number of bget() calls */ +#endif + buf = (void *) ((((char *) ba) + sizeof(struct bhead))); + return buf; + } else { + struct bhead *ba; + + ba = BH(((char *) b) + b->bh.bsize); + assert(ba->prevfree == b->bh.bsize); + + /* The buffer isn't big enough to split. Give the whole + shebang to the caller and remove it from the free list. */ + + assert(b->ql.blink->ql.flink == b); + assert(b->ql.flink->ql.blink == b); + b->ql.blink->ql.flink = b->ql.flink; + b->ql.flink->ql.blink = b->ql.blink; + +#ifdef BufStats + totalloc += b->bh.bsize; + numget++; /* Increment number of bget() calls */ +#endif + /* Negate size to mark buffer allocated. */ + b->bh.bsize = -(b->bh.bsize); + + /* Zero the back pointer in the next buffer in memory + to indicate that this buffer is allocated. */ + ba->prevfree = 0; + + /* Give user buffer starting at queue links. */ + buf = (void *) &(b->ql); + return buf; + } + } + b = b->ql.flink; /* Link to next buffer */ + } +#ifdef BECtl + + /* We failed to find a buffer. If there's a compact function + defined, notify it of the size requested. If it returns + TRUE, try the allocation again. */ + + if ((compfcn == NULL) || (!(*compfcn)(size, ++compactseq))) { + break; + } + } + + /* No buffer available with requested size free. */ + + /* Don't give up yet -- look in the reserve supply. */ + + if (acqfcn != NULL) { + if (size > exp_incr - sizeof(struct bhead)) { + + /* Request is too large to fit in a single expansion + block. Try to satisy it by a direct buffer acquisition. */ + + struct bdhead *bdh; + + size += sizeof(struct bdhead) - sizeof(struct bhead); + if ((bdh = BDH((*acqfcn)((bufsize) size))) != NULL) { + + /* Mark the buffer special by setting the size field + of its header to zero. */ + bdh->bh.bsize = 0; + bdh->bh.prevfree = 0; + bdh->tsize = size; +#ifdef BufStats + totalloc += size; + numget++; /* Increment number of bget() calls */ + numdget++; /* Direct bget() call count */ +#endif + buf = (void *) (bdh + 1); + return buf; + } + + } else { + + /* Try to obtain a new expansion block */ + + void *newpool; + + if ((newpool = (*acqfcn)((bufsize) exp_incr)) != NULL) { + bpool(newpool, exp_incr); + buf = bget(requested_size); /* This can't, I say, can't + get into a loop. */ + return buf; + } + } + } + + /* Still no buffer available */ + +#endif /* BECtl */ + + return NULL; +} + +/* BGETZ -- Allocate a buffer and clear its contents to zero. We clear + the entire contents of the buffer to zero, not just the + region requested by the caller. */ + +void *bgetz(size) + bufsize size; +{ + char *buf = (char *) bget(size); + + if (buf != NULL) { + struct bhead *b; + bufsize rsize; + + b = BH(buf - sizeof(struct bhead)); + rsize = -(b->bsize); + if (rsize == 0) { + struct bdhead *bd; + + bd = BDH(buf - sizeof(struct bdhead)); + rsize = bd->tsize - sizeof(struct bdhead); + } else { + rsize -= sizeof(struct bhead); + } + assert(rsize >= size); + V memset(buf, 0, (MemSize) rsize); + } + return ((void *) buf); +} + +/* BGETR -- Reallocate a buffer. This is a minimal implementation, + simply in terms of brel() and bget(). It could be + enhanced to allow the buffer to grow into adjacent free + blocks and to avoid moving data unnecessarily. */ + +void *bgetr(buf, size) + void *buf; + bufsize size; +{ + void *nbuf; + bufsize osize; /* Old size of buffer */ + struct bhead *b; + + if ((nbuf = bget(size)) == NULL) { /* Acquire new buffer */ + return NULL; + } + if (buf == NULL) { + return nbuf; + } + b = BH(((char *) buf) - sizeof(struct bhead)); + osize = -b->bsize; +#ifdef BECtl + if (osize == 0) { + /* Buffer acquired directly through acqfcn. */ + struct bdhead *bd; + + bd = BDH(((char *) buf) - sizeof(struct bdhead)); + osize = bd->tsize - sizeof(struct bdhead); + } else +#endif + osize -= sizeof(struct bhead); + assert(osize > 0); + V memcpy((char *) nbuf, (char *) buf, /* Copy the data */ + (MemSize) ((size < osize) ? size : osize)); + brel(buf); + return nbuf; +} + +/* BREL -- Release a buffer. */ + +void brel(buf) + void *buf; +{ + struct bfhead *b, *bn; + + b = BFH(((char *) buf) - sizeof(struct bhead)); +#ifdef BufStats + numrel++; /* Increment number of brel() calls */ +#endif + assert(buf != NULL); + +#ifdef BECtl + if (b->bh.bsize == 0) { /* Directly-acquired buffer? */ + struct bdhead *bdh; + + bdh = BDH(((char *) buf) - sizeof(struct bdhead)); + assert(b->bh.prevfree == 0); +#ifdef BufStats + totalloc -= bdh->tsize; + assert(totalloc >= 0); + numdrel++; /* Number of direct releases */ +#endif /* BufStats */ +#ifdef FreeWipe + V memset((char *) buf, 0x55, + (MemSize) (bdh->tsize - sizeof(struct bdhead))); +#endif /* FreeWipe */ + assert(relfcn != NULL); + (*relfcn)((void *) bdh); /* Release it directly. */ + return; + } +#endif /* BECtl */ + + /* Buffer size must be negative, indicating that the buffer is + allocated. */ + + if (b->bh.bsize >= 0) { + bn = NULL; + } + assert(b->bh.bsize < 0); + + /* Back pointer in next buffer must be zero, indicating the + same thing: */ + + assert(BH((char *) b - b->bh.bsize)->prevfree == 0); + +#ifdef BufStats + totalloc += b->bh.bsize; + assert(totalloc >= 0); +#endif + + /* If the back link is nonzero, the previous buffer is free. */ + + if (b->bh.prevfree != 0) { + + /* The previous buffer is free. Consolidate this buffer with it + by adding the length of this buffer to the previous free + buffer. Note that we subtract the size in the buffer being + released, since it's negative to indicate that the buffer is + allocated. */ + + register bufsize size = b->bh.bsize; + + /* Make the previous buffer the one we're working on. */ + assert(BH((char *) b - b->bh.prevfree)->bsize == b->bh.prevfree); + b = BFH(((char *) b) - b->bh.prevfree); + b->bh.bsize -= size; + } else { + + /* The previous buffer isn't allocated. Insert this buffer + on the free list as an isolated free block. */ + + assert(freelist.ql.blink->ql.flink == &freelist); + assert(freelist.ql.flink->ql.blink == &freelist); + b->ql.flink = &freelist; + b->ql.blink = freelist.ql.blink; + freelist.ql.blink = b; + b->ql.blink->ql.flink = b; + b->bh.bsize = -b->bh.bsize; + } + + /* Now we look at the next buffer in memory, located by advancing from + the start of this buffer by its size, to see if that buffer is + free. If it is, we combine this buffer with the next one in + memory, dechaining the second buffer from the free list. */ + + bn = BFH(((char *) b) + b->bh.bsize); + if (bn->bh.bsize > 0) { + + /* The buffer is free. Remove it from the free list and add + its size to that of our buffer. */ + + assert(BH((char *) bn + bn->bh.bsize)->prevfree == bn->bh.bsize); + assert(bn->ql.blink->ql.flink == bn); + assert(bn->ql.flink->ql.blink == bn); + bn->ql.blink->ql.flink = bn->ql.flink; + bn->ql.flink->ql.blink = bn->ql.blink; + b->bh.bsize += bn->bh.bsize; + + /* Finally, advance to the buffer that follows the newly + consolidated free block. We must set its backpointer to the + head of the consolidated free block. We know the next block + must be an allocated block because the process of recombination + guarantees that two free blocks will never be contiguous in + memory. */ + + bn = BFH(((char *) b) + b->bh.bsize); + } +#ifdef FreeWipe + V memset(((char *) b) + sizeof(struct bfhead), 0x55, + (MemSize) (b->bh.bsize - sizeof(struct bfhead))); +#endif + assert(bn->bh.bsize < 0); + + /* The next buffer is allocated. Set the backpointer in it to point + to this buffer; the previous free buffer in memory. */ + + bn->bh.prevfree = b->bh.bsize; + +#ifdef BECtl + + /* If a block-release function is defined, and this free buffer + constitutes the entire block, release it. Note that pool_len + is defined in such a way that the test will fail unless all + pool blocks are the same size. */ + + if (relfcn != NULL && + ((bufsize) b->bh.bsize) == (pool_len - sizeof(struct bhead))) { + + assert(b->bh.prevfree == 0); + assert(BH((char *) b + b->bh.bsize)->bsize == ESent); + assert(BH((char *) b + b->bh.bsize)->prevfree == b->bh.bsize); + /* Unlink the buffer from the free list */ + b->ql.blink->ql.flink = b->ql.flink; + b->ql.flink->ql.blink = b->ql.blink; + + (*relfcn)(b); +#ifdef BufStats + numprel++; /* Nr of expansion block releases */ + numpblk--; /* Total number of blocks */ + assert(numpblk == numpget - numprel); +#endif /* BufStats */ + } +#endif /* BECtl */ +} + +#ifdef BECtl + +/* BECTL -- Establish automatic pool expansion control */ + +void bectl(compact, acquire, release, pool_incr) + int (*compact) _((bufsize sizereq, int sequence)); + void *(*acquire) _((bufsize size)); + void (*release) _((void *buf)); + bufsize pool_incr; +{ + compfcn = compact; + acqfcn = acquire; + relfcn = release; + exp_incr = pool_incr; +} +#endif + +/* BPOOL -- Add a region of memory to the buffer pool. */ + +void bpool(buf, len) + void *buf; + bufsize len; +{ + struct bfhead *b = BFH(buf); + struct bhead *bn; + +#ifdef SizeQuant + len &= ~(SizeQuant - 1); +#endif +#ifdef BECtl + if (pool_len == 0) { + pool_len = len; + } else if (len != pool_len) { + pool_len = -1; + } +#ifdef BufStats + numpget++; /* Number of block acquisitions */ + numpblk++; /* Number of blocks total */ + assert(numpblk == numpget - numprel); +#endif /* BufStats */ +#endif /* BECtl */ + + /* Since the block is initially occupied by a single free buffer, + it had better not be (much) larger than the largest buffer + whose size we can store in bhead.bsize. */ + + assert(len - sizeof(struct bhead) <= -((bufsize) ESent + 1)); + + /* Clear the backpointer at the start of the block to indicate that + there is no free block prior to this one. That blocks + recombination when the first block in memory is released. */ + + b->bh.prevfree = 0; + + /* Chain the new block to the free list. */ + + assert(freelist.ql.blink->ql.flink == &freelist); + assert(freelist.ql.flink->ql.blink == &freelist); + b->ql.flink = &freelist; + b->ql.blink = freelist.ql.blink; + freelist.ql.blink = b; + b->ql.blink->ql.flink = b; + + /* Create a dummy allocated buffer at the end of the pool. This dummy + buffer is seen when a buffer at the end of the pool is released and + blocks recombination of the last buffer with the dummy buffer at + the end. The length in the dummy buffer is set to the largest + negative number to denote the end of the pool for diagnostic + routines (this specific value is not counted on by the actual + allocation and release functions). */ + + len -= sizeof(struct bhead); + b->bh.bsize = (bufsize) len; +#ifdef FreeWipe + V memset(((char *) b) + sizeof(struct bfhead), 0x55, + (MemSize) (len - sizeof(struct bfhead))); +#endif + bn = BH(((char *) b) + len); + bn->prevfree = (bufsize) len; + /* Definition of ESent assumes two's complement! */ + assert((~0) == -1); + bn->bsize = ESent; +} + +#ifdef BufStats + +/* BSTATS -- Return buffer allocation free space statistics. */ + +void bstats(curalloc, totfree, maxfree, nget, nrel) + bufsize *curalloc, *totfree, *maxfree; + long *nget, *nrel; +{ + struct bfhead *b = freelist.ql.flink; + + *nget = numget; + *nrel = numrel; + *curalloc = totalloc; + *totfree = 0; + *maxfree = -1; + while (b != &freelist) { + assert(b->bh.bsize > 0); + *totfree += b->bh.bsize; + if (b->bh.bsize > *maxfree) { + *maxfree = b->bh.bsize; + } + b = b->ql.flink; /* Link to next buffer */ + } +} + +#ifdef BECtl + +/* BSTATSE -- Return extended statistics */ + +void bstatse(pool_incr, npool, npget, nprel, ndget, ndrel) + bufsize *pool_incr; + long *npool, *npget, *nprel, *ndget, *ndrel; +{ + *pool_incr = (pool_len < 0) ? -exp_incr : exp_incr; + *npool = numpblk; + *npget = numpget; + *nprel = numprel; + *ndget = numdget; + *ndrel = numdrel; +} +#endif /* BECtl */ +#endif /* BufStats */ + +#ifdef DumpData + +/* BUFDUMP -- Dump the data in a buffer. This is called with the user + data pointer, and backs up to the buffer header. It will + dump either a free block or an allocated one. */ + +void bufdump(buf) + void *buf; +{ + struct bfhead *b; + unsigned char *bdump; + bufsize bdlen; + + b = BFH(((char *) buf) - sizeof(struct bhead)); + assert(b->bh.bsize != 0); + if (b->bh.bsize < 0) { + bdump = (unsigned char *) buf; + bdlen = (-b->bh.bsize) - sizeof(struct bhead); + } else { + bdump = (unsigned char *) (((char *) b) + sizeof(struct bfhead)); + bdlen = b->bh.bsize - sizeof(struct bfhead); + } + + while (bdlen > 0) { + int i, dupes = 0; + bufsize l = bdlen; + char bhex[50], bascii[20]; + + if (l > 16) { + l = 16; + } + + for (i = 0; i < l; i++) { + V sprintf(bhex + i * 3, "%02X ", bdump[i]); + bascii[i] = isprint(bdump[i]) ? bdump[i] : ' '; + } + bascii[i] = 0; + V printf("%-48s %s\n", bhex, bascii); + bdump += l; + bdlen -= l; + while ((bdlen > 16) && (memcmp((char *) (bdump - 16), + (char *) bdump, 16) == 0)) { + dupes++; + bdump += 16; + bdlen -= 16; + } + if (dupes > 1) { + V printf( + " (%d lines [%d bytes] identical to above line skipped)\n", + dupes, dupes * 16); + } else if (dupes == 1) { + bdump -= 16; + bdlen += 16; + } + } +} +#endif + +#ifdef BufDump + +/* BPOOLD -- Dump a buffer pool. The buffer headers are always listed. + If DUMPALLOC is nonzero, the contents of allocated buffers + are dumped. If DUMPFREE is nonzero, free blocks are + dumped as well. If FreeWipe checking is enabled, free + blocks which have been clobbered will always be dumped. */ + +void bpoold(buf, dumpalloc, dumpfree) + void *buf; + int dumpalloc, dumpfree; +{ + struct bfhead *b = BFH(buf); + + while (b->bh.bsize != ESent) { + bufsize bs = b->bh.bsize; + + if (bs < 0) { + bs = -bs; + V printf("Allocated buffer: size %6ld bytes.\n", (long) bs); + if (dumpalloc) { + bufdump((void *) (((char *) b) + sizeof(struct bhead))); + } + } else { + char *lerr = ""; + + assert(bs > 0); + if ((b->ql.blink->ql.flink != b) || + (b->ql.flink->ql.blink != b)) { + lerr = " (Bad free list links)"; + } + V printf("Free block: size %6ld bytes.%s\n", + (long) bs, lerr); +#ifdef FreeWipe + lerr = ((char *) b) + sizeof(struct bfhead); + if ((bs > sizeof(struct bfhead)) && ((*lerr != 0x55) || + (memcmp(lerr, lerr + 1, + (MemSize) (bs - (sizeof(struct bfhead) + 1))) != 0))) { + V printf( + "(Contents of above free block have been overstored.)\n"); + bufdump((void *) (((char *) b) + sizeof(struct bhead))); + } else +#endif + if (dumpfree) { + bufdump((void *) (((char *) b) + sizeof(struct bhead))); + } + } + b = BFH(((char *) b) + bs); + } +} +#endif /* BufDump */ + +#ifdef BufValid + +/* BPOOLV -- Validate a buffer pool. If NDEBUG isn't defined, + any error generates an assertion failure. */ + +int bpoolv(buf) + void *buf; +{ + struct bfhead *b = BFH(buf); + + while (b->bh.bsize != ESent) { + bufsize bs = b->bh.bsize; + + if (bs < 0) { + bs = -bs; + } else { + char *lerr = ""; + + assert(bs > 0); + if (bs <= 0) { + return 0; + } + if ((b->ql.blink->ql.flink != b) || + (b->ql.flink->ql.blink != b)) { + V printf("Free block: size %6ld bytes. (Bad free list links)\n", + (long) bs); + assert(0); + return 0; + } +#ifdef FreeWipe + lerr = ((char *) b) + sizeof(struct bfhead); + if ((bs > sizeof(struct bfhead)) && ((*lerr != 0x55) || + (memcmp(lerr, lerr + 1, + (MemSize) (bs - (sizeof(struct bfhead) + 1))) != 0))) { + V printf( + "(Contents of above free block have been overstored.)\n"); + bufdump((void *) (((char *) b) + sizeof(struct bhead))); + assert(0); + return 0; + } +#endif + } + b = BFH(((char *) b) + bs); + } + return 1; +} +#endif /* BufValid */ + + /***********************\ + * * + * Built-in test program * + * * + \***********************/ + +#ifdef TestProg + +#define Repeatable 1 /* Repeatable pseudorandom sequence */ + /* If Repeatable is not defined, a + time-seeded pseudorandom sequence + is generated, exercising BGET with + a different pattern of calls on each + run. */ +#define OUR_RAND /* Use our own built-in version of + rand() to guarantee the test is + 100% repeatable. */ + +#ifdef BECtl +#define PoolSize 300000 /* Test buffer pool size */ +#else +#define PoolSize 50000 /* Test buffer pool size */ +#endif +#define ExpIncr 32768 /* Test expansion block size */ +#define CompactTries 10 /* Maximum tries at compacting */ + +#define dumpAlloc 0 /* Dump allocated buffers ? */ +#define dumpFree 0 /* Dump free buffers ? */ + +#ifndef Repeatable +extern long time(); +#endif + +extern char *malloc(); +extern int free _((char *)); + +static char *bchain = NULL; /* Our private buffer chain */ +static char *bp = NULL; /* Our initial buffer pool */ + +#include <math.h> + +#ifdef OUR_RAND + +static unsigned long int next = 1; + +/* Return next random integer */ + +int rand() +{ + next = next * 1103515245L + 12345; + return (unsigned int) (next / 65536L) % 32768L; +} + +/* Set seed for random generator */ + +void srand(seed) + unsigned int seed; +{ + next = seed; +} +#endif + +/* STATS -- Edit statistics returned by bstats() or bstatse(). */ + +static void stats(when) + char *when; +{ + bufsize cural, totfree, maxfree; + long nget, nfree; +#ifdef BECtl + bufsize pincr; + long totblocks, npget, nprel, ndget, ndrel; +#endif + + bstats(&cural, &totfree, &maxfree, &nget, &nfree); + V printf( + "%s: %ld gets, %ld releases. %ld in use, %ld free, largest = %ld\n", + when, nget, nfree, (long) cural, (long) totfree, (long) maxfree); +#ifdef BECtl + bstatse(&pincr, &totblocks, &npget, &nprel, &ndget, &ndrel); + V printf( + " Blocks: size = %ld, %ld (%ld bytes) in use, %ld gets, %ld frees\n", + (long)pincr, totblocks, pincr * totblocks, npget, nprel); + V printf(" %ld direct gets, %ld direct frees\n", ndget, ndrel); +#endif /* BECtl */ +} + +#ifdef BECtl +static int protect = 0; /* Disable compaction during bgetr() */ + +/* BCOMPACT -- Compaction call-back function. */ + +static int bcompact(bsize, seq) + bufsize bsize; + int seq; +{ +#ifdef CompactTries + char *bc = bchain; + int i = rand() & 0x3; + +#ifdef COMPACTRACE + V printf("Compaction requested. %ld bytes needed, sequence %d.\n", + (long) bsize, seq); +#endif + + if (protect || (seq > CompactTries)) { +#ifdef COMPACTRACE + V printf("Compaction gave up.\n"); +#endif + return 0; + } + + /* Based on a random cast, release a random buffer in the list + of allocated buffers. */ + + while (i > 0 && bc != NULL) { + bc = *((char **) bc); + i--; + } + if (bc != NULL) { + char *fb; + + fb = *((char **) bc); + if (fb != NULL) { + *((char **) bc) = *((char **) fb); + brel((void *) fb); + return 1; + } + } + +#ifdef COMPACTRACE + V printf("Compaction bailed out.\n"); +#endif +#endif /* CompactTries */ + return 0; +} + +/* BEXPAND -- Expand pool call-back function. */ + +static void *bexpand(size) + bufsize size; +{ + void *np = NULL; + bufsize cural, totfree, maxfree; + long nget, nfree; + + /* Don't expand beyond the total allocated size given by PoolSize. */ + + bstats(&cural, &totfree, &maxfree, &nget, &nfree); + + if (cural < PoolSize) { + np = (void *) malloc((unsigned) size); + } +#ifdef EXPTRACE + V printf("Expand pool by %ld -- %s.\n", (long) size, + np == NULL ? "failed" : "succeeded"); +#endif + return np; +} + +/* BSHRINK -- Shrink buffer pool call-back function. */ + +static void bshrink(buf) + void *buf; +{ + if (((char *) buf) == bp) { +#ifdef EXPTRACE + V printf("Initial pool released.\n"); +#endif + bp = NULL; + } +#ifdef EXPTRACE + V printf("Shrink pool.\n"); +#endif + free((char *) buf); +} + +#endif /* BECtl */ + +/* Restrict buffer requests to those large enough to contain our pointer and + small enough for the CPU architecture. */ + +static bufsize blimit(bs) + bufsize bs; +{ + if (bs < sizeof(char *)) { + bs = sizeof(char *); + } + + /* This is written out in this ugly fashion because the + cool expression in sizeof(int) that auto-configured + to any length int befuddled some compilers. */ + + if (sizeof(int) == 2) { + if (bs > 32767) { + bs = 32767; + } + } else { + if (bs > 200000) { + bs = 200000; + } + } + return bs; +} + +int main() +{ + int i; + double x; + + /* Seed the random number generator. If Repeatable is defined, we + always use the same seed. Otherwise, we seed from the clock to + shake things up from run to run. */ + +#ifdef Repeatable + V srand(1234); +#else + V srand((int) time((long *) NULL)); +#endif + + /* Compute x such that pow(x, p) ranges between 1 and 4*ExpIncr as + p ranges from 0 to ExpIncr-1, with a concentration in the lower + numbers. */ + + x = 4.0 * ExpIncr; + x = log(x); + x = exp(log(4.0 * ExpIncr) / (ExpIncr - 1.0)); + +#ifdef BECtl + bectl(bcompact, bexpand, bshrink, (bufsize) ExpIncr); + bp = malloc(ExpIncr); + assert(bp != NULL); + bpool((void *) bp, (bufsize) ExpIncr); +#else + bp = malloc(PoolSize); + assert(bp != NULL); + bpool((void *) bp, (bufsize) PoolSize); +#endif + + stats("Create pool"); + V bpoolv((void *) bp); + bpoold((void *) bp, dumpAlloc, dumpFree); + + for (i = 0; i < TestProg; i++) { + char *cb; + bufsize bs = pow(x, (double) (rand() & (ExpIncr - 1))); + + assert(bs <= (((bufsize) 4) * ExpIncr)); + bs = blimit(bs); + if (rand() & 0x400) { + cb = (char *) bgetz(bs); + } else { + cb = (char *) bget(bs); + } + if (cb == NULL) { +#ifdef EasyOut + break; +#else + char *bc = bchain; + + if (bc != NULL) { + char *fb; + + fb = *((char **) bc); + if (fb != NULL) { + *((char **) bc) = *((char **) fb); + brel((void *) fb); + } + continue; + } +#endif + } + *((char **) cb) = (char *) bchain; + bchain = cb; + + /* Based on a random cast, release a random buffer in the list + of allocated buffers. */ + + if ((rand() & 0x10) == 0) { + char *bc = bchain; + int i = rand() & 0x3; + + while (i > 0 && bc != NULL) { + bc = *((char **) bc); + i--; + } + if (bc != NULL) { + char *fb; + + fb = *((char **) bc); + if (fb != NULL) { + *((char **) bc) = *((char **) fb); + brel((void *) fb); + } + } + } + + /* Based on a random cast, reallocate a random buffer in the list + to a random size */ + + if ((rand() & 0x20) == 0) { + char *bc = bchain; + int i = rand() & 0x3; + + while (i > 0 && bc != NULL) { + bc = *((char **) bc); + i--; + } + if (bc != NULL) { + char *fb; + + fb = *((char **) bc); + if (fb != NULL) { + char *newb; + + bs = pow(x, (double) (rand() & (ExpIncr - 1))); + bs = blimit(bs); +#ifdef BECtl + protect = 1; /* Protect against compaction */ +#endif + newb = (char *) bgetr((void *) fb, bs); +#ifdef BECtl + protect = 0; +#endif + if (newb != NULL) { + *((char **) bc) = newb; + } + } + } + } + } + stats("\nAfter allocation"); + if (bp != NULL) { + V bpoolv((void *) bp); + bpoold((void *) bp, dumpAlloc, dumpFree); + } + + while (bchain != NULL) { + char *buf = bchain; + + bchain = *((char **) buf); + brel((void *) buf); + } + stats("\nAfter release"); +#ifndef BECtl + if (bp != NULL) { + V bpoolv((void *) bp); + bpoold((void *) bp, dumpAlloc, dumpFree); + } +#endif + + return 0; +} +#endif Propchange: trunk/reactos/boot/freeldr/freeldr/rtl/bget.c ------------------------------------------------------------------------------ svn:eol-style = native

16 years, 8 months

[fireball] 31755: - Sync up Mm interface with WinLdr branch (introduce the concept of a memory type at every allocation, however in freeldr's implementation it's just ignored now). - Copy winldr's files from the branch, with the only #ifdef WHEN_MERGE_COMPLETE hack.

by fireball＠svn.reactos.org

Author: fireball Date: Sun Jan 13 15:53:49 2008 New Revision: 31755 URL: http://svn.reactos.org/svn/reactos?rev=31755&view=rev Log: - Sync up Mm interface with WinLdr branch (introduce the concept of a memory type at every allocation, however in freeldr's implementation it's just ignored now). - Copy winldr's files from the branch, with the only #ifdef WHEN_MERGE_COMPLETE hack. Added: trunk/reactos/boot/freeldr/freeldr/include/winldr.h - copied unchanged from r31751, branches/winldr/include/winldr.h trunk/reactos/boot/freeldr/freeldr/windows/conversion.c - copied unchanged from r31751, branches/winldr/windows/conversion.c trunk/reactos/boot/freeldr/freeldr/windows/peloader.c - copied unchanged from r31751, branches/winldr/windows/peloader.c trunk/reactos/boot/freeldr/freeldr/windows/winldr.c - copied, changed from r31751, branches/winldr/windows/winldr.c trunk/reactos/boot/freeldr/freeldr/windows/wlmemory.c - copied unchanged from r31751, branches/winldr/windows/wlmemory.c trunk/reactos/boot/freeldr/freeldr/windows/wlregistry.c - copied unchanged from r31751, branches/winldr/windows/wlregistry.c Modified: trunk/reactos/boot/freeldr/freeldr/arch/i386/loader.c trunk/reactos/boot/freeldr/freeldr/include/mm.h trunk/reactos/boot/freeldr/freeldr/linuxboot.c trunk/reactos/boot/freeldr/freeldr/mm/meminit.c trunk/reactos/boot/freeldr/freeldr/mm/mm.c Modified: trunk/reactos/boot/freeldr/freeldr/arch/i386/loader.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/arch/… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/arch/i386/loader.c (original) +++ trunk/reactos/boot/freeldr/freeldr/arch/i386/loader.c Sun Jan 13 15:53:49 2008 @@ -513,7 +513,7 @@ /* Allocate memory for the driver */ DriverSize = NtHeader->OptionalHeader.SizeOfImage; - LoadBase = MmAllocateMemoryAtAddress(DriverSize, LoadBase); + LoadBase = MmAllocateMemoryAtAddress(DriverSize, LoadBase, LoaderSystemCode); ASSERT(LoadBase); /* Copy headers over */ Modified: trunk/reactos/boot/freeldr/freeldr/include/mm.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/inclu… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/include/mm.h (original) +++ trunk/reactos/boot/freeldr/freeldr/include/mm.h Sun Jan 13 15:53:49 2008 @@ -47,6 +47,14 @@ ( ((a) >> MM_PAGE_SHIFT) + ((a) & MM_PAGE_MASK ? 1 : 0) ) #endif // defined __i386__ or _PPC_ or _MIPS_ +// +// This is the zone which is used by the OS loader +// +#define LOADER_HIGH_ZONE ((16*1024*1024) >> MM_PAGE_SHIFT) //16Mb page + +// HEAP and STACK size +#define HEAP_PAGES 0x100//0x18 +#define STACK_PAGES 0x00 typedef struct { @@ -79,7 +87,7 @@ VOID MmSortBiosMemoryMap(PBIOS_MEMORY_MAP BiosMemoryMap, ULONG MapCount); // Sorts the BIOS_MEMORY_MAP array so the first element corresponds to the first address in memory VOID MmInitPageLookupTable(PVOID PageLookupTable, ULONG TotalPageCount, PBIOS_MEMORY_MAP BiosMemoryMap, ULONG MapCount); // Inits the page lookup table according to the memory types in the memory map VOID MmMarkPagesInLookupTable(PVOID PageLookupTable, ULONG StartPage, ULONG PageCount, TYPE_OF_MEMORY PageAllocated); // Marks the specified pages as allocated or free in the lookup table -VOID MmAllocatePagesInLookupTable(PVOID PageLookupTable, ULONG StartPage, ULONG PageCount); // Allocates the specified pages in the lookup table +VOID MmAllocatePagesInLookupTable(PVOID PageLookupTable, ULONG StartPage, ULONG PageCount, TYPE_OF_MEMORY MemoryType); // Allocates the specified pages in the lookup table ULONG MmCountFreePagesInLookupTable(PVOID PageLookupTable, ULONG TotalPageCount); // Returns the number of free pages in the lookup table ULONG MmFindAvailablePages(PVOID PageLookupTable, ULONG TotalPageCount, ULONG PagesNeeded, BOOLEAN FromEnd); // Returns the page number of the first available page range from the beginning or end of memory ULONG MmFindAvailablePagesBeforePage(PVOID PageLookupTable, ULONG TotalPageCount, ULONG PagesNeeded, ULONG LastPage); // Returns the page number of the first available page range before the specified page @@ -93,12 +101,17 @@ //BOOLEAN MmInitializeMemoryManager(ULONG LowMemoryStart, ULONG LowMemoryLength); BOOLEAN MmInitializeMemoryManager(VOID); +VOID MmInitializeHeap(PVOID PageLookupTable); PVOID MmAllocateMemory(ULONG MemorySize); +PVOID MmAllocateMemoryWithType(ULONG MemorySize, TYPE_OF_MEMORY MemoryType); VOID MmFreeMemory(PVOID MemoryPointer); VOID MmChangeAllocationPolicy(BOOLEAN PolicyAllocatePagesFromEnd); //PVOID MmAllocateLowMemory(ULONG MemorySize); //VOID MmFreeLowMemory(PVOID MemoryPointer); -PVOID MmAllocateMemoryAtAddress(ULONG MemorySize, PVOID DesiredAddress); -PVOID MmAllocateHighestMemoryBelowAddress(ULONG MemorySize, PVOID DesiredAddress); +PVOID MmAllocateMemoryAtAddress(ULONG MemorySize, PVOID DesiredAddress, TYPE_OF_MEMORY MemoryType); +PVOID MmAllocateHighestMemoryBelowAddress(ULONG MemorySize, PVOID DesiredAddress, TYPE_OF_MEMORY MemoryType); + +PVOID MmHeapAlloc(ULONG MemorySize); +VOID MmHeapFree(PVOID MemoryPointer); #endif // defined __MEMORY_H Modified: trunk/reactos/boot/freeldr/freeldr/linuxboot.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/linux… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/linuxboot.c (original) +++ trunk/reactos/boot/freeldr/freeldr/linuxboot.c Sun Jan 13 15:53:49 2008 @@ -374,7 +374,7 @@ UiDrawStatusText(StatusText); // Allocate memory for Linux kernel - LinuxKernelLoadAddress = MmAllocateMemoryAtAddress(LinuxKernelSize, (PVOID)LINUX_KERNEL_LOAD_ADDRESS); + LinuxKernelLoadAddress = MmAllocateMemoryAtAddress(LinuxKernelSize, (PVOID)LINUX_KERNEL_LOAD_ADDRESS, LoaderSystemCode); if (LinuxKernelLoadAddress != (PVOID)LINUX_KERNEL_LOAD_ADDRESS) { return FALSE; @@ -451,11 +451,11 @@ //LinuxInitrdLoadAddress = MmAllocateMemoryAtAddress(LinuxInitrdSize, (PVOID)ROUND_UP((LINUX_KERNEL_LOAD_ADDRESS + LinuxKernelSize), 0x100000)); if (LinuxSetupSector->Version <= 0x0202) { - LinuxInitrdLoadAddress = MmAllocateHighestMemoryBelowAddress(LinuxInitrdSize, (PVOID)LINUX_MAX_INITRD_ADDRESS); - } - else - { - LinuxInitrdLoadAddress = MmAllocateHighestMemoryBelowAddress(LinuxInitrdSize, (PVOID)LinuxSetupSector->InitrdAddressMax); + LinuxInitrdLoadAddress = MmAllocateHighestMemoryBelowAddress(LinuxInitrdSize, (PVOID)LINUX_MAX_INITRD_ADDRESS, LoaderSystemCode); + } + else + { + LinuxInitrdLoadAddress = MmAllocateHighestMemoryBelowAddress(LinuxInitrdSize, (PVOID)LinuxSetupSector->InitrdAddressMax, LoaderSystemCode); } if (LinuxInitrdLoadAddress == NULL) { Modified: trunk/reactos/boot/freeldr/freeldr/mm/meminit.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/mm/me… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/mm/meminit.c (original) +++ trunk/reactos/boot/freeldr/freeldr/mm/meminit.c Sun Jan 13 15:53:49 2008 @@ -281,7 +281,7 @@ DbgPrint((DPRINT_MEMORY, "MmMarkPagesInLookupTable() Done\n")); } -VOID MmAllocatePagesInLookupTable(PVOID PageLookupTable, ULONG StartPage, ULONG PageCount) +VOID MmAllocatePagesInLookupTable(PVOID PageLookupTable, ULONG StartPage, ULONG PageCount, TYPE_OF_MEMORY MemoryType) { PPAGE_LOOKUP_TABLE_ITEM RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTable; ULONG Index; Modified: trunk/reactos/boot/freeldr/freeldr/mm/mm.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/mm/mm… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/mm/mm.c (original) +++ trunk/reactos/boot/freeldr/freeldr/mm/mm.c Sun Jan 13 15:53:49 2008 @@ -57,7 +57,7 @@ AllocateFromEnd = PolicyAllocatePagesFromEnd; } -PVOID MmAllocateMemory(ULONG MemorySize) +PVOID MmAllocateMemoryWithType(ULONG MemorySize, TYPE_OF_MEMORY MemoryType) { ULONG PagesNeeded; ULONG FirstFreePageFromEnd; @@ -100,7 +100,7 @@ return NULL; } - MmAllocatePagesInLookupTable(PageLookupTableAddress, FirstFreePageFromEnd, PagesNeeded); + MmAllocatePagesInLookupTable(PageLookupTableAddress, FirstFreePageFromEnd, PagesNeeded, MemoryType); FreePagesInLookupTable -= PagesNeeded; MemPointer = (PVOID)(FirstFreePageFromEnd * MM_PAGE_SIZE); @@ -123,7 +123,13 @@ return MemPointer; } -PVOID MmAllocateMemoryAtAddress(ULONG MemorySize, PVOID DesiredAddress) +PVOID MmAllocateMemory(ULONG MemorySize) +{ + // Temporary forwarder... + return MmAllocateMemoryWithType(MemorySize, LoaderOsloaderHeap); +} + +PVOID MmAllocateMemoryAtAddress(ULONG MemorySize, PVOID DesiredAddress, TYPE_OF_MEMORY MemoryType) { ULONG PagesNeeded; ULONG StartPageNumber; @@ -166,7 +172,7 @@ return NULL; } - MmAllocatePagesInLookupTable(PageLookupTableAddress, StartPageNumber, PagesNeeded); + MmAllocatePagesInLookupTable(PageLookupTableAddress, StartPageNumber, PagesNeeded, MemoryType); FreePagesInLookupTable -= PagesNeeded; MemPointer = (PVOID)(StartPageNumber * MM_PAGE_SIZE); @@ -182,7 +188,7 @@ return MemPointer; } -PVOID MmAllocateHighestMemoryBelowAddress(ULONG MemorySize, PVOID DesiredAddress) +PVOID MmAllocateHighestMemoryBelowAddress(ULONG MemorySize, PVOID DesiredAddress, TYPE_OF_MEMORY MemoryType) { ULONG PagesNeeded; ULONG FirstFreePageFromEnd; @@ -221,7 +227,7 @@ return NULL; } - MmAllocatePagesInLookupTable(PageLookupTableAddress, FirstFreePageFromEnd, PagesNeeded); + MmAllocatePagesInLookupTable(PageLookupTableAddress, FirstFreePageFromEnd, PagesNeeded, MemoryType); FreePagesInLookupTable -= PagesNeeded; MemPointer = (PVOID)(FirstFreePageFromEnd * MM_PAGE_SIZE); @@ -301,6 +307,18 @@ //VerifyHeap(); #endif // DBG } + +PVOID MmHeapAlloc(ULONG MemorySize) +{ + // Stub for WinLdr + return NULL; +} + +VOID MmHeapFree(PVOID MemoryPointer) +{ + // Stub for WinLdr +} + #ifdef DBG VOID VerifyHeap(VOID) Copied: trunk/reactos/boot/freeldr/freeldr/windows/winldr.c (from r31751, branches/winldr/windows/winldr.c) URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/windo… ============================================================================== --- branches/winldr/windows/winldr.c (original) +++ trunk/reactos/boot/freeldr/freeldr/windows/winldr.c Sun Jan 13 15:53:49 2008 @@ -429,7 +429,11 @@ AllocateAndInitLPB(&LoaderBlock); /* Detect hardware */ +#if WHEN_MERGE_COMPLETE MachHwDetect(&LoaderBlock->ConfigurationRoot); +#else + MachHwDetect(); +#endif /* Load kernel */ strcpy(FileName, BootPath); @@ -491,7 +495,7 @@ /* "Stop all motors", change videomode */ DiskStopFloppyMotor(); - MachVideoPrepareForReactOS(); + MachVideoPrepareForReactOS(FALSE); /* Debugging... */ //DumpMemoryAllocMap();

16 years, 8 months

[gbrunmar] 31754: Refactored d3d9 a bit

by gbrunmar＠svn.reactos.org

Author: gbrunmar Date: Sun Jan 13 14:45:31 2008 New Revision: 31754 URL: http://svn.reactos.org/svn/reactos?rev=31754&view=rev Log: Refactored d3d9 a bit Added: trunk/reactos/dll/directx/d3d9/d3d9_common.h (with props) trunk/reactos/dll/directx/d3d9/d3d9_create.c (with props) trunk/reactos/dll/directx/d3d9/d3d9_create.h (with props) Modified: trunk/reactos/dll/directx/d3d9/d3d9.c trunk/reactos/dll/directx/d3d9/d3d9.rbuild trunk/reactos/dll/directx/d3d9/d3d9_helpers.c trunk/reactos/dll/directx/d3d9/d3d9_helpers.h trunk/reactos/dll/directx/d3d9/d3d9_impl.c trunk/reactos/dll/directx/d3d9/d3d9_private.h Modified: trunk/reactos/dll/directx/d3d9/d3d9.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/d3d9/d3d9.c?re… ============================================================================== --- trunk/reactos/dll/directx/d3d9/d3d9.c (original) +++ trunk/reactos/dll/directx/d3d9/d3d9.c Sun Jan 13 14:45:31 2008 @@ -7,13 +7,15 @@ * Gregor Brunmar <gregor (dot) brunmar (at) home (dot) se> */ -#include <windows.h> -#include "d3d9_private.h" +#include <d3d9.h> #include "d3d9_helpers.h" +#include "d3d9_create.h" #include <debug.h> #define DEBUG_MESSAGE_BUFFER_SIZE 512 + +typedef IDirect3D9* (WINAPI *LPDIRECT3DCREATE9)(UINT); static LPCSTR D3dError_WrongSdkVersion = "D3D ERROR: D3D header version mismatch.\n" Modified: trunk/reactos/dll/directx/d3d9/d3d9.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/d3d9/d3d9.rbui… ============================================================================== --- trunk/reactos/dll/directx/d3d9/d3d9.rbuild (original) +++ trunk/reactos/dll/directx/d3d9/d3d9.rbuild Sun Jan 13 14:45:31 2008 @@ -13,5 +13,6 @@ <file>d3d9.c</file> <file>d3d9_helpers.c</file> <file>d3d9_impl.c</file> + <file>d3d9_create.c</file> <file>d3d9.rc</file> </module> Added: trunk/reactos/dll/directx/d3d9/d3d9_common.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/d3d9/d3d9_comm… ============================================================================== --- trunk/reactos/dll/directx/d3d9/d3d9_common.h (added) +++ trunk/reactos/dll/directx/d3d9/d3d9_common.h Sun Jan 13 14:45:31 2008 @@ -1,0 +1,19 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS ReactX + * FILE: dll/directx/d3d9/d3d9_common.h + * PURPOSE: d3d9.dll common functions, defines and macros + * PROGRAMERS: Gregor Brunmar <gregor (dot) brunmar (at) home (dot) se> + */ +#ifndef _D3D9_COMMON_H_ +#define _D3D9_COMMON_H_ + +#define COBJMACROS +#include <windows.h> + +#define DLLAPI __declspec(dllexport) +#define DX_D3D9_DEBUG 0x80000000 + +extern const struct IDirect3D9Vtbl Direct3D9_Vtbl; + +#endif // _D3D9_COMMON_H_ Propchange: trunk/reactos/dll/directx/d3d9/d3d9_common.h ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/dll/directx/d3d9/d3d9_create.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/d3d9/d3d9_crea… ============================================================================== --- trunk/reactos/dll/directx/d3d9/d3d9_create.c (added) +++ trunk/reactos/dll/directx/d3d9/d3d9_create.c Sun Jan 13 14:45:31 2008 @@ -1,0 +1,128 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS ReactX + * FILE: dll/directx/d3d9/d3d9_create.c + * PURPOSE: d3d9.dll internal create functions and data + * PROGRAMERS: Gregor Brunmar <gregor (dot) brunmar (at) home (dot) se> + */ + +typedef struct IDirect3D9 *LPDIRECT3D9; + +#include "d3d9_create.h" +#include "d3d9_helpers.h" +#include <debug.h> +#include <ddrawi.h> + +static const GUID DISPLAY_GUID = { 0x67685559, 0x3106, 0x11D0, { 0xB9, 0x71, 0x00, 0xAA, 0x00, 0x34, 0x2F, 0x9F } }; + +static CHAR D3D9_PrimaryDeviceName[CCHDEVICENAME]; + +static BOOL GetDisplayDeviceInfo(IN OUT LPDIRECT3D9_INT pDirect3D9) +{ + DISPLAY_DEVICEA DisplayDevice; + DWORD AdapterIndex; + DWORD Planes; + DWORD Bpp; + HDC hDC; + + memset(&DisplayDevice, 0, sizeof(DISPLAY_DEVICEA)); + DisplayDevice.cb = sizeof(DISPLAY_DEVICEA); + + pDirect3D9->dwNumDisplayAdapters = 0; + D3D9_PrimaryDeviceName[0] = '\0'; + + AdapterIndex = 0; + while (EnumDisplayDevicesA(NULL, AdapterIndex, &DisplayDevice, 0) == TRUE) + { + if ((DisplayDevice.StateFlags & (DISPLAY_DEVICE_DISCONNECT | DISPLAY_DEVICE_MIRRORING_DRIVER)) == 0 && + (DisplayDevice.StateFlags & (DISPLAY_DEVICE_PRIMARY_DEVICE | DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)) != 0) + { + memcpy(&pDirect3D9->DisplayAdapters[0].DisplayGuid, &DISPLAY_GUID, sizeof(GUID)); + + lstrcpynA(pDirect3D9->DisplayAdapters[0].szDeviceName, DisplayDevice.DeviceName, MAX_PATH); + + if (pDirect3D9->dwNumDisplayAdapters == 0) + lstrcpynA(D3D9_PrimaryDeviceName, DisplayDevice.DeviceName, sizeof(D3D9_PrimaryDeviceName)); + + pDirect3D9->DisplayAdapters[0].dwStateFlags = DisplayDevice.StateFlags; + pDirect3D9->DisplayAdapters[0].bInUseFlag = TRUE; + + ++pDirect3D9->dwNumDisplayAdapters; + break; + } + } + + AdapterIndex = 0; + while (EnumDisplayDevicesA(NULL, AdapterIndex, &DisplayDevice, 0) == TRUE) + { + if ((DisplayDevice.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) != 0 && + (DisplayDevice.StateFlags & (DISPLAY_DEVICE_MIRRORING_DRIVER | DISPLAY_DEVICE_PRIMARY_DEVICE)) == 0) + { + memcpy(&pDirect3D9->DisplayAdapters[pDirect3D9->dwNumDisplayAdapters].DisplayGuid, &DISPLAY_GUID, sizeof(GUID)); + + lstrcpynA(pDirect3D9->DisplayAdapters[pDirect3D9->dwNumDisplayAdapters].szDeviceName, DisplayDevice.DeviceName, MAX_PATH); + + pDirect3D9->DisplayAdapters[pDirect3D9->dwNumDisplayAdapters].dwStateFlags = DisplayDevice.StateFlags; + pDirect3D9->DisplayAdapters[pDirect3D9->dwNumDisplayAdapters].bInUseFlag = TRUE; + + ++pDirect3D9->dwNumDisplayAdapters; + } + } + + hDC = GetDC(NULL); + Planes = GetDeviceCaps(hDC, PLANES); + Bpp = GetDeviceCaps(hDC, BITSPIXEL); + ReleaseDC(NULL, hDC); + + if (Planes * Bpp < 8) + return FALSE; + + hDC = CreateDCA(NULL, D3D9_PrimaryDeviceName, NULL, NULL); + + if (hDC == NULL) + return FALSE; + + return TRUE; +} + +HRESULT CreateD3D9(OUT LPDIRECT3D9 *ppDirect3D9) +{ + LPDIRECT3D9_INT pDirect3D9; + + if (ppDirect3D9 == 0) + return DDERR_INVALIDPARAMS; + + if (AlignedAlloc((LPVOID *)&pDirect3D9, sizeof(DIRECT3D9_INT)) != S_OK) + return DDERR_OUTOFMEMORY; + + if (pDirect3D9 == 0) + return DDERR_OUTOFMEMORY; + + pDirect3D9->unknown000007 = 0; + pDirect3D9->lpInt = 0; + + pDirect3D9->lpVtbl = &Direct3D9_Vtbl; + //pDirect3D9->dwProcessId = GetCurrentThreadId(); + pDirect3D9->dwRefCnt = 1; + + pDirect3D9->unknown004576 = 0; + pDirect3D9->unknown004578 = 0; + pDirect3D9->unknown004579 = 0; + pDirect3D9->unknown004580 = 0; + pDirect3D9->unknown004581 = 0; + pDirect3D9->unknown004582 = 0; + pDirect3D9->unknown004583 = 0; + pDirect3D9->unknown004589 = 0x20; + + pDirect3D9->lpInt = pDirect3D9; + pDirect3D9->unknown000007 = 1; + + //InitializeCriticalSection(&pDirect3D9->d3d9_cs); + + //memset(pDirect3D9->DisplayAdapters, 0, sizeof(pDirect3D9->DisplayAdapters)); + GetDisplayDeviceInfo(pDirect3D9); + + *ppDirect3D9 = (LPDIRECT3D9)&pDirect3D9->lpVtbl; + + return ERROR_SUCCESS; +} Propchange: trunk/reactos/dll/directx/d3d9/d3d9_create.c ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/dll/directx/d3d9/d3d9_create.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/d3d9/d3d9_crea… ============================================================================== --- trunk/reactos/dll/directx/d3d9/d3d9_create.h (added) +++ trunk/reactos/dll/directx/d3d9/d3d9_create.h Sun Jan 13 14:45:31 2008 @@ -1,0 +1,16 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS ReactX + * FILE: dll/directx/d3d9/d3d9_create.h + * PURPOSE: d3d9.dll internal create functions and data + * PROGRAMERS: Gregor Brunmar <gregor (dot) brunmar (at) home (dot) se> + */ +#ifndef _D3D9_CREATE_H_ +#define _D3D9_CREATE_H_ + +#include "d3d9_private.h" + +/* Creates a Direct3D9 object */ +HRESULT CreateD3D9(OUT LPDIRECT3D9 *ppDirect3D9); + +#endif // _D3D9_CREATE_H_ Propchange: trunk/reactos/dll/directx/d3d9/d3d9_create.h ------------------------------------------------------------------------------ svn:eol-style = native Modified: trunk/reactos/dll/directx/d3d9/d3d9_helpers.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/d3d9/d3d9_help… ============================================================================== --- trunk/reactos/dll/directx/d3d9/d3d9_helpers.c (original) +++ trunk/reactos/dll/directx/d3d9/d3d9_helpers.c Sun Jan 13 14:45:31 2008 @@ -6,6 +6,7 @@ * PROGRAMERS: Gregor Brunmar <gregor (dot) brunmar (at) home (dot) se> */ +#include <d3d9.h> #include "d3d9_helpers.h" #include <stdio.h> #include <ddraw.h> @@ -14,10 +15,6 @@ #define MEM_ALIGNMENT 0x20 static LPCSTR D3D9_DebugRegPath = "Software\\Microsoft\\Direct3D"; - -static const GUID DISPLAY_GUID = { 0x67685559, 0x3106, 0x11D0, { 0xB9, 0x71, 0x00, 0xAA, 0x00, 0x34, 0x2F, 0x9F } }; - -static CHAR D3D9_PrimaryDeviceName[32]; LPDIRECT3D9_INT impl_from_IDirect3D9(LPDIRECT3D9 iface) { @@ -63,110 +60,6 @@ Buffer[BufferSize-1] = '\0'; return 0; -} - -static BOOL GetDisplayDeviceInfo(IN OUT LPDIRECT3D9_INT pDirect3D9) -{ - DISPLAY_DEVICEA DisplayDevice; - DWORD AdapterIndex; - DWORD Planes; - DWORD Bpp; - HDC hDC; - - memset(&DisplayDevice, 0, sizeof(DISPLAY_DEVICEA)); - DisplayDevice.cb = sizeof(DISPLAY_DEVICEA); - - pDirect3D9->dwNumDisplayAdapters = 0; - D3D9_PrimaryDeviceName[0] = '\0'; - - AdapterIndex = 0; - while (EnumDisplayDevicesA(NULL, AdapterIndex, &DisplayDevice, 0) == TRUE) - { - if ((DisplayDevice.StateFlags & (DISPLAY_DEVICE_DISCONNECT | DISPLAY_DEVICE_MIRRORING_DRIVER)) == 0 && - (DisplayDevice.StateFlags & (DISPLAY_DEVICE_PRIMARY_DEVICE | DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)) != 0) - { - memcpy(&pDirect3D9->DisplayAdapters[0].DisplayGuid, &DISPLAY_GUID, sizeof(GUID)); - - lstrcpynA(pDirect3D9->DisplayAdapters[0].szDeviceName, DisplayDevice.DeviceName, MAX_PATH); - - if (pDirect3D9->dwNumDisplayAdapters == 0) - lstrcpynA(D3D9_PrimaryDeviceName, DisplayDevice.DeviceName, sizeof(D3D9_PrimaryDeviceName)); - - pDirect3D9->DisplayAdapters[0].dwStateFlags = DisplayDevice.StateFlags; - pDirect3D9->DisplayAdapters[0].bInUseFlag = TRUE; - - ++pDirect3D9->dwNumDisplayAdapters; - } - } - - AdapterIndex = 0; - while (EnumDisplayDevicesA(NULL, AdapterIndex, &DisplayDevice, 0) == TRUE) - { - if ((DisplayDevice.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) != 0 && - (DisplayDevice.StateFlags & (DISPLAY_DEVICE_MIRRORING_DRIVER | DISPLAY_DEVICE_PRIMARY_DEVICE)) == 0) - { - memcpy(&pDirect3D9->DisplayAdapters[pDirect3D9->dwNumDisplayAdapters].DisplayGuid, &DISPLAY_GUID, sizeof(GUID)); - - lstrcpynA(pDirect3D9->DisplayAdapters[pDirect3D9->dwNumDisplayAdapters].szDeviceName, DisplayDevice.DeviceName, MAX_PATH); - - pDirect3D9->DisplayAdapters[pDirect3D9->dwNumDisplayAdapters].dwStateFlags = DisplayDevice.StateFlags; - pDirect3D9->DisplayAdapters[pDirect3D9->dwNumDisplayAdapters].bInUseFlag = TRUE; - - ++pDirect3D9->dwNumDisplayAdapters; - } - } - - hDC = GetDC(NULL); - Planes = GetDeviceCaps(hDC, PLANES); - Bpp = GetDeviceCaps(hDC, BITSPIXEL); - ReleaseDC(NULL, hDC); - - if (Planes * Bpp < 8) - return FALSE; - - return TRUE; -} - -HRESULT CreateD3D9(OUT LPDIRECT3D9 *ppDirect3D9) -{ - LPDIRECT3D9_INT pDirect3D9; - - if (ppDirect3D9 == 0) - return DDERR_INVALIDPARAMS; - - if (AlignedAlloc((LPVOID *)&pDirect3D9, sizeof(DIRECT3D9_INT)) != S_OK) - return DDERR_OUTOFMEMORY; - - if (pDirect3D9 == 0) - return DDERR_OUTOFMEMORY; - - pDirect3D9->unknown000007 = 0; - pDirect3D9->lpInt = 0; - - pDirect3D9->lpVtbl = &Direct3D9_Vtbl; - //pDirect3D9->dwProcessId = GetCurrentThreadId(); - pDirect3D9->dwRefCnt = 1; - - pDirect3D9->unknown004576 = 0; - pDirect3D9->unknown004578 = 0; - pDirect3D9->unknown004579 = 0; - pDirect3D9->unknown004580 = 0; - pDirect3D9->unknown004581 = 0; - pDirect3D9->unknown004582 = 0; - pDirect3D9->unknown004583 = 0; - pDirect3D9->unknown004589 = 0x20; - - pDirect3D9->lpInt = pDirect3D9; - pDirect3D9->unknown000007 = 1; - - //InitializeCriticalSection(&pDirect3D9->d3d9_cs); - - //memset(pDirect3D9->DisplayAdapters, 0, sizeof(pDirect3D9->DisplayAdapters)); - GetDisplayDeviceInfo(pDirect3D9); - - *ppDirect3D9 = (LPDIRECT3D9)&pDirect3D9->lpVtbl; - - return ERROR_SUCCESS; } HRESULT AlignedAlloc(IN OUT LPVOID *ppObject, IN SIZE_T dwSize) Modified: trunk/reactos/dll/directx/d3d9/d3d9_helpers.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/d3d9/d3d9_help… ============================================================================== --- trunk/reactos/dll/directx/d3d9/d3d9_helpers.h (original) +++ trunk/reactos/dll/directx/d3d9/d3d9_helpers.h Sun Jan 13 14:45:31 2008 @@ -8,6 +8,7 @@ #ifndef _D3D9_HELPERS_H_ #define _D3D9_HELPERS_H_ +#include "d3d9_common.h" #include "d3d9_private.h" /* Convert a IDirect3D9 pointer safely to the internal implementation struct */ @@ -19,9 +20,6 @@ /* Formats debug strings */ HRESULT FormatDebugString(IN OUT LPSTR Buffer, IN LONG BufferSize, IN LPCSTR FormatString, ... ); -/* Creates a Direct3D9 object */ -HRESULT CreateD3D9(OUT LPDIRECT3D9 *ppDirect3D9); - /* Allocates memory and returns an aligned pointer */ HRESULT AlignedAlloc(IN OUT LPVOID *ppObject, IN SIZE_T dwSize); Modified: trunk/reactos/dll/directx/d3d9/d3d9_impl.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/d3d9/d3d9_impl… ============================================================================== --- trunk/reactos/dll/directx/d3d9/d3d9_impl.c (original) +++ trunk/reactos/dll/directx/d3d9/d3d9_impl.c Sun Jan 13 14:45:31 2008 @@ -5,8 +5,10 @@ * PURPOSE: IDirect3D9 implementation * PROGRAMERS: Gregor Brunmar <gregor (dot) brunmar (at) home (dot) se> */ + +#include "d3d9_common.h" +#include <d3d9.h> #include "d3d9_helpers.h" - #include <debug.h> /* IDirect3D9: IUnknown implementation */ Modified: trunk/reactos/dll/directx/d3d9/d3d9_private.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/d3d9/d3d9_priv… ============================================================================== --- trunk/reactos/dll/directx/d3d9/d3d9_private.h (original) +++ trunk/reactos/dll/directx/d3d9/d3d9_private.h Sun Jan 13 14:45:31 2008 @@ -1,23 +1,14 @@ /* * COPYRIGHT: See COPYING in the top level directory * PROJECT: ReactOS ReactX - * FILE: dll/directx/d3d9/d3d9_helpers.c - * PURPOSE: d3d9.dll helper functions + * FILE: dll/directx/d3d9/d3d9_private.h + * PURPOSE: d3d9.dll internal structures * PROGRAMERS: Gregor Brunmar <gregor (dot) brunmar (at) home (dot) se> */ #ifndef _D3D9_PRIVATE_H_ #define _D3D9_PRIVATE_H_ -#define COBJMACROS #include <windows.h> -#include <d3d9.h> - -#define DLLAPI __declspec(dllexport) -#define DX_D3D9_DEBUG 0x80000000 - -typedef IDirect3D9* (WINAPI *LPDIRECT3DCREATE9)(UINT); - -extern const IDirect3D9Vtbl Direct3D9_Vtbl; typedef struct _tagDIRECT3D9DisplayAdapterInfo_ { @@ -133,7 +124,7 @@ typedef struct _tagDIRECT3D9_INT_ { -/* 0x0000 */ const IDirect3D9Vtbl *lpVtbl; /* LPDIRECTD3D9 functoions table */ +/* 0x0000 */ const struct IDirect3D9Vtbl *lpVtbl; /* LPDIRECTD3D9 functoions table */ /* 0x0004 */ CRITICAL_SECTION d3d9_cs; /* 0x001c */ DWORD unknown000007; /* 0x00000001 */ /* 0x0020 */ DWORD dwProcessId;

16 years, 8 months

[cwittich] 31753: -use ExAllocatePoolWithTag instead of ExAllocatePool -add missing critical region acquiring to the NtfsCreate routine.

by cwittich＠svn.reactos.org

Author: cwittich Date: Sun Jan 13 14:36:54 2008 New Revision: 31753 URL: http://svn.reactos.org/svn/reactos?rev=31753&view=rev Log: -use ExAllocatePoolWithTag instead of ExAllocatePool -add missing critical region acquiring to the NtfsCreate routine. Modified: trunk/reactos/drivers/filesystems/ntfs/create.c trunk/reactos/drivers/filesystems/ntfs/dirctl.c trunk/reactos/drivers/filesystems/ntfs/fsctl.c trunk/reactos/drivers/filesystems/ntfs/mft.c trunk/reactos/drivers/filesystems/ntfs/ntfs.h Modified: trunk/reactos/drivers/filesystems/ntfs/create.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/ntfs/c… ============================================================================== --- trunk/reactos/drivers/filesystems/ntfs/create.c (original) +++ trunk/reactos/drivers/filesystems/ntfs/create.c Sun Jan 13 14:36:54 2008 @@ -60,7 +60,7 @@ /* construct absolute path name */ ASSERT(wcslen (Fcb->PathName) + 1 + wcslen (pRelativeFileName) + 1 <= MAX_PATH); - rcName = ExAllocatePool(NonPagedPool, MAX_PATH * sizeof(WCHAR)); + rcName = ExAllocatePoolWithTag(NonPagedPool, MAX_PATH * sizeof(WCHAR), TAG_NTFS); if (!rcName) { return(STATUS_INSUFFICIENT_RESOURCES); @@ -223,11 +223,13 @@ DeviceExt = DeviceObject->DeviceExtension; + FsRtlEnterFileSystem(); ExAcquireResourceExclusiveLite(&DeviceExt->DirResource, TRUE); Status = NtfsCreateFile(DeviceObject, Irp); ExReleaseResourceLite(&DeviceExt->DirResource); + FsRtlExitFileSystem(); ByeBye: Irp->IoStatus.Status = Status; Modified: trunk/reactos/drivers/filesystems/ntfs/dirctl.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/ntfs/d… ============================================================================== --- trunk/reactos/drivers/filesystems/ntfs/dirctl.c (original) +++ trunk/reactos/drivers/filesystems/ntfs/dirctl.c Sun Jan 13 14:36:54 2008 @@ -521,7 +521,7 @@ { First = TRUE; Ccb->DirectorySearchPattern = - ExAllocatePool(NonPagedPool, SearchPattern->Length + sizeof(WCHAR)); + ExAllocatePoolWithTag(NonPagedPool, SearchPattern->Length + sizeof(WCHAR), TAG_NTFS); if (!Ccb->DirectorySearchPattern) { return(STATUS_INSUFFICIENT_RESOURCES); @@ -536,7 +536,7 @@ else if (!Ccb->DirectorySearchPattern) { First = TRUE; - Ccb->DirectorySearchPattern = ExAllocatePool(NonPagedPool, 2 * sizeof(WCHAR)); + Ccb->DirectorySearchPattern = ExAllocatePoolWithTag(NonPagedPool, 2 * sizeof(WCHAR), TAG_NTFS); if (!Ccb->DirectorySearchPattern) { return(STATUS_INSUFFICIENT_RESOURCES); Modified: trunk/reactos/drivers/filesystems/ntfs/fsctl.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/ntfs/f… ============================================================================== --- trunk/reactos/drivers/filesystems/ntfs/fsctl.c (original) +++ trunk/reactos/drivers/filesystems/ntfs/fsctl.c Sun Jan 13 14:36:54 2008 @@ -91,8 +91,8 @@ } DPRINT1("BytesPerSector: %lu\n", DiskGeometry.BytesPerSector); - BootSector = ExAllocatePool(NonPagedPool, - DiskGeometry.BytesPerSector); + BootSector = ExAllocatePoolWithTag(NonPagedPool, + DiskGeometry.BytesPerSector, TAG_NTFS); if (BootSector == NULL) { return(STATUS_INSUFFICIENT_RESOURCES); @@ -150,8 +150,8 @@ } DPRINT("BytesPerSector: %lu\n", DiskGeometry.BytesPerSector); - BootSector = ExAllocatePool(NonPagedPool, - DiskGeometry.BytesPerSector); + BootSector = ExAllocatePoolWithTag(NonPagedPool, + DiskGeometry.BytesPerSector, TAG_NTFS); if (BootSector == NULL) { return(STATUS_INSUFFICIENT_RESOURCES); @@ -201,8 +201,8 @@ ExFreePool(BootSector); - MftRecord = ExAllocatePool(NonPagedPool, - NtfsInfo->BytesPerFileRecord); + MftRecord = ExAllocatePoolWithTag(NonPagedPool, + NtfsInfo->BytesPerFileRecord, TAG_NTFS); if (MftRecord == NULL) { return STATUS_INSUFFICIENT_RESOURCES; @@ -220,7 +220,7 @@ return Status; } - VolumeRecord = ExAllocatePool(NonPagedPool, NtfsInfo->BytesPerFileRecord); + VolumeRecord = ExAllocatePoolWithTag(NonPagedPool, NtfsInfo->BytesPerFileRecord, TAG_NTFS); if (VolumeRecord == NULL) { ExFreePool (MftRecord); Modified: trunk/reactos/drivers/filesystems/ntfs/mft.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/ntfs/m… ============================================================================== --- trunk/reactos/drivers/filesystems/ntfs/mft.c (original) +++ trunk/reactos/drivers/filesystems/ntfs/mft.c Sun Jan 13 14:36:54 2008 @@ -58,8 +58,8 @@ BytesPerFileRecord = Vcb->NtfsInfo.BytesPerFileRecord; - MftRecord = ExAllocatePool(NonPagedPool, - BytesPerFileRecord); + MftRecord = ExAllocatePoolWithTag(NonPagedPool, + BytesPerFileRecord, TAG_NTFS); if (MftRecord == NULL) { return STATUS_INSUFFICIENT_RESOURCES; @@ -86,7 +86,7 @@ n = AttributeDataLength (FindAttribute (MftRecord, AttributeData, 0)) / BytesPerFileRecord; - FileRecord = ExAllocatePool(NonPagedPool, BytesPerFileRecord); + FileRecord = ExAllocatePoolWithTag(NonPagedPool, BytesPerFileRecord, TAG_NTFS); if (FileRecord == NULL) { ExFreePool(MftRecord); @@ -198,7 +198,7 @@ LONG m = (Vcb->NtfsInfo.BytesPerCluster / BytesPerFileRecord) - 1; ULONG n = m > 0 ? (index & m) : 0; - p = ExAllocatePool(NonPagedPool, clusters * Vcb->NtfsInfo.BytesPerCluster); + p = ExAllocatePoolWithTag(NonPagedPool, clusters * Vcb->NtfsInfo.BytesPerCluster, TAG_NTFS); ReadVCN (Vcb, Mft, AttributeData, vcn, clusters, p); Modified: trunk/reactos/drivers/filesystems/ntfs/ntfs.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/ntfs/n… ============================================================================== --- trunk/reactos/drivers/filesystems/ntfs/ntfs.h (original) +++ trunk/reactos/drivers/filesystems/ntfs/ntfs.h Sun Jan 13 14:36:54 2008 @@ -15,6 +15,8 @@ #ifndef TAG #define TAG(A, B, C, D) (ULONG)(((A)<<0) + ((B)<<8) + ((C)<<16) + ((D)<<24)) #endif + +#define TAG_NTFS TAG('N', 'T', 'F', 'S') #define ROUND_UP(N, S) ((((N) + (S) - 1) / (S)) * (S))

16 years, 8 months

[hpoussin] 31752: buildno.cpp depends of version.h

by hpoussin＠svn.reactos.org

Author: hpoussin Date: Sun Jan 13 13:52:55 2008 New Revision: 31752 URL: http://svn.reactos.org/svn/reactos?rev=31752&view=rev Log: buildno.cpp depends of version.h Modified: trunk/reactos/tools/buildno/buildno.mak Modified: trunk/reactos/tools/buildno/buildno.mak URL: http://svn.reactos.org/svn/reactos/trunk/reactos/tools/buildno/buildno.mak?… ============================================================================== --- trunk/reactos/tools/buildno/buildno.mak (original) +++ trunk/reactos/tools/buildno/buildno.mak Sun Jan 13 13:52:55 2008 @@ -29,6 +29,8 @@ BUILDNO_HOST_LFLAGS = $(TOOLS_LFLAGS) +BUILDNO_VERSION = include$(SEP)reactos$(SEP)version.h + .PHONY: buildno buildno: $(BUILDNO_TARGET) @@ -36,7 +38,7 @@ $(ECHO_LD) ${host_gpp} $^ $(BUILDNO_HOST_LFLAGS) -o $@ -$(BUILDNO_INT_)buildno.o: $(BUILDNO_BASE_)buildno.cpp | $(BUILDNO_INT) +$(BUILDNO_INT_)buildno.o: $(BUILDNO_BASE_)buildno.cpp $(BUILDNO_VERSION) | $(BUILDNO_INT) $(ECHO_CC) ${host_gpp} $(BUILDNO_HOST_CXXFLAGS) -c $< -o $@ @@ -45,6 +47,10 @@ -@$(rm) $(BUILDNO_TARGET) $(BUILDNO_OBJECTS) 2>$(NUL) clean: buildno_clean +# Uncomment the following line if you want to automatically +# update build number after SVN update +#.PHONY: $(BUILDNO_TARGET) + $(BUILDNO_H): $(BUILDNO_TARGET) ${mkdir} $(INTERMEDIATE_)include$(SEP)reactos 2>$(NUL) $(ECHO_BUILDNO)

16 years, 8 months

[fireball] 31751: - Add prefetcher initialize stub and CcFastMdlReadNotPossible from trunk. - Silence a debug print.

by fireball＠svn.reactos.org

Author: fireball Date: Sun Jan 13 12:57:08 2008 New Revision: 31751 URL: http://svn.reactos.org/svn/reactos?rev=31751&view=rev Log: - Add prefetcher initialize stub and CcFastMdlReadNotPossible from trunk. - Silence a debug print. Modified: branches/cache_manager_rewrite/cc/cacheman.c branches/cache_manager_rewrite/cc/copy.c branches/cache_manager_rewrite/cc/view.c Modified: branches/cache_manager_rewrite/cc/cacheman.c URL: http://svn.reactos.org/svn/reactos/branches/cache_manager_rewrite/cc/cachem… ============================================================================== --- branches/cache_manager_rewrite/cc/cacheman.c (original) +++ branches/cache_manager_rewrite/cc/cacheman.c Sun Jan 13 12:57:08 2008 @@ -14,7 +14,26 @@ #define NDEBUG #include <internal/debug.h> +PFSN_PREFETCHER_GLOBALS CcPfGlobals; + /* FUNCTIONS *****************************************************************/ + +VOID +NTAPI +CcPfInitializePrefetcher(VOID) +{ + /* Notify debugger */ + DbgPrintEx(DPFLTR_PREFETCHER_ID, + DPFLTR_TRACE_LEVEL, + "CCPF: InitializePrefetecher()\n"); + + /* Setup the Prefetcher Data */ + InitializeListHead(&CcPfGlobals.ActiveTraces); + InitializeListHead(&CcPfGlobals.CompletedTraces); + ExInitializeFastMutex(&CcPfGlobals.CompletedTracesLock); + + /* FIXME: Setup the rest of the prefetecher */ +} BOOLEAN NTAPI CcInitializeCacheManager (VOID) Modified: branches/cache_manager_rewrite/cc/copy.c URL: http://svn.reactos.org/svn/reactos/branches/cache_manager_rewrite/cc/copy.c… ============================================================================== --- branches/cache_manager_rewrite/cc/copy.c (original) +++ branches/cache_manager_rewrite/cc/copy.c Sun Jan 13 12:57:08 2008 @@ -30,6 +30,7 @@ #endif ULONG CcFastMdlReadWait; +ULONG CcFastMdlReadNotPossible; ULONG CcFastReadNotPossible; ULONG CcFastReadWait; ULONG CcFastReadNoWait; Modified: branches/cache_manager_rewrite/cc/view.c URL: http://svn.reactos.org/svn/reactos/branches/cache_manager_rewrite/cc/view.c… ============================================================================== --- branches/cache_manager_rewrite/cc/view.c (original) +++ branches/cache_manager_rewrite/cc/view.c Sun Jan 13 12:57:08 2008 @@ -137,7 +137,7 @@ MEMORY_AREA_CACHE_SEGMENT, &CcCacheViewBase, Size, 0, &CcCacheViewMemoryArea, FALSE, FALSE, BoundaryAddressMultiple); MmUnlockAddressSpace (MmGetKernelAddressSpace ()); - DPRINT1 ("CcCacheViewBase: %x\n", CcCacheViewBase); + DPRINT ("CcCacheViewBase: %x\n", CcCacheViewBase); if (!NT_SUCCESS (Status)) { KEBUGCHECK (0);

16 years, 8 months

← Newer
1
...
29
30
31
32
33
34
35
...
54
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs January 2008