microsoft/procdump-for-linuxUna versione per Linux dello strumento Sysinternals ProcDump
# ProcDump [](https://dev.azure.com/sysinternals/Tools/_build/latest?definitionId=341&branchName=master)
ProcDump è una reimmaginazione per Linux e Mac del classico strumento ProcDump della suite Sysinternals per Windows. ProcDump offre un modo conveniente per gli sviluppatori Linux e Mac di creare core dump delle loro applicazioni basati su trigger di performance. ProcDump per Linux e Mac fa parte di [Sysinternals](https://sysinternals.com).
# Installazione e Utilizzo
## Requisiti
* Sistema operativo Linux minimo:
* Red Hat Enterprise Linux / CentOS 7
* Fedora 29
* Ubuntu 16.04 LTS
* `gdb` >= 7.6.1
* Mac OS minimo: Sierra
## Installare ProcDump
Si prega di vedere le istruzioni di installazione [qui](https://github.com/microsoft/procdump-for-linux/blob/master/INSTALL.md).
## Compilare
Si prega di vedere le istruzioni di compilazione [qui](https://github.com/microsoft/procdump-for-linux/blob/master/BUILD.md).
## Utilizzo
**MODIFICA SOSTANZIALE** Con il rilascio di ProcDump 1.3, gli switch sono ora allineati con la versione Windows di ProcDump.
Si noti che la versione [Mac](https://github.com/microsoft/ProcDump-for-Mac) attualmente ha un insieme limitato di trigger.
```
Capture Usage:
procdump [-n Count]
[-s Seconds]
[-c|-cl CPU_Usage]
[-m|-ml Commit_Usage1[,Commit_Usage2...]]
[-gcm [<GCGeneration>: | LOH: | POH:]Memory_Usage1[,Memory_Usage2...]]
[-gcgen Generation]
[-restrack [nodump]]
[-sr Sample_Rate]
[-tc Thread_Threshold]
[-fc FileDescriptor_Threshold]
[-sig Signal_Number1[,Signal_Number2...]]
[-e]
[-f Include_Filter,...]
[-fx Exclude_Filter]
[-mc Custom_Dump_Mask]
[-pf Polling_Frequency]
[-o]
[-log syslog|stdout]
{
{{[-w] Process_Name | [-pgid] PID} [Dump_File | Dump_Folder]}
}
Options:
-n Number of dumps to write before exiting.
-s Consecutive seconds before dump is written (default is 10).
-c CPU threshold above which to create a dump of the process.
-cl CPU threshold below which to create a dump of the process.
-m Memory commit threshold(s) (MB) above which to create dumps.
-ml Memory commit threshold(s) (MB) below which to create dumps.
-gcm [.NET] GC memory threshold(s) (MB) above which to create dumps for the specified generation or heap (default is total .NET memory usage).
-gcgen [.NET] Create dump when the garbage collection of the specified generation starts and finishes.
-restrack Enable memory leak tracking (malloc family of APIs). If used without other triggers, use 't' to manually capture a restrack report. When used with other triggers, the 'nodump' option can be used to prevent dump generation and only produce restrack report(s).
-sr Sample rate when using -restrack.
-tc Thread count threshold above which to create a dump of the process.
-fc File descriptor count threshold above which to create a dump of the process.
-sig Comma separated list of signal number(s) during which any signal results in a dump of the process.
-e [.NET] Create dump when the process encounters an exception.
-f Filter (include) on the content of .NET exceptions (comma separated). Wildcards (*) are supported.
-fx Filter (exclude) on the content of -restrack call stacks. Wildcards (*) are supported.
-mc Custom core dump mask (in hex) indicating what memory should be included in the core dump. Please see 'man core' (/proc/[pid]/coredump_filter) for available options.
-pf Polling frequency.
-o Overwrite existing dump file.
-log Writes extended ProcDump tracing to the specified output stream (syslog or stdout).
-w Wait for the specified process to launch if it's not running.
-pgid Process ID specified refers to a process group ID.
```
### Rilevamento delle risorse
Lo switch -restrack attiva il rilevamento delle risorse, consentendo il monitoraggio e la segnalazione di qualsiasi allocazione di risorse che non è stata liberata al momento della generazione del core dump. I risultati vengono salvati in un file con estensione '.restrack'. Attualmente, vengono tracciate le seguenti funzioni di allocazione/deallocazione delle risorse:
Allocazione:
* malloc
* calloc
* realloc
* reallocarray
* mmap
Deallocazione:
* free
* munmap
La versione Mac attualmente non implementa il rilevamento delle risorse.
### Esempi
> I seguenti esempi hanno tutti come target un processo con pid == 1234
Il seguente creerà un core dump immediatamente.
```
sudo procdump 1234
```
Il seguente creerà 3 core dump a distanza di 10 secondi.
```
sudo procdump -n 3 1234
```
Il seguente creerà 3 core dump a distanza di 5 secondi.
```
sudo procdump -n 3 -s 5 1234
```
Il seguente creerà un core dump ogni volta che l'utilizzo della CPU del processo è >= 65%, fino a 3 volte, con almeno 10 secondi tra ogni dump.
```
sudo procdump -c 65 -n 3 1234
```
Il seguente creerà un core dump ogni volta che l'utilizzo della CPU del processo è >= 65%, fino a 3 volte, con almeno 5 secondi tra ogni dump.
```
sudo procdump -c 65 -n 3 -s 5 1234
```
Il seguente creerà un core dump quando l'utilizzo della CPU è al di fuori dell'intervallo [10,65].
```
sudo procdump -cl 10 -c 65 1234
```
Il seguente creerà un core dump quando l'utilizzo della CPU è >= 65% o l'utilizzo della memoria è >= 100 MB.
```
sudo procdump -c 65 -m 100 1234
```
Il seguente creerà un core dump quando l'utilizzo della memoria è >= 100 MB seguito da un altro dump quando l'utilizzo della memoria è >= 200 MB.
```
sudo procdump -m 100,200 1234
```
Il seguente creerà un report di memory leak (nessun dump) ogni volta che l'utente preme 't':
```
sudo procdump -restrack 1234
```
Il seguente creerà 3 report di memory leak (nessun dump) a distanza di 5 secondi:
```
sudo procdump -n 3 -s 5 -restrack nodump 1234
```
Il seguente creerà un core dump e un report di memory leak quando l'utilizzo della memoria è >= 100 MB
```
sudo procdump -m 100 -restrack 1234
```
Il seguente creerà un report di memory leak (nessun dump) quando l'utilizzo della memoria è >= 100 MB
```
sudo procdump -m 100 -restrack nodump 1234
```
Il seguente creerà un core dump e un report di memory leak quando l'utilizzo della memoria è >= 100 MB campionando ogni decima allocazione di memoria.
```
sudo procdump -m 100 -restrack -sr 10 1234
```
Il seguente creerà un core dump e un report di memory leak quando l'utilizzo della memoria è >= 100 MB ed esclude tutti gli stack di chiamate che contengono frame con la stringa "cache"
```
sudo procdump -m 100 -restrack -fx *cache* 1234
```
Il seguente creerà un core dump quando l'utilizzo totale della memoria .NET è >= 100 MB seguito da un altro dump quando l'utilizzo della memoria è >= 200 MB.
```
sudo procdump -gcm 100,200 1234
```
Il seguente creerà un core dump quando l'utilizzo della memoria .NET per la generazione 1 è >= 1 MB seguito da un altro dump quando l'utilizzo della memoria è >= 2 MB.
```
sudo procdump -gcm 1:1,2 1234
```
Il seguente creerà un core dump quando l'utilizzo della memoria .NET Large Object Heap è >= 100 MB seguito da un altro dump quando l'utilizzo della memoria è >= 200 MB.
```
sudo procdump -gcm LOH:100,200 1234
```
Il seguente creerà un core dump all'inizio e alla fine di una garbage collection della generazione 1 .NET.
```
sudo procdump -gcgen 1
```
Il seguente creerà un core dump immediatamente nella directory `/tmp`.
```
sudo procdump 1234 /tmp
```
Il seguente creerà un core dump nella directory corrente con il nome dump_0.1234. Se viene usato -n, i file saranno nominati dump_0.1234, dump_1.1234 e così via.
```
sudo procdump 1234 dump
```
Il seguente creerà un core dump quando si verifica un SIGSEGV.
```
sudo procdump -sig 11 1234
```
Il seguente creerà un core dump quando si verifica un SIGSEGV in cui il core dump contiene solo mapping privati anonimi.
```
sudo procdump -mc 1 -sig 11 1234
```
Il seguente creerà un core dump quando l'applicazione .NET di destinazione lancia una System.InvalidOperationException
```
sudo procdump -e -f System.InvalidOperationException 1234
```
Il filtro di inclusione supporta la corrispondenza parziale e con wildcard, quindi anche il seguente creerà un core dump per una System.InvalidOperationException
```
sudo procdump -e -f InvalidOperation 1234
```
oppure
```
sudo procdump -e -f "*Invali*Operation*" 1234
```
> Tutte le opzioni possono anche essere usate con `-w`, per attendere qualsiasi processo con il nome specificato.
Il seguente attende un processo chiamato `my_application` e crea un core dump immediatamente quando viene trovato.
```
sudo procdump -w my_application
```
## Limitazioni attuali
* Attualmente funziona solo su Linux Kernel versione 3.5+ o macOS Sierra+.
* Non ha piena parità di funzionalità con la versione Windows di ProcDump, in particolare la funzionalità stay alive e i contatori di prestazioni personalizzati
# Feedback
* Fai una domanda su StackOverflow (tagga con ProcDumpForLinux)
* Richiedi una nuova funzionalità su GitHub
* Vota per le richieste di funzionalità più popolari
* Segnala un bug su GitHub Issues
# Contribuire
Se sei interessato a risolvere problemi e contribuire direttamente al codice, consulta il [documento Come contribuire](https://github.com/microsoft/procdump-for-linux/blob/master/CONTRIBUTING.md), che copre quanto segue:
* Come compilare ed eseguire dal sorgente
* Il flusso di lavoro di sviluppo, inclusi debug ed esecuzione di test
* Linee guida per la codifica
* Invio di pull request
Consulta anche il nostro [Codice di condotta](https://github.com/microsoft/procdump-for-linux/blob/master/CODE_OF_CONDUCT.md).
# Licenza
Copyright (c) Microsoft Corporation. Tutti i diritti riservati.
Concesso in licenza secondo i termini della MIT License.
ProcDump per Linux:
* Clona, compila e collega staticamente libbpf (https://github.com/libbpf/libbpf)
* Copia il codice sorgente per la risoluzione dei simboli da BCC (https://github.com/iovisor/bcc).
* Usa eBPF