Condividi tramite

Usare lo strumento Sqldumper.exe per generare un file 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 di dump della memoria di SQL Server e processi correlati per il debug. Questo articolo descrive come usare Sqldumper.exe per generare un file di dump per le attività di segnalazione errori o debug Di Watson.

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

Come eseguire Sqldumper.exe manualmente

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

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

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

  1. Aprire <SQLServerInstall Drive>:\Program Files\Microsoft SQL Server\<number>\Shared folder.

    In questo percorso della cartella il <numero> è un segnaposto per una delle versioni seguenti:

    • 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

    Note

    In questo percorso della cartella, <number> è lo stesso segnaposto che cambia con la versione di 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

    • Mini-dump file:

      Sqldumper.exe <ProcessID> 0 0x0120

    • Mini-dump file che include la memoria a cui si fa riferimento indirettamente (questa è l'opzione consigliata e viene usata 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

    Note

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

Se Sqldumper.exe viene eseguito correttamente, lo strumento genera un file 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 di file simile nella stessa cartella. Se nella cartella sono presenti file che corrispondono al modello specificato, è consigliabile confrontare le date e le ore di creazione per trovare 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 avere l'identificatore del 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à di 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. Prendere nota dell'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 di Sqlservr.exe .
  6. Chiudere Gestione attività.

In alternativa, usare il file di log degli errori di SQL Server per ottenere l'identificatore del processo dell'applicazione SQL Server in esecuzione nel computer. Parte del file di log degli errori di 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 di Sqlservr.exe .

Percorso di output per i file di dump della memoria

SQLDumper.exe genera principalmente file di dump della memoria per il processo di SQL Server quando è necessario un dump della memoria per risolvere problemi specifici, ad esempio eccezioni, asserzioni o utilità di pianificazione non yield. 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 DI SQL.

Come modificare il percorso predefinito

Se, ad esempio, le dimensioni del file di dump sono troppo grandi, è possibile modificare il percorso seguendo questa procedura:

  1. Aprire Gestione configurazione SQL Server.
  2. In Servizi SQL Server individuare l'istanza di SQL Server sottoposta a indagine.
  3. Fare clic con il pulsante destro del mouse su tale voce, selezionare Proprietà e quindi passare alla scheda Avanzate .
  4. Modificare tale directory di dump sul percorso desiderato e quindi selezionare OK.
  5. Riavviare SQL Server (quando 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 di dimensioni pari alla memoria attualmente in uso dell'applicazione Windows. Assicurarsi che sia disponibile spazio su disco sufficiente 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 desidera che lo strumento Sqldumper.exe scriva il file di dump. La directory deve esistere già prima di eseguire Sqldumper.exe. In caso contrario, Sqldumper.exe ha esito negativo. Non usare un percorso UNC (Universal Naming Convention) come percorso per il file di dump. I passaggi seguenti forniscono un esempio di come specificare il percorso 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>

    Note

    <MdumpPath> è un segnaposto per la directory in cui si desidera 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 di dump completo o un file di dump filtrato da generare, Sqldumper.exe potrebbe richiedere alcuni minuti per generare il file di dump. Il tempo impiegato dipende dalle variabili seguenti:

  • Quantità di memoria attualmente in uso Sqlservr.exe .
  • Velocità di scrittura dell'unità utilizzata dallo strumento per archiviare il file di dump.

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

Requisiti relativi alle autorizzazioni

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 in cui è in esecuzione il servizio SQL Server.

Affinché lo strumento Sqldumper.exe funzioni correttamente tramite Desktop remoto o tramite Servizi terminal, è necessario avviare Desktop remoto o Servizi terminal nella 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 verrà usata la sessione della console.

Se si rileva che nella cartella corrente non è stato generato alcun file dump dopo l'esecuzione di Sqldumper.exe, controllare l'output della riga di comando generato dallo strumento per identificare la potenziale 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:

Message Causa
"OpenProcess failed 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" È stato passato un parametro non valido 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 minidump 6"
  • "Tipo di callback sconosciuto durante minidump 7"

Impatto della generazione di dump

Quando viene richiesto un file dump di un processo in modalità utente (come descritto 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 richiesta per serializzare il contenuto del dump nella destinazione del file.

Frozen significa che il processo non sarà in grado di eseguire alcuna richiesta utente o qualsiasi operazione interna, incluso qualsiasi meccanismo di polling delle risorse, ad esempio l'implementazione di IsAlive e Look Alive di Windows Clustering (vedere la sezione Dump della memoria nei failover del cluster per informazioni dettagliate su come gestire tale situazione). Qualsiasi timeout che si basa sull'orologio a muro potrebbe anche essere violato a causa del blocco.

In base all'istruzione precedente, la durata del blocco è il fattore critico qui, basato sui seguenti elementi:

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

Inoltre, è consigliabile pianificare le dimensioni del file di dump su disco, soprattutto se sono presenti più dump e se sono selezionati tipi di dump non predefiniti di grandi dimensioni. Assicurarsi di esaminare i tipi di dump per sapere cosa aspettarsi. Per impostazione predefinita, alcuni metodi di dump creano il dump nella cartella \Log dell'istanza di SQL Server, che, nella configurazione semplice predefinita, sarebbe anche disco di sistema e disco di dati+log per SQL Server. L'applicazione di tale disco alla saturazione ha un impatto grave sulla disponibilità di SQL Server e/o 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 AlwaysOn (sia l'istanza del cluster di failover che il gruppo di disponibilità). La generazione di dump di processi diversi influisce in modo diverso sulle risorse. 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 del cluster di failover o in un'istanza del gruppo di disponibilità di SQL Server, il cluster SQL Server o il gruppo di disponibilità potrebbe eseguire il failover in un altro nodo se il dump richiede troppo tempo per il completamento. Questo potrebbe essere particolarmente problematico nei sistemi che usano grandi quantità di RAM o se si genera un dump di memoria filtrato o completo. Per impedire 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 del cluster di failover:
    • Fare clic con il pulsante destro del mouse sulla risorsa DI SQL Server in Amministrazione cluster, selezionare Se la risorsa non riesce, non riavviare nella scheda Criteri .
    • Nella scheda Proprietà aumentare il timeout di 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 viene ignorata e la risorsa viene 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 timeout della sessione per una replica di disponibilità (SQL Server).
    • Modificare il failover automatico di tutte le repliche impostando il failover manuale. In SSMS fare clic con il pulsante destro del mouse sulla replica, scegliere 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à, selezionare Proprietà e quindi passare alla scheda Proprietà per modificare entrambe le impostazioni. Per altre informazioni, vedere Configurazione delle impostazioni HealthCheckTimeout.

Miglioramenti del prodotto per ridurre l'impatto su SQL Server

Quattro importanti miglioramenti vengono aggiunti alle versioni recenti di SQL Server per ridurre le dimensioni del file di dump e/o del tempo per la generazione del dump della memoria:

Meccanismo di filtro bitmap

SQL Server alloca una bitmap che tiene traccia delle pagine i memoria da escludere da un dump filtrato. Sqldumper.exe legge la bitmap e filtra le pagine senza bisogno di leggere altri metadati del gestore della memoria. Nel log degli errori di SQL Server vengono visualizzati i messaggi seguenti 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

    • Questa opzione non è disponibile in RTM fino a CU15.
    • In SQL Server 2017 CU16 è possibile abilitare il filtro 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 disabilitata 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 dell'indice. Ciò riduce significativamente la quantità di spazio su disco usato dai dump della memoria e non blocca temporaneamente il processo per generare un dump. Questo è stato aggiunto in SQL Server 2019.

Output abbreviato nel log degli errori

Il contenuto generato nel log degli errori di SQL Server da un singolo dump della memoria non solo può essere sovraccarico, ma può anche rallentare il processo di generazione di un dump della 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 al momento della 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 stampava le informazioni per ogni sessione o thread quando un dump manuale è stato attivato dall'utente, ad esempio.

Compressione parallela dei dump di memoria

Per generare dump più velocemente e renderli di dimensioni inferiori, è stata introdotta una funzionalità di dump della memoria compressa in SQL Server 2022 CU8 e SQL Server 2019 CU23. Quando viene attivato, Sqldumper.exe crea più thread per leggere contemporaneamente la memoria di un processo, lo comprime e quindi lo salva nel file di dump. Questa compressione parallela multithread riduce le dimensioni dei file e accelera il processo di dump 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 compressi.

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

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

È anche possibile limitare il numero di core Sqldumper.exe possibile usare per creare il dump compresso usando il parametro , dove X è il -cpu:X 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 della 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 del 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 processi chiave o dati del thread. Sono in genere pochi megabyte di dimensioni e sono veloci da generare (da meno di un secondo a un paio di secondi). Anche i sistemi server più grandi (con centinaia di CPU indirettamente che determinano un numero elevato di thread nel processo di SQL Server) superano raramente 20-30 MB: le dimensioni di un mini dump non aumentano con le dimensioni del processo di SQL Server. Questo tipo di dump è il tipo predefinito usato da SQL Server durante la generazione automatica di dump della memoria in caso di eccezioni, problemi dell'utilità di pianificazione, problemi di latch, danneggiamento del database e asserzioni.

Note

SQL Server, come parte della strumentazione predefinita, genererà "mini dump di diagnostica" automatizzati in alcune situazioni specifiche. Questa operazione è quindi considerata abbastanza sicura che SQL Server possa attivarlo automaticamente quando necessario.

Dump completi

Un dump completo della memoria è una copia completa dello spazio del processo di destinazione attivo. Ciò includerebbe quindi tutto lo stato del thread, tutta la memoria allocata del processo e tutti i moduli caricati. I dump completi avranno quindi una dimensione, che è approssimativamente la stessa del processo di SQL Server, che a sua volta può essere quasi grande quanto la RAM di sistema totale. Nei server di grandi dimensioni dedicati a una singola istanza di SQL Server che potrebbe significare un file, ovvero diverse centinaia di gigabyte o più. Senza bisogno di dire, tale file richiederà molto tempo per generare e quindi indurrà un blocco prolungato. Le prestazioni del disco per la destinazione del file del dump influiranno significativamente sul tempo di congelamento. 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 che eseguono SQL Server aumentano costantemente, i dump completi diventano più difficili. I dump filtrati vengono quindi implementati. Un dump filtrato è un subset di un dump completo, in cui grandi aree di memoria di SQL Server vengono escluse in tempo reale e non scritte su disco. In genere, la memoria esclusa non comporta alcun valore aggiunto per la risoluzione dei problemi. Alcuni esempi sono le pagine di dati/indice e alcune cache interne, ad esempio pagine di dati Hekaton e memoria del pool di log. Questo dump filtrato comporta un file di dimensioni inferiori rispetto a un dump completo, ma il dump mantiene comunque quasi tutta la sua utilità. I dump filtrati hanno sostituito i dump completi come opzione preferita in gran 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 del 30-60% delle dimensioni del processo di SQL Server. Pertanto, è consigliabile pianificare una dimensione possibile quanto un dump completo come un'opzione peggiore, 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: è una questione di se i guadagni 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. Anche se l'aspettativa è che la maggior parte dei dati o delle pagine di indice viene esclusa dal dump, quelle che sono esclusivamente latch e che vengono modificate non verranno omesse.

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

Poiché puoi usare Sqldumper.exe per generare un file di dump su richiesta per qualsiasi applicazione Microsoft Windows, potresti prendere in considerazione l'uso dell'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 di SQL Server chiama internamente lo strumento Sqldumper.exe per generare un file di dump quando il processo riscontra eventuali eccezioni. SQL Server passa i parametri a Sqldumper.exe. È possibile usare i flag di traccia per modificare i parametri passati da SQL Server 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 a cui si fa riferimento). Ad esempio:

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

Se sono attivi due o più flag di traccia, viene 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 crea un dump di memoria completo.

Generare un dump della memoria nei failover del cluster

Negli scenari di failover del cluster, la DLL della risorsa di 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 ha avuto esito negativo, la DLL della risorsa SQL Server usa l'utilità Sqldumper.exe per ottenere un file 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 utilizzati Sqldumper.exe.

Se una delle proprietà non è impostata, Sqldumper.exe non può generare il file di dump. Un messaggio di avviso viene 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 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 verificare se vengono applicate le impostazioni, è possibile eseguire il comando di PowerShell seguente:

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:

    • La proprietà SqlDumperDumpFlags

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

      • Tutti i file di dump completi del thread

        • Istanza predefinita

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

        • Istanza denominata

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

      • Tutti i file mini-dump del thread

        • Istanza predefinita

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

        • Istanza denominata

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

      • File di dump del thread filtrato

        • Istanza predefinita

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

        • Istanza denominata

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

    • La proprietà SqlDumperDumpPath

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

      Note

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

    • La proprietà SqlDumperDumpTimeOut

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

      Note

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

Il tempo impiegato dallo strumento per generare un file dump di un processo di SQL Server dipende dalla configurazione del computer. Per un computer con una grande quantità di memoria, il tempo potrebbe essere significativo. Per stimare il tempo necessario per il 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 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 di 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:

    • La proprietà SqlDumperDumpFlags

      • Istanza predefinita

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

      • Istanza denominata

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

    • La proprietà SqlDumperDumpPath

      • Istanza predefinita

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

      • Istanza denominata

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

    • La 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 della memoria nella directory LOG dell'installazione dell'istanza di SQL Server. Il comando creerà per impostazione predefinita un minidump con tutti i thread, con 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à DBCC STACKDUMP estese introdotte 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 recuperato il file di dump, è necessario disabilitare il flag di traccia usando il comando DBCC TRACEOFF (<TraceNumber>, -1); per evitare inavvertitamente di aggiornare tutti i minidump di diagnostica automatica di SQL Server a dump di dimensioni maggiori. Nel comando <TraceNumber> è il flag di traccia abilitato in precedenza, ad esempio 2551 o 2544. Ad esempio:

DBCC TRACEOFF(2551, -1)

Se non si è 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. Viceversa, se 2551 è ancora attivo, si noterà quanto riportato di seguito:

TraceFlag Stato Generale Sessione
2551 1 1 0

Note

L'oggetto traceflag abilitato da DBCC TRACEON viene reimpostato (rimosso) dopo il riavvio del servizio.

Funzionalità DBCC STACKDUMP estese introdotte in SQL Server 2019

A partire da SQL Server 2019 CU2, il DBCC STACKDUMP comando è stato esteso per supportare la generazione di dump di tipi diversi: mini, filtrati e dump completi. Questo comando elimina la necessità di usare i 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 generare un dump della 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 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

Note

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

"File ... Non è possibile caricare SQLDumpHelper.ps1 perché l'esecuzione di script è disabilitata in questo sistema".

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

  1. Avviare la console di Windows PowerShell 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

    Note

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