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 verktyget Sqldumper.exe 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ökningsuppgifter.

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

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.

Följ dessa steg för att generera 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 filen Dbghelp.dll finns i den här mappen.

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

  4. I kommandotolken skriver du följande kommando och trycker sedan på Retur:

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

    Kommentar

    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

    Kommentar

    <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 du vill använda.

Så här hämtar du en Identifierare för Microsoft Windows-programprocess

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 Windows Aktivitetshanteraren 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 Sqlservr.exe 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 Sqlservr.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 schemaläggare som inte ger avkastning. I sådana fall anropar SQL Server SQLDumper.exe för att generera en minnesdumpfil för processen. Som standard lagras minnesdumpfilen i katalogen SQL-instansen MSSQL\LOG\ .

Så här ändrar du 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 Konfigurationshanteraren för SQL Server.
  2. Under SQL Server Services letar du reda på 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 (när det är 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 för närvarande använder. 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 verktyget Sqldumper.exe 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 en plats för dumpfilen. Följande steg innehåller ett exempel på hur du anger platsen för minidumpfilen:

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

  2. I kommandotolken skriver du följande kommando och trycker sedan på Retur:

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

  3. I kommandotolken skriver du följande kommando och trycker sedan på Retur:

    Sqldumper.exe ProcessID 0 0x0128 0 <MdumpPath>

    Kommentar

    <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. Hur mycket 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 ett kluster redundansväxling ske.

Behörighet som krävs

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 verktyget Sqldumper.exe ska fungera via Fjärrskrivbord eller terminaltjänster måste du starta Fjärrskrivbord eller Terminal Services i konsolläge. Om du till exempel vill starta Fjärrskrivbord i konsolläget 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 kommandoradsutdata som genereras av verktyget för att identifiera den potentiella orsaken till felet. Den här informationen loggas också i filen Sqldumper_errorlog.log 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 återanropstyp under minidump 6"
  • "Okänd återanropstyp under minidump 7"

Inverkan av dumpningsgenerering

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.

Frozen 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 på 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 vid en enda aktiv instans som 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 en möjlighet och om stora, icke-standarddumptyper väljs. 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 standardkonfigurationen även skulle vara systemdisk och data+loggdisk för SQL Server. Att göra disken 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 resurser vid redundans i AlwaysOn-kontexter (både redundansklusterinstans och tillgänglighetsgrupp). Dumpgenereringen av olika processer påverkar resurser på olika sätt. Läs avsnitten Impact of dump generation and Dump types (Påverkan av dumpgenerering och dumptyper ) noggrant.

När du registrerar en SQL Server-dump på en redundansklusterinstans eller en tillgänglighetsgruppsinstans 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 för 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, starta 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, starta inte om 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 sessionstimeouten, till exempel 120 sekunder för alla repliker. I SQL Server Management Studio (SSMS) högerklickar du på den replik som ska konfigureras och väljer sedan Egenskaper. Ändra fältet Sessionstimeout (sekunder) till 120 sekunder. Mer information finns i Ändra tidsgränsen för session för en tillgänglighetsreplik (SQL Server).
    • Ändra automatisk redundansväxling för alla repliker till manuell redundans. I SSMS högerklickar du på repliken, väljer Egenskaper och ändrar 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å Resurs för tillgänglighetsgruppen, 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 större 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 ut sidor utan att behöva läsa andra metadata för minneshanteraren. Följande meddelanden visas 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 aktiveras bitmappsfiltreringen 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 aktiveras bitmappsfiltreringen 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, anspråk och 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å sakta ner processen att generera en minnesdump på grund av den tid som krävs för serialisering av all denna information i ett textformat i felloggen. I SQL Server 2019 har innehållet som lagras i felloggen vid dumpgenereringen 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 avstickar 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 någon annan nyckelprocess eller tråddata. De är vanligtvis några megabyte i storlek 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 standardtypen som används av SQL Server när du genererar minnesdumpar automatiskt vid undantag, schemaläggningsproblem, spärrproblem, skadade databaser och anspråk.

Kommentar

SQL Server, som en del av den inbyggda instrumentationen, 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 minnesdumpning är en fullständig kopia av det aktiva målprocessutrymmet. Det skulle därför omfatta alla trådtillstånd, allokerat minne och alla inlästa moduler. Fullständiga dumpar har därför en storlek, vilket är ungefär samma som SQL Server-processen, som i sin tur kan vara nästan lika stor som det totala system-RAM-minnet. På stora servrar som är dedikerade till en enskild 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

I takt med att RAM-storleken på vanliga servrar som kör SQL Server stadigt ökar 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 i farten och inte skrivs till disk. Vanligtvis ger det exkluderade minnet inget mervärde i felsökningen. Exempel är data-/indexsidor och vissa interna cacheminnen som Hekaton-datasidor och loggpoolminne. Den här filtrerade dumpen resulterar i en mindre fil än en fullständig dump, men dumpen behåller fortfarande 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 möjlig storlek så stor 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 PROCESSOR-/RAM-hastighet påverkar detta).

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 icke-SQL Server-program.

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 försäkran inträffar. Dessa spårningsflaggor finns i intervallet 2540 till 2559. Du kan använda en 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 respekteras 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 klusterredundansscenarier kan SQL Server-resurs-DLL hämta en dumpfil innan redundansväxlingen sker för att hjälpa till med 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 tidsgräns som angetts av användaren. Resurs-DLL:n väntar tills dumpfilen har slutförts innan resurs-DLL:n 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 tas online.

Klusterkonfiguration för SQLDumper i 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 klusterresurskommandot :

  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:

      • Fullständig dumpfil för alla trådar

        • Standardinstans

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

        • Namngiven instans

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

      • All minidumpfil för tråd

        • 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>

      Kommentar

      <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>

      Kommentar

      <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. De giltiga värdena 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

Följ dessa steg om du vill ta 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

Så här använder du DBCC STACKDUMP

Kommandot DBCC STACKDUMP kan hjälpa dig att skapa en minnesdump i LOG-katalogen för din SQL Server-instansinstallation. 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 i DBCC STACKDUMP SQL Server 2019 finns i Utökade DBCC STACKDUMP-funktioner som introducerades i SQL Server 2019.

Aktivera spårningsflaggor 2551 genom att använda 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

Kommentar

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 synliga prestandaökningar under den tid det tar SQLDumper.exe att generera en minnesdump.

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

Är TEXT_DUMP = LIMITED 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

Kommentar

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

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

    Kommentar

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