Cum se elimină informațiile de registry pentru dispozitivele care nu vor fi utilizate din nou

INTRODUCERE

Când un dispozitiv de stocare este conectat la Windows, chiar dacă numai pentru scurt timp, windows creează informațiile de registry pentru dispozitiv. În timp, registry poate conține mai multe intrări pentru dispozitivele care nu vor fi utilizate din nou. Acest articol descrie cum se elimină informațiile de registry de sistem.

Este responsabilitatea de software care stabilește conexiunea între dispozitiv de stocare și Windows să curățați în mod corespunzător informațiile pentru dispozitiv. Acest proces este necesar, deoarece Windows nu știe că atunci când un dispozitiv de stocare se elimină definitiv sau temporar. Dar software-ul care stabilește conexiunea de obicei cunoașteți. De exemplu, dacă software-ul de copiere de rezervă este montare unitate logică numere (LUNs) pentru scopuri de copiere de rezervă și apoi face LUNs, ar fi responsabilitatea de software copie de rezervă pentru a șterge informațiile de luni de la Windows, deoarece același dispozitiv de stocare nu va mai fi utilizat din nou de Windows.

Mai multe informații

Când un nou dispozitiv este conectat la un computer Windows înregistrări informațiile despre dispozitiv în registry de sistem. Pentru majoritatea dispozitivelor, această procedură nu reprezintă o problemă. Cu toate acestea, după un dispozitiv de stocare este prezentat de o luni printr-un canal de fibre sau prin iSCSI, dispozitivul poate să nu fi întâlnite din nou de computer. De exemplu, un dispozitiv poate fi identificat un număr serial sau pagini SCSI 0x80 și 0x83.

În această situație, registry poate conține intrări pentru dispozitivele care nu pot să apară din nou. Nu numai face aceste intrări ocupa spațiu în registry, aceste intrări în cele din urmă poate cauza probleme la operațional. De exemplu, deoarece indexurile pentru funcționalitatea Plug and Play utilizează patru cifre zecimal valori, o problemă poate apărea când 10,001 dispozitivul este conectat.

Pentru a rezolva această limitare în funcționalitatea Plug and Play, poate doriți să eliminați informațiile despre dispozitiv din registry atunci când dispozitivul este o unitate de hard disk care nu mai este prezent. Puteți face acest lucru utilizând utilitarul .

Cum se construiți pentru Windows Server 2003, Windows Server 2008, Windows Server 2008 R2 și Visual Studio 2005

Pentru a curăța registry pentru clasa de disc GUID_DEVCLASS_DISKDRIVE GUID și pentru GUID_DEVCLASS_VOLUME disc clasă GUID, urmați acești pași.

Notă Vă recomandăm să utilizați utilitarul pentru această activitate. Pașii următori și exemplu de cod în Pasul 7 sunt furnizate numai în scop informativ.

  1. Apelați funcția SetupDiGetClassDevs pentru a obține informații pentru clasa care este asociată cu GUID-ul.

  2. Apelați funcția SetupDiEnumDeviceInfo pentru a obține informații de instanță pentru fiecare dispozitiv din clasa curentă.

  3. Apelați funcția CM_Get_DevNode_Status pentru a vedea dacă informațiile curente de dispozitiv reprezintă un dispozitiv absente. Determinați dacă funcția starea este egală cu CR_NO_SUCH_DEVINST sau la CR_NO_SUCH_VALUE.

  4. Opțional, pentru un dispozitiv absente, apelați funcția CM_Get_Device_ID pentru a obține instance ID-ul dispozitivului și să afișeze ID-ul înainte de a elimina informațiile.

  5. Pentru dispozitivul absente, utilizați informațiile de clasă obținută în pasul 1 și informațiile instanță obținută în pasul 2. Apelați funcția SetupDiCallClassInstaller (DIF_REMOVE,...) pentru a elimina informațiile de registry.

  6. Când toate dispozitivele din clasa curente au fost tratate, apelați funcția SetupDiDestroyDeviceInfoList să curățați.

Notă În unele scenarii, trebuie să curățați registry nu numai pentru GUID_DEVCLASS_DISKDRIVE și GUID_DEVCLASS_VOLUME de disc clasă GUID-urile, dar, de asemenea, pentru GUID_DEVCLASS_SCSIADAPTER și GUID_DEVCLASS_VOLUMESNAPSHOT class GUID-urile de disc. Pentru aceasta, trebuie să modificați definiția DiskClassesToClean în următorul exemplu de cod.

Următoarele Win32 console application este un exemplu de o aplicație care golește registry. Pentru a utiliza această aplicație, urmați acești pași.

Microsoft furnizează exemple de programare scop ilustrativ, fără nicio garanţie explicită sau implicită. Aceasta include, dar nu se limitează la, garanţiile implicite de vandabilitate sau de potrivire pentru un anumit scop. Acest articol presupune că sunteţi familiarizat cu limbajul de programare care este prezentat şi cu instrumentele utilizate pentru a crea şi a depana proceduri. Specialiștii în asistență Microsoft pot ajuta la explicarea funcționalității unei anumite proceduri. Cu toate acestea, nu vor modifica aceste exemple pentru a furniza funcționalitate suplimentară construi proceduri pentru a răspunde cerințelor dvs. specifice.

  1. În Microsoft Visual Studio 2005, nou , faceți clic pe meniul fișier și apoi faceți clic pe proiect.

  2. Extindeți Visual C++, și apoi faceți clic pe Win32.

  3. Faceți clic pe Win32 Console Application, tastați Cleanup în caseta text nume și apoi faceți clic pe OK.

  4. Faceți clic pe Terminare în caseta de dialog Win32 Application Wizard .

  5. În Explorer soluție, extindeți Fișierele sursă, faceți clic dreapta pe Cleanup.cppși apoi faceți clic pe Vizualizare cod.

  6. Găsiți codul următor:

    int _tmain(int argc, _TCHAR* argv[])
    {
    return 0;
    }
    
  7. Înlocuiți codul pe care l-ați găsit la Pasul 6 cu următorul cod.

    /**************************************************************************************************/     
    /*                                                                                                */     
    /* Copyright (c) 2007 Microsoft Corporation.  All Rights Reserved                                 */     
    /*                                                                                                */     
    /**************************************************************************************************/     
    
    #pragma warning( disable : 4201 ) // nonstandard extension used : nameless strut/union
    
    #include <windows.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <stddef.h>
    #include <tchar.h>
    #include <setupapi.h>
    #include <cfgmgr32.h>
    #include <initguid.h>
    #include <devguid.h>
    
    #define SIZECHARS(x) (sizeof((x))/sizeof(TCHAR))
    #define arraysize(p) (sizeof(p)/sizeof((p)[0]))
    
    CONST GUID *DiskClassesToClean[2] = {
        &GUID_DEVCLASS_DISKDRIVE,
        &GUID_DEVCLASS_VOLUME
    };
    
    /**************************************************************************************************/
    /*                                                                                                */
    /* The user must be member of Administrator group and must have backup and restore permissions         */
    /* (SE_BACKUP_NAME and SE_RESTORE_NAME). No check for these is performed in this example.              */
    /*                                                                                                */
    /**************************************************************************************************/
    int
    __cdecl
    main(
         IN int    ArgC,
         IN char * pArgV[]
        )
    {
        HDEVINFO DeviceInfoSet;
        SP_DEVINFO_DATA DeviceInfoData;
        ULONG DevicesRemoved = 0,
              i,
              MemberIndex,
              Status, 
              Problem,
              ulClassesToCleanIdx;
        BOOL bDoRemove = TRUE;
        CONFIGRET cr;
        TCHAR DeviceInstanceId[MAX_DEVICE_ID_LEN];
        OSVERSIONINFO osvi;
        const GUID ** ClassesToClean;
    
        //
        // Parse parameters.
        //
        for (i = 1; i < (ULONG)ArgC; i++) {
            //
            // Check for help.
            //
            if ( (lstrcmpi(pArgV[i], TEXT("-?")) == 0) ||
                    (lstrcmpi(pArgV[i], TEXT("/?")) == 0) ){
    
                printf("\nCleanUp will remove phantom storage device nodes from this machine.\n\n");
                printf("Usage:  CleanUp \n");
                printf("\twhere /n displays but does not remove the phantom devnodes.\n");
                printf("\nBackup and Restore privileges are required to run this utility.\n");
                return 0;
            }
    
            //
            // Check for -n, which means just list the devices that we would remove.
            //
            if ( (lstrcmpi(pArgV[i], TEXT("-n")) == 0) ||
                 (lstrcmpi(pArgV[i], TEXT("/n")) == 0) ) {
                bDoRemove = FALSE;
            }
        }
    
        //
        // Run only on Windows XP/2003 (version 5.1) or later.
        //
    
        ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
        osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    
        if (!GetVersionEx(&osvi)) {
            printf("CleanUp:  Unable to verify Windows version, exiting...\n");
            return -1;
        }
    
        if ((osvi.dwMajorVersion == 5) &&
            ((osvi.dwMinorVersion == 1) || (osvi.dwMinorVersion == 2))) {
        }
        else if (osvi.dwMajorVersion>=6) {
        }
        else
        {
            printf("CleanUp:  This utility is  designed to run on Windows XP/2003 and later\n");
            return -1;
        }
    
        ClassesToClean = DiskClassesToClean;
        ulClassesToCleanIdx = arraysize(DiskClassesToClean);
    
        for (i=0; (i<ulClassesToCleanIdx) && (bDoRemove); i++) {
    
            DeviceInfoSet = SetupDiGetClassDevs(ClassesToClean[i],
                                                NULL,
                                                NULL,
                                                0
                                                );
    
            if (INVALID_HANDLE_VALUE!=DeviceInfoSet) {
    
                DeviceInfoData.cbSize = sizeof(DeviceInfoData);
                MemberIndex = 0;
    
                while (SetupDiEnumDeviceInfo(DeviceInfoSet,
                                             MemberIndex++,
                                             &DeviceInfoData
                                             )) {
    
                    //
                    // Determine whether this device is a phantom.
                    //
                    cr = CM_Get_DevNode_Status(&Status,
                                               &Problem,
                                               DeviceInfoData.DevInst,
                                               0
                                               );
    
                    if ((cr == CR_NO_SUCH_DEVINST) ||
                        (cr == CR_NO_SUCH_VALUE)) {
                        //
                        // This is a phantom. Now get the DeviceInstanceId so we
                        // can display this as output, then delete the phantom if requested.
                        //
                        if (CM_Get_Device_ID(DeviceInfoData.DevInst,
                                             DeviceInstanceId,
                                             SIZECHARS(DeviceInstanceId),
                                             0) == CR_SUCCESS) {
    
                            if (bDoRemove) {
                                printf("DevNodePhantomCleaner:  %s will be removed.\n",
                                       DeviceInstanceId);
    
                                //
                                // Call DIF_REMOVE to remove the device's hardware
                                // and software registry keys.
                                //
                                if (SetupDiCallClassInstaller(DIF_REMOVE,
                                                              DeviceInfoSet,
                                                              &DeviceInfoData
                                                              )) {
                                    DevicesRemoved++;
                                } else {
                                    printf("CleanUp:  Error 0x%X removing phantom\n",
                                           GetLastError);
                                }
                            } else {
                                printf("CleanUp:  %s would have been removed.\n",
                                       DeviceInstanceId);
                            }
                        }
                    }
                }
    
                SetupDiDestroyDeviceInfoList(DeviceInfoSet);
            }
        }
    
        return DevicesRemoved;
    }
  8. Faceți clic pe meniul de depanare și apoi faceți clic pe Start depanare.

Cum se construiți pentru Windows Server 2012 şi Visual Studio 2012

Pentru a construi pentru Windows Server 2012 și Microsoft Visual Studio 2012, urmați acești pași.

Notă Vă recomandăm să utilizați utilitarul pentru această activitate. Pașii următori și exemplu de cod în Pasul 7 sunt furnizate numai în scop informativ.

  1. Microsoft Visual Studio 2012, nou , faceți clic pe meniul fișier și apoi faceți clic pe proiect.

  2. În caseta de dialog New Project , tastați Cleanup în câmpul nume și apoi faceți dublu clic pe Win32 Project.

  3. În Expertul de aplicație Win32, faceți clic pe Următorul.

  4. Sub tipul aplicației, faceți clic pentru a selecta Console Applicationși apoi faceți clic pe Terminare.

  5. În Explorer soluție, extindeți Fișierele sursă, faceți clic dreapta pe Cleanup.cppși apoi faceți clic pe Vizualizare cod.

  6. Găsiți codul următor:

    int _tmain(int argc, _TCHAR* argv[])
    {
    return 0;
    }
    
  7. Înlocuiți codul pe care l-ați găsit la Pasul 6 cu următorul cod.

    //DevPhantomClnr.cpp : Defines the entry point for the console application.
    // 
     
    #include "stdafx.h"
    
    /**************************************************************************************************/     
    /*                                                                                                */     
    /* Copyright (c) 2007 Microsoft Corporation.  All Rights Reserved                                 */     
    /*                                                                                                */     
    /**************************************************************************************************/     
    
    #pragma warning( disable : 4201 ) // nonstandard extension used : nameless strut/union
    
    #include <windows.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <stddef.h>
    #include <tchar.h>
    #include <setupapi.h>
    #include <cfgmgr32.h>
    #include <initguid.h>
    #include <devguid.h>
    
    #define SIZECHARS(x) (sizeof((x))/sizeof(TCHAR))
    #define arraysize(p) (sizeof(p)/sizeof((p)[0]))
    
    CONST GUID *DiskClassesToClean[2] = {
        &GUID_DEVCLASS_DISKDRIVE,
        &GUID_DEVCLASS_VOLUME
    };
    
    /**************************************************************************************************/
    /*                                                                                                */
    /* The user must be member of Administrator group and must have backup and restore permissions         */
    /* (SE_BACKUP_NAME and SE_RESTORE_NAME). No check for these is performed in this example.              */
    /*                                                                                                */
    /**************************************************************************************************/
    int
    __cdecl
    main(
         IN int    ArgC,
         IN LPCWSTR pArgV[]
        )
    {
        HDEVINFO DeviceInfoSet;
        SP_DEVINFO_DATA DeviceInfoData;
        ULONG DevicesRemoved = 0,
              i,
              MemberIndex,
              Status, 
              Problem,
              ulClassesToCleanIdx;
        BOOL bDoRemove = TRUE;
        CONFIGRET cr;
        TCHAR DeviceInstanceId[MAX_DEVICE_ID_LEN];
        OSVERSIONINFO osvi;
        const GUID ** ClassesToClean;
    
        //
        // Parse parameters.
        //
        for (i = 1; i < (ULONG)ArgC; i++) {
            //
            // Check for help.
            //
            if ( (lstrcmpi(pArgV[i], L"-?") == 0) ||
                    (lstrcmpi(pArgV[i], L"/?") == 0) ){
    
                printf("\nDevNodePhantomCleaner will remove phantom storage device nodes from this machine.\n\n");
                printf("Usage:  nDevNodePhantomCleaner \n");
                printf("\tWhere /n displays but does not remove the phantom devnodes.\n");
                printf("\nBackup and Restore privileges are required to run this utility.\n");
                return 0;
            }
    
            //
            // Check for -n, which means just list the devices that we would remove.
            //
            if ( (lstrcmpi(pArgV[i], L"-n") == 0) ||
                 (lstrcmpi(pArgV[i], L"/n") == 0) ) {
                bDoRemove = FALSE;
            }
        }
    
        //
        // Run only on Windows XP/2003 (version 5.1) or later.
        //
    
        ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
        osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    
        if (!GetVersionEx(&osvi)) {
            printf("DevNodePhantomCleaner:  Unable to verify Windows version, exiting...\n");
            return -1;
        }
    
        if ((osvi.dwMajorVersion == 5) &&
            ((osvi.dwMinorVersion == 1) || (osvi.dwMinorVersion == 2))) {
        
        // 5.1 || 5.2
    
        }
    
        else if (osvi.dwMajorVersion>=6) {
        
        //Nothing special on 6.x
    
        }
    
        else
        {
            printf("DevNodePhantomCleaner:  This utility is  designed to run on Windows XP/2003 and later\n");
            return -1;
        }
    
        ClassesToClean = DiskClassesToClean;
        ulClassesToCleanIdx = arraysize(DiskClassesToClean);
    
        for (i=0; (i<ulClassesToCleanIdx) && (bDoRemove); i++) {
    
            DeviceInfoSet = SetupDiGetClassDevs(ClassesToClean[i],
                                                NULL,
                                                NULL,
                                                0
                                                );
    
            if (INVALID_HANDLE_VALUE!=DeviceInfoSet) {
    
                DeviceInfoData.cbSize = sizeof(DeviceInfoData);
                MemberIndex = 0;
    
                while (SetupDiEnumDeviceInfo(DeviceInfoSet,
                                             MemberIndex++,
                                             &DeviceInfoData
                                             )) {
    
                    //
                    // Determine whether this device is a phantom.
                    //
                    cr = CM_Get_DevNode_Status(&Status,
                                               &Problem,
                                               DeviceInfoData.DevInst,
                                               0
                                               );
    
                    if ((cr == CR_NO_SUCH_DEVINST) ||
                        (cr == CR_NO_SUCH_VALUE)) {
                        //
                        // This is a phantom. Now get the DeviceInstanceId so we
                        // can display this as output, then delete the phantom if requested.
                        //
                        if (CM_Get_Device_ID(DeviceInfoData.DevInst,
                                             DeviceInstanceId,
                                             SIZECHARS(DeviceInstanceId),
                                             0) == CR_SUCCESS) {
    
                            if (bDoRemove) {
                                printf("DevNodePhantomCleaner:  %ws will be removed.\n",
                                       DeviceInstanceId);
    
                                //
                                // Call DIF_REMOVE to remove the device's hardware
                                // and software registry keys.
                                //
                                if (SetupDiCallClassInstaller(DIF_REMOVE,
                                                              DeviceInfoSet,
                                                              &DeviceInfoData
                                                              )) {
                                    DevicesRemoved++;
                                } else {
                                    printf("DevNodePhantomCleaner:  Error 0x%x removing phantom\n",
                                           GetLastError());
                                }
                            } else {
                                printf("DevNodePhantomCleaner:  %ws would have been removed.\n",
                                       DeviceInstanceId);
                            }
                        }
                    }
                }
    
                SetupDiDestroyDeviceInfoList(DeviceInfoSet);
            }
        }
    
        return DevicesRemoved;
    }
  8. În soluții Explorer, faceți clic dreapta pe Cleanup, și apoi faceți clic pe Proprietăți.

  9. Extindeți Proprietăți Configuration, extindeți Linkerși apoi faceți clic pe intrare.

  10. Selectați Dependențele suplimentare, faceți clic pe săgeata în jos și apoi selectați Editare.

  11. Suplimentare dependențele caseta de dialog, tastați setupapi.lib şi cfgmgr32.lib.

  12. Faceți clic pe OK de două ori.

  13. Compilare proiectul.

Aveți nevoie de ajutor suplimentar?

Extindeți-vă competențele
Explorați instruirea
Fiți primul care obține noile caracteristici
Alăturați-vă la Microsoft Insider

V-a fost de ajutor această informație?

Vă mulțumim pentru feedback!

Vă mulțumim pentru feedback! Se pare că ar fi util să luați legătura cu unul dintre agenții noștri de asistență Office.

×