Dela via

Använd verktyget Sqldumper.exe för att generera en dumpfil i SQL Server

  • Artikel

Den här artikeln innehåller allmänna riktlinjer för det Sqldumper.exe verktyg som ingår i SQL Server. Det här verktyget används för att generera olika typer av dumpfiler.

Ursprunglig produktversion: SQL Server 2019, SQL Server 2017, SQL Server 2016, SQL Server 2014, SQL Server 2012, SQL Server 2008, SQL Server 2005
Ursprungligt KB-nummer: 917825

Sammanfattning

Verktyget Sqldumper.exe ingår i Microsoft SQL Server. Den genererar minnesdumpfiler för SQL Server och relaterade processer för felsökning. Den här artikeln beskriver hur du använder Sqldumper.exe för att generera en dumpfil för Watson-felrapportering eller felsökning av uppgifter.

Artikeln beskriver också två andra metoder för att generera dumpfiler:

  • Det anslutna PowerShell-skriptet automatiserar SQLDumper.exe kommandoradsalternativ.
  • Kommandot DBCC STACKDUMP Transact-SQL (T-SQL) kan användas för att generera en dumpfil i SQL Server.

Så här kör du Sqldumper.exe manuellt

Kör verktyget Sqldumper.exe under kontexten för mappen där SQL Server ursprungligen installerade verktyget.

Som standard är installationssökvägen för Sqldumper.exe SQLServerInstall Drive>:\Program Files\Microsoft SQL Server\90\Shared\SQLDumper.exe.< Observera att <SQLServerInstall Drive> är en platshållare för den enhet där du installerade SQL Server.

Så här genererar du en dumpfil med hjälp av verktyget Sqldumper.exe:

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

    I den här mappsökvägen <är talet> en platshållare för någon av följande versioner:

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

  2. Kontrollera att Dbghelp.dll filen finns i den här mappen.

  3. Välj Starta>körning, skriv cmd och välj sedan OK.

  4. Skriv följande kommando i kommandotolken och tryck sedan på Retur:

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

    Obs!

    I den här mappsökvägen <är talet> samma platshållare som ändras med SQL Server-versionen, enligt beskrivningen tidigare.

  5. Om du vill generera en viss typ av dumpfil skriver du motsvarande kommando i kommandotolken och trycker sedan på Retur:

    • Fullständig dumpfil:

      Sqldumper.exe <ProcessID> 0 0x01100

    • Minidumpfil:

      Sqldumper.exe <ProcessID> 0 0x0120

    • Minidumpfil som innehåller indirekt refererat minne (det här är det rekommenderade alternativet och används också av SQL Server som standard när den automatiskt genererar minnesdumpfiler):

      Sqldumper.exe <ProcessID> 0 0x0128

    • Filtrerad dumpfil:

      Sqldumper.exe <ProcessID> 0 0x8100

    Obs!

    <ProcessID> är en platshållare för processidentifieraren för det Windows-program som du vill generera en dumpfil för.

Om Sqldumper.exe körs genererar verktyget en dumpfil i mappen där verktyget är installerat.

Dumpfilen som Sqldumper.exe genererar har ett filnamnsmönster som liknar SQLDmpr<xxxx.mdmp>.

I det här mönstret <är xxxx> ett ökande antal som bestäms baserat på andra filer som har ett liknande filnamn i samma mapp. Om det finns filer i mappen som matchar det angivna mönstret bör du överväga att jämföra deras skapandedatum och tidpunkter för att hitta den fil som du vill använda.

Så här hämtar du en Microsoft Windows-programprocessidentifierare

Om du vill generera en dumpfil med hjälp av verktyget Sqldumper.exe måste du ha processidentifieraren för Windows-programmet som du vill generera en dumpfil för. Så här hämtar du processidentifieraren:

  1. Tryck på Ctrl+Alt+Ta bort och välj Aktivitetshanteraren.
  2. I dialogrutan Aktivitetshanteraren i Windows väljer du fliken Processer .
  3. På menyn Visa väljer du Välj kolumner.
  4. I dialogrutan Välj kolumner markerar du kryssrutan PID (processidentifierare) och väljer sedan OK.
  5. Observera processidentifieraren för det Windows-program som du vill generera en dumpfil för. Observera processidentifieraren för denSqlservr.exe processen för SQL Server-programmet.
  6. Stäng Aktivitetshanteraren.

Du kan också använda SQL Server-felloggfilen för att hämta processidentifieraren för SQL Server-programmet som körs på datorn. En del av SQL Server-felloggfilen liknar följande exempel:

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.

Talet som visas efter Server process ID är processidentifieraren för denSqlservr.exe processen.

Utdatasökväg för minnesdumpfiler

SQLDumper.exe genererar främst minnesdumpfiler för SQL Server-processen när en minnesdump behövs för att lösa specifika problem, till exempel undantag, kontroller eller icke-givande schemaläggare. I sådana fall anropar SQL Server SQLDumper.exe för att generera en minnesdumpfil av processen. Som standard lagras minnesdumpfilen i katalogen MSSQL\LOG\ för SQL-instansen.

Ändra standardsökvägen

Om till exempel dumpfilstorleken är för stor kan du ändra sökvägen genom att följa dessa steg:

  1. Öppna SQL Server Configuration Manager.
  2. Under SQL Server Services letar du upp den SQL Server-instans som är under undersökning.
  3. Högerklicka på posten, välj Egenskaper och gå sedan till fliken Avancerat .
  4. Ändra dumpkatalogen till önskad sökväg och välj sedan OK.
  5. Starta om SQL Server (om möjligt) för att den nya inställningen ska börja gälla.

När verktyget Sqldumper.exe används manuellt för att generera en dumpfil för alla Windows-program kan dumpfilen vara lika stor som det minne som Windows-programmet använder för närvarande. Kontrollera att det finns tillräckligt med diskutrymme på den enhet som Sqldumper.exe skriver dumpfilen till.

Ange en anpassad utdatamapp i kommandot

Du kan ange den katalog där du vill att Sqldumper.exe verktyg ska skriva dumpfilen. Katalogen måste redan finnas innan du kör Sqldumper.exe. Annars misslyckas Sqldumper.exe. Använd inte en UNC-sökväg (Universal Naming Convention) som plats för dumpfilen. Följande steg ger ett exempel på hur du anger platsen för minidumpfilen:

  1. Välj Starta>körning, skriv cmd och välj sedan OK.

  2. Skriv följande kommando i kommandotolken och tryck sedan på Retur:

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

  3. Skriv följande kommando i kommandotolken och tryck sedan på Retur:

    Sqldumper.exe ProcessID 0 0x0128 0 <MdumpPath>

    Obs!

    <MdumpPath> är en platshållare för katalogen där du vill att Sqldumper.exe verktyget ska skriva dumpfilen. Som standard skrivs filen till den aktuella mappen.

Om du anger en fullständig dumpfil eller en filtrerad dumpfil som ska genereras kan Sqldumper.exe ta flera minuter att generera dumpfilen. Den tid det tar beror på följande variabler:

  • Mängden minne som Sqlservr.exe använder för närvarande.
  • Skrivhastigheten för den enhet som används av verktyget för att lagra dumpfilen.

Under den här tiden bearbetar inte Sqldumper.exe-verktyget kommandon. Du kommer att märka att servern slutar svara. Dessutom kan en klusterredundansväxling ske.

Behörighetskrav

Om du vill köra Sqldumper.exe måste du logga in på Windows med någon av följande metoder:

  • Använd ett konto som är medlem i administratörsgruppen på datorn.
  • Använd samma användarkonto som SQL Server-tjänsten körs under.

För att Sqldumper.exe verktyget ska fungera via Fjärrskrivbord eller via Terminal Services måste du starta Fjärrskrivbord eller Terminaltjänster i konsolläge. Om du till exempel vill starta Fjärrskrivbord i konsolläge väljer du Starta>körning, skriver mstsc /console och väljer sedan OK. Om målservern kör Windows 2000 ignoreras alternativet /console tyst. Du kan ansluta till servern via Fjärrskrivbord, men du kommer inte att använda konsolsessionen.

Om du upptäcker att ingen dumpfil har genererats i den aktuella mappen när du har kört Sqldumper.exe kontrollerar du kommandoradens utdata som genereras av verktyget för att identifiera den potentiella orsaken till felet. Den här informationen loggas också i den Sqldumper_errorlog.log filen i den aktuella katalogen. Följande är två möjliga felmeddelanden och deras orsaker:

Meddelande Orsak
"OpenProcess misslyckades 0x57 – parametern är felaktig" Ett ogiltigt process-ID skickades till verktyget Sqldumper.exe.
"Ogiltigt värde för tråd-ID – <ogiltigt parameterfel> " En ogiltig parameter skickades till verktyget Sqldumper.exe.

Om ett felmeddelande som liknar något av följande genereras kan du ignorera det här meddelandet på ett säkert sätt:

  • "Okänd typ av återanrop under minidump 6"
  • "Okänd återanropstyp under minidump 7"

Effekten av generering av dumpar

När en dumpfil för en process i användarläge begärs (enligt beskrivningen i den här artikeln, till skillnad från kerneldumpar för operativsystem, som ligger utanför vårt omfång), är målprocessen (här SQLServer.exe) låst under den tid det tar att serialisera dumpinnehållet till filmålet.

Fryst innebär att processen inte kan köra någon användarbegäran eller någon intern åtgärd, inklusive någon resursavsökningsmekanism, till exempel implementeringen av Windows Clusterings IsAlive och Looks Alive (se avsnittet Minnesdumpar på klusterredundans för mer information om hur du hanterar den situationen). All timeout som förlitar sig på klocktid i väggen kan också brytas på grund av frysningen.

Baserat på föregående instruktion är varaktigheten för frysningen den kritiska faktorn här, som drivs av följande:

  • Den typ av dump som valts .
  • Storleken på SQL Server-processen i minnet, som om en enda aktiv instans kör standardparametrar ofta ligger nära serverns totala fysiska RAM-minne.
  • Prestanda för disken som används som mål för dumpen.

Dessutom bör storleken på dumpfilen på disken planeras, särskilt om flera dumpar är möjliga och om stora dumptyper som inte är standard är markerade. Kontrollera att du granskar dumptyperna för att veta vad du kan förvänta dig. Som standard skapar vissa dumpmetoder dumpen i SQL Server-instansens \Log-mapp , som i den enkla standardkonfigurationen också skulle vara systemdisk och data+loggdisk för SQL Server. Att ta disken till mättnad har stor inverkan på SQL Server och/eller systemets tillgänglighet.

Hantera påverkan på klustrade system

Processen pausas tillfälligt under dumpgenereringen. Detta kan påverka tillgängligheten för SQL Server-tjänsten och utlösa resursredundans i AlwaysOn-kontexter (både redundansklusterinstans och tillgänglighetsgrupp). Dumpgenereringen av olika processer påverkar resurser på olika sätt. Läs avsnitten Effekt av dumpgenerering och Dump-typer noggrant.

När du samlar in en SQL Server-dump på en redundansklusterinstans eller en tillgänglighetsgruppinstans av SQL Server kan den klustrade SQL Server eller tillgänglighetsgruppen redundansväxla till en annan nod om dumpen tar för lång tid att slutföra. Detta kan vara särskilt problematiskt på system som använder stora mängder RAM-minne eller om du genererar en filtrerad eller fullständig minnesdump. Om du vill förhindra redundans använder du följande inställningar innan du samlar in dumpfilen. Ändringen kan återställas när en dumpfil har tagits:

  • För redundansklusterinstans (FCI):
    • Högerklicka på SQL Server-resursen i Klusteradministratör, välj Om resursen misslyckas startar du inte om på fliken Principer .
    • Öka tidsgränsen för HealthCheck på fliken Egenskaper. Ange till exempel egenskapsvärdet till 180 sekunder eller högre. Om tidsgränsen nås ignoreras principen Om resursen misslyckas ignoreras inte omstarten och resursen startas om.
    • På fliken Egenskaper ändrar du värdet FailureConditionLevel till noll.
  • Använd alla följande inställningar för tillgänglighetsgruppen:
    • Öka sessionstimeout, till exempel 120 sekunder för alla repliker. I SQL Server Management Studio (SSMS) högerklickar du på repliken som ska konfigureras och väljer sedan Egenskaper. Ändra fältet Sessionstimeout (sekunder) till 120 sekunder. Mer information finns i Ändra Session-Timeout period för en tillgänglighetsreplik (SQL Server).
    • Ändra den automatiska redundansväxlingen för alla repliker till manuell redundans. Högerklicka på repliken i SSMS, välj Egenskaper och ändra den automatiska redundansväxlingen för alla repliker till manuell redundans på fliken Egenskaper . Mer information finns i Ändra redundansläget för en tillgänglighetsreplik (SQL Server).
    • Öka LeaseTimeout till 60 000 ms (60 sekunder) och ändra HealthCheckTimeout till 90 000 ms (90 sekunder). I Klusteradministratör högerklickar du på AG-resurs, väljer Egenskaper och växlar sedan till fliken Egenskaper för att ändra båda inställningarna. Mer information finns i Konfigurera egenskapsinställningar för HealthCheckTimeout.

Produktförbättringar för att minska påverkan på SQL Server

Fyra viktiga förbättringar läggs till i de senaste versionerna av SQL Server för att minska storleken på dumpfilen och/eller tiden för att generera minnesdumpen:

Mekanism för bitmappsfiltrering

SQL Server allokerar en bitmapp som håller reda på minnessidor som ska undantas från en filtrerad dump. Sqldumper.exe läser bitmappen och filtrerar bort sidor utan att behöva läsa andra metadata för minneshanteraren. Du ser följande meddelanden i SQL Server-felloggen när bitmappen är aktiverad eller inaktiverad:

Page exclusion bitmap is enabled. och Page exclusion bitmap is disabled.

  • SQL Server 2016

    Från och med SQL Server 2016 SP2 CU13 är bitmappsfiltreringen aktiverad som standard.

  • SQL Server 2017

    • Detta är inte tillgängligt i RTM via CU15.
    • I SQL Server 2017 CU16 kan du aktivera bitmappsfiltreringen via T8089 och inaktivera den genom att stänga av T8089.
    • Från och med SQL Server 2017 CU20 är bitmappsfiltreringen aktiverad som standard. SpårningsflaggaN T8089 tillämpas inte längre och ignoreras om den är aktiverad. Bitmappsfiltreringen kan inaktiveras via T8095.

  • SQL Server 2019

    Detta är aktiverat som standard i SQL Server 2019 RTM. Den kan inaktiveras via T8095.

Eliminering av upprepade dumpar i samma problem

Upprepade minnesdumpar på samma problem elimineras. Med hjälp av en stacksignatur håller SQL-motorn reda på om ett undantag redan har inträffat och inte skapar en ny minnesdump om det redan finns en. Detta gäller för åtkomstöverträdelser, stackspill, kontroller och fel vid indexfel. Detta minskar avsevärt mängden diskutrymme som används av minnesdumpar och låser inte processen tillfälligt för att generera en dump. Detta lades till i SQL Server 2019.

Förkortade utdata i felloggen

Innehållet som genereras i SQL Server-felloggen från en enda minnesdump kan inte bara vara överväldigande, utan det kan också göra processen att generera en minnesdump långsammare på grund av den tid som krävs för att serialisera all denna information till ett textformat i felloggen. I SQL Server 2019 har innehållet som lagras i felloggen vid generering av dumpar minskat avsevärt och det kan se ut så här:

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.

Tidigare skulle SQL Server skriva ut information för varje session eller tråd när en manuell dump utlöstes av användaren till exempel.

Parallell komprimering av minnesdumpar

För att generera dumpar snabbare och göra dem mindre i storlek introducerades en komprimerad minnesdumpfunktion i SQL Server 2022 CU8 och SQL Server 2019 CU23. När den aktiveras skapar Sqldumper.exe flera trådar för att läsa en process minne samtidigt, komprimerar den och sparar den sedan i dumpfilen. Den här parallella komprimering med flera trådar minskar filstorleken och påskyndar dumpningsprocessen när den används med fullständiga och filtrerade dumpar.

Du kan aktivera spårningsflagga 2610 för att aktivera komprimerad minnesdump:

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

Du kan också lägga till -T2610 som en startparameter i SQL Server-instansen så att den alltid skapar komprimerade minnesdumpar.

Om du kör Sqldumper.exe manuellt kan du använda parametern -zdmp för att avbilda en komprimerad minnesdump. Till exempel:

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

Du kan också begränsa hur många kärnor Sqldumper.exe kan använda för att skapa den komprimerade dumpen med hjälp av parametern -cpu:X , där X är antalet processorer. Den här parametern är endast tillgänglig när du kör Sqldumper.exe manuellt från kommandoraden:

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

Faktorer som förhindrar eller fördröjer skapandet av minnesdumpar

Följande faktorer är kända för att orsaka fördröjningar eller förhindra skapandet av minnesdumpar.

  • I/O-sökvägen där minnesdumpar skrivs fungerar dåligt. I sådana fall är nästa logiska steg att undersöka och lösa disk-I/O-prestanda.
  • Ett antivirusprogram eller annan övervakningsprogramvara stör SQLDumper.exe. I vissa fall avskräcker programvara från tredje part Funktionen ReadProcessMemory . Detta kan avsevärt öka dumpvaraktigheten. Lös de flesta av dessa problem genom att inaktivera den störande programvaran eller lägga till SQLDumper.exe i en undantagslista.

Dumptyper

Följande metoder kan användas för att generera tre olika typer av dumpar: minidumpar, fullständiga dumpar och filtrerade dumpar.

Minidumpar med refererat minne

Den här typen av minnesdump är en ögonblicksbild av alla aktiva trådar i processen ("trådstackar") tillsammans med ett begränsat extrahering av minnet som refereras av trådstackarna och andra nyckelprocess- eller tråddata. De är vanligtvis några megabyte stora och är snabba att generera (från mindre än en sekund till ett par sekunder). Ännu större serversystem (med hundratals processorer som indirekt driver ett stort antal trådar i SQL Server-processen) överskrider sällan 20–30 MB: storleken på en minidump växer inte med storleken på SQL Server-processen. Den här dumptypen är den standardtyp som används av SQL Server när du genererar minnesdumpar automatiskt vid undantag, schemaläggningsproblem, spärrproblem, skadade databaser och kontroller.

Obs!

SQL Server, som en del av dess inbyggda instrumentation, genererar automatiserade "diagnostiska minidumpar" i vissa specifika situationer. Den här åtgärden anses därför vara tillräckligt säker för att SQL Server ska kunna utlösa den automatiskt när det behövs.

Fullständiga dumpar

En fullständig minnesdump är en fullständig kopia av det aktiva målprocessutrymmet. Det skulle därför omfatta alla trådtillstånd, allokerat minne för processen och alla inlästa moduler. Fullständiga dumpar har därför en storlek, vilket är ungefär samma för SQL Server-processen, som i sin tur kan vara nästan lika stor som det totala systemets RAM-minne. På stora servrar som är dedikerade till en enda SQL Server-instans kan det innebära en fil, som är flera hundratals gigabyte eller mer. Naturligtvis kommer en sådan fil att ta lång tid att generera och kommer därför att leda till långvarig frysning. Diskprestanda för dumpens filmål påverkar frysningstiden avsevärt. Den här typen av dump används sällan för SQL Server nuförtiden, enligt beskrivningen i följande förklaring.

Filtrerade dumpar

När RAM-storleken på vanliga servrar som kör SQL Server ökar stadigt blir fullständiga dumpar mer svårhanterliga. Filtrerade dumpar implementeras därför. En filtrerad dump är en delmängd av en fullständig dump, där stora delar av SQL Server-minnet exkluderas direkt och inte skrivs till disken. Vanligtvis ger det exkluderade minnet inget mervärde för felsökningen. Exempel är data-/indexsidor och vissa interna cacheminnen som Hekaton-datasidor och loggpoolsminne. Den här filtrerade dumpen resulterar i en mindre fil än en fullständig dump gör, men dumpen behåller nästan all användbarhet. Filtrerade dumpar har ersatt fullständiga dumpar som det föredragna alternativet i en stor majoritet av situationer där minidumpar inte räcker till. Minskningen i storlek kan variera jämfört med en fullständig dump, men det är fortfarande en ganska stor fil, som ofta är 30–60 procent av SQL Server-processstorleken. Därför är det bäst att planera för en så stor storlek som en fullständig dump som ett sämsta alternativ, vilket lämnar en bra säkerhetsmarginal. En filtrerad dump kanske inte nödvändigtvis är snabbare att generera än en fullständig dump i alla fall: det handlar om huruvida vinsterna som är relaterade till antalet undvikna I/O överskrider den tid som krävs för att implementera filterlogik (diskhastighet och CPU/RAM-hastighet påverkar det).

Du kan använda följande fråga för att få en ungefärlig uppskattning av den filtrerade dumpstorleken. Även om förväntningarna är att de flesta data- eller indexsidor undantas från dumpen utelämnas inte de som är exklusivt låsta och ändras.

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

Eftersom du kan använda Sqldumper.exe för att generera en dumpfil på begäran för alla Microsoft Windows-program kan du överväga att använda alternativet filtrerad dump. En filtrerad dumpfil är dock endast tillämplig och meningsfull i kontexten för SQL Server. Du kan fortfarande generera en minidump, en fullständig dumpfil eller program som inte är SQL Server.You can still generate a mini-dump, a full dump file, or non-SQL Server applications successfully.

SQL Server-processen anropar Sqldumper.exe verktyget internt för att generera en dumpfil när processen upplever några undantag. SQL Server skickar parametrar till Sqldumper.exe. Du kan använda spårningsflaggor för att ändra de parametrar som SQL Server skickar till verktyget som standard när ett undantag eller en kontroll inträffar. Dessa spårningsflaggor finns i intervallet 2540 till 2559. Du kan använda någon av dessa spårningsflaggor för att ändra standarddumptypen SQLDumper.exe generera (standardvärdet är en minidump med refererat minne). Till exempel:

  • Spårningsflagga 2551: Skapar en filtrerad minnesdump.
  • Spårningsflagga 2544: Skapar en fullständig minnesdump.
  • Spårningsflagga 8026: SQL Server rensar en dumputlösare när dumpen har genererats en gång.

Om två eller flera spårningsflaggor är aktiva används alternativet som anger den största minnesdumpen. Om till exempel spårningsflaggorna 2551 och 2544 används skapar SQL Server en fullständig minnesdump.

Generera en minnesdump vid klusterredundans

I scenarier med klusterredundans kan SQL Server-resurs-DLL hämta en dumpfil innan redundansväxlingen utförs för felsökning. När SQL Server-resurs-DLL:en fastställer att en SQL Server-resurs har misslyckats använder SQL Server-resurs-DLL:en Sqldumper.exe-verktyget för att hämta en dumpfil för SQL Server-processen. För att säkerställa att Sqldumper.exe verktyget genererar dumpfilen måste du ange följande tre egenskaper som förutsättningar:

  • SqlDumperDumpTimeOut

    En användardefinerad tidsgräns. Resurs-DLL väntar tills dumpfilen har slutförts innan resurs-DLL stoppar SQL Server-tjänsten.

  • SqlDumperDumpPath

    Platsen där verktyget Sqldumper.exe genererar dumpfilen.

  • SqlDumperDumpFlags

    Flaggor som Sqldumper.exe använder.

Om någon av egenskaperna inte har angetts kan Sqldumper.exe inte generera dumpfilen. Ett varningsmeddelande loggas både i händelseloggen och i klusterloggen när resursen är online.

Klusterkonfiguration för SQLDumper på SQL Server 2012 och senare versioner

Du kan använda ALTER SERVER CONFIGURATION kommandot (T-SQL) för att ändra dessa egenskaper. Till exempel:

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;

Du kan också använda PowerShell-skript. Till exempel för en namngiven instans 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

Om du vill kontrollera om inställningarna tillämpas kan du köra följande PowerShell-kommando:

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

Klusterkonfiguration för SQLDumper på SQL Server 2008/2008 R2 eller Windows 2012 och tidigare versioner

Följ dessa steg om du vill ange Sqldumper.exe egenskaper för klusterredundans med hjälp av kommandot klusterresurs :

  1. Välj Starta>körning, skriv cmd och välj sedan OK.
  2. För varje egenskap skriver du motsvarande kommando i kommandotolken och trycker sedan på Retur:

    • Egenskapen SqlDumperDumpFlags

      Om du vill ange SqlDumperDumpFlags egenskapen för en specifik dumpfil skriver du motsvarande kommando i kommandotolken och trycker sedan på Retur:

      • Alla trådens fullständiga dumpfil

        • Standardinstans

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

        • Namngiven instans

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

      • Minidumpfil för alla trådar

        • Standardinstans

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

        • Namngiven instans

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

      • Filtrerat alla tråddumpfiler

        • Standardinstans

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

        • Namngiven instans

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

    • Egenskapen SqlDumperDumpPath

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

      Obs!

      <DirectoryPath> är en platshållare för katalogen där dumpfilen ska genereras, och den bör anges inom citattecken (" ").

    • Egenskapen SqlDumperDumpTimeOut

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

      Obs!

      <Timeout> är en platshållare för tidsgränsen i millisekunder (ms).

Den tid det tar för verktyget att generera en dumpfil för en SQL Server-process beror på datorkonfigurationen. För en dator med en stor mängd minne kan tiden vara betydande. Om du vill beräkna den tid som krävs för processen använder du verktyget Sqldumper.exe för att manuellt generera en dumpfil. Giltiga värden för egenskapen SqlDumperDumpTimeOut är från 10 000 ms till MAXDWORD. MAXDWORD representerar det högsta värdet i intervallet för DWORD-datatypen (4294967295).

Du kan kontrollera att inställningarna är aktiverade genom att köra följande kommando:

cluster resource "SQL Server" /priv

Ta bort Sqldumper.exe egenskaper för klusterredundans

Så här tar du bort Sqldumper.exe verktygsegenskaper för klusterredundans:

  1. Välj Starta>körning, skriv cmd och välj sedan OK.

  2. För en specifik egenskap skriver du motsvarande kommando i kommandotolken och trycker sedan på Retur:

    • Egenskapen SqlDumperDumpFlags

      • Standardinstans

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

      • Namngiven instans

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

    • Egenskapen SqlDumperDumpPath

      • Standardinstans

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

      • Namngiven instans

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

    • Egenskapen SqlDumperDumpTimeOut

      • Standardinstans

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

      • Namngiven instans

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

Använda DBCC STACKDUMP

Kommandot DBCC STACKDUMP kan hjälpa dig att skapa en minnesdump i LOG-katalogen för installationen av SQL Server-instansen. Kommandot skapar som standard en minidump med alla trådar, som har begränsad storlek och är tillräcklig för att återspegla tillståndet för SQL Server-processen. Kör följande kommando i en SQL Server-klient:

DBCC STACKDUMP

Utökade funktioner DBCC STACKDUMP i SQL Server 2019 finns i Utökade DBCC STACKDUMP-funktioner som introducerades i SQL Server 2019.

Aktivera spårningsflaggor 2551 med hjälp av följande kommando för att aktivera den här metoden för att skapa en filtrerad dump:

DBCC TRACEON(2551, -1)
GO
DBCC STACKDUMP

Om du vill skapa en fullständig dump använder du spårningsflaggan 2544.

När du har hämtat dumpfilen bör du inaktivera spårningsflaggan med hjälp av kommandot DBCC TRACEOFF (<TraceNumber>, -1); för att undvika att oavsiktligt uppgradera alla ytterligare SQL Server-minidumpar med självdiagnostik till större dumpar. I kommandot <är TraceNumber> den spårningsflagga som du tidigare har aktiverat, till exempel 2551 eller 2544. Till exempel:

DBCC TRACEOFF(2551, -1)

Om du är osäker på vilken spårningsflagga som förblir aktiv kör du följande kommando:

DBCC TRACESTATUS(-1)

En tom resultatuppsättning anger att ingen spårningsflagga är aktiv. Om 2551 däremot fortfarande är aktivt skulle du se:

TraceFlag Status Global Session
2551 1 1 0

Obs!

Aktiverad traceflag av DBCC TRACEON återställs (tas bort) efter en omstart av tjänsten.

Utökade DBCC STACKDUMP-funktioner som introducerades i SQL Server 2019

Från och med SQL Server 2019 CU2 DBCC STACKDUMP utökades kommandot för att stödja generering av dumpar av olika typer: mini, filtrerade och fullständiga dumpar. Det här kommandot eliminerar behovet av att använda spårningsflaggor. Du kan också begränsa textutdata i den andra textfilen som genereras med minnesdumpen. Detta kan ge synlig prestandaökning under den tid det tar SQLDumper.exe att generera en minnesdump.

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

TEXT_DUMP = LIMITED är standardalternativet. Om du vill få detaljerade utdata i SQLDump000X.txt-filen kan du använda TEXT_DUMP = DETAILED.

Om du vill generera en filtrerad dump med begränsade utdata i .txt-filen kör du följande kommando:

DBCC STACKDUMP WITH FILTERED_DUMP , TEXT_DUMP = LIMITED

Så här använder du ett PowerShell-skript för att generera en dumpfil med SQLDumper

  • Spara följande kod som en PS1-fil, till exempel SQLDumpHelper.ps1:

    Kodinformation

    $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."

  • Kör den från kommandotolken som administratör med hjälp av följande kommando:

    Powershell.exe -File SQLDumpHelper.ps1

  • Eller kör den från Windows PowerShell-konsolen och kör den som administratör med hjälp av följande kommando:

    .\SQLDumpHelper.ps1

Obs!

Om du aldrig har kört PowerShell-skript i systemet kan du få följande felmeddelande:

"Filen ...SQLDumpHelper.ps1 kan inte läsas in eftersom skript som körs är inaktiverade i det här systemet."

Följ dessa steg för att aktivera möjligheten att köra kommandona:

  1. Starta Windows PowerShell-konsolen med alternativet Kör som administratör . Endast medlemmar i gruppen Administratörer på datorn kan ändra körningsprincipen.

  2. Aktivera körning av osignerade skript med följande kommando:

    Set-ExecutionPolicy RemoteSigned

    Obs!

    På så sätt kan du köra osignerade skript som du skapar på din lokala dator och signerade skript från Internet.