Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
perf.c
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 12k
Category:

Windows Kernel

Development Platform:

Visual C++

perf.c：Code Content
  1. /*++
  3. Microsoft Confidential
  4. Copyright (c) 1992-1997  Microsoft Corporation
  5. All rights reserved
  7. Module Name:
  9.     perf.c
  11. Abstract:
  13.     Implements the Performance dialog of the System Control Panel Applet
  15. Author:
  17.     Eric Flo (ericflo) 19-Jun-1995
  19. Revision History:
  21.     15-Oct-1997 scotthal
  22.         Complete overhaul
  24. --*/
  25. #include <sysdm.h>
  26. #include <help.h>
  28. #define PROCESS_PRIORITY_SEPARATION_MASK    0x00000003
  29. #define PROCESS_PRIORITY_SEPARATION_MAX     0x00000002
  30. #define PROCESS_PRIORITY_SEPARATION_MIN     0x00000000
  32. #define PROCESS_QUANTUM_VARIABLE_MASK       0x0000000c
  33. #define PROCESS_QUANTUM_VARIABLE_DEF        0x00000000
  34. #define PROCESS_QUANTUM_VARIABLE_VALUE      0x00000004
  35. #define PROCESS_QUANTUM_FIXED_VALUE         0x00000008
  36. #define PROCESS_QUANTUM_LONG_MASK           0x00000030
  37. #define PROCESS_QUANTUM_LONG_DEF            0x00000000
  38. #define PROCESS_QUANTUM_LONG_VALUE          0x00000010
  39. #define PROCESS_QUANTUM_SHORT_VALUE         0x00000020
  41. #define X86PROG_FILENAME TEXT("x86prog.exe")
  42. //
  43. // Globals
  44. //
  46. HKEY  m_hKeyPerf = NULL;
  47. TCHAR m_szRegPriKey[] = TEXT( "SYSTEM\CurrentControlSet\Control\PriorityControl" );
  48. TCHAR m_szRegPriority[] = TEXT( "Win32PrioritySeparation" );
  51. //
  52. // Help ID's
  53. //
  55. DWORD aPerformanceHelpIds[] = {
  56.     IDC_STATIC,                  NO_HELP,
  57.     IDC_PERF_VM_ALLOCD,          (IDH_PERF + 1),
  58.     IDC_PERF_VM_ALLOCD_LABEL,    (IDH_PERF + 1),
  59.     IDC_PERF_GROUP,              NO_HELP,
  60.     IDC_PERF_TEXT,               (IDH_PERF + 3),
  61.     IDC_PERF_WORKSTATION,        (IDH_PERF + 4),
  62.     IDC_PERF_SERVER,             (IDH_PERF + 5),
  63.     IDC_PERF_VM_GROUP,           NO_HELP,
  64.     IDC_PERF_CHANGE,             (IDH_PERF + 7),
  65.     IDC_PERF_X86PROG_GROUP,      NO_HELP,
  66.     IDC_PERF_X86PROG_ICON,       (IDH_PERF + 8),
  67.     IDC_PERF_X86PROG_TEXT,       (IDH_PERF + 8),
  68.     IDC_PERF_X86PROG_BUTTON,     (IDH_PERF + 9),
  69.     0, 0
  70. };
  73. INT_PTR
  74. APIENTRY 
  75. PerformanceDlgProc(
  76.     IN HWND hDlg, 
  77.     IN UINT uMsg, 
  78.     IN WPARAM wParam, 
  79.     IN LPARAM lParam
  80. )
  81. /*++
  83. Routine Description:
  85.     Handles messages sent to Performance dialog
  87. Arguments:
  89.     hDlg -
  90.         Supplies window handle
  92.     uMsg -
  93.         Supplies message being sent
  95.     wParam -
  96.         Supplies message parameter
  98.     lParam -
  99.         Supplies message parameter
  101. Return Value:
  103.     TRUE if message was handled
  104.     FALSE if message was unhandled
  106. --*/
  107. {
  108.     static int    iNewChoice = 0;
  109.     LONG   RegRes;
  110.     DWORD  Type, Value, Length;
  111.     static int InitPos;
  112.     static int InitRegVal;
  113.     static int NewRegVal;
  114.     static BOOL fVMInited = FALSE;
  115.     static BOOL fTempPfWarningShown = FALSE;
  116.     BOOL fTempPf;
  117.     BOOL fWorkstationProduct = IsWorkstationProduct();
  118.     BOOL fAdministrator = IsUserAdmin();
  119.     BOOL fVariableQuanta = FALSE;
  120.     BOOL fShortQuanta = FALSE;
  122.     switch (uMsg)
  123.     {
  124.     case WM_INITDIALOG:
  125.         InitPos = 0;
  126.         InitRegVal = 0;
  128.         //
  129.         // initialize from the registry
  130.         //
  132.         RegRes = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
  133.                                m_szRegPriKey,
  134.                                0,
  135.                                fAdministrator ? KEY_QUERY_VALUE | KEY_SET_VALUE : KEY_QUERY_VALUE,
  136.                                &m_hKeyPerf );
  138.         if( RegRes == ERROR_SUCCESS ) {
  139.             Length = sizeof( Value );
  140.             RegRes = RegQueryValueEx( m_hKeyPerf,
  141.                                       m_szRegPriority,
  142.                                       NULL,
  143.                                       &Type,
  144.                                       (LPBYTE) &Value,
  145.                                       &Length );
  147.             if( RegRes == ERROR_SUCCESS ) {
  148.                 InitRegVal = Value;
  149.                 InitPos = InitRegVal & PROCESS_PRIORITY_SEPARATION_MASK;
  150.                 if ( InitPos > PROCESS_PRIORITY_SEPARATION_MAX ) {
  151.                     InitPos = PROCESS_PRIORITY_SEPARATION_MAX;
  152.                     }
  154.             }
  155.         } 
  156.         
  157.         if ((RegRes != ERROR_SUCCESS) || (!fAdministrator))  {
  158.             EnableWindow(GetDlgItem(hDlg, IDC_PERF_WORKSTATION), FALSE);
  159.             EnableWindow(GetDlgItem(hDlg, IDC_PERF_SERVER), FALSE);
  160.         }
  162.         NewRegVal = InitRegVal;
  164.         //
  165.         // determine if we are using fixed or variable quantums
  166.         //
  167.         switch ( InitRegVal & PROCESS_QUANTUM_VARIABLE_MASK ) {
  168.             case PROCESS_QUANTUM_VARIABLE_VALUE:
  169.                 fVariableQuanta = TRUE;
  170.                 break;
  172.             case PROCESS_QUANTUM_FIXED_VALUE:
  173.                 fVariableQuanta = FALSE;
  174.                 break;
  176.             case PROCESS_QUANTUM_VARIABLE_DEF:
  177.             default:
  178.                 if ( fWorkstationProduct ) {
  179.                     fVariableQuanta = TRUE;
  180.                     }
  181.                 else {
  182.                     fVariableQuanta = FALSE;
  183.                     }
  184.                 break;
  185.             }
  187.         //
  188.         // determine if we are using long or short
  189.         //
  190.         switch ( InitRegVal & PROCESS_QUANTUM_LONG_MASK ) {
  191.             case PROCESS_QUANTUM_LONG_VALUE:
  192.                 fShortQuanta = FALSE;
  193.                 break;
  195.             case PROCESS_QUANTUM_SHORT_VALUE:
  196.                 fShortQuanta = TRUE;
  197.                 break;
  199.             case PROCESS_QUANTUM_LONG_DEF:
  200.             default:
  201.                 if ( fWorkstationProduct ) {
  202.                     fShortQuanta = TRUE;
  203.                     }
  204.                 else {
  205.                     fShortQuanta = FALSE;
  206.                     }
  207.                 break;
  208.             }
  209.         
  210.         //
  211.         // Short, Variable Quanta == Workstation-like interactive response
  212.         // Long, Fixed Quanta == Server-like interactive response
  213.         //
  214.         if (fVariableQuanta && fShortQuanta) {
  215.             iNewChoice = PROCESS_PRIORITY_SEPARATION_MAX;
  217.             CheckRadioButton(
  218.                 hDlg,
  219.                 IDC_PERF_WORKSTATION,
  220.                 IDC_PERF_SERVER,
  221.                 IDC_PERF_WORKSTATION
  222.             );
  223.         } // if
  224.         else {
  225.             iNewChoice = PROCESS_PRIORITY_SEPARATION_MIN;
  227.             CheckRadioButton(
  228.                 hDlg,
  229.                 IDC_PERF_WORKSTATION,
  230.                 IDC_PERF_SERVER,
  231.                 IDC_PERF_SERVER
  232.             );
  233.         } // else
  235.         //
  236.         // Init the virtual memory part
  237.         //
  238.         if (VirtualInitStructures()) {
  239.             fVMInited = TRUE;
  240.             SetDlgItemMB( hDlg, IDC_PERF_VM_ALLOCD, VirtualMemComputeAllocated(hDlg, &fTempPf) );
  241.             //
  242.             // If the system created a temp pagefile, warn the user that
  243.             // the total pagefile size may appear a bit large, but only
  244.             // do so once per System Applet invokation.
  245.             //
  246.             if (fTempPf && !fTempPfWarningShown) {
  247.                 MsgBoxParam(
  248.                     hDlg,
  249.                     IDS_TEMP_PAGEFILE_WARN,
  250.                     INITS + 1,
  251.                     MB_ICONINFORMATION | MB_OK
  252.                 );
  253.                 fTempPfWarningShown = TRUE;
  254.             } // if (fTempPf...
  255.         }
  256.         break;
  258.     case WM_DESTROY:
  259.         //
  260.         // If the dialog box is going away, then close the
  261.         // registry key.
  262.         //
  265.         if (m_hKeyPerf) {
  266.             RegCloseKey( m_hKeyPerf );
  267.             m_hKeyPerf = NULL;
  268.         }
  270.         if (fVMInited) {
  271.             VirtualFreeStructures();
  272.         }
  273.         break;
  275.     case WM_COMMAND: {
  276.         LRESULT lres;
  278.         switch (LOWORD(wParam)) {
  279.             case IDOK:
  280.                 // 
  281.                 // Save new time quantum stuff, if it has changed
  282.                 //
  283.                 NewRegVal &= ~PROCESS_PRIORITY_SEPARATION_MASK;
  284.                 NewRegVal |= iNewChoice;
  285.     
  286.                 if ( NewRegVal != InitRegVal ) {
  287.     
  288.                     Value = NewRegVal;
  289.     
  290.                     if( m_hKeyPerf )
  291.                     {
  292.                         Type = REG_DWORD;
  293.                         Length = sizeof( Value );
  294.                         RegSetValueEx( m_hKeyPerf,
  295.                                        m_szRegPriority,
  296.                                        0,
  297.                                        REG_DWORD,
  298.                                        (LPBYTE) &Value,
  299.                                        Length );
  300.                         InitRegVal = Value;
  301.     
  302.                         //
  303.                         // Kernel monitors this part of the 
  304.                         // registry, so don't tell user he has to reboot
  305.                         //
  306.                     }
  307.                 }
  308.     
  309.                 EndDialog(hDlg, 0);
  310.                 break;
  312.             case IDCANCEL:
  313.                 EndDialog(hDlg, 0);
  314.                 break;
  316.             case IDC_PERF_CHANGE: {
  317.                 lres = DialogBox(
  318.                     hInstance, 
  319.                     MAKEINTRESOURCE(DLG_VIRTUALMEM),
  320.                     hDlg, 
  321.                     VirtualMemDlg
  322.                 );
  324.                 if (fVMInited) {
  325.                     SetDlgItemMB( 
  326.                         hDlg, 
  327.                         IDC_PERF_VM_ALLOCD, 
  328.                         VirtualMemComputeAllocated(hDlg, NULL) 
  329.                     );
  330.                 }
  331.                 if ((lres != RET_NO_CHANGE) && (lres != RET_CHANGE_NO_REBOOT)) {
  332.                     MsgBoxParam(
  333.                         hDlg,
  334.                         SYSTEM + 42,
  335.                         INITS + 1,
  336.                         MB_OK | MB_ICONINFORMATION
  337.                     );
  339.                     g_fRebootRequired = TRUE;
  340.                 }
  341.                 }
  342.                 break;
  343.             
  344.             case IDC_PERF_WORKSTATION:
  345.                 if (BN_CLICKED == HIWORD(wParam)) {
  346.                     //
  347.                     // Workstations have maximum foreground boost
  348.                     //
  349.                     iNewChoice = PROCESS_PRIORITY_SEPARATION_MAX;
  351.                     //
  352.                     // Workstations have variable, short quanta
  353.                     NewRegVal &= ~PROCESS_QUANTUM_VARIABLE_MASK;
  354.                     NewRegVal |= PROCESS_QUANTUM_VARIABLE_VALUE;
  355.                     NewRegVal &= ~PROCESS_QUANTUM_LONG_MASK;
  356.                     NewRegVal |= PROCESS_QUANTUM_SHORT_VALUE;
  357.                 } // if    
  358.                 break;
  360.             case IDC_PERF_SERVER:
  361.                 if (BN_CLICKED == HIWORD(wParam)) {
  362.                     //
  363.                     // Servers have minimum foreground boost
  364.                     //
  365.                     iNewChoice = PROCESS_PRIORITY_SEPARATION_MIN;
  367.                     //
  368.                     // Servers have fixed, long quanta
  369.                     //
  370.                     NewRegVal &= ~PROCESS_QUANTUM_VARIABLE_MASK;
  371.                     NewRegVal |= PROCESS_QUANTUM_FIXED_VALUE;
  372.                     NewRegVal &= ~PROCESS_QUANTUM_LONG_MASK;
  373.                     NewRegVal |= PROCESS_QUANTUM_LONG_VALUE;
  374.                 } // if
  375.                 break;
  377.             case IDC_PERF_X86PROG_BUTTON: 
  378.                 if (BN_CLICKED == HIWORD(wParam)) {
  379.                     SHELLEXECUTEINFO sei;
  381.                     memset(&sei, 0, sizeof(SHELLEXECUTEINFO));
  383.                     sei.cbSize = sizeof(SHELLEXECUTEINFO);
  384.                     sei.hwnd = hDlg;
  385.                     sei.lpVerb = TEXT("Open");
  386.                     sei.lpFile = X86PROG_FILENAME;
  387.                     sei.nShow = SW_SHOW;
  389.                     ShellExecuteEx(&sei);
  390.                 } // if
  391.                 break;
  393.             default: {
  394.                 break;
  395.                 }
  396.             }
  397.         }
  398.         break;
  400.     case WM_HELP:      // F1
  401.         WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP,
  402.         (DWORD_PTR) (LPSTR) aPerformanceHelpIds);
  403.         break;
  405.     case WM_CONTEXTMENU:      // right mouse click
  406.         WinHelp((HWND) wParam, HELP_FILE, HELP_CONTEXTMENU,
  407.         (DWORD_PTR) (LPSTR) aPerformanceHelpIds);
  408.         break;
  410.     default:
  411.         return FALSE;
  412.     }
  414.     return TRUE;
  415. }