Use la utilidad Sqldumper.exe para generar un archivo de volcado de memoria en SQL Server

En este artículo se proporcionan instrucciones generales para la utilidad Sqldumper.exe que se incluye con SQL Server. Puede usar esta utilidad para generar diferentes tipos de archivos de volcado de memoria.

Versión original del producto:   SQL Server 2017, SQL Server 2016, SQL Server 2014, SQL Server 2012, SQL Server 2008, SQL Server 2005
Número KB original:   917825

Resumen

La Sqldumper.exe se incluye con Microsoft SQL Server. En este artículo se describe cómo usar la utilidad Sqldumper.exe para generar un archivo de volcado de memoria para los informes de errores de Watson o para las tareas de depuración.

Nota

Además de la utilidad Sqldumper.exe, también están disponibles los siguientes métodos:

  • Puede usar el comando DBCC STACKDUMP para generar un archivo de volcado de memoria SQL Server. Para obtener más información, vea Cómo usar DBCC STACKDUMP.
  • También puede usar un script de PowerShell para automatizar la línea de comandos de SQLDumper.

Advertencia

La generación de archivos de volcado de proceso puede afectar a la disponibilidad del servicio (aquí SQL Server) y desencadenar la conmutación por error de recursos en contextos AlwaysOn (instancia de clúster de conmutación por error y grupo de disponibilidad). Las opciones que se usan para generar los archivos de volcado de memoria marcarán una gran diferencia. Asegúrese de leer las secciones Impacto de generación de volcado de memoria y Tipos de volcado de memoria.

Cuando se captura un archivo de volcado de memoria de proceso de SQL Server (especialmente un archivo de volcado filtrado o un archivo de volcado completo) en un SQL Server agrupado o en un SQL Server que hospeda una instancia de Grupo de disponibilidad AlwaysOn (AG), el SQL Server o ag agrupado puede conmutar por error a otro nodo si el archivo de volcado tarda demasiado tiempo en completarse. Para evitar la posible conmutación por error, puede usar la siguiente configuración antes de capturar el archivo de volcado de memoria y puede revertir el cambio después de tomar un archivo de volcado de memoria:

  • En el caso de SQL Server clúster (FCI), haga clic con el botón secundario en SQL Server recurso en administrador de clústeres, seleccione "Si se produce un error en el recurso, no reiniciar" en la pestaña Directivas.
  • Para AG, aplique todas las opciones de configuración siguientes:
    • Aumente el tiempo de espera de sesión, por ejemplo, 120 segundos para todas las réplicas. En SQL Server Management Studio, haga clic con el botón secundario en la réplica que se va a configurar y, a continuación, seleccione Propiedades. Cambie Session-Timeout campo (segundos) a 120 segundos. Para obtener más información, vea Cambiar el período de Session-Timeout para una réplica de disponibilidad (SQL Server).
    • Cambie la conmutación por error automática de todas las réplicas a la conmutación por error manual. En SQL Server Management Studio, haga clic con el botón secundario en la réplica, seleccione Propiedades y, a continuación, cambie la "conmutación por error automática" de todas las réplicas a la conmutación por error manual en la pestaña Propiedades. Para obtener más información, vea Cambiar el modo de conmutación por error de una réplica de disponibilidad (SQL Server).
    • Aumente a LeaseTimeout 60.000 ms (60 segundos) y cambie a HealthCheckTimeout 90.000 ms (90 segundos). En Administrador de clústeres, haga clic con el botón secundario en el recurso AG, seleccione Propiedades y, a continuación, cambie a la pestaña Propiedades para modificar ambas opciones. Para obtener más información, vea Configuración de la propiedad HealthCheckTimeout.

Cómo ejecutar la utilidad Sqldumper.exe manualmente

Ejecute la Sqldumper.exe en el contexto de la carpeta donde SQL Server instaló originalmente la utilidad. De forma predeterminada, la ruta de instalación de Sqldumper.exe utilidad es la siguiente:

SQLServerInstallDrive:\Program Files\Microsoft SQL Server\90\Shared\SQLDumper.exe

Nota

SQLServerInstallDrive es un marcador de posición para la unidad donde se instaló SQL Server 2005.

Para generar un archivo de volcado de memoria mediante la utilidad Sqldumper.exe, siga estos pasos:

  1. Abra la carpeta siguiente:

    SQLServerInstallDrive:\Program Files\Microsoft SQL Server\number\Shared

    Nota

    En esta ruta de acceso a la carpeta, el número es un marcador de posición para uno de los siguientes elementos:

    • 140 para SQL Server 2017
    • 130 para SQL Server 2016
    • 120 para SQL Server 2014
    • 110 para SQL Server 2012
    • 100 para SQL Server 2008
    • 90 para SQL Server 2005
  2. Asegúrese de que el Dbghelp.dll está en esta carpeta.

  3. Seleccione Inicio, ejecutar, escriba cmd y, a continuación, seleccione Aceptar.

  4. En el símbolo del sistema, escriba el siguiente comando y presione ENTRAR:

    cd SQLServerInstallDrive:\Program Files\Microsoft SQL Server\number\Shared
    

    Nota

    En esta ruta de acceso de carpeta, es el mismo marcador de posición que number cambia SQL Server versión como se describió anteriormente.

  5. Para generar un tipo específico de archivo de volcado de memoria, escriba el comando correspondiente en el símbolo del sistema y, a continuación, presione ENTRAR:

    • Archivo de volcado completo

      Sqldumper.exe ProcessID 0 0x01100
      
    • Archivo de volcado de memoria

      - Sqldumper.exe ProcessID 0 0x0120
      
    • Archivo de minivolca que incluye memoria a la que se hace referencia indirectamente. Esta es la opción recomendada y también se usa SQL Server de forma predeterminada al generar automáticamente volcados de memoria

      Sqldumper.exe ProcessID 0 0x0128
      
    • Archivo de volcado filtrado

      Sqldumper.exe ProcessID 0 0x8100
      

    Nota

    ProcessID es un marcador de posición para el identificador de proceso de la aplicación de Windows para la que quieres generar un archivo de volcado de memoria.

Si la Sqldumper.exe se ejecuta correctamente, la utilidad genera un archivo de volcado de memoria en la carpeta donde está instalada la utilidad.

El archivo de volcado de Sqldumper.exe genera tiene un patrón de nombre de archivo similar al siguiente:
SQLDmpr xxxx.mdmp
En este patrón, xxxx es un número creciente que se determina en función de otros archivos que tienen un nombre de archivo similar en la misma carpeta. Si ya tiene archivos en la carpeta que tienen nombres de archivo en el patrón especificado, es posible que tenga que comparar la fecha y la hora en que se creó el archivo para identificar el archivo que desea.

Información y consideraciones adicionales

SQLDumper.exe existe principalmente para generar volcados de memoria para el proceso de SQL Server en escenarios donde se necesita un volcado de memoria para resolver problemas específicos (excepciones, afirmaciones, programadores sin rendimiento, etc.). En estos casos, SQL Server llama al SQLDumper.exe para generar un volcado de memoria de su proceso. El volcado de memoria se almacena en una ruta configurada en SQL Server Configuration Manager con un directorio de ubicación MSSQL\LOG\ predeterminado. Si en algunos casos el tamaño del volcado es demasiado grande, por ejemplo, puede modificar la ruta de acceso haciendo lo siguiente:

  1. Abrir SQL Server Configuration Manager
  2. En SQL Server servicios de búsqueda localice el SQL Server que se está investigando
  3. Haga clic con el botón secundario en él, elija Propiedades y vaya a la pestaña Avanzadas
  4. Modifique ese directorio de volcado de memoria a la ruta de acceso deseada y seleccione Aceptar
  5. Reinicie SQL Server (cuando sea posible) para que la nueva configuración suba efecto.

Cuando la utilidad Sqldumper.exe se usa manualmente para generar un archivo de volcado de memoria para cualquier aplicación de Windows, el archivo de volcado de memoria puede ser tan grande como la memoria que la aplicación de Windows está usando actualmente. Asegúrese de que hay suficiente espacio en disco disponible en la unidad en la que la Sqldumper.exe está escribiendo el archivo de volcado de memoria.

Puede especificar el directorio donde desea que la Sqldumper.exe escriba el archivo de volcado de memoria. El directorio ya debe existir antes de ejecutar la Sqldumper.exe usuario. De lo contrario, Sqldumper.exe la utilidad de actualización. No use una ruta de acceso UNC como ubicación para el archivo de volcado de memoria. A continuación se muestra un ejemplo de cómo especificar la ubicación del archivo de volcado de memoria del archivo de volcado de memoria:

  1. Seleccione Inicio, ejecutar, escriba cmd y, a continuación, seleccione Aceptar.

  2. En el símbolo del sistema, escriba el siguiente comando y presione ENTRAR:

    cd **SQLServerInstallDrive** :\Program Files\Microsoft SQL Server\number\Shared
    
  3. Escriba el siguiente comando en el símbolo del sistema y, a continuación, presione ENTRAR:

    Sqldumper.exe ProcessID 0 0x0128 0 MdumpPath
    

    Nota

    MdumpPath es un marcador de posición para el directorio donde desea que la Sqldumper.exe escriba el archivo de volcado de memoria. De forma predeterminada, el archivo se escribe en la carpeta actual.

Si especifica un archivo de volcado completo o un archivo de volcado filtrado que se generará, la utilidad Sqldumper.exe puede tardar varios minutos en generar el archivo de volcado de memoria. El tiempo depende de las siguientes variables:

  • La cantidad de memoria que la Sqldumper.exe está usando actualmente
  • La velocidad de la unidad en la que la utilidad está escribiendo el archivo de volcado de memoria

Durante este tiempo, la Sqldumper.exe no procesará comandos. Observará que el servidor ha dejado de responder. Además, puede producirse una conmutación por error de clúster.

Para ejecutar la Sqldumper.exe, debes iniciar sesión en Windows mediante uno de los siguientes métodos:

  • Use una cuenta que sea miembro del grupo de administradores en el equipo.
  • Use la misma cuenta de usuario con la que se ejecuta SQL Server servicio.

Para que la Sqldumper.exe funcione correctamente a través de Escritorio remoto o Terminal Services, debe iniciar Escritorio remoto o Terminal Services en modo de consola. Por ejemplo, para iniciar Escritorio remoto en modo de consola, seleccione Inicio , ejecutar , escriba mstsc /consola y, a continuación, seleccione Aceptar. Si el servidor de destino ejecuta Windows 2000, la opción /console se omite silenciosamente. Puede conectarse al servidor a través de Escritorio remoto. Pero no se va a usar la sesión de consola.

Si observa que no se ha generado ningún archivo de volcado de memoria en la carpeta actual después de ejecutar la utilidad Sqldumper.exe, revise la información que la utilidad ha generado en la línea de comandos para intentar determinar la posible causa del error. Esta información también se registra en el archivo Sqldumper_errorlog.log en el directorio actual. Los siguientes son dos posibles mensajes de error y sus causas:

  • Mensaje 1

    Error al 0x57 OpenProcess: el parámetro es incorrecto

    Se ha pasado un identificador de proceso no válido a la Sqldumper.exe datos.

  • Mensaje 2

    Valor no válido para el identificador de subproceso: <invalid parameter> error de parámetro

    Se pasó un parámetro no válido a la utilidad Sqldumper.exe datos.

Si se genera un mensaje de error similar a uno de los siguientes, puede omitir este mensaje de forma segura:

Tipo de devolución de llamada desconocido durante el minidump 6
Tipo de devolución de llamada desconocido durante el minidump 7

Impacto de la generación de volcado de memoria

Cuando se solicita un volcado de un proceso de modo de usuario (como se describe en este artículo, para que se contraste con los volcados de kernel del sistema operativo, que están fuera de nuestro ámbito), el proceso de destino (aquí SQLServer.exe) se inmoviliza durante la duración que tarda en serializar el contenido del volcado de memoria en su destino de archivo.

Inmovilizado significa que no podrá procesar ninguna solicitud de usuario ni avanzar en ninguna operación interna, incluido cualquier mecanismo de sondeo de recursos como la implementación de IsAlive y Looks Alive de Windows Clustering (consulta la sección "Conmutaciones por error de clúster y la utilidad Sqldumper.exe" para obtener detalles sobre cómo controlar esa situación). Cualquier tiempo de espera que dependa de la hora del reloj también puede vulnerarse como consecuencia de la inmovilización.

Como se puede derivar de la instrucción anterior, la duración de la inmovilización es, por lo tanto, el factor crítico aquí y se impulsa por lo siguiente:

  • El tipo de volcado seleccionado
  • El tamaño de SQL Server proceso en la memoria, que en el caso de una sola instancia activa que ejecuta los parámetros predeterminados suele estar cerca de la RAM física total del servidor.
  • Rendimiento del disco usado como destino del volcado de memoria.

Además, se debe planear el tamaño del archivo de volcado de memoria en el disco, especialmente si varios volcados son una posibilidad y si se seleccionan tipos de volcado grandes no predeterminados. Asegúrese de revisar la sección "Tipos de volcado de memoria" para saber qué esperar. De forma predeterminada, algunos métodos de volcado de memoria crearán el volcado de memoria en la carpeta \Log de la instancia de SQL Server, que, de forma predeterminada, también sería el disco del sistema y el disco de datos+registro para SQL Server. Llevar ese disco a la saturación tendrá un impacto grave en la SQL Server y/o la disponibilidad del sistema.

Se han agregado tres mejoras principales a las versiones recientes de SQL Server para reducir el tamaño del archivo de volcado de memoria o el tiempo para generar el volcado de memoria:

  • Mecanismo de filtrado de mapa de bits

  • Eliminación de volcados repetidos en el mismo problema

  • Salida abreviada en el registro de errores

SQL Server asigna un mapa de bits que realiza un seguimiento de las páginas de memoria que se excluirán de un volcado filtrado. Sqldumper.exe lee el mapa de bits y filtra las páginas sin necesidad de leer ningún otro metadato del administrador de memoria. Verá los siguientes mensajes en el registro de errores de SQL Server cuando el mapa de bits está habilitado o deshabilitado Page exclusion bitmap is enabled. respectivamente: Page exclusion bitmap is disabled.

  • SQL Server 2016

    A partir de SQL Server 2016 SP2 CU13, el filtrado de mapas de bits está habilitado de forma predeterminada.

  • SQL Server 2017

    • Esto no está disponible en RTM a CU15.
    • En SQL Server 2017 CU16, puede habilitar el filtrado de mapas de bits a través de T8089 y deshabilitarlo desactivando T8089.
    • A partir SQL Server 2017 CU20, el filtrado de mapas de bits está habilitado de forma predeterminada. La marca de seguimiento T8089 ya no se aplicará y se omitirá si está activada. El filtrado de mapa de bits se puede deshabilitar a través de T8095.
  • SQL Server 2019

    Esto está habilitado de forma predeterminada en SQL Server 2019 RTM. Se puede deshabilitar a través de T8095.

Eliminación de volcados repetidos en el mismo problema: se eliminan los volcados de memoria repetidos en el mismo problema. Con una firma de pila, el motor SQL realiza un seguimiento de si ya se ha producido una excepción y no producirá un nuevo volcado de memoria si ya hay uno. Esto se aplica a las excepciones de infracción de acceso, desbordamiento de pila, aserciones e índices dañados. Esto reduce significativamente la cantidad de espacio en disco que usan los volcados de memoria y no inmoviliza temporalmente el proceso para generar un volcado de memoria. Esto se agregó en SQL Server 2019.

Resultado abreviado en el registro de errores: el contenido generado en el registro de errores de SQL Server desde un único volcado de memoria no solo puede ser abrumador, sino que también ha ralentizado el proceso de generación de un volcado de memoria debido al tiempo que toda esta información se tuvo que serializar en un formato de texto en el registro de errores. En SQL Server 2019, el contenido almacenado en el registro de errores tras la generación del volcado de memoria se ha reducido en gran medida y puede tener este aspecto:

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.

Anteriormente, SQL Server información para cada sesión o subproceso cuando el usuario desencadenaba un volcado manual, por ejemplo.

Tipos de volcado de memoria

Los métodos descritos pueden generar tres tipos diferentes de volcados de memoria: volcados de memoria, volcados completos y volcados filtrados.
Los mini volcados con memoria a la que se hace referencia son una instantánea de todos los subprocesos activos del proceso ("pilas de subprocesos"), junto con un extracto limitado de la memoria a la que hacen referencia las pilas de subprocesos y otros datos clave de procesos o subprocesos. Normalmente tienen unos pocos megabytes de tamaño y son rápidos de generar (de menos de un segundo a un par de segundos). Incluso los sistemas de servidor más grandes (con cientos de SQL Server CPU que impulsan indirectamente un gran número de subprocesos en un proceso) rara vez superarán los 20-30 MB: el tamaño de un minivolcamiento no crece con el tamaño de SQL Server proceso. Este tipo de volcado de memoria es el tipo predeterminado usado por SQL Server al generar volcados de memoria automáticamente en excepciones, problemas de programador, problemas de bloqueos, etc.

Nota

SQL Server, como parte de su instrumentación integrada, generará "volcados de memoria de diagnóstico" automatizados en algunas situaciones específicas. Por lo tanto, esta operación se considera lo suficientemente segura SQL Server puede desencadenarla automáticamente cuando sea necesario.

Los volcados completos son una copia completa del espacio de proceso de destino activo. Por lo tanto, esto incluiría todo el estado del subproceso, la memoria asignada a todos los procesos y todos los módulos cargados. Por lo tanto, los volcados completos tendrán un tamaño, que es aproximadamente el mismo que SQL Server proceso, que a su vez puede ser casi tan grande como la RAM total del sistema. En servidores grandes dedicados a una única SQL Server de datos, esto puede significar un archivo, que es varios cientos de gigabytes o más. No hace falta decir que un archivo de este tipo llevará mucho tiempo generarse y, por lo tanto, provocará la inmovilización. El rendimiento del disco para el destino del archivo de volcado será un controlador importante para inmovilizar el tiempo. Este tipo de volcado de memoria rara vez se usa SQL Server hoy**, como se explicará en la siguiente descripción de tipo.

Volcados filtrados: a medida que el tamaño de RAM de los servidores típicos que ejecutan SQL Server ha aumentado continuamente, los volcados completos son cada vez más difíciles de manejar. Por lo tanto, se implementaron volcados filtrados: son un subconjunto de volcados de memoria completos, donde las grandes áreas de estructuras de memoria pertenecientes a SQL Server se omiten de manera propósito y no se serializan en el disco, ya que no aportan ningún valor agregado de solución de problemas (normalmente, páginas de datos/índice, algunas cachés internas como las páginas de datos de Hekaton y la memoria del grupo de registros). Esto da como resultado un archivo, que es menor que un volcado completo mientras conserva casi toda su utilidad, y esto ha reemplazado los volcados completos como opción preferida en una gran mayoría de situaciones en las que los mini volcados no eran suficientes. La disminución de tamaño frente al volcado completo puede variar mucho, pero sigue siendo un archivo bastante grande, que suele ser el 30-60 % del tamaño del proceso de SQL Server, por lo que es mejor planear un tamaño posible tan grande como un volcado completo como la peor opción, lo que debería dejar un buen margen de seguridad. Es posible que un volcado filtrado no sea necesariamente más rápido de generar que un volcado completo en todos los casos: es cuestión de si las ganancias vinculadas al número de E/S evitadas superan el tiempo necesario para implementar la lógica de filtro (por lo que la velocidad del disco y la velocidad de CPU/RAM influirán en ello).

Puedes usar la utilidad Sqldumper.exe para generar un archivo de volcado de memoria a petición para cualquier aplicación de Microsoft Windows. Por ejemplo, puede generar un archivo de volcado de memoria para depurar un problema de aplicación cuando un equipo que ejecuta Microsoft SQL Server no responde a las solicitudes del usuario. Un archivo de volcado de memoria puede ser un archivo de volcado de memoria o un archivo de volcado completo. Un archivo de volcado filtrado solo es aplicable y significativo en el contexto de SQL Server.

El SQL Server llama a la utilidad Sqldumper.exe internamente para generar un archivo de volcado de memoria cuando el proceso experimenta excepciones. SQL Server pasa marcas a la utilidad Sqldumper.exe datos. Puede usar marcas de seguimiento para cambiar las marcas que SQL Server pasa a la utilidad en el contexto de una excepción o en el contexto de una aserción. Estas marcas de seguimiento están entre 2540 y 2559. Puede usar estas marcas de seguimiento para generar determinados tipos de archivos de volcado de memoria. Por ejemplo:

  • Marca de seguimiento 2551: produce un volcado de memoria filtrado.
  • Marca de seguimiento 2544: produce un volcado de memoria completo.
  • Marca de seguimiento 8026: SQL Server borrará un desencadenador de volcado de memoria después de generar el volcado de memoria una vez.

Si hay dos o más marcas de seguimiento activas, se respetará la opción que indica el volcado de memoria más grande. Por ejemplo, si se usan las marcas de seguimiento 2551 y 2544, SQL Server creará un volcado de memoria completo.

Cómo obtener un identificador de proceso de aplicación de Microsoft Windows

Para generar un archivo de volcado de memoria mediante la utilidad Sqldumper.exe, debes tener el identificador de proceso de la aplicación de Windows para la que quieres generar un archivo de volcado de memoria. Para obtener el identificador del proceso, siga estos pasos:

  1. Presione CTRL+ALT+SUPR y, a continuación, seleccione Administrador de tareas.
  2. En el cuadro de diálogo Administrador de tareas de Windows, seleccione la pestaña Procesos.
  3. En el menú Ver, seleccione Seleccionar columnas.
  4. En el cuadro de diálogo Seleccionar columnas, haga clic para activar la casilla PID (Identificador de proceso) y, a continuación, seleccione Aceptar.
  5. Observa el identificador de proceso de la aplicación de Windows para la que quieres generar un archivo de volcado de memoria. Para la SQL Server, observe el identificador de proceso del Sqlservr.exe proceso.
  6. Cierre el Administrador de tareas.

También puede obtener el identificador de proceso de la SQL Server que se ejecuta en el equipo mediante el archivo de registro SQL Server de errores. Por ejemplo, parte del archivo de registro SQL Server de errores se asemeja a lo siguiente:

Fecha y hora del servidor Microsoft SQL Server 2005 - 9.00.1399.06 (Intel X86)
Fecha y hora
Copyright (c) 1988-2005 Microsoft Corporation
Enterprise Edition en Windows NT 5.2 (compilación 3790: Service Pack 1)

Servidor de fecha y hora (c) 2005 Microsoft Corporation.
Servidor de fecha y hora Reservados todos los derechos.
El identificador de proceso del servidor de fecha y hora es 3716.

El número que aparece después del identificador de proceso de servidor es el identificador de proceso del Sqlservr.exe proceso.

Conmutación por error de clúster y la utilidad Sqldumper.exe clúster

En escenarios de conmutación por error de clúster, SQL Server DLL de recursos de clúster ahora puede obtener un archivo de volcado de memoria antes de que se produzca la conmutación por error. Cuando la DLL del recurso SQL Server determina que se ha fallado un recurso SQL Server, la DLL de recursos de SQL Server usa la utilidad Sqldumper.exe para obtener un archivo de volcado del proceso SQL Server. Para asegurarse de que la Sqldumper.exe genera correctamente el archivo de volcado de memoria, debe establecer las tres propiedades siguientes como requisitos previos:

  • SqlDumperDumpTimeOut Tiempo de espera especificado por el usuario. La DLL de recursos espera a que se complete el archivo de volcado de memoria antes de que la DLL de recursos detenga SQL Server servicio.
  • SqlDumperDumpPath
    Ubicación donde la utilidad Sqldumper.exe genera el archivo de volcado de memoria.
  • SqlDumperDumpFlags
    Marcas que usa la Sqldumper.exe de datos.

Si alguna de las propiedades no está establecida, la Sqldumper.exe no puede generar el archivo de volcado de memoria. Se registrará un mensaje de advertencia tanto en el registro de eventos como en el registro de clúster siempre que el recurso esté conectado.

Para SQL Server 2012 y versiones posteriores

Puede usar el comando ALTER SERVER CONFIGURATION (T-SQL) para modificar estas propiedades. Por ejemplo:

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;

Como alternativa, puede usar scripts de PowerShell. Por ejemplo, para una instancia con nombre 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

Para validar que se ha aplicado la configuración, puede ejecutar este comando de PowerShell:

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

Para SQL Server 2008/2008 R2 o Windows 2012 y versiones anteriores

Para establecer las propiedades de Sqldumper.exe para la conmutación por error del clúster, siga estos pasos:

  1. Seleccione Inicio, ejecutar, escriba cmd y, a continuación, seleccione Aceptar.
  2. Para cada propiedad, escriba el comando correspondiente en el símbolo del sistema y, a continuación, presione ENTRAR:
    • La propiedad Para establecer la propiedad para un tipo específico de archivo de volcado de memoria, escriba el comando correspondiente en el símbolo del sistema SqlDumperDumpFlags SqlDumperDumpFlags y, a continuación, presione ENTRAR:

      • Archivo de volcado completo de subprocesos

        • Instancia predeterminada
          recurso de clúster "SQL Server" /priv SqlDumperDumpFlags = 0x01100

        • Instancia con nombre
          recurso de clúster "SQL Server (INSTANCE1)" /priv SqlDumperDumpFlags = 0x01100

      • Todos los archivos de minivolcación de subprocesos

        • Instancia predeterminada
          recurso de clúster "SQL Server" /priv SqlDumperDumpFlags = 0x0120
        • Instancia con nombre
          recurso de clúster "SQL Server (INSTANCE1)" /priv SqlDumperDumpFlags = 0x0120
      • Filtrado de todos los archivos de volcado de subprocesos

        • Instancia predeterminada
          recurso de clúster "SQL Server" /priv SqlDumperDumpFlags = 0x8100

        • Instancia con nombre
          recurso de clúster "SQL Server (INSTANCE1)" /priv SqlDumperDumpFlags = 0x8100

    • La SqlDumperDumpPath propiedad

      recurso de clúster "SQL Server" /priv SqlDumperDumpPath= DirectoryPath

      Nota

      DirectoryPath es un marcador de posición para el directorio en el que se generará el archivo de volcado de memoria y debe especificarse entre comillas (" ").

    • La propiedad SqlDumperDumpTimeOut

      recurso de clúster "SQL Server" /priv SqlDumperDumpTimeOut= Timeout

      Nota

      El tiempo de espera es un marcador de posición para el tiempo de espera en milisegundos (ms).

      El tiempo que tarda la utilidad en generar un archivo de volcado de memoria SQL Server proceso depende de la configuración del equipo. En el caso de un equipo que tiene mucha memoria, el tiempo podría ser importante. Para obtener una estimación del tiempo que tarda el proceso, use la utilidad Sqldumper.exe para generar manualmente un archivo de volcado de memoria. Los valores válidos para la propiedad SqlDumperDumpTimeOut van de 10.000 ms a MAXDWORD. MAXDWORD representa el valor más alto del intervalo del tipo de datos DWORD (4294967295).

Para comprobar que la configuración se ha habilitado, puede ejecutar el siguiente comando:

cluster resource "SQL Server" /priv "

Para quitar las propiedades de Sqldumper.exe para la conmutación por error del clúster, siga estos pasos:

  1. Seleccione Inicio, ejecutar, escriba cmd y, a continuación, seleccione Aceptar.
  2. Para una propiedad específica, escriba el comando correspondiente en el símbolo del sistema y, a continuación, presione ENTRAR:
    • La SqlDumperDumpFlags propiedad

      • Instancia predeterminada
        recurso de clúster "SQL Server" /priv:SqlDumperDumpFlags /usedefault
      • Instancia con nombre
        recurso de clúster "SQL Server (INSTANCIA1)" /priv:SqlDumperDumpFlags /usedefault
    • La SqlDumperDumpPath propiedad

      • Instancia predeterminada
        recurso de clúster "SQL Server" /priv:SqlDumperDumpPath /usedefault
      • Instancia con nombre
        recurso de clúster "SQL Server (INSTANCIA1)" /priv:SqlDumperDumpPath /usedefault
    • La SqlDumperDumpTimeOut propiedad

      • Instancia predeterminada
        recurso de clúster "SQL Server" /priv:SqlDumperDumpTimeOut /usedefault
      • Instancia con nombre
        recurso de clúster "SQL Server (INSTANCIA1)" /priv:SqlDumperDumpTimeOut /usedefault

Cómo usar DBCC STACKDUMP

El comando puede ayudarle a crear un volcado de memoria en el directorio LOG de DBCC STACKDUMP la SQL Server de la instancia. De forma predeterminada, el comando creará un minidump con todos los subprocesos, que tiene un tamaño limitado y es adecuado para reflejar el estado de SQL Server proceso. Simplemente ejecute el siguiente comando en un SQL Server cliente:

 DBCC STACKDUMP

Para habilitar este método para crear un volcado filtrado, active las marcas de seguimiento 2551 con el siguiente comando:

dbcc traceon(2551, -1)
go
dbcc stackdump

Para crear un volcado completo, use la marca de seguimiento 2544.

Nota

Después de obtener el archivo de volcado SQL Server de memoria, debe deshabilitar la marca de seguimiento mediante el siguiente comando para evitar la actualización involuntaria de todos los minidumps de autodiagnóstico lejos a volcados de memoria más grandes:

DBCC TRACEOFF (TraceNumber, -1);
GO

Dónde está la marca de seguimiento que ha habilitado TraceNumber anteriormente como 2551 o 2544.

En caso de que no esté seguro de qué marca de seguimiento permanece activa, puede ejecutar:

 DBCC TRACESTATUS(-1)

Un conjunto de resultados vacío indica que no hay ninguna marca de seguimiento activa. Por el contrario, si 2551 sigue activo, verá:

TraceFlag Estado Global Sesión
2551 1 1 0

Nota

Los traceflag servicios habilitados por DBCC TRACEON se restablecen (se quitan) después de reiniciar el servicio.

Cómo usar un script de PowerShell para generar un archivo de volcado de memoria con SQLDumper

  • Guarde el código siguiente como un archivo ps1, por ejemplo, SQLDumpHelper.ps1:

    Detalles del código

    $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!"
         #break
    }
    #what product would you like to generate a memory dump
    while(($ProductNumber -ne "1") -and ($ProductNumber -ne "2") -and ($ProductNumber -ne "3") -and ($ProductNumber -ne "4") -and ($ProductNumber -ne "5"))
    {
        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 -ne "1") -and ($ProductNumber -ne "2") -and ($ProductNumber -ne "3") -and ($ProductNumber -ne "4")-and ($ProductNumber -ne "5"))
        {
            Write-Host ""
            Write-Host "Please enter a valid number from list above!"
            Write-Host ""
            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 curerntly 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(($isInt -eq $false) -or ($ValidPid -eq $false))
        {
            Write-Host "Please enter the PID for the desired SQL service from list above" -ForegroundColor Yellow
            $SqlPidStr = Read-Host ">"
    
                try
                {
                    $SqlPidInt = [convert]::ToInt32($SqlPidStr)
                    $isInt = $true
                }
                catch [FormatException]
                {
                     Write-Host "The value entered for PID '",$SqlPidStr,"' is not an integer"
                }
    
            #validate this PID is in the list discovered
            for($i=0;$i -lt $SqlTaskList.Count;$i++)
            {
                if($SqlPidInt -eq [int]$SqlTaskList.PID[$i])
                {
                    $ValidPid = $true
                    break;
                }
                else
                {
                    $ValidPid = $false
                }
            }
         }
         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(($SqlDumpTypeSelection  -ne "1") -and ($SqlDumpTypeSelection -ne "2") -And ($SqlDumpTypeSelection -ne "3") -And ($SqlDumpTypeSelection -ne "4" ))
        {
            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 -ne "1") -and ($SqlDumpTypeSelection -ne "2") -And ($SqlDumpTypeSelection -ne "3") -And ($SqlDumpTypeSelection -ne "4" ))
            {
                Write-Host ""
                Write-Host "Please enter a valid type of memory dump!"
                Write-Host ""
                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(($SSASDumpTypeSelection  -ne "1") -and ($SSASDumpTypeSelection -ne "2"))
        {
            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 -ne "1") -and ($SSASDumpTypeSelection -ne "2"))
            {
                Write-Host ""
                Write-Host "Please enter a valid type of memory dump!"
                Write-Host ""
                Start-Sleep -Milliseconds 300
            }
        }
        Write-Host ""
        switch ($SSASDumpTypeSelection)
        {
            "1" {$DumpType="0x0";break}
            "2" {$DumpType="0x34";break}
            default {"0x0120"; break}
        }
    }
    elseif ($ProductNumber -eq "3" -or $ProductNumber -eq "4" -or $ProductNumber -eq "5")  #SSIS/SSRS/SQL Agent dump
    {
        #ask what type of SSIS memory dump
        while(($SSISDumpTypeSelection   -ne "1") -and ($SSISDumpTypeSelection  -ne "2"))
        {
            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  -ne "1") -and ($SSISDumpTypeSelection  -ne "2"))
            {
                Write-Host ""
                Write-Host "Please enter a valid type of memory dump!"
                Write-Host ""
                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
        }
    }
    #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"
    
        $TestPathResult = Test-Path -Path $SQLDumperDir
    
        if ($TestPathResult -eq $true)
        {
            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?" -ForegroundColor Yellow
    #validate Y/N input
    while (($YesNo -ne "y") -and ($YesNo -ne "n"))
    {
        $YesNo = Read-Host "Enter Y or N>"
        if (($YesNo -eq "y") -or ($YesNo -eq "n"))
        {
            break
        }
        else
        {
            Write-Host "Not a valid 'Y' or 'N' response"
        }
    }
    #get input on how many dumps and at what interval
    if ($YesNo -eq "y")
    {
        while(($isIntValDcnt -eq $false))
        {
            Write-Host "How many dumps would you like to generate for this SQL Server?" -ForegroundColor Yellow
            $DumpCountStr = Read-Host ">"
    
            try
            {
                $DumpCountInt = [convert]::ToInt32($DumpCountStr)
                $isIntValDcnt = $true
            }
            catch [FormatException]
             {
                 Write-Host "The value entered for dump count '",$DumpCountStr,"' is not an integer"
             }
        }
        while(($isIntValDelay -eq $false))
          {
              Write-Host "How frequently (in seconds) would you like to generate the memory dumps?" -ForegroundColor Yellow
              $DelayIntervalStr = Read-Host ">"
    
              try{
                      $DelayIntervalInt = [convert]::ToInt32($DelayIntervalStr)
                      $isIntValDelay = $true
                  }
              catch [FormatException]
                  {
                       Write-Host "The value entered for frequency (in seconds)'",$DelayIntervalStr,"' is not an integer"
                  }
          }
        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'. `Or if SQLDumper.exe failed look in the folder from which you are running this script"
    
  • Ejecutarlo desde el símbolo del sistema como administrador **** mediante el siguiente comando:

    Powershell.exe -File SQLDumpHelper.ps1
    
  • También puede ejecutarlo desde Windows PowerShell consola y ejecutarlo como administrador mediante el siguiente comando:

    .\SQLDumpHelper.ps1
    

Nota

Si nunca ha ejecutado scripts de PowerShell en el sistema, es posible que reciba el mensaje de error: no se puede cargar el archivo ...SQLDumpHelper.ps1 porque la ejecución de scripts está deshabilitada en este sistema."

Debe habilitar la capacidad de ejecutarlos siguiendo estos pasos:

  1. Inicie Windows PowerShell consola con la opción Ejecutar como administrador. Solo los miembros del grupo Administradores del equipo pueden cambiar la directiva de ejecución.

  2. Habilite la ejecución de scripts sin signo mediante el siguiente comando:

    Set-ExecutionPolicy RemoteSigned
    

    Nota

    Esto le permitirá ejecutar scripts sin firmar que cree en el equipo local y scripts firmados desde Internet.