Usare lo strumento Sqldumper.exe per generare un file di dump in SQL Server

  • Articolo

Questo articolo fornisce linee guida generali per lo strumento Sqldumper.exe incluso in SQL Server. Questo strumento viene usato per generare diversi tipi di file di dump.

Versione originale del prodotto: SQL Server 2019, SQL Server 2017, SQL Server 2016, SQL Server 2014, SQL Server 2012, SQL Server 2008, SQL Server 2005
Numero KB originale: 917825

Riepilogo

Lo strumento Sqldumper.exe è incluso in Microsoft SQL Server. Genera file dump di memoria di SQL Server e processi correlati per il debug. Questo articolo descrive come usare Sqldumper.exe per generare un file di dump per la segnalazione degli errori o le attività di debug di Watson.

L'articolo descrive anche altri due metodi per generare file di dump:

  • Lo script di PowerShell collegato automatizza SQLDumper.exe opzioni della riga di comando.
  • Il comando Transact-SQL (T-SQL) DBCC STACKDUMP può essere usato per generare un file di dump in SQL Server.

Come eseguire Sqldumper.exe manualmente

Eseguire lo strumento Sqldumper.exe nel contesto della cartella in cui SQL Server installato in origine.

Per impostazione predefinita, il percorso di installazione di Sqldumper.exe è <SQLServerInstall Unità>:\Programmi\Microsoft SQL Server\90\Shared\SQLDumper.exe. Si noti che <l'unità> SQLServerInstall è un segnaposto per l'unità in cui è stata installata SQL Server.

Per generare un file di dump usando lo strumento Sqldumper.exe, seguire questa procedura:

  1. Aprire <la cartella SQLServerInstall Drive>:\Programmi\Microsoft SQL Server\<number>\Shared.

    In questo percorso di cartella il <numero> è un segnaposto per uno dei seguenti elementi:

    • 150 per SQL Server 2019
    • 140 per SQL Server 2017
    • 130 per SQL Server 2016
    • 120 per SQL Server 2014
    • 110 per SQL Server 2012
    • 100 per SQL Server 2008
    • 90 per SQL Server 2005

  2. Assicurarsi che il file Dbghelp.dll si trova in questa cartella.

  3. Selezionare Avvia>esecuzione, digitare cmd e quindi selezionare OK.

  4. Al prompt dei comandi digitare il comando seguente e quindi premere INVIO:

    cd <SQLServerInstall Drive>:\Program Files\Microsoft SQL Server\<number>\Shared

    Nota

    In questo percorso di cartella il <numero> è lo stesso segnaposto che cambia con la versione SQL Server, come descritto in precedenza.

  5. Per generare un tipo specifico di file di dump, digitare il comando corrispondente al prompt dei comandi e quindi premere INVIO:

    • File di dump completo:

      Sqldumper.exe <ProcessID> 0 0x01100

    • File mini-dump:

      Sqldumper.exe <ProcessID> 0 0x0120

    • File mini-dump che include la memoria a cui viene fatto riferimento indirettamente (questa è l'opzione consigliata e viene usato anche da SQL Server per impostazione predefinita quando genera automaticamente i file di dump della memoria):

      Sqldumper.exe <ProcessID> 0 0x0128

    • File di dump filtrato:

      Sqldumper.exe <ProcessID> 0 0x8100

    Nota

    <ProcessID> è un segnaposto per l'identificatore di processo dell'applicazione Windows per cui si vuole generare un file di dump.

Se Sqldumper.exe viene eseguito correttamente, lo strumento genera un file di dump nella cartella in cui è installato lo strumento.

Il file di dump generato Sqldumper.exe ha un modello di nome file simile a SQLDmpr<xxxx.mdmp>.

In questo modello xxxx <> è un numero crescente determinato in base ad altri file con un nome file simile nella stessa cartella. Se nella cartella sono già presenti file con nomi di file nel modello specificato, potrebbe essere necessario confrontare la data e l'ora in cui il file è stato creato per identificare il file desiderato.

Come ottenere un identificatore del processo dell'applicazione Microsoft Windows

Per generare un file di dump usando lo strumento Sqldumper.exe, è necessario disporre dell'identificatore di processo dell'applicazione Windows per cui si vuole generare un file di dump. Ecco come ottenere l'identificatore del processo:

  1. Premere CTRL+ALT+CANC e selezionare Gestione attività.
  2. Nella finestra di dialogo Gestione attività Windows selezionare la scheda Processi .
  3. Scegliere Seleziona colonne dal menu Visualizza.
  4. Nella finestra di dialogo Seleziona colonne selezionare la casella di controllo PID (Identificatore processo) e quindi selezionare OK.
  5. Si noti l'identificatore del processo dell'applicazione Windows per cui si vuole generare un file di dump. Per l'applicazione SQL Server, prendere nota dell'identificatore del processo diSqlservr.exe.
  6. Chiudere Gestione attività.

In alternativa, usare il file di log degli errori SQL Server per ottenere l'identificatore di processo dell'applicazione SQL Server in esecuzione nel computer. Parte del file di log degli errori SQL Server è simile all'esempio seguente:

2021-09-15 11:50:32.690 Server       Microsoft SQL Server 2019 (RTM-CU12) (KB5004524) - 15.0.4153.1 (X64)
    Jul 19 2021 15:37:34
    Copyright (C) 2019 Microsoft Corporation
    Enterprise Edition (64-bit) on Windows 10 Pro 10.0 <X64> (Build 19043: ) (Hypervisor)
2021-09-15 11:50:32.690 Server       UTC adjustment: -5:00
2021-09-15 11:50:32.690 Server       (c) Microsoft Corporation.
2021-09-15 11:50:32.690 Server       All rights reserved.
2021-09-15 11:50:32.690 Server       Server process ID is 7028.

Il numero visualizzato dopo Server process ID è l'identificatore del processo per il processo Sqlservr.exe .

Percorso di output per i file di dump della memoria

SQLDumper.exe esiste principalmente per generare file di dump della memoria per il processo di SQL Server in scenari in cui è necessario un dump di memoria per risolvere problemi specifici, ad esempio eccezioni, asserzioni, utilità di pianificazione senza rendimento. In questi casi, SQL Server richiama il SQLDumper.exe per generare un file di dump della memoria del relativo processo. Per impostazione predefinita, il file di dump della memoria viene archiviato nella directory MSSQL\LOG\ dell'istanza SQL.

Come modificare il percorso predefinito

Se, ad esempio, le dimensioni del file di dump sono troppo grandi, è possibile modificare il percorso eseguendo le operazioni seguenti:

  1. Aprire Gestione configurazione SQL Server.
  2. In Servizi SQL Server individuare l'istanza di SQL Server in fase di analisi.
  3. Fare clic con il pulsante destro del mouse su tale voce, selezionare Proprietà e quindi passare alla scheda Avanzate .
  4. Modificare la directory di dump nel percorso desiderato e quindi selezionare OK.
  5. Riavviare SQL Server (se possibile) per rendere effettiva la nuova impostazione.

Quando lo strumento Sqldumper.exe viene usato manualmente per generare un file di dump per qualsiasi applicazione Windows, il file di dump potrebbe essere grande quanto la memoria attualmente in uso nell'applicazione Windows. Assicurarsi che spazio su disco sufficiente sia disponibile nell'unità in cui Sqldumper.exe sta scrivendo il file di dump.

Specificare una cartella di output personalizzata nel comando

È possibile specificare la directory in cui si vuole che lo strumento Sqldumper.exe scriva il file di dump. La directory deve essere già esistente prima di eseguire Sqldumper.exe. In caso contrario, Sqldumper.exe avrà esito negativo. Non usare un percorso UNC come percorso per il file di dump. Di seguito è riportato un esempio di come specificare il percorso del file di dump del file mini-dump:

  1. Selezionare Avvia>esecuzione, digitare cmd e quindi selezionare OK.

  2. Al prompt dei comandi digitare il comando seguente e quindi premere INVIO:

    cd <SQLServerInstall Drive>:\Program Files\Microsoft SQL Server\<number>\Shared

  3. Al prompt dei comandi digitare il comando seguente e quindi premere INVIO:

    Sqldumper.exe ProcessID 0 0x0128 0 <MdumpPath>

    Nota

    <MdumpPath> è un segnaposto per la directory in cui si vuole che lo strumento Sqldumper.exe scriva il file di dump. Per impostazione predefinita, il file viene scritto nella cartella corrente.

Se si specifica un file dump completo o un file di dump filtrato da generare, Sqldumper.exe potrebbero essere necessari alcuni minuti per generare il file di dump. Il tempo impiegato dipende dalle variabili seguenti:

  • Quantità di memoria attualmente in usoSqlservr.exe .
  • Velocità dell'unità in cui lo strumento scrive il file di dump.

Durante questo periodo, lo strumento Sqldumper.exe non elabora i comandi. Si noterà che il server ha smesso di rispondere. Inoltre, potrebbe verificarsi un failover del cluster.

Requisiti di autorizzazione

Per eseguire Sqldumper.exe, è necessario accedere a Windows usando uno dei metodi seguenti:

  • Usare un account membro del gruppo dell'amministratore nel computer.
  • Usare lo stesso account utente con cui è in esecuzione il servizio SQL Server.

Affinché lo strumento Sqldumper.exe funzioni correttamente tramite Desktop remoto o Servizi terminal, è necessario avviare Desktop remoto o Servizi terminal in modalità console. Ad esempio, per avviare Desktop remoto in modalità console, selezionare Avvia>esecuzione, digitare mstsc /console e quindi selezionare OK. Se il server di destinazione esegue Windows 2000, l'opzione /console viene ignorata automaticamente. È possibile connettersi al server tramite Desktop remoto, ma non si usa la sessione della console.

Se si nota che nella cartella corrente non è stato generato alcun file di dump dopo l'esecuzione di Sqldumper.exe, esaminare le informazioni generate dallo strumento nella riga di comando per cercare di determinare la possibile causa dell'errore. Queste informazioni vengono registrate anche nel file Sqldumper_errorlog.log nella directory corrente. Di seguito sono riportati due possibili messaggi di errore e le relative cause:

Messaggio Causa
"OpenProcess non è riuscito 0x57 - Il parametro non è corretto" Un ID processo non valido è stato passato all'utilità Sqldumper.exe.
"Valore non valido per l'ID thread - <Errore parametro> non valido" Un parametro non valido è stato passato all'utilità Sqldumper.exe.

Se viene generato un messaggio di errore simile a uno dei seguenti, è possibile ignorare questo messaggio in modo sicuro:

  • "Tipo di callback sconosciuto durante il minidump 6"
  • "Tipo di callback sconosciuto durante il minidump 7"

Impatto della generazione di dump

Quando viene richiesto un file di dump di un processo in modalità utente (come illustrato in questo articolo, anziché i dump del kernel del sistema operativo, che non rientrano nell'ambito), il processo di destinazione (qui SQLServer.exe) viene bloccato per la durata necessaria per serializzare il contenuto del dump nella destinazione del file.

Bloccato significa che il processo non sarà in grado di eseguire alcuna richiesta utente o operazione interna, inclusi i meccanismi di polling delle risorse, ad esempio l'implementazione di IsAlive e Looks Alive di Windows Clustering. Per informazioni dettagliate su come gestire tale situazione, vedere la sezione Dump della memoria nei failover del cluster . Qualsiasi timeout che si basa sull'ora dell'orologio a muro potrebbe anche essere violato a causa del blocco.

Come può essere derivato dall'istruzione precedente, la durata del blocco è quindi il fattore critico in questo caso ed è determinata dal seguente:

  • Tipo di dump selezionato.
  • Le dimensioni di SQL Server processo in memoria, che nel caso di una singola istanza attiva che esegue parametri predefiniti sono spesso vicine alla RAM fisica totale del server.
  • Prestazioni del disco usato come destinazione per il dump.

È inoltre necessario pianificare le dimensioni del file di dump sul disco, in particolare se sono possibili più dump e se sono selezionati tipi di dump di grandi dimensioni non predefiniti. Assicurarsi di esaminare i tipi di dump per sapere cosa aspettarsi. Per impostazione predefinita, alcuni metodi di dump creeranno il dump nella cartella \Log dell'istanza di SQL Server, che, nella configurazione semplice predefinita, sarebbe anche disco di sistema e disco dati e log per SQL Server. La saturazione del disco avrà un impatto grave sulla SQL Server e/o sulla disponibilità del sistema.

Gestire l'impatto sui sistemi in cluster

Il processo viene sospeso temporaneamente durante la generazione del dump. Ciò potrebbe influire sulla disponibilità del servizio SQL Server e attivare il failover delle risorse nei contesti Always On (istanza del cluster di failover e gruppo di disponibilità). La generazione di dump di processi diversi influisce sulle risorse in modo diverso. Leggere attentamente le sezioni Impatto della generazione di dump e dei tipi di dump .

Quando si acquisisce un dump di SQL Server in un'istanza cluster di failover o in un'istanza del gruppo di disponibilità di SQL Server, il SQL Server cluster o il gruppo di disponibilità potrebbe eseguire il failover in un altro nodo se il dump richiede troppo tempo per il completamento. Ciò può essere particolarmente problematico nei sistemi che usano quantità molto elevate di RAM o se si genera un dump di memoria filtrato o completo. Per evitare il failover, usare le impostazioni seguenti prima di acquisire il file di dump. La modifica può essere ripristinata dopo l'acquisizione di un file di dump:

  • Per l'istanza cluster di failover:
    • Fare clic con il pulsante destro del mouse SQL Server risorsa in Amministratore cluster, selezionare Se la risorsa ha esito negativo, non riavviare nella scheda Criteri.
    • Nella scheda Proprietà aumentare il timeout healthcheck. Ad esempio, impostare il valore della proprietà su 180 secondi o superiore. Se viene raggiunto questo timeout, il criterio Se la risorsa ha esito negativo, non riavviare verrà ignorato e la risorsa verrà comunque riavviata.
    • Nella scheda Proprietà modificare il valore FailureConditionLevel su zero.
  • Per il gruppo di disponibilità, applicare tutte le impostazioni seguenti:
    • Aumentare il timeout della sessione, ad esempio 120 secondi per tutte le repliche. In SQL Server Management Studio (SSMS) fare clic con il pulsante destro del mouse sulla replica da configurare e quindi scegliere Proprietà. Modificare il campo Timeout sessione (secondi) su 120 secondi. Per altre informazioni, vedere Modificare il periodo di Session-Timeout per una replica di disponibilità (SQL Server).
    • Modificare il failover automatico di tutte le repliche in failover manuale. In SSMS fare clic con il pulsante destro del mouse su Replica, selezionare Proprietà e modificare il failover automatico di tutte le repliche in failover manuale nella scheda Proprietà. Per altre informazioni, vedere Modificare la modalità di failover di una replica di disponibilità (SQL Server).
    • Aumentare LeaseTimeout a 60.000 ms (60 secondi) e impostare HealthCheckTimeout su 90.000 ms (90 secondi). In Amministratore cluster fare clic con il pulsante destro del mouse sulla risorsa gruppo di disponibilità, scegliere Proprietà e quindi passare alla scheda Proprietà per modificare entrambe le impostazioni. Per altre informazioni, vedere Configurare le impostazioni delle proprietà HealthCheckTimeout.

Miglioramenti del prodotto per ridurre l'impatto sulle SQL Server

Sono stati aggiunti quattro miglioramenti principali alle versioni recenti di SQL Server per ridurre le dimensioni del file di dump e/o il tempo per la generazione del dump di memoria:

Meccanismo di filtro delle bitmap

SQL Server alloca una bitmap che tiene traccia delle pagine di memoria da escludere da un dump filtrato. Sqldumper.exe legge la bitmap e filtra le pagine senza la necessità di leggere altri metadati di Gestione memoria. I messaggi seguenti vengono visualizzati nel log degli errori SQL Server quando la bitmap è abilitata o disabilitata rispettivamente:

Page exclusion bitmap is enabled. e Page exclusion bitmap is disabled.

  • SQL Server 2016

    A partire da SQL Server 2016 SP2 CU13 il filtro bitmap è abilitato per impostazione predefinita.

  • SQL Server 2017

    • Non è disponibile in RTM fino a CU15.
    • In SQL Server 2017 CU16 è possibile abilitare il filtro delle bitmap tramite T8089 e disabilitarlo disattivando T8089.
    • A partire da SQL Server 2017 CU20 il filtro bitmap è abilitato per impostazione predefinita. Il flag di traccia T8089 non verrà più applicato e verrà ignorato se attivato. Il filtro bitmap può essere disabilitato tramite T8095.

  • SQL Server 2019

    Questa opzione è abilitata per impostazione predefinita in SQL Server 2019 RTM. Può essere disabilitato tramite T8095.

Eliminazione di dump ripetuti sullo stesso problema

I dump di memoria ripetuti sullo stesso problema vengono eliminati. Usando una firma dello stack, il motore SQL tiene traccia se si è già verificata un'eccezione e non produrrà un nuovo dump di memoria se ne esiste già uno. Questo vale per le violazioni di accesso, l'overflow dello stack, le asserzioni e le eccezioni di danneggiamento degli indici. Ciò riduce significativamente la quantità di spazio su disco usata dai dump di memoria e non blocca temporaneamente il processo per generare un dump. Questa operazione è stata aggiunta nel SQL Server 2019.

Output abbreviato nel log degli errori

Il contenuto generato nel log degli errori di SQL Server da un singolo dump di memoria non solo può essere sovraccarico, ma può anche rallentare il processo di generazione di un dump di memoria a causa del tempo necessario per serializzare tutte queste informazioni in un formato di testo nel log degli errori. In SQL Server 2019, il contenuto archiviato nel log degli errori durante la generazione del dump è stato notevolmente ridotto e potrebbe essere simile al seguente:

DateTimespidS pid    **Dump thread - spid = 0, EC = 0x0000015C7169BF40
DateTimespidS pid    *
DateTimespidS pid    *User initiated stack dump. This is not a server exception dump.
DateTimespidS pid    *
DateTimespidS pid    Stack Signature for the dump is 0x00000000788399E5
DateTimespidS pid    External dump process return code 0x20000001.
External dump process returned no errors.

In precedenza SQL Server stampavano le informazioni per ogni sessione o thread, ad esempio quando l'utente attivava un dump manuale.

Compressione parallela dei dump di memoria

Per generare dump più velocemente e renderli più piccoli, è stata introdotta una funzionalità di dump della memoria compressa in SQL Server 2022 CU8 e SQL Server 2019 CU23. Quando attivato, Sqldumper.exe crea più thread per leggere contemporaneamente la memoria di un processo, la comprime e quindi la salva nel file di dump. Questa compressione parallela a più thread riduce le dimensioni del file e velocizza il processo di dumping quando viene usato con dump completi e filtrati.

È possibile attivare il flag di traccia 2610 per abilitare il dump della memoria compressa:

DBCC TRACEON (2610,-1)
GO
DBCC STACKDUMP with FILTERED_DUMP
GO
DBCC TRACEOFF (2610,-1)

In alternativa, è possibile aggiungere -T2610 come parametro di avvio all'istanza di SQL Server in modo che crei sempre dump di memoria compressa.

Se si esegue manualmente Sqldumper.exe, è possibile usare il -zdmp parametro per acquisire un dump di memoria compressa. Ad esempio:

Sqldumper.exe <ProcessID> 0 0x8100 0 d:\temp -zdmp

È anche possibile limitare il numero di core Sqldumper.exe possono usare per creare il dump compresso usando il -cpu:X parametro , dove X è il numero di CPU. Questo parametro è disponibile solo quando si esegue manualmente Sqldumper.exe dalla riga di comando:

Sqldumper.exe <ProcessID> 0 0x8100 0 d:\temp -zdmp -cpu:8

Fattori che impediscono o ritardano la creazione di dump di memoria

I fattori seguenti sono noti per causare ritardi o impedire la creazione di dump di memoria.

  • Il percorso di I/O in cui vengono scritti i dump di memoria non funziona correttamente. In questi casi, per analizzare e risolvere le prestazioni di I/O del disco è il passaggio logico successivo.
  • Un antivirus o un altro software di monitoraggio interferisce con SQLDumper.exe. In alcuni casi, la funzione ReadProcessMemory viene deviazione software di terze parti. Ciò può aumentare notevolmente la durata del dump. Per risolvere la maggior parte di questi problemi, disabilitare il software che interferisce o aggiungere SQLDumper.exe a un elenco di esclusione.

Tipi di dump

I metodi seguenti possono essere usati per generare tre diversi tipi di dump: mini dump, dump completi e dump filtrati.

Mini dump con memoria a cui si fa riferimento

Questo tipo di dump della memoria è uno snapshot di tutti i thread attivi del processo ("stack di thread"), insieme a un estratto limitato della memoria a cui fanno riferimento gli stack di thread e altri dati del processo o del thread chiave. In genere hanno dimensioni di pochi megabyte e sono veloci da generare (da meno di un secondo a un paio di secondi). I sistemi server ancora più grandi (con centinaia di CPU che guidano indirettamente un numero elevato di thread nel processo SQL Server) raramente superano i 20-30 MB: le dimensioni di un mini dump non aumentano con le dimensioni del processo SQL Server. Questo tipo di dump è il tipo predefinito usato da SQL Server durante la generazione automatica di dump di memoria in caso di eccezioni, problemi dell'utilità di pianificazione, problemi di latch, danneggiamento del database, asserzioni.

Nota

SQL Server, come parte della strumentazione predefinita, genererà "mini dump diagnostici" automatizzati in alcune situazioni specifiche. Questa operazione è quindi considerata sufficientemente sicura da SQL Server può attivarla automaticamente quando necessario.

Dump completi

Un dump di memoria completa è una copia completa dello spazio del processo di destinazione attivo. Ciò includerebbe quindi tutto lo stato del thread, tutta la memoria allocata dal processo e tutti i moduli caricati. I dump completi avranno quindi una dimensione, che è approssimativamente la stessa di SQL Server processo, che a sua volta può essere quasi uguale alla RAM di sistema totale. Nei server di grandi dimensioni dedicati a una singola istanza di SQL Server, ciò potrebbe significare un file, che è di diverse centinaia di gigabyte o più. Inutile dire che un file di questo tipo richiederà molto tempo per la generazione e pertanto genererà un blocco prolungato. Le prestazioni del disco per la destinazione del file del dump influiranno in modo significativo sul tempo di blocco. Questo tipo di dump viene usato raramente per SQL Server al giorno d'oggi, come descritto nella spiegazione seguente.

Dump filtrati

Man mano che le dimensioni della RAM dei server tipici in esecuzione SQL Server aumentano costantemente, i dump completi diventano più ingombranti. I dump filtrati vengono quindi implementati. Un dump filtrato è un subset di un dump completo, in cui grandi aree della memoria SQL Server vengono escluse in tempo reale e non scritte su disco. In genere la memoria esclusa non aggiunge alcun valore aggiunto alla risoluzione dei problemi. Esempi sono le pagine di dati/indici e alcune cache interne come le pagine di dati Hekaton e la memoria del pool di log. Questo dump filtrato restituisce un file più piccolo rispetto a un dump completo, ma il dump conserva ancora quasi tutta la sua utilità. I dump filtrati hanno sostituito i dump completi come opzione preferita nella maggior parte delle situazioni in cui i mini dump non sono sufficienti. La riduzione delle dimensioni può variare rispetto a un dump completo, ma è ancora un file piuttosto grande, che spesso è il 30-60% delle dimensioni del processo SQL Server. Pertanto, è meglio pianificare una dimensione possibile come un dump completo come opzione peggiore, il che lascia un buon margine di sicurezza. Un dump filtrato potrebbe non essere necessariamente più veloce da generare rispetto a un dump completo in ogni caso: si tratta di stabilire se i miglioramenti correlati al numero di operazioni di I/O evitate superano il tempo necessario per implementare la logica di filtro (la velocità del disco e la velocità della CPU/RAM influiscono su questo aspetto).

È possibile usare la query seguente per ottenere una stima approssimativa delle dimensioni del dump filtrato. Sebbene l'aspettativa sia che la maggior parte dei dati o delle pagine di indice siano escluse dal dump, quelle che vengono latch e modificate in modo esclusivo non verranno omesse.

SELECT SUM(pages_kb)
FROM sys.dm_os_memory_clerks
WHERE type != 'MEMORYCLERK_SQLBUFFERPOOL'

Poiché è possibile usare Sqldumper.exe per generare un file di dump su richiesta per qualsiasi applicazione Microsoft Windows, è possibile usare l'opzione dump filtrata. Tuttavia, un file di dump filtrato è applicabile e significativo solo nel contesto di SQL Server. È comunque possibile generare un mini-dump, un file di dump completo o applicazioni non SQL Server correttamente.

Il processo SQL Server chiama internamente lo strumento Sqldumper.exe per generare un file di dump quando il processo presenta eccezioni. SQL Server passa parametri a Sqldumper.exe. È possibile usare i flag di traccia per modificare i parametri che SQL Server passano allo strumento per impostazione predefinita quando si verifica un'eccezione o un'asserzione. Questi flag di traccia sono compresi nell'intervallo compreso tra 2540 e 2559. È possibile usare uno di questi flag di traccia per modificare il tipo di dump predefinito SQLDumper.exe generare (il valore predefinito è un mini-dump con memoria di riferimento). Ad esempio:

  • Flag di traccia 2551: produce un dump di memoria filtrato.
  • Flag di traccia 2544: produce un dump di memoria completa.
  • Flag di traccia 8026: SQL Server cancella un trigger di dump dopo aver generato il dump una volta.

Se sono attivi due o più flag di traccia, verrà rispettata l'opzione che indica il dump di memoria più grande. Ad esempio, se vengono usati i flag di traccia 2551 e 2544, SQL Server creerà un dump di memoria completa.

Generare un dump di memoria nei failover del cluster

Negli scenari di failover del cluster, la DLL della risorsa SQL Server può ottenere un file di dump prima che si verifichi il failover per facilitare la risoluzione dei problemi. Quando la DLL della risorsa SQL Server determina che una risorsa SQL Server non è riuscita, la DLL della risorsa SQL Server usa l'utilità Sqldumper.exe per ottenere un file di dump del processo di SQL Server. Per assicurarsi che lo strumento Sqldumper.exe generi correttamente il file di dump, è necessario impostare le tre proprietà seguenti come prerequisiti:

  • SqlDumperDumpTimeOut

    Timeout specificato dall'utente. La DLL della risorsa attende il completamento del file di dump prima che la DLL della risorsa arresti il servizio SQL Server.

  • SqlDumperDumpPath

    Percorso in cui lo strumento Sqldumper.exe genera il file di dump.

  • SqlDumperDumpFlags

    Flag usati Sqldumper.exe.

Se una delle proprietà non è impostata, Sqldumper.exe non è in grado di generare il file di dump. Un messaggio di avviso verrà registrato sia nel registro eventi che nel log del cluster ogni volta che la risorsa viene portata online.

Configurazione del cluster per SQLDumper in SQL Server 2012 e versioni successive

È possibile usare il ALTER SERVER CONFIGURATION comando (T-SQL) per modificare queste proprietà. Ad esempio:

ALTER SERVER CONFIGURATION SET FAILOVER CLUSTER PROPERTY SqlDumperDumpTimeOut = 0;
ALTER SERVER CONFIGURATION SET FAILOVER CLUSTER PROPERTY SqlDumperDumpPath = 'C:\temp\';
ALTER SERVER CONFIGURATION SET FAILOVER CLUSTER PROPERTY SqlDumperDumpFlags = 296;

In alternativa, è possibile usare gli script di PowerShell. Ad esempio, per un'istanza denominata SQL2017AG:

Get-ClusterResource -Name "SQL Server (SQL2017AG)" | Set-ClusterParameter -Name "SqlDumperDumpPath" -Value "C:\temp"
Get-ClusterResource -Name "SQL Server (SQL2017AG)" | Set-ClusterParameter -Name "SqlDumperDumpFlags" -Value 296
Get-ClusterResource -Name "SQL Server (SQL2017AG)" | Set-ClusterParameter -Name "SqlDumperDumpTimeOut" -Value 0

Per convalidare che le impostazioni siano state applicate, è possibile eseguire questo comando di PowerShell:

Get-ClusterResource -Name "SQL Server (SQL2017AG)" | Get-ClusterParameter

Configurazione del cluster per SQLDumper in SQL Server 2008/2008 R2 o Windows 2012 e versioni precedenti

Per impostare le proprietà dell'utilità Sqldumper.exe per il failover del cluster usando il comando della risorsa cluster , seguire questa procedura:

  1. Selezionare Avvia>esecuzione, digitare cmd e quindi selezionare OK.
  2. Per ogni proprietà digitare il comando corrispondente al prompt dei comandi e quindi premere INVIO:

    • Proprietà SqlDumperDumpFlags

      Per impostare la SqlDumperDumpFlags proprietà per un tipo specifico di file di dump, digitare il comando corrispondente al prompt dei comandi e quindi premere INVIO:

      • File di dump completo di tutti i thread

        • Istanza predefinita

          cluster resource "SQL Server" /priv SqlDumperDumpFlags = 0x01100

        • Istanza denominata

          cluster resource "SQL Server (INSTANCE1)" /priv SqlDumperDumpFlags = 0x01100

      • Tutti i file di mini dump del thread

        • Istanza predefinita

          cluster resource "SQL Server" /priv SqlDumperDumpFlags = 0x0120

        • Istanza denominata

          cluster resource "SQL Server (INSTANCE1)" /priv SqlDumperDumpFlags = 0x0120

      • Filtrato tutto il file di dump del thread

        • Istanza predefinita

          cluster resource "SQL Server" /priv SqlDumperDumpFlags = 0x8100

        • Istanza denominata

          cluster resource "SQL Server  (INSTANCE1)" /priv SqlDumperDumpFlags = 0x8100

    • Proprietà SqlDumperDumpPath

      cluster resource "SQL Server" /priv SqlDumperDumpPath = <DirectoryPath>

      Nota

      <DirectoryPath> è un segnaposto per la directory in cui verrà generato il file di dump e deve essere specificato tra virgolette (" ").

    • Proprietà SqlDumperDumpTimeOut

      cluster resource "SQL Server" /priv SqlDumperDumpTimeOut = <Timeout>

      Nota

      <Il timeout> è un segnaposto per il timeout in millisecondi (ms).

Il tempo impiegato dallo strumento per generare un file di dump di un processo di SQL Server dipende dalla configurazione del computer. Per un computer che ha un sacco di ricordi, il tempo potrebbe essere significativo. Per ottenere una stima del tempo impiegato dal processo, usare lo strumento Sqldumper.exe per generare manualmente un file di dump. I valori validi per la SqlDumperDumpTimeOut proprietà sono compresi tra 10.000 ms e MAXDWORD. MAXDWORD rappresenta il valore più alto nell'intervallo del tipo di dati DWORD (4294967295).

Per verificare che le impostazioni siano state abilitate, è possibile eseguire il comando seguente:

cluster resource "SQL Server" /priv

Rimuovere le proprietà Sqldumper.exe per il failover del cluster

Per rimuovere le proprietà dello strumento Sqldumper.exe per il failover del cluster, seguire questa procedura:

  1. Selezionare Avvia>esecuzione, digitare cmd e quindi selezionare OK.
  2. Per una proprietà specifica, digitare il comando corrispondente al prompt dei comandi e quindi premere INVIO:

    • Proprietà SqlDumperDumpFlags

      • Istanza predefinita

          cluster resource "SQL Server" /priv:SqlDumperDumpFlags /usedefault

      • Istanza denominata

          cluster resource "SQL Server (INSTANCE1)" /priv:SqlDumperDumpFlags /usedefault

    • Proprietà SqlDumperDumpPath

      • Istanza predefinita

        cluster resource "SQL Server" /priv:SqlDumperDumpPath /usedefault

      • Istanza denominata

        cluster resource "SQL Server (INSTANCE1)" /priv:SqlDumperDumpPath /usedefault

    • Proprietà SqlDumperDumpTimeOut

      • Istanza predefinita

        cluster resource "SQL Server" /priv:SqlDumperDumpTimeOut /usedefault

      • Istanza denominata

        cluster resource "SQL Server (INSTANCE1)" /priv:SqlDumperDumpTimeOut /usedefault

Come usare DBCC STACKDUMP

Il DBCC STACKDUMP comando consente di creare un dump di memoria nella directory LOG dell'installazione dell'istanza di SQL Server. Il comando creerà per impostazione predefinita un minidump con tutti i thread, che ha dimensioni limitate ed è adeguato per riflettere lo stato del processo di SQL Server. Eseguire il comando seguente in un client SQL Server:

DBCC STACKDUMP

Per le funzionalità estese di DBCC STACKDUMP in SQL Server 2019, vedere Funzionalità estesa DBCC STACKDUMP introdotta in SQL Server 2019.

Per abilitare questo metodo per creare un dump filtrato, attivare i flag di traccia 2551 usando il comando seguente:

DBCC TRACEON(2551, -1)
GO
DBCC STACKDUMP

Per creare un dump completo, usare il flag di traccia 2544.

Dopo aver ottenuto il file di dump, è necessario disabilitare il flag di traccia usando il comando DBCC TRACEOFF (<TraceNumber>, -1); per evitare inavvertitamente l'aggiornamento di tutti gli altri SQL Server minidump autodiagnosi a dump più grandi. Nel comando TraceNumber> è il flag di traccia abilitato in precedenza, <ad esempio 2551 o 2544. Ad esempio:

DBCC TRACEOFF(2551, -1)

Nel caso in cui non si sia certi del flag di traccia che rimane attivo, eseguire il comando seguente:

DBCC TRACESTATUS(-1)

Un set di risultati vuoto indica che non è attivo alcun flag di traccia. Al contrario, se 2551 è ancora attivo, verrà visualizzato:

TraceFlag Stato Globale Sessione
2551 1 1 0

Nota

I traceflag valori abilitati da DBCC TRACEON vengono reimpostati (rimossi) dopo il riavvio di un servizio.

Funzionalità ESTESA DBCC STACKDUMP introdotta in SQL Server 2019

A partire da SQL Server 2019 CU2, il comando è stato esteso per supportare la DBCC STACKDUMP generazione di dump di diversi tipi: dump mini, filtrati e completi. Questo comando elimina la necessità di usare flag di traccia. Consente inoltre di limitare l'output di testo nell'altro file di testo generato con il dump della memoria. In questo modo è possibile ottenere un miglioramento visibile delle prestazioni nel tempo necessario SQLDumper.exe per generare un dump di memoria.

DBCC STACKDUMP WITH MINI_DUMP | FILTERED_DUMP | FULL_DUMP [, TEXT_DUMP = LIMITED | DETAILED]

è TEXT_DUMP = LIMITED l'opzione predefinita. Se si vuole ricevere un output dettagliato nel file SQLDump000X.txt , è possibile usare TEXT_DUMP = DETAILED.

Per generare un dump filtrato con output limitato nel file .txt , eseguire il comando seguente:

DBCC STACKDUMP WITH FILTERED_DUMP , TEXT_DUMP = LIMITED

Come usare uno script di PowerShell per generare un file di dump con SQLDumper

  • Salvare il codice seguente come file PS1, ad esempio SQLDumpHelper.ps1:

    Dettagli del codice

    $isInt = $false
$isIntValDcnt = $false
$isIntValDelay = $false
$SqlPidInt = 0
$NumFoler = ""
$OneThruFour = ""
$SqlDumpTypeSelection = ""
$SSASDumpTypeSelection = ""
$SSISDumpTypeSelection = ""
$SQLNumfolder = 0
$SQLDumperDir = ""
$OutputFolder = ""
$DumpType = "0x0120"
$ValidPid
$SharedFolderFound = $false
$YesNo = ""
$ProductNumber = ""
$ProductStr = ""

Write-Host ""
Write-Host "`******************************************************************"
Write-Host "This script helps you generate one or more SQL Server memory dumps"
Write-Host "It presents you with choices on:`
            -target SQL Server process (if more than one)
            -type of memory dump
            -count and time interval (if multiple memory dumps)
You can interrupt this script using CTRL+C"
Write-Host "***********************************************************************"

# check for administrator rights
# debugging tools like SQLDumper.exe require Admin privileges to generate a memory dump

if (-not ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator))
{
    Write-Warning "Administrator rights are required to generate a memory dump!`nPlease re-run this script as an Administrator!"
    return
}

# what product would you like to generate a memory dump
while ($true)
{
    Write-Host "Which product would you like to generate a memory dump of?" -ForegroundColor Yellow
    Write-Host "1) SQL Server"
    Write-Host "2) SSAS (Analysis Services)"
    Write-Host "3) SSIS (Integration Services)"
    Write-Host "4) SSRS (Reporting Services)"
    Write-Host "5) SQL Server Agent"
    Write-Host ""
    $ProductNumber = Read-Host "Enter 1-5>"

    if ($ProductNumber -in 1,2,3,4,5)
    {
        break
    }
    Write-Host "`nPlease enter a valid number from list above!`n"
    Start-Sleep -Milliseconds 300
}

if ($ProductNumber -eq "1")
{
    $SqlTaskList = Tasklist /SVC /FI "imagename eq sqlservr*" /FO CSV | ConvertFrom-Csv
    $ProductStr = "SQL Server"
}
elseif ($ProductNumber -eq "2")
{
    $SqlTaskList = Tasklist /SVC /FI "imagename eq msmdsrv*" /FO CSV | ConvertFrom-Csv
    $ProductStr = "SSAS (Analysis Services)"
}
elseif ($ProductNumber -eq "3")
{
    $SqlTaskList = Tasklist /SVC /FI "imagename eq msdtssrvr*" /FO CSV | ConvertFrom-Csv
    $ProductStr = "SSIS (Integration Services)"
}
elseif ($ProductNumber -eq "4")
{
    $SqlTaskList = Tasklist /SVC /FI "imagename eq reportingservicesservice*" /FO CSV | ConvertFrom-Csv
    $ProductStr = "SSRS (Reporting Services)"
}
elseif ($ProductNumber -eq "5")
{
    $SqlTaskList = Tasklist /SVC /FI "imagename eq sqlagent*" /FO CSV | ConvertFrom-Csv
    $ProductStr = "SQL Server Agent"
}

if ($SqlTaskList.Count -eq 0)
{
    Write-Host "There are currently no running instances of $ProductStr. Exiting..." -ForegroundColor Green
    break
}

# if multiple SQL Server instances, get the user to input PID for desired SQL Server
if ($SqlTaskList.Count -gt 1)
{
    Write-Host "More than one $ProductStr instance found."

    $SqlTaskList | Select-Object PID, "Image name", Services | Out-Host

    # check input and make sure it is a valid integer
    while ($true)
    {
        Write-Host "Please enter the PID for the desired SQL service from list above" -ForegroundColor Yellow
        $SqlPidStr = Read-Host ">"

        if( $SqlPidStr -in $SqlTaskList.PID)
        {
            $SqlPidInt = [int]$SqlPidStr
            break
        }
    }

    Write-Host "Using PID=$SqlPidInt for generating a $ProductStr memory dump" -ForegroundColor Green
    Write-Host ""

}
else # if only one SQL Server/SSAS on the box, go here
{
    $SqlTaskList | Select-Object PID, "Image name", Services | Out-Host
    $SqlPidInt = [convert]::ToInt32($SqlTaskList.PID)

    Write-Host "Using PID=", $SqlPidInt, " for generating a $ProductStr memory dump" -ForegroundColor Green
    Write-Host ""
}

# dump type

if ($ProductNumber -eq "1")  # SQL Server memory dump
{
    # ask what type of SQL Server memory dump
    while($true)
    {
        Write-Host "Which type of memory dump would you like to generate?" -ForegroundColor Yellow
        Write-Host "1) Mini-dump"
        Write-Host "2) Mini-dump with referenced memory " -NoNewLine; Write-Host "(Recommended)"
        Write-Host "3) Filtered dump " -NoNewline; Write-Host "(Not Recommended)" -ForegroundColor Red
        Write-Host "4) Full dump  " -NoNewline; Write-Host "(Do Not Use on Production systems!)" -ForegroundColor Red
        Write-Host ""
        $SqlDumpTypeSelection = Read-Host "Enter 1-4>"

        if ($SqlDumpTypeSelection -in 1,2,3,4)
        {
            break
        }
        Write-Host "`nPlease enter a valid type of memory dump!`n"
        Start-Sleep -Milliseconds 300
    }

    Write-Host ""

    switch ($SqlDumpTypeSelection)
    {
        "1" { $DumpType="0x0120"; break }
        "2" { $DumpType="0x0128"; break }
        "3" { $DumpType="0x8100"; break }
        "4" { $DumpType="0x01100"; break }
        default { "0x0120"; break }
    }
}
elseif ($ProductNumber -eq "2")  # SSAS dump
{
    # ask what type of SSAS memory dump
    while($true)
    {
        Write-Host "Which type of memory dump would you like to generate?" -ForegroundColor Yellow
        Write-Host "1) Mini-dump"
        Write-Host "2) Full dump  " -NoNewline; Write-Host "(Do Not Use on Production systems!)" -ForegroundColor Red
        Write-Host ""
        $SSASDumpTypeSelection = Read-Host "Enter 1-2>"

        if ($SSASDumpTypeSelection -in 1,2)
        {
            break
        }
        Write-Host "`nPlease enter a valid type of memory dump!`n"
        Start-Sleep -Milliseconds 300
    }

    Write-Host ""

    switch ($SSASDumpTypeSelection)
    {
        "1" {$DumpType="0x0";break}
        "2" {$DumpType="0x34";break}
        default {"0x0120"; break}
    }
}
elseif ($ProductNumber -in 3,4,5)  # SSIS/SSRS/SQL Agent dump
{
    # ask what type of SSIS memory dump
    while($true)
    {
        Write-Host "Which type of memory dump would you like to generate?" -ForegroundColor Yellow
        Write-Host "1) Mini-dump"
        Write-Host "2) Full dump"
        Write-Host ""
        $SSISDumpTypeSelection = Read-Host "Enter 1-2>"

        if ($SSISDumpTypeSelection -in 1,2)
        {
            break
        }
        Write-Host "`nPlease enter a valid type of memory dump!`n"
        Start-Sleep -Milliseconds 300
    }

    Write-Host ""

    switch ($SSISDumpTypeSelection)
    {
        "1" { $DumpType="0x0"; break }
        "2" { $DumpType="0x34"; break }
        default { "0x0120"; break }
    }
}

# Sqldumper.exe PID 0 0x0128 0 c:\temp
# output folder
while($OutputFolder -eq "" -or !(Test-Path -Path $OutputFolder))
{
    Write-Host ""
    Write-Host "Where would your like the memory dump stored (output folder)?" -ForegroundColor Yellow
    $OutputFolder = Read-Host "Enter an output folder with no quotes (e.g. C:\MyTempFolder or C:\My Folder)"
    if ($OutputFolder -eq "" -or !(Test-Path -Path $OutputFolder))
    {
        Write-Host "'" $OutputFolder "' is not a valid folder. Please, enter a valid folder location" -ForegroundColor Yellow
    }
}

# strip the last character of the Output folder if it is a backslash "\". Else Sqldumper.exe will fail
if ($OutputFolder.Substring($OutputFolder.Length-1) -eq "\")
{
    $OutputFolder = $OutputFolder.Substring(0, $OutputFolder.Length-1)
    Write-Host "Stripped the last '\' from output folder name. Now folder name is  $OutputFolder"
}

# find the highest version of SQLDumper.exe on the machine
$NumFolder = dir "C:\Program Files\Microsoft SQL Server\1*" | Select-Object @{name = "DirNameInt"; expression={[int]($_.Name)}}, Name, Mode | Where-Object Mode -Match "da*" | Sort-Object DirNameInt -Descending

for( $j=0; $j -lt $NumFolder.Count; $j++)
{
    $SQLNumfolder = $NumFolder.DirNameInt[$j]   # start with the highest value from sorted folder names - latest version of dumper
    $SQLDumperDir = "C:\Program Files\Microsoft SQL Server\" + $SQLNumfolder.ToString() + "\Shared\"
    $TestPathDumperDir = $SQLDumperDir + "sqldumper.exe"

    if (Test-Path -Path $SQLDumperDir)
    {
        break
    }
}

# build the SQLDumper.exe command e.g. (Sqldumper.exe 1096 0 0x0128 0 c:\temp\)

$cmd = "$([char]34)"+$SQLDumperDir + "sqldumper.exe$([char]34)"
$arglist = $SqlPidInt.ToString() + " 0 " +$DumpType +" 0 $([char]34)" + $OutputFolder + "$([char]34)"
Write-Host "Command for dump generation: ", $cmd, $arglist -ForegroundColor Green

# do-we-want-multiple-dumps section
Write-Host ""
Write-Host "This utility can generate multiple memory dumps, at a certain interval"
Write-Host "Would you like to collect multiple memory dumps (2 or more)?" -ForegroundColor Yellow

# validate Y/N input
while ($true)
{
    $YesNo = Read-Host "Enter Y or N>"

    if ($YesNo -in "y","n")
    {
        break
    }
    Write-Host "Not a valid 'Y' or 'N' response"
}

# get input on how many dumps and at what interval
if ($YesNo -eq "y")
{
    [int]$DumpCountInt=0
    while (1 -ge $DumpCountInt)
    {
        Write-Host "How many dumps would you like to generate for this $ProductStr ?" -ForegroundColor Yellow
        $DumpCountStr = Read-Host ">"

        if ([int]::TryParse($DumpCountStr, [ref]$DumpCountInt) -and $DumpCountInt -gt 1)
        {
            break
        }
        Write-Host "Please enter a number greater than one." -ForegroundColor Red
    }

    [int]$DelayIntervalInt=0
    while ($true)
    {
        Write-Host "How frequently (in seconds) would you like to generate the memory dumps?" -ForegroundColor Yellow
        $DelayIntervalStr = Read-Host ">"

        if ([int]::TryParse($DelayIntervalStr, [ref]$DelayIntervalInt) -and $DelayIntervalInt -gt 0)
        {
            break
        }
        Write-Host "Please enter a number greater than zero." -ForegroundColor Red
    }

    Write-Host "Generating $DumpCountInt memory dumps at a $DelayIntervalStr-second interval" -ForegroundColor Green

    # loop to generate multiple dumps
    $cntr = 0
    while ($true)
    {
        Start-Process -FilePath $cmd -Wait -Verb runAs -ArgumentList $arglist
        $cntr++

        Write-Host "Generated $cntr memory dump(s)." -ForegroundColor Green

        if ($cntr -ge $DumpCountInt)
        {
            break
        }
        Start-Sleep -S $DelayIntervalInt
    }

    # print what files exist in the output folder
    Write-Host ""
    Write-Host "Here are all the memory dumps in the output folder '$OutputFolder'" -ForegroundColor Green
    $MemoryDumps = $OutputFolder + "\SQLDmpr*"
    Get-ChildItem -Path $MemoryDumps

    Write-Host ""
    Write-Host "Process complete"
}
else # produce just a single dump
{
    Start-Process -FilePath $cmd -Wait -Verb runAs -ArgumentList $arglist

    # print what files exist in the output folder
    Write-Host ""
    Write-Host "Here are all the memory dumps in the output folder '$OutputFolder'" -ForegroundColor Green
    $MemoryDumps = $OutputFolder + "\SQLDmpr*"
    Get-ChildItem -Path $MemoryDumps

    Write-Host ""
    Write-Host "Process complete"
}

Write-Host "For errors and completion status, review SQLDUMPER_ERRORLOG.log created by SQLDumper.exe in the output folder '$OutputFolder'.`nOr if SQLDumper.exe failed, look in the folder from which you are running this script."

  • Eseguirlo dal prompt dei comandi come amministratore usando il comando seguente:

    Powershell.exe -File SQLDumpHelper.ps1

  • In alternativa, eseguirlo dalla console di Windows PowerShell ed eseguirlo come amministratore usando il comando seguente:

    .\SQLDumpHelper.ps1

Nota

Se non sono mai stati eseguiti script di PowerShell nel sistema, è possibile che venga visualizzato il messaggio di errore seguente:

"Impossibile caricare il file ...SQLDumpHelper.ps1 perché l'esecuzione di script è disabilitata nel sistema."

Per abilitare la possibilità di eseguire i comandi, seguire questa procedura:

  1. Avviare Windows PowerShell console usando l'opzione Esegui come amministratore. Solo i membri del gruppo administrators nel computer possono modificare i criteri di esecuzione.

  2. Abilitare l'esecuzione di script non firmati con il comando seguente:

    Set-ExecutionPolicy RemoteSigned

    Nota

    In questo modo è possibile eseguire script non firmati creati nel computer locale e script firmati da Internet.