Ros-diffs

ros-diffs@reactos.org

81390 discussions

[pschweitzer] 54550: [MSVCRT_APITEST] Add more tests
by pschweitzer＠svn.reactos.org 30 Nov '11

30 Nov '11

Author: pschweitzer Date: Wed Nov 30 21:03:35 2011 New Revision: 54550 URL: http://svn.reactos.org/svn/reactos?rev=54550&view=rev Log: [MSVCRT_APITEST] Add more tests Modified: trunk/rostests/apitests/msvcrt/ieee.c Modified: trunk/rostests/apitests/msvcrt/ieee.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/msvcrt/ieee.c?re… ============================================================================== --- trunk/rostests/apitests/msvcrt/ieee.c [iso-8859-1] (original) +++ trunk/rostests/apitests/msvcrt/ieee.c [iso-8859-1] Wed Nov 30 21:03:35 2011 @@ -7,6 +7,7 @@ #include <wine/test.h> #include <float.h> +#include <math.h> typedef union { @@ -199,7 +200,7 @@ ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n"); } -void test_scalb(void) +void test_j0(void) { ieee_double tested; ieee_double expected; @@ -210,6 +211,278 @@ errno = 0xDEADBEEF; tested.l = 0xFFFFFFFFFFFFFFFFLL; expected.l = 0xFFFFFFFFFFFFFFFFLL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF8000000000001LL; + expected.l = 0xFFF8000000000001LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF8000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF7FFFFFFFFFFFFLL; + expected.l = 0xFFFFFFFFFFFFFFFFLL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF0000000000001LL; + expected.l = 0xFFF8000000000001LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF0000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFEFFFFFFFFFFFFFLL; + expected.l = 0x1FE7206E1D6FDCFALL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x8010000000000000LL; + expected.l = 0x3FF0000000000000LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x800FFFFFFFFFFFFFLL; + expected.l = 0x3FF0000000000000LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x8000000000000001LL; + expected.l = 0x3FF0000000000000LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x8000000000000000LL; + expected.l = 0x3FF0000000000000LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x0000000000000000LL; + expected.l = 0x3FF0000000000000LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x0000000000000001LL; + expected.l = 0x3FF0000000000000LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x000FFFFFFFFFFFFFLL; + expected.l = 0x3FF0000000000000LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x0010000000000000LL; + expected.l = 0x3FF0000000000000LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FEFFFFFFFFFFFFFLL; + expected.l = 0x1FE7206E1D6FDCFALL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF0000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF0000000000001LL; + expected.l = 0x7FF8000000000001LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF7FFFFFFFFFFFFLL; + expected.l = 0x7FFFFFFFFFFFFFFFLL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF8000000000000LL; + expected.l = 0x7FF8000000000000LL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FFFFFFFFFFFFFFFLL; + expected.l = 0x7FFFFFFFFFFFFFFFLL; + result.d = _j0(tested.d); + ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); +} + +void test_j1(void) +{ + ieee_double tested; + ieee_double expected; + ieee_double result; + + expected.l = 0; + + errno = 0xDEADBEEF; + tested.l = 0xFFFFFFFFFFFFFFFFLL; + expected.l = 0xFFFFFFFFFFFFFFFFLL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF8000000000001LL; + expected.l = 0xFFF8000000000001LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF8000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF7FFFFFFFFFFFFLL; + expected.l = 0xFFFFFFFFFFFFFFFFLL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF0000000000001LL; + expected.l = 0xFFF8000000000001LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF0000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFEFFFFFFFFFFFFFLL; + expected.l = 0x9FE7206E1D6FDCFALL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x8010000000000000LL; + expected.l = 0x8008000000000000LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x800FFFFFFFFFFFFFLL; + expected.l = 0x8008000000000000LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x8000000000000001LL; + expected.l = 0x8000000000000000LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x8000000000000000LL; + expected.l = 0x8000000000000000LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x0000000000000000LL; + expected.l = 0x0000000000000000LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x0000000000000001LL; + expected.l = 0x0000000000000000LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x000FFFFFFFFFFFFFLL; + expected.l = 0x0008000000000000LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x0010000000000000LL; + expected.l = 0x0008000000000000LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FEFFFFFFFFFFFFFLL; + expected.l = 0x1FE7206E1D6FDCFALL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF0000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF0000000000001LL; + expected.l = 0x7FF8000000000001LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF7FFFFFFFFFFFFLL; + expected.l = 0x7FFFFFFFFFFFFFFFLL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF8000000000000LL; + expected.l = 0x7FF8000000000000LL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FFFFFFFFFFFFFFFLL; + expected.l = 0x7FFFFFFFFFFFFFFFLL; + result.d = _j1(tested.d); + ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); +} + +void test_scalb(void) +{ + ieee_double tested; + ieee_double expected; + ieee_double result; + + expected.l = 0; + + errno = 0xDEADBEEF; + tested.l = 0xFFFFFFFFFFFFFFFFLL; + expected.l = 0xFFFFFFFFFFFFFFFFLL; result.d = _scalb(tested.d, 3); ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l); ok(errno == EDOM, "errno: %d\n", errno); @@ -332,6 +605,278 @@ expected.l = 0x7FFFFFFFFFFFFFFFLL; result.d = _scalb(tested.d, 3); ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); +} + +void test_y0(void) +{ + ieee_double tested; + ieee_double expected; + ieee_double result; + + expected.l = 0; + + errno = 0xDEADBEEF; + tested.l = 0xFFFFFFFFFFFFFFFFLL; + expected.l = 0xFFFFFFFFFFFFFFFFLL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF8000000000001LL; + expected.l = 0xFFF8000000000001LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF8000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF7FFFFFFFFFFFFLL; + expected.l = 0xFFFFFFFFFFFFFFFFLL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF0000000000001LL; + expected.l = 0xFFF8000000000001LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF0000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFEFFFFFFFFFFFFFLL; + expected.l = 0xFFF8000000000000LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x8010000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x800FFFFFFFFFFFFFLL; + expected.l = 0xFFF8000000000000LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x8000000000000001LL; + expected.l = 0xFFF8000000000000LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x8000000000000000LL; + expected.l = 0xFFF0000000000000LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == ERANGE, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x0000000000000000LL; + expected.l = 0xFFF0000000000000LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == ERANGE, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x0000000000000001LL; + expected.l = 0xC07D9FFC3469E1B3LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x000FFFFFFFFFFFFFLL; + expected.l = 0xC07C30D8F820740ELL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x0010000000000000LL; + expected.l = 0xC07C30D8F820740ELL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FEFFFFFFFFFFFFFLL; + expected.l = 0x9FD5A36F8428F58BLL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF0000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF0000000000001LL; + expected.l = 0x7FF8000000000001LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF7FFFFFFFFFFFFLL; + expected.l = 0x7FFFFFFFFFFFFFFFLL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF8000000000000LL; + expected.l = 0x7FF8000000000000LL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FFFFFFFFFFFFFFFLL; + expected.l = 0x7FFFFFFFFFFFFFFFLL; + result.d = _y0(tested.d); + ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); +} + +void test_y1(void) +{ + ieee_double tested; + ieee_double expected; + ieee_double result; + + expected.l = 0; + + errno = 0xDEADBEEF; + tested.l = 0xFFFFFFFFFFFFFFFFLL; + expected.l = 0xFFFFFFFFFFFFFFFFLL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF8000000000001LL; + expected.l = 0xFFF8000000000001LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF8000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF7FFFFFFFFFFFFLL; + expected.l = 0xFFFFFFFFFFFFFFFFLL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF0000000000001LL; + expected.l = 0xFFF8000000000001LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFF0000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0xFFEFFFFFFFFFFFFFLL; + expected.l = 0xFFF8000000000000LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x8010000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x800FFFFFFFFFFFFFLL; + expected.l = 0xFFF8000000000000LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x8000000000000001LL; + expected.l = 0xFFF8000000000000LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x8000000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == ERANGE, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x0000000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == ERANGE, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x0000000000000001LL; + expected.l = 0xFFF0000000000000LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x000FFFFFFFFFFFFFLL; + expected.l = 0xFFC45F306DC9C884LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x0010000000000000LL; + expected.l = 0xFFC45F306DC9C883LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FEFFFFFFFFFFFFFLL; + expected.l = 0x9FD5A36F8428F58BLL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == 0xDEADBEEF, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF0000000000000LL; + expected.l = 0xFFF8000000000000LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF0000000000001LL; + expected.l = 0x7FF8000000000001LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF7FFFFFFFFFFFFLL; + expected.l = 0x7FFFFFFFFFFFFFFFLL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FF8000000000000LL; + expected.l = 0x7FF8000000000000LL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); + ok(errno == EDOM, "errno: %d\n", errno); + errno = 0xDEADBEEF; + tested.l = 0x7FFFFFFFFFFFFFFFLL; + expected.l = 0x7FFFFFFFFFFFFFFFLL; + result.d = _y1(tested.d); + ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l); ok(errno == EDOM, "errno: %d\n", errno); } @@ -340,5 +885,9 @@ test_finite(); test_fpclass(); test_isnan(); + test_j0(); + test_j1(); test_scalb(); + test_y0(); + test_y1(); }

1 0

[cgutman] 54549: [NTOSKRNL] - Optimize CcRosTrimCache by eliminating an extra loop of all segments - Allow swapping of dirty segments by flushing them first
by cgutman＠svn.reactos.org 30 Nov '11

30 Nov '11

Author: cgutman Date: Wed Nov 30 17:10:43 2011 New Revision: 54549 URL: http://svn.reactos.org/svn/reactos?rev=54549&view=rev Log: [NTOSKRNL] - Optimize CcRosTrimCache by eliminating an extra loop of all segments - Allow swapping of dirty segments by flushing them first Modified: trunk/reactos/ntoskrnl/cc/view.c Modified: trunk/reactos/ntoskrnl/cc/view.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cc/view.c?rev=545… ============================================================================== --- trunk/reactos/ntoskrnl/cc/view.c [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/cc/view.c [iso-8859-1] Wed Nov 30 17:10:43 2011 @@ -302,79 +302,80 @@ ULONG PagesFreed; KIRQL oldIrql; LIST_ENTRY FreeList; - + PFN_NUMBER Page; + ULONG i; + DPRINT("CcRosTrimCache(Target %d)\n", Target); - + + InitializeListHead(&FreeList); + + /* Flush dirty pages to disk */ + CcRosFlushDirtyPages(Target, NrFreed); + + if ((*NrFreed) != 0) DPRINT1("Flushed %d dirty cache pages to disk\n", (*NrFreed)); + *NrFreed = 0; - - InitializeListHead(&FreeList); KeAcquireGuardedMutex(&ViewLock); + current_entry = CacheSegmentLRUListHead.Flink; - while (current_entry != &CacheSegmentLRUListHead && Target > 0) + while (current_entry != &CacheSegmentLRUListHead) { current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT, CacheSegmentLRUListEntry); current_entry = current_entry->Flink; - + KeAcquireSpinLock(&current->Bcb->BcbLock, &oldIrql); - if (current->MappedCount > 0 && !current->Dirty && !current->PageOut) + /* Reference the cache segment */ + CcRosCacheSegmentIncRefCount(current); + + /* Check if it's mapped and not dirty */ + if (current->MappedCount > 0 && !current->Dirty) { - ULONG i; - - CcRosCacheSegmentIncRefCount(current); - current->PageOut = TRUE; + /* We have to break these locks because Cc sucks */ KeReleaseSpinLock(&current->Bcb->BcbLock, oldIrql); KeReleaseGuardedMutex(&ViewLock); + + /* Page out the segment */ for (i = 0; i < current->Bcb->CacheSegmentSize / PAGE_SIZE; i++) { - PFN_NUMBER Page; - Page = (PFN_NUMBER)(MmGetPhysicalAddress((char*)current->BaseAddress + i * PAGE_SIZE).QuadPart >> PAGE_SHIFT); + Page = (PFN_NUMBER)(MmGetPhysicalAddress((PUCHAR)current->BaseAddress + (i * PAGE_SIZE)).QuadPart >> PAGE_SHIFT); + MmPageOutPhysicalAddress(Page); } + + /* Reacquire the locks */ KeAcquireGuardedMutex(&ViewLock); KeAcquireSpinLock(&current->Bcb->BcbLock, &oldIrql); - CcRosCacheSegmentDecRefCount(current); } - + + /* Dereference the cache segment */ + CcRosCacheSegmentDecRefCount(current); + + /* Check if we can free this entry now */ if (current->ReferenceCount == 0) { - PagesPerSegment = current->Bcb->CacheSegmentSize / PAGE_SIZE; - // PagesFreed = PagesPerSegment; - PagesFreed = min(PagesPerSegment, Target); - Target -= PagesFreed; - (*NrFreed) += PagesFreed; - } - - KeReleaseSpinLock(&current->Bcb->BcbLock, oldIrql); - } - - current_entry = CacheSegmentLRUListHead.Flink; - while (current_entry != &CacheSegmentLRUListHead) - { - current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT, - CacheSegmentLRUListEntry); - current->PageOut = FALSE; - current_entry = current_entry->Flink; - - KeAcquireSpinLock(&current->Bcb->BcbLock, &oldIrql); - if (current->ReferenceCount == 0) - { + ASSERT(!current->Dirty); + ASSERT(!current->MappedCount); + RemoveEntryList(&current->BcbSegmentListEntry); - KeReleaseSpinLock(&current->Bcb->BcbLock, oldIrql); RemoveEntryList(&current->CacheSegmentListEntry); RemoveEntryList(&current->CacheSegmentLRUListEntry); InsertHeadList(&FreeList, &current->BcbSegmentListEntry); + + /* Calculate how many pages we freed for Mm */ + PagesPerSegment = current->Bcb->CacheSegmentSize / PAGE_SIZE; + PagesFreed = min(PagesPerSegment, Target); + Target -= PagesFreed; + (*NrFreed) += PagesFreed; } - else - { - KeReleaseSpinLock(&current->Bcb->BcbLock, oldIrql); - } - } - + + KeReleaseSpinLock(&current->Bcb->BcbLock, oldIrql); + } + KeReleaseGuardedMutex(&ViewLock); - + while (!IsListEmpty(&FreeList)) { current_entry = RemoveHeadList(&FreeList); @@ -382,7 +383,9 @@ BcbSegmentListEntry); CcRosInternalFreeCacheSegment(current); } - + + DPRINT1("Evicted %d cache pages\n", (*NrFreed)); + return(STATUS_SUCCESS); }

1 0

[tfaber] 54548: [NTDLL_APITEST] - Add NtAllocateVirtualMemory test, which is a small stress test for virtual memory allocation/freeing/reuse - Can be used to reproduce bug 5857 in third stage (inst...
by tfaber＠svn.reactos.org 30 Nov '11

30 Nov '11

Author: tfaber Date: Wed Nov 30 17:00:23 2011 New Revision: 54548 URL: http://svn.reactos.org/svn/reactos?rev=54548&view=rev Log: [NTDLL_APITEST] - Add NtAllocateVirtualMemory test, which is a small stress test for virtual memory allocation/freeing/reuse - Can be used to reproduce bug 5857 in third stage (install with VT-x enabled, then disable for the test) - Shows that the bug is a race condition in Mm, and not heap's fault - I've put ASSERTs instead of ok's for easier debugging Added: trunk/rostests/apitests/ntdll/NtAllocateVirtualMemory.c (with props) Modified: trunk/rostests/apitests/ntdll/CMakeLists.txt trunk/rostests/apitests/ntdll/ntdll_apitest.rbuild trunk/rostests/apitests/ntdll/testlist.c Modified: trunk/rostests/apitests/ntdll/CMakeLists.txt URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/ntdll/CMakeLists… ============================================================================== --- trunk/rostests/apitests/ntdll/CMakeLists.txt [iso-8859-1] (original) +++ trunk/rostests/apitests/ntdll/CMakeLists.txt [iso-8859-1] Wed Nov 30 17:00:23 2011 @@ -1,7 +1,6 @@ - -add_definitions(-D_DLL -D__USE_CRTIMP) list(APPEND SOURCE + NtAllocateVirtualMemory.c NtFreeVirtualMemory.c RtlInitializeBitMap.c SystemInfo.c Added: trunk/rostests/apitests/ntdll/NtAllocateVirtualMemory.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/ntdll/NtAllocate… ============================================================================== --- trunk/rostests/apitests/ntdll/NtAllocateVirtualMemory.c (added) +++ trunk/rostests/apitests/ntdll/NtAllocateVirtualMemory.c [iso-8859-1] Wed Nov 30 17:00:23 2011 @@ -1,0 +1,245 @@ +/* + * PROJECT: ReactOS API Tests + * LICENSE: GPLv2+ - See COPYING in the top level directory + * PURPOSE: Stress Test for virtual memory allocation + * PROGRAMMER: Thomas Faber <thfabba(a)gmx.de> + */ + +#define WIN32_NO_STATUS +#include <stdio.h> +#include <wine/test.h> +#include <ndk/rtlfuncs.h> +#include <ndk/mmfuncs.h> + +static PVOID Allocations[4096] = { NULL }; +static ULONG CurrentAllocation = 0; + +static +VOID +ValidateAllocations(VOID) +{ + ULONG i; + + ASSERT(CurrentAllocation < sizeof(Allocations) / sizeof(Allocations[0])); + for (i = 0; i < CurrentAllocation; ++i) + { + PUCHAR UserBuffer = Allocations[i]; + SIZE_T AllocationSize; + SIZE_T DataSize; + + if (UserBuffer == NULL) + continue; + + AllocationSize = ((PSIZE_T)UserBuffer)[-2]; + DataSize = ((PSIZE_T)UserBuffer)[-1]; + ASSERT(DataSize != 0); + ASSERT(((SIZE_T)UserBuffer + DataSize) % PAGE_SIZE == 0); + } +} + +static +PVOID +Allocate( + SIZE_T DataSize) +{ + NTSTATUS Status; + PVOID AllocationStart = NULL; + SIZE_T AllocationSize = PAGE_ROUND_UP(DataSize + PAGE_SIZE + 2 * sizeof(SIZE_T)); + PVOID FirstPageStart; + SIZE_T NumberOfPages = AllocationSize / PAGE_SIZE; + SIZE_T Size; + PUCHAR UserBuffer; + + Status = NtAllocateVirtualMemory(NtCurrentProcess(), &AllocationStart, 0, &AllocationSize, MEM_RESERVE, PAGE_NOACCESS); + + if (!NT_SUCCESS(Status)) + return NULL; + + FirstPageStart = (PUCHAR)AllocationStart + AllocationSize - PAGE_SIZE * NumberOfPages; + Size = (NumberOfPages - 1) * PAGE_SIZE; + Status = NtAllocateVirtualMemory(NtCurrentProcess(), &FirstPageStart, 0, &Size, MEM_COMMIT, PAGE_READWRITE); + if (!NT_SUCCESS(Status)) + { + Size = 0; + Status = NtFreeVirtualMemory(NtCurrentProcess(), &AllocationStart, &AllocationSize, MEM_RELEASE); + ASSERT(Status == STATUS_SUCCESS); + return NULL; + } + + UserBuffer = AllocationStart; + UserBuffer += AllocationSize - PAGE_SIZE - DataSize; + RtlFillMemory(FirstPageStart, UserBuffer - (PUCHAR)FirstPageStart, 0xae); + RtlZeroMemory(UserBuffer, DataSize); + ((PSIZE_T)UserBuffer)[-2] = AllocationSize; + ((PSIZE_T)UserBuffer)[-1] = DataSize; + + Allocations[CurrentAllocation++] = UserBuffer; + ValidateAllocations(); + return UserBuffer; +} + +static +VOID +Free( + PVOID UserBuffer) +{ + NTSTATUS Status; + PVOID AllocationStart; + SIZE_T Zero = 0; + SIZE_T AllocationSize; + SIZE_T DataSize; + ULONG i; + + AllocationSize = ((PSIZE_T)UserBuffer)[-2]; + DataSize = ((PSIZE_T)UserBuffer)[-1]; + ASSERT(DataSize != 0); + + AllocationStart = (PUCHAR)UserBuffer + DataSize + PAGE_SIZE - AllocationSize; + ASSERT((SIZE_T)AllocationStart % PAGE_SIZE == 0); + + RtlFillMemory(UserBuffer, DataSize, 0xbe); + ((PSIZE_T)UserBuffer)[-1] = 0; + ((PSIZE_T)UserBuffer)[-2] = 0xFAFBFCFD; + + for (i = 0; i < CurrentAllocation; ++i) + if (Allocations[i] == UserBuffer) + { + Allocations[i] = NULL; + break; + } + ValidateAllocations(); + + Status = NtFreeVirtualMemory(NtCurrentProcess(), &AllocationStart, &Zero, MEM_RELEASE); + ASSERT(Status == STATUS_SUCCESS); +} + +static +PVOID +ReAllocate( + PVOID OldUserBuffer, + SIZE_T NewDataSize) +{ + PVOID NewUserBuffer; + SIZE_T OldDataSize; + + OldDataSize = ((PSIZE_T)OldUserBuffer)[-1]; + ASSERT(OldDataSize != 0); + + NewUserBuffer = Allocate(NewDataSize); + ASSERT(((PSIZE_T)OldUserBuffer)[-1] == OldDataSize); + RtlCopyMemory(NewUserBuffer, OldUserBuffer, min(OldDataSize, NewDataSize)); + ASSERT(((PSIZE_T)OldUserBuffer)[-1] == OldDataSize); + Free(OldUserBuffer); + return NewUserBuffer; +} + +static +VOID +AccessMemory1( + PVOID UserBuffer, + SIZE_T DataSize) +{ + PBYTE Buffer = UserBuffer; + SIZE_T i; + + for (i = 0; i < DataSize; ++i) + Buffer[i] = LOBYTE(i); +} + +static +BOOLEAN +CheckMemory1( + PVOID UserBuffer, + SIZE_T DataSize) +{ + PBYTE Buffer = UserBuffer; + SIZE_T i; + + for (i = 0; i < DataSize; ++i) + if (Buffer[i] != LOBYTE(i)) + { + trace("Mismatch in region %p at index %lu. Value=%02x\n", UserBuffer, (ULONG)i, Buffer[i]); + ASSERT(FALSE); + return FALSE; + } + return TRUE; +} + +static +VOID +AccessMemory2( + PVOID UserBuffer, + SIZE_T DataSize) +{ + PBYTE Buffer = UserBuffer; + SIZE_T i; + + for (i = 0; i < DataSize; ++i) + Buffer[i] = UCHAR_MAX - LOBYTE(i); +} + +static +BOOLEAN +CheckMemory2( + PVOID UserBuffer, + SIZE_T DataSize) +{ + PBYTE Buffer = UserBuffer; + SIZE_T i; + + for (i = 0; i < DataSize; ++i) + if (Buffer[i] != UCHAR_MAX - LOBYTE(i)) + { + trace("Mismatch in region %p at index %lu. Value=%02x\n", UserBuffer, (ULONG)i, Buffer[i]); + ASSERT(FALSE); + return FALSE; + } + return TRUE; +} + +#define RUNS 32 + +START_TEST(NtAllocateVirtualMemory) +{ + PVOID Mem1, Mem2; + SIZE_T Size1, Size2; + ULONG i; + + Size1 = 32; + Mem1 = Allocate(Size1); + AccessMemory1(Mem1, Size1); + Size2 = 128; + Mem2 = Allocate(Size2); + AccessMemory2(Mem2, Size2); + for (i = 0; i < RUNS; ++i) + { + PVOID New; + ok(CheckMemory1(Mem1, Size1) == TRUE, "CheckMemory1 failure\n"); + New = ReAllocate(Mem1, Size1 * 3 / 2); + if (New == NULL) + { + skip("Realloc failure\n"); + break; + } + Mem1 = New; + ok(CheckMemory1(Mem1, Size1) == TRUE, "CheckMemory1 failure\n"); + Size1 = Size1 * 3 / 2; + AccessMemory1(Mem1, Size1); + + ok(CheckMemory2(Mem2, Size2) == TRUE, "CheckMemory2 failure\n"); + New = ReAllocate(Mem2, Size2 + 128); + if (New == NULL) + { + skip("Realloc failure\n"); + break; + } + Mem2 = New; + ok(CheckMemory2(Mem2, Size2) == TRUE, "CheckMemory2 failure\n"); + Size2 += 128; + AccessMemory2(Mem2, Size2); + } + ok(CheckMemory2(Mem2, Size2) == TRUE, "CheckMemory2 failure\n"); + Free(Mem2); + ok(CheckMemory1(Mem1, Size1) == TRUE, "CheckMemory1 failure\n"); + Free(Mem1); +} Propchange: trunk/rostests/apitests/ntdll/NtAllocateVirtualMemory.c ------------------------------------------------------------------------------ svn:eol-style = native Modified: trunk/rostests/apitests/ntdll/ntdll_apitest.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/ntdll/ntdll_apit… ============================================================================== --- trunk/rostests/apitests/ntdll/ntdll_apitest.rbuild [iso-8859-1] (original) +++ trunk/rostests/apitests/ntdll/ntdll_apitest.rbuild [iso-8859-1] Wed Nov 30 17:00:23 2011 @@ -10,7 +10,8 @@ <library>pseh</library> <file>testlist.c</file> - <file>NtFreeVirtualMemory.c</file> + <file>NtAllocateVirtualMemory.c</file> + <file>NtFreeVirtualMemory.c</file> <file>RtlInitializeBitMap.c</file> <file>ZwContinue.c</file> <file>SystemInfo.c</file> Modified: trunk/rostests/apitests/ntdll/testlist.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/ntdll/testlist.c… ============================================================================== --- trunk/rostests/apitests/ntdll/testlist.c [iso-8859-1] (original) +++ trunk/rostests/apitests/ntdll/testlist.c [iso-8859-1] Wed Nov 30 17:00:23 2011 @@ -5,17 +5,19 @@ #define STANDALONE #include "wine/test.h" +extern void func_NtAllocateVirtualMemory(void); +extern void func_NtFreeVirtualMemory(void); +extern void func_NtSystemInformation(void); extern void func_RtlInitializeBitMap(void); extern void func_ZwContinue(void); -extern void func_NtFreeVirtualMemory(void); -extern void func_NtSystemInformation(void); const struct test winetest_testlist[] = { - { "RtlInitializeBitMap", func_RtlInitializeBitMap }, - { "ZwContinue", func_ZwContinue }, - { "NtFreeVirtualMemory", func_NtFreeVirtualMemory }, - { "NtSystemInformation", func_NtSystemInformation }, + { "NtAllocateVirtualMemory", func_NtAllocateVirtualMemory }, + { "NtFreeVirtualMemory", func_NtFreeVirtualMemory }, + { "NtSystemInformation", func_NtSystemInformation }, + { "RtlInitializeBitMap", func_RtlInitializeBitMap }, + { "ZwContinue", func_ZwContinue }, { 0, 0 } };

1 0

[rharabien] 54547: [SHELL32] - Restore functionality of Start Menu from old shell32
by rharabien＠svn.reactos.org 30 Nov '11

30 Nov '11

Author: rharabien Date: Wed Nov 30 12:21:27 2011 New Revision: 54547 URL: http://svn.reactos.org/svn/reactos?rev=54547&view=rev Log: [SHELL32] - Restore functionality of Start Menu from old shell32 Modified: trunk/reactos/dll/win32/shell32/shell32_main.cpp trunk/reactos/dll/win32/shell32/startmenu.cpp trunk/reactos/dll/win32/shell32/startmenu.h Modified: trunk/reactos/dll/win32/shell32/shell32_main.cpp URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shell32/shell32_… ============================================================================== --- trunk/reactos/dll/win32/shell32/shell32_main.cpp [iso-8859-1] (original) +++ trunk/reactos/dll/win32/shell32/shell32_main.cpp [iso-8859-1] Wed Nov 30 12:21:27 2011 @@ -1287,7 +1287,7 @@ OBJECT_ENTRY(CLSID_RecycleBin, CRecycleBin) OBJECT_ENTRY(CLSID_OpenWithMenu, COpenWithMenu) OBJECT_ENTRY(CLSID_NewMenu, CNewMenu) -OBJECT_ENTRY(CLSID_StartMenu, CStartMenuCallback) +OBJECT_ENTRY(CLSID_StartMenu, CStartMenu) OBJECT_ENTRY(CLSID_MenuBandSite, CMenuBandSite) END_OBJECT_MAP() Modified: trunk/reactos/dll/win32/shell32/startmenu.cpp URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shell32/startmen… ============================================================================== --- trunk/reactos/dll/win32/shell32/startmenu.cpp [iso-8859-1] (original) +++ trunk/reactos/dll/win32/shell32/startmenu.cpp [iso-8859-1] Wed Nov 30 12:21:27 2011 @@ -22,148 +22,324 @@ WINE_DEFAULT_DEBUG_CHANNEL(shell32start); -CStartMenuCallback::CStartMenuCallback() -{ -} - -CStartMenuCallback::~CStartMenuCallback() -{ -} - -HRESULT STDMETHODCALLTYPE CStartMenuCallback::SetSite(IUnknown *pUnkSite) -{ - return E_NOTIMPL; -} - -HRESULT STDMETHODCALLTYPE CStartMenuCallback::GetSite(REFIID riid, void **ppvSite) -{ - return E_NOTIMPL; -} - -HRESULT STDMETHODCALLTYPE CStartMenuCallback::CallbackSM(LPSMDATA psmd, UINT uMsg, WPARAM wParam, LPARAM lParam) -{ +CStartMenu::CStartMenu() +{ + m_pBandSite = NULL; + m_pUnkSite = NULL; +} + +CStartMenu::~CStartMenu() +{ +} + +HRESULT STDMETHODCALLTYPE CStartMenu::ContextSensitiveHelp(BOOL fEnterMode) +{ + UNIMPLEMENTED; + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CStartMenu::GetWindow(HWND *phwnd) +{ + UNIMPLEMENTED; + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CStartMenu::GetClient(IUnknown **ppunkClient) +{ + TRACE("(%p, %p)\n", this, ppunkClient); + + *ppunkClient = (IUnknown*)m_pBandSite; + (*ppunkClient)->AddRef(); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE CStartMenu::OnPosRectChangeDB(LPRECT prc) +{ + UNIMPLEMENTED; + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CStartMenu::SetClient(IUnknown *punkClient) +{ + UNIMPLEMENTED; + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CStartMenu::OnSelect(DWORD dwSelectType) +{ + UNIMPLEMENTED; + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CStartMenu::Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags) +{ + UNIMPLEMENTED; + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CStartMenu::SetSubMenu(IMenuPopup *pmp, BOOL fSet) +{ + UNIMPLEMENTED; + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CStartMenu::SetSite(IUnknown *pUnkSite) +{ + TRACE("(%p, %p)\n", this, pUnkSite); + + if (m_pUnkSite) + m_pUnkSite->Release(); + m_pUnkSite = pUnkSite; + if (m_pUnkSite) + m_pUnkSite->AddRef(); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE CStartMenu::GetSite(REFIID riid, void **ppvSite) +{ + TRACE("(%p, %s, %p)\n", this, debugstr_guid(&riid), ppvSite); + + if (!m_pUnkSite) + return E_FAIL; + + return m_pUnkSite->QueryInterface(riid, ppvSite); +} + +HRESULT STDMETHODCALLTYPE CStartMenu::Initialize() +{ + HRESULT hr; + CComObject<CMenuBandSite> *pBandSiteObj; + + TRACE("(%p)\n", this); + + //pBandSiteObj = new CComObject<CMenuBandSite>(); + ATLTRY (pBandSiteObj = new CComObject<CMenuBandSite>); + if (pBandSiteObj == NULL) + return E_OUTOFMEMORY; + + hr = pBandSiteObj->QueryInterface(IID_IBandSite, (VOID**)&m_pBandSite); + if (FAILED(hr)) + return NULL; + + return m_pBandSite->AddBand((IMenuBand*)this); +} + +HRESULT STDMETHODCALLTYPE CStartMenu::IsMenuMessage(MSG *pmsg) +{ + UNIMPLEMENTED; + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CStartMenu::TranslateMenuMessage(MSG *pmsg, LRESULT *plRet) +{ + UNIMPLEMENTED; return E_NOTIMPL; } CMenuBandSite::CMenuBandSite() { + m_pObjects = NULL; + m_cObjects = 0; } CMenuBandSite::~CMenuBandSite() { } +HRESULT STDMETHODCALLTYPE CMenuBandSite::AddBand(IUnknown *punk) +{ + IUnknown **pObjects; + + TRACE("punk %p\n", punk); + + if (!punk) + return E_FAIL; + + pObjects = (IUnknown**)CoTaskMemAlloc(sizeof(IUnknown*) * (m_cObjects + 1)); + if (!pObjects) + return E_FAIL; + + RtlMoveMemory(pObjects, m_pObjects, sizeof(IUnknown*) * m_cObjects); + + CoTaskMemFree(m_pObjects); + + m_pObjects = pObjects; + + m_pObjects[m_cObjects] = punk; + punk->AddRef(); + + m_cObjects++; + + return S_OK; +} + +HRESULT STDMETHODCALLTYPE CMenuBandSite::EnumBands(UINT uBand, DWORD *pdwBandID) +{ + ULONG Index, ObjectCount; + + TRACE("uBand %uu pdwBandID %p\n", uBand, pdwBandID); + + if (uBand == (UINT)-1) + return m_cObjects; + + ObjectCount = 0; + + for(Index = 0; Index < m_cObjects; Index++) + { + if (m_pObjects[Index] != NULL) + { + if (uBand == ObjectCount) + { + *pdwBandID = Index; + return S_OK; + } + ObjectCount++; + } + } + return E_FAIL; +} + +HRESULT STDMETHODCALLTYPE CMenuBandSite::QueryBand(DWORD dwBandID, IDeskBand **ppstb, DWORD *pdwState, LPWSTR pszName, int cchName) +{ + UNIMPLEMENTED; + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CMenuBandSite::SetBandState(DWORD dwBandID, DWORD dwMask, DWORD dwState) +{ + UNIMPLEMENTED; + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CMenuBandSite::RemoveBand(DWORD dwBandID) +{ + TRACE("dwBandID %u\n", dwBandID); + + if (m_cObjects <= dwBandID) + return E_FAIL; + + if (m_pObjects[dwBandID]) + { + m_pObjects[dwBandID]->Release(); + m_pObjects[dwBandID] = NULL; + } + + return S_OK; +} + +HRESULT STDMETHODCALLTYPE CMenuBandSite::GetBandObject(DWORD dwBandID, REFIID riid, VOID **ppv) +{ + TRACE("dwBandID %u riid %p ppv %p\n", dwBandID, riid, ppv); + + if (m_cObjects <= dwBandID) + return E_FAIL; + + if (m_pObjects[dwBandID]) + { + return m_pObjects[dwBandID]->QueryInterface(riid, ppv); + } + + return E_FAIL; +} + +HRESULT STDMETHODCALLTYPE CMenuBandSite::SetBandSiteInfo(const BANDSITEINFO *pbsinfo) +{ + UNIMPLEMENTED; + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CMenuBandSite::GetBandSiteInfo(BANDSITEINFO *pbsinfo) +{ + UNIMPLEMENTED; + return E_NOTIMPL; +} + HRESULT STDMETHODCALLTYPE CMenuBandSite::GetWindow(HWND *phwnd) { + UNIMPLEMENTED; return E_NOTIMPL; } HRESULT STDMETHODCALLTYPE CMenuBandSite::ContextSensitiveHelp(BOOL fEnterMode) { + UNIMPLEMENTED; return E_NOTIMPL; } HRESULT STDMETHODCALLTYPE CMenuBandSite::SetDeskBarSite(IUnknown *punkSite) { + UNIMPLEMENTED; return E_NOTIMPL; } HRESULT STDMETHODCALLTYPE CMenuBandSite::SetModeDBC(DWORD dwMode) { + UNIMPLEMENTED; return E_NOTIMPL; } HRESULT STDMETHODCALLTYPE CMenuBandSite::UIActivateDBC(DWORD dwState) { + UNIMPLEMENTED; return E_NOTIMPL; } HRESULT STDMETHODCALLTYPE CMenuBandSite::GetSize(DWORD dwWhich, LPRECT prc) { + UNIMPLEMENTED; + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CMenuBandSite::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[ ], OLECMDTEXT *pCmdText) +{ + UNIMPLEMENTED; + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CMenuBandSite::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut) +{ + UNIMPLEMENTED; return E_NOTIMPL; } HRESULT STDMETHODCALLTYPE CMenuBandSite::UIActivateIO(BOOL fActivate, LPMSG lpMsg) { + UNIMPLEMENTED; return E_NOTIMPL; } HRESULT STDMETHODCALLTYPE CMenuBandSite::HasFocusIO() { + UNIMPLEMENTED; return E_NOTIMPL; } HRESULT STDMETHODCALLTYPE CMenuBandSite::TranslateAcceleratorIO(LPMSG lpMsg) { + UNIMPLEMENTED; return E_NOTIMPL; } HRESULT STDMETHODCALLTYPE CMenuBandSite::OnFocusChangeIS(IUnknown *punkObj, BOOL fSetFocus) { + UNIMPLEMENTED; return E_NOTIMPL; } HRESULT STDMETHODCALLTYPE CMenuBandSite::OnWinEvent(HWND paramC, UINT param10, WPARAM param14, LPARAM param18, LRESULT *param1C) { + UNIMPLEMENTED; return E_NOTIMPL; } HRESULT STDMETHODCALLTYPE CMenuBandSite::IsWindowOwner(HWND paramC) { + UNIMPLEMENTED; return E_NOTIMPL; } HRESULT STDMETHODCALLTYPE CMenuBandSite::QueryService(REFGUID guidService, REFIID riid, void **ppvObject) { - return E_NOTIMPL; -} - -HRESULT STDMETHODCALLTYPE CMenuBandSite::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[ ], OLECMDTEXT *pCmdText) -{ - return E_NOTIMPL; -} - -HRESULT STDMETHODCALLTYPE CMenuBandSite::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut) -{ - return E_NOTIMPL; -} - -HRESULT STDMETHODCALLTYPE CMenuBandSite::AddBand(IUnknown *punk) -{ - return E_NOTIMPL; -} - -HRESULT STDMETHODCALLTYPE CMenuBandSite::EnumBands(UINT uBand, DWORD *pdwBandID) -{ - return E_NOTIMPL; -} - -HRESULT STDMETHODCALLTYPE CMenuBandSite::QueryBand(DWORD dwBandID, IDeskBand **ppstb, DWORD *pdwState, LPWSTR pszName, int cchName) -{ - return E_NOTIMPL; -} - -HRESULT STDMETHODCALLTYPE CMenuBandSite::SetBandState(DWORD dwBandID, DWORD dwMask, DWORD dwState) -{ - return E_NOTIMPL; -} - -HRESULT STDMETHODCALLTYPE CMenuBandSite::RemoveBand(DWORD dwBandID) -{ - return E_NOTIMPL; -} - -HRESULT STDMETHODCALLTYPE CMenuBandSite::GetBandObject(DWORD dwBandID, REFIID riid, VOID **ppv) -{ - return E_NOTIMPL; -} - -HRESULT STDMETHODCALLTYPE CMenuBandSite::SetBandSiteInfo(const BANDSITEINFO *pbsinfo) -{ - return E_NOTIMPL; -} - -HRESULT STDMETHODCALLTYPE CMenuBandSite::GetBandSiteInfo(BANDSITEINFO *pbsinfo) -{ - return E_NOTIMPL; -} + UNIMPLEMENTED; + return E_NOTIMPL; +} Modified: trunk/reactos/dll/win32/shell32/startmenu.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shell32/startmen… ============================================================================== --- trunk/reactos/dll/win32/shell32/startmenu.h [iso-8859-1] (original) +++ trunk/reactos/dll/win32/shell32/startmenu.h [iso-8859-1] Wed Nov 30 12:21:27 2011 @@ -21,51 +21,91 @@ #ifndef _STARTMENU_H_ #define _STARTMENU_H_ -class CStartMenuCallback : - public CComCoClass<CStartMenuCallback, &CLSID_NULL>, +class CStartMenu : + public CComCoClass<CStartMenu, &CLSID_StartMenu>, public CComObjectRootEx<CComMultiThreadModelNoCS>, + public IMenuPopup, public IObjectWithSite, - public IShellMenuCallback + public IInitializeObject, + public IMenuBand // FIXME { private: + IBandSite *m_pBandSite; + IUnknown *m_pUnkSite; + public: - CStartMenuCallback(); - ~CStartMenuCallback(); + CStartMenu(); + ~CStartMenu(); + + // *** IOleWindow methods *** + virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode); + virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *phwnd); + + // *** IDeskBar methods *** + virtual HRESULT STDMETHODCALLTYPE GetClient(IUnknown **ppunkClient); + virtual HRESULT STDMETHODCALLTYPE OnPosRectChangeDB(LPRECT prc); + virtual HRESULT STDMETHODCALLTYPE SetClient(IUnknown *punkClient); + + // *** IMenuPopup methods *** + virtual HRESULT STDMETHODCALLTYPE OnSelect(DWORD dwSelectType); + virtual HRESULT STDMETHODCALLTYPE Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags); + virtual HRESULT STDMETHODCALLTYPE SetSubMenu(IMenuPopup *pmp, BOOL fSet); // *** IObjectWithSite methods *** virtual HRESULT STDMETHODCALLTYPE SetSite(IUnknown *pUnkSite); virtual HRESULT STDMETHODCALLTYPE GetSite(REFIID riid, void **ppvSite); - // *** IShellMenuCallback methods *** - virtual HRESULT STDMETHODCALLTYPE CallbackSM(LPSMDATA psmd, UINT uMsg, WPARAM wParam, LPARAM lParam); + // *** IInitializeObject methods *** + virtual HRESULT STDMETHODCALLTYPE Initialize(); + + // *** IMenuBand methods *** FIXME + virtual HRESULT STDMETHODCALLTYPE IsMenuMessage(MSG *pmsg); + virtual HRESULT STDMETHODCALLTYPE TranslateMenuMessage(MSG *pmsg, LRESULT *plRet); -DECLARE_NO_REGISTRY() -DECLARE_NOT_AGGREGATABLE(CStartMenuCallback) +DECLARE_REGISTRY_RESOURCEID(IDR_STARTMENU) +DECLARE_NOT_AGGREGATABLE(CStartMenu) DECLARE_PROTECT_FINAL_CONSTRUCT() -BEGIN_COM_MAP(CStartMenuCallback) +BEGIN_COM_MAP(CStartMenu) + COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IOleWindow) + COM_INTERFACE_ENTRY_IID(IID_IDeskBar, IDeskBar) + COM_INTERFACE_ENTRY_IID(IID_IMenuPopup, IMenuPopup) COM_INTERFACE_ENTRY_IID(IID_IObjectWithSite, IObjectWithSite) - COM_INTERFACE_ENTRY_IID(IID_IShellMenuCallback, IShellMenuCallback) + COM_INTERFACE_ENTRY_IID(IID_IInitializeObject, IInitializeObject) + COM_INTERFACE_ENTRY_IID(IID_IMenuBand, IMenuBand) // FIXME: Win does not export it END_COM_MAP() }; class CMenuBandSite : public CComCoClass<CMenuBandSite, &CLSID_MenuBandSite>, public CComObjectRootEx<CComMultiThreadModelNoCS>, + public IBandSite, public IDeskBarClient, + public IOleCommandTarget, public IInputObject, public IInputObjectSite, public IWinEventHandler, - public IServiceProvider, - public IOleCommandTarget, - public IBandSite + public IServiceProvider { private: + IUnknown **m_pObjects; + ULONG m_cObjects; + public: CMenuBandSite(); ~CMenuBandSite(); - + + // *** IBandSite methods *** + virtual HRESULT STDMETHODCALLTYPE AddBand(IUnknown *punk); + virtual HRESULT STDMETHODCALLTYPE EnumBands(UINT uBand, DWORD *pdwBandID); + virtual HRESULT STDMETHODCALLTYPE QueryBand(DWORD dwBandID, IDeskBand **ppstb, DWORD *pdwState, LPWSTR pszName, int cchName); + virtual HRESULT STDMETHODCALLTYPE SetBandState(DWORD dwBandID, DWORD dwMask, DWORD dwState); + virtual HRESULT STDMETHODCALLTYPE RemoveBand(DWORD dwBandID); + virtual HRESULT STDMETHODCALLTYPE GetBandObject(DWORD dwBandID, REFIID riid, VOID **ppv); + virtual HRESULT STDMETHODCALLTYPE SetBandSiteInfo(const BANDSITEINFO *pbsinfo); + virtual HRESULT STDMETHODCALLTYPE GetBandSiteInfo(BANDSITEINFO *pbsinfo); + // *** IOleWindow methods *** virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *phwnd); virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode); @@ -75,6 +115,10 @@ virtual HRESULT STDMETHODCALLTYPE SetModeDBC(DWORD dwMode); virtual HRESULT STDMETHODCALLTYPE UIActivateDBC(DWORD dwState); virtual HRESULT STDMETHODCALLTYPE GetSize(DWORD dwWhich, LPRECT prc); + + // *** IOleCommandTarget methods *** + virtual HRESULT STDMETHODCALLTYPE QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[ ], OLECMDTEXT *pCmdText); + virtual HRESULT STDMETHODCALLTYPE Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut); // *** IInputObject methods *** virtual HRESULT STDMETHODCALLTYPE UIActivateIO(BOOL fActivate, LPMSG lpMsg); @@ -91,34 +135,20 @@ // *** IServiceProvider methods *** virtual HRESULT STDMETHODCALLTYPE QueryService(REFGUID guidService, REFIID riid, void **ppvObject); - // *** IOleCommandTarget methods *** - virtual HRESULT STDMETHODCALLTYPE QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[ ], OLECMDTEXT *pCmdText); - virtual HRESULT STDMETHODCALLTYPE Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut); - - // *** IBandSite methods *** - virtual HRESULT STDMETHODCALLTYPE AddBand(IUnknown *punk); - virtual HRESULT STDMETHODCALLTYPE EnumBands(UINT uBand, DWORD *pdwBandID); - virtual HRESULT STDMETHODCALLTYPE QueryBand(DWORD dwBandID, IDeskBand **ppstb, DWORD *pdwState, LPWSTR pszName, int cchName); - virtual HRESULT STDMETHODCALLTYPE SetBandState(DWORD dwBandID, DWORD dwMask, DWORD dwState); - virtual HRESULT STDMETHODCALLTYPE RemoveBand(DWORD dwBandID); - virtual HRESULT STDMETHODCALLTYPE GetBandObject(DWORD dwBandID, REFIID riid, VOID **ppv); - virtual HRESULT STDMETHODCALLTYPE SetBandSiteInfo(const BANDSITEINFO *pbsinfo); - virtual HRESULT STDMETHODCALLTYPE GetBandSiteInfo(BANDSITEINFO *pbsinfo); - DECLARE_REGISTRY_RESOURCEID(IDR_MENUBANDSITE) DECLARE_NOT_AGGREGATABLE(CMenuBandSite) DECLARE_PROTECT_FINAL_CONSTRUCT() BEGIN_COM_MAP(CMenuBandSite) + COM_INTERFACE_ENTRY_IID(IID_IBandSite, IBandSite) COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IOleWindow) COM_INTERFACE_ENTRY_IID(IID_IDeskBarClient, IDeskBarClient) + COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget) COM_INTERFACE_ENTRY_IID(IID_IInputObject, IInputObject) COM_INTERFACE_ENTRY_IID(IID_IInputObjectSite, IInputObjectSite) COM_INTERFACE_ENTRY_IID(IID_IWinEventHandler, IWinEventHandler) COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider) - COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget) - COM_INTERFACE_ENTRY_IID(IID_IBandSite, IBandSite) END_COM_MAP() };

1 0

[rharabien] 54546: [EXPLORER-NEW] - Improve start menu initialization a bit so it shows what failed
by rharabien＠svn.reactos.org 30 Nov '11

30 Nov '11

Author: rharabien Date: Wed Nov 30 12:20:08 2011 New Revision: 54546 URL: http://svn.reactos.org/svn/reactos?rev=54546&view=rev Log: [EXPLORER-NEW] - Improve start menu initialization a bit so it shows what failed Modified: trunk/reactos/base/shell/explorer-new/startmnu.c Modified: trunk/reactos/base/shell/explorer-new/startmnu.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/shell/explorer-new/st… ============================================================================== --- trunk/reactos/base/shell/explorer-new/startmnu.c [iso-8859-1] (original) +++ trunk/reactos/base/shell/explorer-new/startmnu.c [iso-8859-1] Wed Nov 30 12:20:08 2011 @@ -843,110 +843,120 @@ IN HBITMAP hbmBanner OPTIONAL, IN BOOL bSmallIcons) { - HRESULT hRet; + HRESULT hr; IObjectWithSite *pOws = NULL; IMenuPopup *pMp = NULL; IStartMenuSite *pSms = NULL; IMenuBand *pMb = NULL; IInitializeObject *pIo; - IUnknown *pUnk; - IBandSite *pBs; + IUnknown *pUnk = NULL; + IBandSite *pBs = NULL; DWORD dwBandId = 0; pSms = CreateStartMenuSite(Tray); if (pSms == NULL) return NULL; - hRet = CoCreateInstance(&CLSID_StartMenu, - NULL, - CLSCTX_INPROC_SERVER, - &IID_IMenuPopup, - (PVOID*)&pMp); - if (SUCCEEDED(hRet)) - { - hRet = IMenuPopup_QueryInterface(pMp, - &IID_IObjectWithSite, - (PVOID*)&pOws); - if (SUCCEEDED(hRet)) - { - /* Set the menu site so we can handle messages */ - hRet = IObjectWithSite_SetSite(pOws, - (IUnknown*)pSms); - if (SUCCEEDED(hRet)) - { - /* Initialize the menu object */ - hRet = IMenuPopup_QueryInterface(pMp, - &IID_IInitializeObject, - (PVOID*)&pIo); - if (SUCCEEDED(hRet)) - { - //hRet = IInitializeObject_Initialize(pIo); - hRet = pIo->lpVtbl->Initialize(pIo); - - //IInitializeObject_Release(pIo); - pIo->lpVtbl->Release(pIo); - } - else - hRet = S_OK; - - /* Everything is initialized now. Let's get the IMenuBand interface. */ - if (SUCCEEDED(hRet)) - { - hRet = IMenuPopup_GetClient(pMp, - &pUnk); - - if (SUCCEEDED(hRet)) - { - hRet = IUnknown_QueryInterface(pUnk, - &IID_IBandSite, - (PVOID*)&pBs); - - if (SUCCEEDED(hRet)) - { - /* Finally we have the IBandSite interface, there's only one - band in it that apparently provides the IMenuBand interface */ - hRet = IBandSite_EnumBands(pBs, - 0, - &dwBandId); - if (SUCCEEDED(hRet)) - { - hRet = IBandSite_GetBandObject(pBs, - dwBandId, - &IID_IMenuBand, - (PVOID*)&pMb); - } - - IBandSite_Release(pBs); - } - - IUnknown_Release(pUnk); - } - } - } - - IObjectWithSite_Release(pOws); - } - } - - IStartMenuSite_Release(pSms); - - if (!SUCCEEDED(hRet)) - { - DbgPrint("Failed to initialize the start menu: 0x%x!\n", hRet); - - if (pMp != NULL) - IMenuPopup_Release(pMp); - - if (pMb != NULL) - IMenuBand_Release(pMb); - - return NULL; + hr = CoCreateInstance(&CLSID_StartMenu, + NULL, + CLSCTX_INPROC_SERVER, + &IID_IMenuPopup, + (PVOID*)&pMp); + if (FAILED(hr)) + { + DbgPrint("CoCreateInstance failed: %x\n", hr); + goto cleanup; + } + + hr = IMenuPopup_QueryInterface(pMp, + &IID_IObjectWithSite, + (PVOID*)&pOws); + if (FAILED(hr)) + { + DbgPrint("IMenuPopup_QueryInterface failed: %x\n", hr); + goto cleanup; + } + + /* Set the menu site so we can handle messages */ + hr = IObjectWithSite_SetSite(pOws, (IUnknown*)pSms); + if (FAILED(hr)) + { + DbgPrint("IObjectWithSite_SetSite failed: %x\n", hr); + goto cleanup; + } + + /* Initialize the menu object */ + hr = IMenuPopup_QueryInterface(pMp, &IID_IInitializeObject, (PVOID*)&pIo); + if (SUCCEEDED(hr)) + { + //hr = IInitializeObject_Initialize(pIo); + hr = pIo->lpVtbl->Initialize(pIo); + + //IInitializeObject_Release(pIo); + pIo->lpVtbl->Release(pIo); + } + else + hr = S_OK; + + /* Everything is initialized now. Let's get the IMenuBand interface. */ + if (FAILED(hr)) + { + DbgPrint("IMenuPopup_QueryInterface failed: %x\n", hr); + goto cleanup; + } + + hr = IMenuPopup_GetClient(pMp, &pUnk); + if (FAILED(hr)) + { + DbgPrint("IMenuPopup_GetClient failed: %x\n", hr); + goto cleanup; + } + + hr = IUnknown_QueryInterface(pUnk, &IID_IBandSite, (PVOID*)&pBs); + if (FAILED(hr)) + { + DbgPrint("IUnknown_QueryInterface pBs failed: %x\n", hr); + goto cleanup; + } + + /* Finally we have the IBandSite interface, there's only one + band in it that apparently provides the IMenuBand interface */ + hr = IBandSite_EnumBands(pBs, 0, &dwBandId); + if (FAILED(hr)) + { + DbgPrint("IBandSite_EnumBands failed: %x\n", hr); + goto cleanup; + } + + hr = IBandSite_GetBandObject(pBs, dwBandId, &IID_IMenuBand, (PVOID*)&pMb); + if (FAILED(hr)) + { + DbgPrint("IBandSite_GetBandObject failed: %x\n", hr); + goto cleanup; } UpdateStartMenu(pMp, hbmBanner, bSmallIcons); - *ppMenuBand = pMb; +cleanup: + if (SUCCEEDED(hr)) + *ppMenuBand = pMb; + else if (pMb != NULL) + IMenuBand_Release(pMb); + + if (pBs != NULL) + IBandSite_Release(pBs); + if (pUnk != NULL) + IUnknown_Release(pUnk); + if (pOws != NULL) + IObjectWithSite_Release(pOws); + if (pMp != NULL) + IMenuPopup_Release(pMp); + if (pSms != NULL) + IStartMenuSite_Release(pSms); + + if (FAILED(hr)) + return NULL; return pMp; }

1 0

[dgorbachev] 54545: [SsStars] Update Starfield screensaver translations (bug #6270): - Polish by Wojtek Kozlowski <=wojtekkozlo664=AT=op=DOT=pl=>; - Russian by Evilslon <=evilslon=AT=mail=DOT=ru=>.
by dgorbachev＠svn.reactos.org 30 Nov '11

30 Nov '11

Author: dgorbachev Date: Wed Nov 30 11:27:50 2011 New Revision: 54545 URL: http://svn.reactos.org/svn/reactos?rev=54545&view=rev Log: [SsStars] Update Starfield screensaver translations (bug #6270): - Polish by Wojtek Kozlowski <=wojtekkozlo664=AT=op=DOT=pl=>; - Russian by Evilslon <=evilslon=AT=mail=DOT=ru=>. Modified: trunk/rosapps/applications/screensavers/ssstars/lang/pl-PL.rc trunk/rosapps/applications/screensavers/ssstars/lang/ru-RU.rc trunk/rosapps/applications/screensavers/ssstars/resource.rc Modified: trunk/rosapps/applications/screensavers/ssstars/lang/pl-PL.rc URL: http://svn.reactos.org/svn/reactos/trunk/rosapps/applications/screensavers/… ============================================================================== --- trunk/rosapps/applications/screensavers/ssstars/lang/pl-PL.rc [iso-8859-1] (original) +++ trunk/rosapps/applications/screensavers/ssstars/lang/pl-PL.rc [iso-8859-1] Wed Nov 30 11:27:50 2011 @@ -1,4 +1,4 @@ -ï»¿LANGUAGE LANG_POLISH, SUBLANG_NEUTRAL +LANGUAGE LANG_POLISH, SUBLANG_DEFAULT // Dialog @@ -24,15 +24,15 @@ WS_TABSTOP CONTROL "",IDC_IMAGE_COSMOS,"Static",SS_BITMAP | SS_CENTERIMAGE, 4,4,284,92 - GROUPBOX "Advanced",IDC_STATIC,16,180,260,72 - CONTROL "Enable background blending",IDC_CHECK_DOBLENDING, + GROUPBOX "Zaawansowane",IDC_STATIC,16,180,260,72 + CONTROL "W³¹cz ³¹czenie t³a",IDC_CHECK_DOBLENDING, "Button",BS_AUTOCHECKBOX | WS_TABSTOP,24,196,110,10 - CONTROL "Enable accurate perspective correction", + CONTROL "W³¹cz precyzyjn¹ poprawê perspektywy", IDC_CHECK_PERSPECTIVE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,24,208,142,10 - CONTROL "Enable texture filtering",IDC_CHECK_FILTERING, + CONTROL "W³¹cz filtrowanie tekstur",IDC_CHECK_FILTERING, "Button",BS_AUTOCHECKBOX | WS_TABSTOP,24,220,90,10 - CONTROL "Enable smooth shading",IDC_CHECK_SHADING,"Button", + CONTROL "W³¹cz wyg³adzanie cieni",IDC_CHECK_SHADING,"Button", BS_AUTOCHECKBOX | WS_TABSTOP,24,232,100,10 PUSHBUTTON "OK",IDOK,60,260,52,16 PUSHBUTTON "Anuluj",IDCANCEL,120,260,52,16 Modified: trunk/rosapps/applications/screensavers/ssstars/lang/ru-RU.rc URL: http://svn.reactos.org/svn/reactos/trunk/rosapps/applications/screensavers/… ============================================================================== --- trunk/rosapps/applications/screensavers/ssstars/lang/ru-RU.rc [iso-8859-1] (original) +++ trunk/rosapps/applications/screensavers/ssstars/lang/ru-RU.rc [iso-8859-1] Wed Nov 30 11:27:50 2011 @@ -1,52 +1,52 @@ -LANGUAGE LANG_RUSSIAN, SUBLANG_NEUTRAL +LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT // Dialog DLG_SCRNSAVECONFIGURE DIALOGEX 0, 0, 292, 282 STYLE DS_SHELLFONT | DS_MODALFRAME | WS_POPUP | WS_CAPTION -CAPTION "Ïàðàìåòðû çàñòàâêè" +CAPTION "ÐÐ°ÑÐ°Ð¼ÐµÑÑÑ Ð·Ð°ÑÑÐ°Ð²ÐºÐ¸" FONT 8, "MS Shell Dlg" BEGIN - GROUPBOX "Íàñòðîéêè",IDC_STATIC,16,100,260,76 - RTEXT "Êîëè÷åñòâî çâ¸çä:",IDC_STATIC,24,116,68,12, + GROUPBOX "ÐÐ°ÑÑÑÐ¾Ð¹ÐºÐ¸",IDC_STATIC,16,100,260,76 + RTEXT "ÐÐ¾Ð»Ð¸ÑÐµÑÑÐ²Ð¾ Ð·Ð²ÑÐ·Ð´:",IDC_STATIC,24,116,68,12, SS_CENTERIMAGE CONTROL "Slider1",IDC_SLIDER_NUM_OF_STARS,"msctls_trackbar32", TBS_BOTH | TBS_NOTICKS | WS_TABSTOP,96,116,140,12 CTEXT "Static",IDC_TEXT_NUM_OF_STARS,240,116,24,12, SS_CENTERIMAGE,WS_EX_STATICEDGE - RTEXT "Ñêîðîñòü:",IDC_STATIC,24,137,68,12,SS_CENTERIMAGE + RTEXT "Ð¡ÐºÐ¾ÑÐ¾ÑÑÑ:",IDC_STATIC,24,137,68,12,SS_CENTERIMAGE CONTROL "Slider1",IDC_SLIDER_SPEED,"msctls_trackbar32",TBS_BOTH | TBS_NOTICKS | WS_TABSTOP,96,137,140,12 CTEXT "Static",IDC_TEXT_SPEED,240,137,24,12,SS_CENTERIMAGE, WS_EX_STATICEDGE - RTEXT "Âðàùåíèå:",IDC_STATIC,24,156,68,12,SS_CENTERIMAGE + RTEXT "ÐÑÐ°ÑÐµÐ½Ð¸Ðµ:",IDC_STATIC,24,156,68,12,SS_CENTERIMAGE COMBOBOX IDC_COMBO_ROTATION,100,156,80,60,CBS_DROPDOWNLIST | WS_TABSTOP CONTROL "",IDC_IMAGE_COSMOS,"Static",SS_BITMAP | SS_CENTERIMAGE, 4,4,284,92 - GROUPBOX "Advanced",IDC_STATIC,16,180,260,72 - CONTROL "Enable background blending",IDC_CHECK_DOBLENDING, + GROUPBOX "ÐÐ¾Ð¿Ð¾Ð»Ð½Ð¸ÑÐµÐ»ÑÐ½ÑÐµ Ð½Ð°ÑÑÑÐ¾Ð¹ÐºÐ¸",IDC_STATIC,16,180,260,72 + CONTROL "ÐÐºÐ»ÑÑÐ¸ÑÑ ÑÐ¾Ð½Ð¾Ð²Ð¾Ðµ ÑÐ¼ÐµÑÐ¸Ð²Ð°Ð½Ð¸Ðµ",IDC_CHECK_DOBLENDING, "Button",BS_AUTOCHECKBOX | WS_TABSTOP,24,196,110,10 - CONTROL "Enable accurate perspective correction", + CONTROL "ÐÐºÐ»ÑÑÐ¸ÑÑ ÑÐ¾ÑÐ½ÑÑ ÐºÐ¾ÑÑÐµÐºÑÐ¸Ñ Ð¿ÐµÑÑÐ¿ÐµÐºÑÐ¸Ð²Ñ", IDC_CHECK_PERSPECTIVE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,24,208,142,10 - CONTROL "Enable texture filtering",IDC_CHECK_FILTERING, + CONTROL "ÐÐºÐ»ÑÑÐ¸ÑÑ ÑÐ¸Ð»ÑÑÑÐ°ÑÐ¸Ñ ÑÐµÐºÑÑÑÑ",IDC_CHECK_FILTERING, "Button",BS_AUTOCHECKBOX | WS_TABSTOP,24,220,90,10 - CONTROL "Enable smooth shading",IDC_CHECK_SHADING,"Button", + CONTROL "ÐÐºÐ»ÑÑÐ¸ÑÑ Ð¼ÑÐ³ÐºÐ¸Ðµ ÑÐµÐ½Ð¸",IDC_CHECK_SHADING,"Button", BS_AUTOCHECKBOX | WS_TABSTOP,24,232,100,10 PUSHBUTTON "OK",IDOK,60,260,52,16 - PUSHBUTTON "Îòìåíà",IDCANCEL,120,260,52,16 - PUSHBUTTON "Î ïðîãðàììå",IDC_BUTTON_ABOUT,179,260,52,16 + PUSHBUTTON "ÐÑÐ¼ÐµÐ½Ð°",IDCANCEL,120,260,52,16 + PUSHBUTTON "Ð Ð¿ÑÐ¾Ð³ÑÐ°Ð¼Ð¼Ðµ",IDC_BUTTON_ABOUT,179,260,52,16 END // String Tables STRINGTABLE DISCARDABLE BEGIN - IDS_DESCRIPTION "Çâ¸çäíîå ïîëå" - IDS_ROTATION_NONE "Îòñóòñòâóåò" - IDS_ROTATION_LINEAR "Ëèíåéíîå" - IDS_ROTATION_PERIODIC "Ïåðèîäè÷åñêîå" - IDS_LICENSE "Çâ¸çäíîå ïîëå - ýòî ñâîáîäíîå ÏÎ, ðàñïðîñòðàíÿåìîå ïîä ëèöåíçèåé GNU GPL." - IDS_AUTHOR "Çàñòàâêó ñîçäàë Carlo Bramini" + IDS_DESCRIPTION "ÐÐ²ÑÐ·Ð´Ð½Ð¾Ðµ Ð¿Ð¾Ð»Ðµ" + IDS_ROTATION_NONE "ÐÑÑÑÑÑÑÐ²ÑÐµÑ" + IDS_ROTATION_LINEAR "ÐÐ¸Ð½ÐµÐ¹Ð½Ð¾Ðµ" + IDS_ROTATION_PERIODIC "ÐÐµÑÐ¸Ð¾Ð´Ð¸ÑÐµÑÐºÐ¾Ðµ" + IDS_LICENSE "ÐÐ²ÑÐ·Ð´Ð½Ð¾Ðµ Ð¿Ð¾Ð»Ðµ â ÑÑÐ¾ ÑÐ²Ð¾Ð±Ð¾Ð´Ð½Ð¾Ðµ ÐÐ, ÑÐ°ÑÐ¿ÑÐ¾ÑÑÑÐ°Ð½ÑÐµÐ¼Ð¾Ðµ Ð¿Ð¾Ð´ Ð»Ð¸ÑÐµÐ½Ð·Ð¸ÐµÐ¹ GNU GPL." + IDS_AUTHOR "ÐÐ°ÑÑÐ°Ð²ÐºÑ ÑÐ¾Ð·Ð´Ð°Ð» ÐÐ°ÑÐ»Ð¾ ÐÑÐ°Ð¼Ð¸Ð½Ð¸" END Modified: trunk/rosapps/applications/screensavers/ssstars/resource.rc URL: http://svn.reactos.org/svn/reactos/trunk/rosapps/applications/screensavers/… ============================================================================== --- trunk/rosapps/applications/screensavers/ssstars/resource.rc [iso-8859-1] (original) +++ trunk/rosapps/applications/screensavers/ssstars/resource.rc [iso-8859-1] Wed Nov 30 11:27:50 2011 @@ -47,9 +47,8 @@ // Language resources #include "lang/en-US.rc" #include "lang/it-IT.rc" -#include "lang/ru-RU.rc" // UTF-8 #pragma code_page(65001) - +#include "lang/ru-RU.rc" #include "lang/pl-PL.rc"

1 0

[cgutman] 54544: [NTOSKRNL] - Many balancer fixes for concurrency, improved swapping efficiency, and reduced code duplication - Move the low memory case back under the PFN lock - Debugging is on fo...
by cgutman＠svn.reactos.org 29 Nov '11

29 Nov '11

Author: cgutman Date: Tue Nov 29 23:59:25 2011 New Revision: 54544 URL: http://svn.reactos.org/svn/reactos?rev=54544&view=rev Log: [NTOSKRNL] - Many balancer fixes for concurrency, improved swapping efficiency, and reduced code duplication - Move the low memory case back under the PFN lock - Debugging is on for now because I don't trust the paging code all that much (it was not used very much until recently) Modified: trunk/reactos/ntoskrnl/mm/ARM3/pfnlist.c trunk/reactos/ntoskrnl/mm/balance.c Modified: trunk/reactos/ntoskrnl/mm/ARM3/pfnlist.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/mm/ARM3/pfnlist.c… ============================================================================== --- trunk/reactos/ntoskrnl/mm/ARM3/pfnlist.c [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/mm/ARM3/pfnlist.c [iso-8859-1] Tue Nov 29 23:59:25 2011 @@ -848,7 +848,10 @@ /* Make an empty software PTE */ MI_MAKE_SOFTWARE_PTE(&TempPte, MM_READWRITE); - + + /* Lock the PFN database */ + OldIrql = KeAcquireQueuedSpinLock(LockQueuePfnLock); + /* Check if we're running low on pages */ if (MmAvailablePages < 128) { @@ -858,12 +861,7 @@ /* Call RosMm and see if it can release any pages for us */ MmRebalanceMemoryConsumers(); - - DPRINT1("Rebalance complete: %d pages left\n", MmAvailablePages); - } - - /* Lock the PFN database */ - OldIrql = KeAcquireQueuedSpinLock(LockQueuePfnLock); + } /* Grab a page */ ASSERT_LIST_INVARIANT(&MmFreePageListHead); Modified: trunk/reactos/ntoskrnl/mm/balance.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/mm/balance.c?rev=… ============================================================================== --- trunk/reactos/ntoskrnl/mm/balance.c [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/mm/balance.c [iso-8859-1] Tue Nov 29 23:59:25 2011 @@ -5,6 +5,7 @@ * PURPOSE: kernel memory managment functions * * PROGRAMMERS: David Welch (welch(a)cwcom.net) + * Cameron Gutman (cameron.gutman(a)reactos.org) */ /* INCLUDES *****************************************************************/ @@ -28,7 +29,6 @@ KEVENT Event; } MM_ALLOCATION_REQUEST, *PMM_ALLOCATION_REQUEST; - /* GLOBALS ******************************************************************/ MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM]; @@ -36,14 +36,12 @@ static ULONG MiNrTotalPages; static LIST_ENTRY AllocationListHead; static KSPIN_LOCK AllocationListLock; -static ULONG MiPagesRequired = 0; -static ULONG MiMinimumPagesPerRun = 10; +static ULONG MiMinimumPagesPerRun; static CLIENT_ID MiBalancerThreadId; static HANDLE MiBalancerThreadHandle = NULL; static KEVENT MiBalancerEvent; static KTIMER MiBalancerTimer; -static LONG MiBalancerWork = 0; /* FUNCTIONS ****************************************************************/ @@ -59,7 +57,8 @@ MiNrTotalPages = NrAvailablePages; /* Set up targets. */ - MiMinimumAvailablePages = 64; + MiMinimumAvailablePages = 128; + MiMinimumPagesPerRun = 256; if ((NrAvailablePages + NrSystemPages) >= 8192) { MiMemoryConsumers[MC_CACHE].PagesTarget = NrAvailablePages / 4 * 3; @@ -105,24 +104,20 @@ KeBugCheck(MEMORY_MANAGEMENT); } - KeAcquireSpinLock(&AllocationListLock, &OldIrql); if (MmGetReferenceCountPage(Page) == 1) { + if(Consumer == MC_USER) MmRemoveLRUUserPage(Page); (void)InterlockedDecrementUL(&MiMemoryConsumers[Consumer].PagesUsed); - if (IsListEmpty(&AllocationListHead) || MmAvailablePages < MiMinimumAvailablePages) - { - KeReleaseSpinLock(&AllocationListLock, OldIrql); - if(Consumer == MC_USER) MmRemoveLRUUserPage(Page); + if (MmAvailablePages < MiMinimumAvailablePages || + (Entry = ExInterlockedRemoveHeadList(&AllocationListHead, &AllocationListLock)) == NULL) + { OldIrql = KeAcquireQueuedSpinLock(LockQueuePfnLock); MmDereferencePage(Page); KeReleaseQueuedSpinLock(LockQueuePfnLock, OldIrql); } else { - Entry = RemoveHeadList(&AllocationListHead); Request = CONTAINING_RECORD(Entry, MM_ALLOCATION_REQUEST, ListEntry); - KeReleaseSpinLock(&AllocationListLock, OldIrql); - if(Consumer == MC_USER) MmRemoveLRUUserPage(Page); MiZeroPhysicalPage(Page); Request->Page = Page; KeSetEvent(&Request->Event, IO_NO_INCREMENT, FALSE); @@ -130,7 +125,6 @@ } else { - KeReleaseSpinLock(&AllocationListLock, OldIrql); OldIrql = KeAcquireQueuedSpinLock(LockQueuePfnLock); MmDereferencePage(Page); KeReleaseQueuedSpinLock(LockQueuePfnLock, OldIrql); @@ -143,17 +137,44 @@ NTAPI MiTrimMemoryConsumer(ULONG Consumer) { - LONG Target; - ULONG NrFreedPages; - - Target = max(MiMinimumPagesPerRun, - MiMemoryConsumers[Consumer].PagesUsed - - MiMemoryConsumers[Consumer].PagesTarget); - - if (MiMemoryConsumers[Consumer].Trim != NULL) - { - MiMemoryConsumers[Consumer].Trim(Target, 0, &NrFreedPages); - } + LONG Target = 0; + ULONG NrFreedPages = 0; + NTSTATUS Status; + + /* Make sure we can trim this consumer */ + if (!MiMemoryConsumers[Consumer].Trim) + return; + + if (MiMemoryConsumers[Consumer].PagesUsed > MiMemoryConsumers[Consumer].PagesTarget) + { + /* Consumer page limit exceeded */ + Target = max(Target, MiMemoryConsumers[Consumer].PagesUsed - MiMemoryConsumers[Consumer].PagesTarget); + } + if (MmAvailablePages < MiMinimumAvailablePages) + { + /* Global page limit exceeded */ + Target = max(Target, MiMinimumAvailablePages - MmAvailablePages); + } + + if (Target) + { + /* Swap at least MiMinimumPagesPerRun */ + Target = max(Target, MiMinimumPagesPerRun); + + /* Now swap the pages out */ + Status = MiMemoryConsumers[Consumer].Trim(Target, 0, &NrFreedPages); + + if (!ExpInTextModeSetup) + DPRINT1("Trimming consumer %d: Freed %d pages with a target of %d pages\n", Consumer, NrFreedPages, Target); + + if (NrFreedPages == 0) + DPRINT1("Ran out of pages to swap! Complete memory exhaustion is imminent!\n"); + + if (!NT_SUCCESS(Status)) + { + KeBugCheck(MEMORY_MANAGEMENT); + } + } } NTSTATUS @@ -188,32 +209,6 @@ return STATUS_SUCCESS; } -VOID -NTAPI -MmRebalanceMemoryConsumers(VOID) -{ - LONG Target; - ULONG i; - ULONG NrFreedPages; - NTSTATUS Status; - - Target = (ULONG)(MiMinimumAvailablePages - MmAvailablePages) + MiPagesRequired; - Target = max(Target, (LONG) MiMinimumPagesPerRun); - - for (i = 0; i < MC_MAXIMUM && Target > 0; i++) - { - if (MiMemoryConsumers[i].Trim != NULL) - { - Status = MiMemoryConsumers[i].Trim(Target, 0, &NrFreedPages); - if (!NT_SUCCESS(Status)) - { - KeBugCheck(MEMORY_MANAGEMENT); - } - Target = Target - NrFreedPages; - } - } -} - static BOOLEAN MiIsBalancerThread(VOID) { @@ -221,28 +216,34 @@ (PsGetCurrentThreadId() == MiBalancerThreadId.UniqueThread); } +VOID +NTAPI +MmRebalanceMemoryConsumers(VOID) +{ + if (MiBalancerThreadHandle != NULL && + !MiIsBalancerThread()) + { + KeSetEvent(&MiBalancerEvent, IO_NO_INCREMENT, FALSE); + } +} + NTSTATUS NTAPI MmRequestPageMemoryConsumer(ULONG Consumer, BOOLEAN CanWait, PPFN_NUMBER AllocatedPage) { - ULONG OldUsed; + ULONG PagesUsed; PFN_NUMBER Page; KIRQL OldIrql; /* * Make sure we don't exceed our individual target. */ - OldUsed = InterlockedIncrementUL(&MiMemoryConsumers[Consumer].PagesUsed); - if (OldUsed >= (MiMemoryConsumers[Consumer].PagesTarget - 1) && - !MiIsBalancerThread()) - { - if (!CanWait) - { - (void)InterlockedDecrementUL(&MiMemoryConsumers[Consumer].PagesUsed); - return(STATUS_NO_MEMORY); - } - MiTrimMemoryConsumer(Consumer); + PagesUsed = InterlockedIncrementUL(&MiMemoryConsumers[Consumer].PagesUsed) + 1; + if (PagesUsed > MiMemoryConsumers[Consumer].PagesTarget && + !MiIsBalancerThread()) + { + MmRebalanceMemoryConsumers(); } /* @@ -259,19 +260,15 @@ } if (Consumer == MC_USER) MmInsertLRULastUserPage(Page); *AllocatedPage = Page; - if (MmAvailablePages <= MiMinimumAvailablePages && - MiBalancerThreadHandle != NULL && - !MiIsBalancerThread()) - { - KeSetEvent(&MiBalancerEvent, IO_NO_INCREMENT, FALSE); - } + if (MmAvailablePages < MiMinimumAvailablePages) + MmRebalanceMemoryConsumers(); return(STATUS_SUCCESS); } /* * Make sure we don't exceed global targets. */ - if (MmAvailablePages <= MiMinimumAvailablePages) + if (MmAvailablePages < MiMinimumAvailablePages) { MM_ALLOCATION_REQUEST Request; @@ -283,18 +280,10 @@ /* Insert an allocation request. */ Request.Page = 0; - KeInitializeEvent(&Request.Event, NotificationEvent, FALSE); - (void)InterlockedIncrementUL(&MiPagesRequired); - - KeAcquireSpinLock(&AllocationListLock, &OldIrql); - - if (MiBalancerThreadHandle != NULL) - { - KeSetEvent(&MiBalancerEvent, IO_NO_INCREMENT, FALSE); - } - InsertTailList(&AllocationListHead, &Request.ListEntry); - KeReleaseSpinLock(&AllocationListLock, OldIrql); + + ExInterlockedInsertTailList(&AllocationListHead, &Request.ListEntry, &AllocationListLock); + MmRebalanceMemoryConsumers(); KeWaitForSingleObject(&Request.Event, 0, @@ -310,13 +299,10 @@ if(Consumer == MC_USER) MmInsertLRULastUserPage(Page); *AllocatedPage = Page; - (void)InterlockedDecrementUL(&MiPagesRequired); - - if (MmAvailablePages <= MiMinimumAvailablePages && - MiBalancerThreadHandle != NULL && - !MiIsBalancerThread()) - { - KeSetEvent(&MiBalancerEvent, IO_NO_INCREMENT, FALSE); + + if (MmAvailablePages < MiMinimumAvailablePages) + { + MmRebalanceMemoryConsumers(); } return(STATUS_SUCCESS); @@ -334,12 +320,10 @@ } if(Consumer == MC_USER) MmInsertLRULastUserPage(Page); *AllocatedPage = Page; - - if (MmAvailablePages <= MiMinimumAvailablePages && - MiBalancerThreadHandle != NULL && - !MiIsBalancerThread()) - { - KeSetEvent(&MiBalancerEvent, IO_NO_INCREMENT, FALSE); + + if (MmAvailablePages < MiMinimumAvailablePages) + { + MmRebalanceMemoryConsumers(); } return(STATUS_SUCCESS); @@ -351,11 +335,6 @@ PVOID WaitObjects[2]; NTSTATUS Status; ULONG i; - ULONG NrFreedPages; - ULONG NrPagesUsed; - ULONG Target; - BOOLEAN ShouldRun; - WaitObjects[0] = &MiBalancerEvent; WaitObjects[1] = &MiBalancerTimer; @@ -371,55 +350,12 @@ NULL, NULL); - if (Status == STATUS_SUCCESS) - { - /* MiBalancerEvent */ - while (MmAvailablePages < MiMinimumAvailablePages + 5) - { - for (i = 0; i < MC_MAXIMUM; i++) - { - if (MiMemoryConsumers[i].Trim != NULL) - { - NrFreedPages = 0; - Status = MiMemoryConsumers[i].Trim(MiMinimumPagesPerRun, 0, &NrFreedPages); - if (!NT_SUCCESS(Status)) - { - KeBugCheck(MEMORY_MANAGEMENT); - } - } - } - } - InterlockedExchange(&MiBalancerWork, 0); - } - else if (Status == STATUS_SUCCESS + 1) - { - /* MiBalancerTimer */ - ShouldRun = MmAvailablePages < MiMinimumAvailablePages + 5 ? TRUE : FALSE; - for (i = 0; i < MC_MAXIMUM; i++) - { - if (MiMemoryConsumers[i].Trim != NULL) - { - NrPagesUsed = MiMemoryConsumers[i].PagesUsed; - if (NrPagesUsed > MiMemoryConsumers[i].PagesTarget || ShouldRun) - { - if (NrPagesUsed > MiMemoryConsumers[i].PagesTarget) - { - Target = max (NrPagesUsed - MiMemoryConsumers[i].PagesTarget, - MiMinimumPagesPerRun); - } - else - { - Target = MiMinimumPagesPerRun; - } - NrFreedPages = 0; - Status = MiMemoryConsumers[i].Trim(Target, 0, &NrFreedPages); - if (!NT_SUCCESS(Status)) - { - KeBugCheck(MEMORY_MANAGEMENT); - } - } - } - } + if (Status == STATUS_WAIT_0 || Status == STATUS_WAIT_1) + { + for (i = 0; i < MC_MAXIMUM; i++) + { + MiTrimMemoryConsumer(i); + } } else {

1 0

[rharabien] 54543: [SHLWAPI] - Add a diff file
by rharabien＠svn.reactos.org 29 Nov '11

29 Nov '11

Author: rharabien Date: Tue Nov 29 19:30:50 2011 New Revision: 54543 URL: http://svn.reactos.org/svn/reactos?rev=54543&view=rev Log: [SHLWAPI] - Add a diff file Added: trunk/reactos/dll/win32/shlwapi/shlwapi_ros.diff Added: trunk/reactos/dll/win32/shlwapi/shlwapi_ros.diff URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shlwapi/shlwapi_… ============================================================================== --- trunk/reactos/dll/win32/shlwapi/shlwapi_ros.diff (added) +++ trunk/reactos/dll/win32/shlwapi/shlwapi_ros.diff [iso-8859-1] Tue Nov 29 19:30:50 2011 @@ -1,0 +1,22 @@ +Index: path.c +=================================================================== +--- path.c (working copy) ++++ path.c (working copy) +@@ -2186,7 +2186,7 @@ + { + TRACE("(%s)\n",debugstr_a(lpszPath)); + +- if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\')) ++ if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\') && (lpszPath[2]!='?')) + return TRUE; + return FALSE; + } +@@ -2200,7 +2200,7 @@ + { + TRACE("(%s)\n",debugstr_w(lpszPath)); + +- if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\')) ++ if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\') && (lpszPath[2]!='?')) + return TRUE; + return FALSE; + }

1 0

[rharabien] 54542: [SHLWAPI] - PathIsUNC returns FALSE for paths starting with "\\?". Should be sent to wine.
by rharabien＠svn.reactos.org 29 Nov '11

29 Nov '11

Author: rharabien Date: Tue Nov 29 19:10:22 2011 New Revision: 54542 URL: http://svn.reactos.org/svn/reactos?rev=54542&view=rev Log: [SHLWAPI] - PathIsUNC returns FALSE for paths starting with "\\?". Should be sent to wine. Modified: trunk/reactos/dll/win32/shlwapi/path.c Modified: trunk/reactos/dll/win32/shlwapi/path.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shlwapi/path.c?r… ============================================================================== --- trunk/reactos/dll/win32/shlwapi/path.c [iso-8859-1] (original) +++ trunk/reactos/dll/win32/shlwapi/path.c [iso-8859-1] Tue Nov 29 19:10:22 2011 @@ -2186,7 +2186,7 @@ { TRACE("(%s)\n",debugstr_a(lpszPath)); - if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\')) + if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\') && (lpszPath[2]!='?')) return TRUE; return FALSE; } @@ -2200,7 +2200,7 @@ { TRACE("(%s)\n",debugstr_w(lpszPath)); - if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\')) + if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\') && (lpszPath[2]!='?')) return TRUE; return FALSE; }

1 0

[cgutman] 54541: [NTOSKRNL] - Call MmReleasePageMemoryConsumer with the consumer that was actually allocated (not always MC_CACHE)
by cgutman＠svn.reactos.org 29 Nov '11

29 Nov '11

Author: cgutman Date: Tue Nov 29 19:08:19 2011 New Revision: 54541 URL: http://svn.reactos.org/svn/reactos?rev=54541&view=rev Log: [NTOSKRNL] - Call MmReleasePageMemoryConsumer with the consumer that was actually allocated (not always MC_CACHE) Modified: trunk/reactos/ntoskrnl/cache/section/reqtools.c Modified: trunk/reactos/ntoskrnl/cache/section/reqtools.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cache/section/req… ============================================================================== --- trunk/reactos/ntoskrnl/cache/section/reqtools.c [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/cache/section/reqtools.c [iso-8859-1] Tue Nov 29 19:08:19 2011 @@ -69,7 +69,7 @@ { while (i > 0) { - MmReleasePageMemoryConsumer(MC_CACHE, Required->Page[i-1]); + MmReleasePageMemoryConsumer(Required->Consumer, Required->Page[i-1]); i--; } return Status; @@ -127,7 +127,7 @@ { DPRINT1("STATUS_NO_MEMORY: %x\n", Status); MmUnlockAddressSpace(MmGetKernelAddressSpace()); - MmReleasePageMemoryConsumer(MC_CACHE, *Page); + MmReleasePageMemoryConsumer(RequiredResources->Consumer, *Page); return STATUS_NO_MEMORY; } @@ -136,7 +136,7 @@ { MmFreeMemoryArea(MmGetKernelAddressSpace(), TmpArea, NULL, NULL); MmUnlockAddressSpace(MmGetKernelAddressSpace()); - MmReleasePageMemoryConsumer(MC_CACHE, *Page); + MmReleasePageMemoryConsumer(RequiredResources->Consumer, *Page); DPRINT1("Status: %x\n", Status); return Status; } @@ -161,7 +161,7 @@ if (!NT_SUCCESS(Status)) { - MmReleasePageMemoryConsumer(MC_CACHE, *Page); + MmReleasePageMemoryConsumer(RequiredResources->Consumer, *Page); DPRINT("Status: %x\n", Status); return Status; }

1 0

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs