10.2.1. ID processo e lignaggio Due degli attributi più fondamentali sono l'ID processo, o pid, e l'ID del suo processo padre. Pid è un numero intero positivo che identifica in modo univoco

10.2.3. Uid del filesystem In casi molto speciali, un programma potrebbe aver bisogno di mantenere i suoi permessi di root per tutto tranne l'accesso al filesystem, che usa l'uid dell'utente. Originariamente utilizzato nello spazio del server NFS Linux

ID dominio Quando si crea un dominio nel database, è necessario specificare un ID dominio che sia univoco a livello globale nel database. Gli sviluppatori utilizzano spesso un prefisso o un suffisso negli identificatori di dominio per migliorare la documentazione. Ad esempio: CREA

ID processo padre (PPID) L'identificatore del processo che lo ha generato

Ci sono momenti in cui l'applicazione inizia a presentare problemi e con essa l'intero ambiente di lavoro, ovviamente, è possibile riavviare il computer e la funzionalità stessa scomparirà, ma questa non è un'opzione per riavviare il computer ogni volta. E per questo c'è un comando Uccisione per aiutarti a fermare il processo congelato.

Squadra Uccisione può essere utilizzato per uccidere o terminare un processo utilizzando "Segnale" o "PID". Il comando Kill invia il segnale specificato per terminare l'applicazione che si comporta in modo anomalo. Se non viene specificato alcun segnale, viene inviato il segnale TERM. Questo segnale TERM ucciderà i processi che non lo catturano; per altri processi potrebbe essere necessario utilizzare il segnale Kill (numero 9), in quanto questo segnale non può essere intercettato.

SIGTERM è un segnale che richiede l'arresto del processo. A questo processo viene concesso del tempo per completare il suo lavoro.

Bene, con l'aiuto del segnale SIGKILL, possiamo forzare l'interruzione immediata del processo. E il Programma non ha il diritto di ignorare questo segnale e termina l'applicazione.

Il seguente è il formato del comando Kill:

uccidere [-segnale | -s segnale] pid ...

Il modo più semplice per terminare un processo è trovare il PID della risorsa e quindi eseguire il PID come argomento con il comando Kill.

Cos'è il PID?

A ogni processo o programma Linux o Unix in esecuzione viene assegnato automaticamente un numero di identificazione del processo (PID) univoco. Il PID assegna automaticamente un numero a ciascun processo nel sistema.

Puoi trovare il PID di una risorsa usando il comando "pidof" o il comando "ps". Per scoprire il PID di un processo (diciamo Firefox) usa il seguente comando

Pidof firefox

Puoi anche usare il comando in una forma diversa:

Ps -A | grep -i firefox

Nell'esempio sopra, viene visualizzato il numero "23814", che è il PID del processo Firefox. Una volta che conosci il PID del processo (firefox), puoi utilizzare il comando Kill per terminare il processo (Firefox) come mostrato di seguito.

Uccidi 23814

Quando il comando esegue la distruzione, ovvero invia un segnale al processo il cui PID viene passato insieme al comando come argomento.

Per essere più specifici, il comando Kill ha le seguenti forme:

• uccidere PID
• uccidere -15 PID
• uccidere -9 PID
• kill -SIGTERM PID
• kill -SIGTERM PID

Il comando Kill ha i seguenti codici di ritorno:

• 0 - in caso di successo
• 1 - fallimento
• 64 - successo parziale (se è specificato più di un processo)

Un altro comando che puoi usare è Uccidi tutti... Killall utilizza anche il nome del processo invece del PID e uccide tutte le istanze del processo con quel nome. Ad esempio, se hai avviato più istanze di Firefox, puoi terminarle tutte con il comando

Killall firefox

Per il server X, c'è un altro comando chiamato Xkill che può uccidere i processi. Il comando Xkill è per la modalità grafica, senza passare attraverso il nome del processo o il PID, cioè se si esegue in un terminale

Oggi parleremo di come gestire i processi che sono congelati e non è possibile terminarli in Ubuntu Linux. Divorano le risorse di sistema caricando il sistema, consumando una parte decente della RAM, il che crea problemi come il rallentamento del computer o il congelamento parziale del sistema per brevi periodi di tempo. Le situazioni sono diverse, a volte il desktop si blocca, a volte l'applicazione si blocca, a volte l'ambiente desktop si blocca, è da queste situazioni che cercheremo una via d'uscita su come fare senza riavviare il sistema e non spegnere il computer con un pulsante sull'unità di sistema del computer, poiché questa non è una buona soluzione.

A volte è necessario interrompere un processo in Ubuntu Linux, come farlo correttamente e non danneggiarlo, discuteremo sia delle soluzioni console che tramite un'interfaccia grafica.

Oggi parleremo di come gestire i processi che sono congelati e non è possibile terminarli in Ubuntu Linux. Divorano le risorse di sistema caricando il sistema, consumando una parte decente della RAM, il che crea problemi come il rallentamento del computer o il congelamento parziale del sistema per brevi periodi di tempo. Le situazioni sono diverse, a volte il desktop si blocca, a volte l'applicazione si blocca, a volte l'ambiente desktop si blocca, è da queste situazioni che cercheremo una via d'uscita, come fare senza riavviare il sistema e non spegnere il computer con un pulsante sull'unità di sistema del computer, poiché questa non è una buona soluzione ...

Quando lavori con Ubuntu Linux, probabilmente hai già delle domande:

Come determinare il PID per terminare successivamente il processo/l'applicazione

Se non vuoi eseguire il comando superiore o un altro analogo più potente htop, quindi preoccupati di cercare l'ID di questo o quell'ID del processo, c'è una via d'uscita / soluzione più semplice da trovare PID processo, puoi usare il comando " pidof" o " PS".

Diciamo che dobbiamo scoprire l'ID del processo dell'applicazione Google Chrome, cosa stiamo facendo in questa situazione, apriamo il terminale Ctrl + Alt + T ed eseguiamo il comando nel terminale:

Pidof chrome

otteniamo l'output:

9497 9183 9123 8815 8788 6042 6033 5938 5916 5911 5908 5900 5892 5836 5831 5819

quasi pronto, abbiamo determinato il PID, leggi come terminare il processo di seguito.

Come uccidere un processo in Linux tramite PID

Abbiamo determinato quale PID nell'applicazione vogliamo eliminare, da quanto sopra, puoi vedere che ho molte schede in esecuzione nel browser ora e oltre a processi del browser separati, di conseguenza, 16 idi, per ucciderli tutti, noi eseguire il comando:

Sudo kill 9497 9183 9123 8815 8788 6042 6033 5938 5916 5911 5908 5900 5892 5836 5831 5819

puoi anche visualizzare tutti i processi attivi nel sistema eseguendo il comando:

Sudo ps axu

si, proprio così. Invece di Chrome, può esserci qualsiasi altra applicazione, skype o qualcos'altro.

Puoi anche utilizzare un comando aggiuntivo per rilevare l'id del processo dell'applicazione che desideri eliminare:

Ps -A | grep -i nome-app

invece di nome-app scriviamo il nome dell'applicazione, non inserire manualmente il nome completo, usa il rilevamento automatico usando i tasti " TAB". Di conseguenza, questo comando visualizzerà il tempo di esecuzione del processo richiesto e, di conseguenza, il suo PID che puoi usare per uccidere, testiamo il comando eseguendo nel terminale:

Ps -A | grep -i skype

otteniamo il seguente risultato:

9257? 00:00:57 skype

tutto ciò di cui abbiamo bisogno è nel palmo della nostra mano, c'è un ID, vediamo anche da quanto tempo questo processo è già in esecuzione.

Come usare il comando Kill in Linux

Ho descritto come ottenere l'identificatore PID sopra, quindi dobbiamo solo usare questo PID insieme a kill per uccidere il processo indesiderato, vedere i dettagli un po' sotto.

Abbiamo capito e ora possiamo uccidere l'applicazione:

Sudo uccidere 9257

tutto qui, l'applicazione viene uccisa.

Come uccidere un processo in Linux per nome

Per uccidere un processo per nome, puoi usare il comando killall, devi prima capire che questo comando uccide tutti i processi che hanno lo stesso nome. Questo è molto conveniente, poiché in questa situazione non abbiamo bisogno di cercare il PID del processo di cui abbiamo bisogno, ad esempio, vogliamo chiudere l'applicazione Skype, eseguire il comando nel terminale:

Sudo killall skype

la stessa opzione:

Sudo killall -s 9 skype

nello stesso momento in cui l'applicazione smette di funzionare, ecco come puoi facilmente uccidere i processi che non ti piacciono.

Comando di morte, che non dovrebbe essere eseguito nel terminale

In precedenza ho scritto materiale sui cattivi consigli, quali comandi non dovrebbero essere eseguiti nel terminale per non uccidere il sistema, ma l'elenco non è perfetto e può essere integrato con molti altri comandi, uno con quello che troverai di seguito.

Lascia che ti faccia un esempio di comando di morte:

Sudo kill -9 -1

questo comando ucciderà tutti i processi attualmente in esecuzione. Non ti consiglierei di eseguirlo, poiché le conseguenze possono essere imprevedibili e molto probabilmente dovrai riavviare il sistema senza un'interfaccia grafica. Nel caso in cui l'interfaccia grafica si guasti improvvisamente, apri il terminale usando i comandi CTRL + ALT + F1, ogni nuova finestra viene aperta con la stessa analogia, cambia semplicemente F1 in F2 e così via.

Puoi anche ottenere aiuto sui comandi che sono stati usati sopra, tramite il terminale, eseguendo i comandi:

Man ps man grep man pidof man kill man killall

Questo conclude il nostro breve materiale, se non capisci qualcosa, chiedi nei commenti al materiale qui sotto.

In questo articolo, proveremo a creare un modulo del kernel in grado di modificare il PID di un processo già in esecuzione in Linux, nonché a sperimentare processi che hanno ricevuto un PID modificato.

Avvertimento Nota: la modifica del PID è un processo non standard e in determinate circostanze può portare al panico del kernel.

La nostra unità di test implementerà il dispositivo a caratteri / dev / test, che cambierà il PID del processo quando viene letto. Per un esempio dell'implementazione di un dispositivo a caratteri, grazie a questo articolo. Il codice completo del modulo è riportato alla fine dell'articolo. Ovviamente, la soluzione più corretta era aggiungere una chiamata di sistema al kernel stesso, ma ciò richiederebbe una ricompilazione del kernel.

Ambiente

Tentativo n. 1 soluzione semplice

La prima idea era semplicemente cambiare il parametro current-> pid dal modulo del kernel a quello desiderato.

Statico ssize_t device_read (file struct * filp, char * buffer, size_t length, loff_t * offset) (printk ("PID:% d. \ N", current-> pid); current-> pid = 1; printk ("new PID:% d. \ N ", corrente-> pid);,)
Per verificare la funzionalità del modulo, ho scritto un programma in C++:

#includere #includere #includere int main() (std :: cout<< "My parent PID " << getppid() << std::endl; std::cout << "My PID " << getpid() << std::endl; std::fstream f("/dev/test",std::ios_base::in); if(!f) { std::cout << "f error"; return -1; } std::string str; f >> str; std :: cout<< "My new PID " << getpid() << std::endl; execl("/bin/bash","/bin/bash",NULL); }
Carica il modulo con insmod, crea / dev / test e provalo.

# ./a.out Il mio PID genitore 293 Il mio PID 782 Il mio nuovo PID 782
Il PID non è cambiato. Questo potrebbe non essere l'unico posto in cui è elencato il PID.

Tentativo # 2 campi PID aggiuntivi

Compilare, provare

Dato che ho testato su SSH, sono stato in grado di ottenere l'output del programma prima che il kernel si bloccasse:

Il mio genitore PID 293 Il mio PID 1689 Il mio nuovo PID 1689
Il primo risultato è già qualcosa. Ma il PID non è ancora cambiato.

Tentativo n. 3 simboli del kernel non esportati

Questa funzione accetta solo lo spazio dei nomi in cui si troverà il nuovo PID, questo spazio può essere ottenuto utilizzando task_active_pid_ns.
Ma c'è un problema: questi simboli del kernel non vengono esportati dal kernel e non possono essere usati nei moduli. Nel risolvere questo problema, uno meraviglioso mi ha aiutato. Il codice della funzione find_sym è preso da lì.

Asmlinkage void statico (* change_pidR) (struct task_struct * task, enum pid_type type, struct pid * pid); static asmlinkage struct pid * (* alloc_pidR) (struct pid_namespace * ns); static int __init test_init (void) (printk (KERN_ALERT "TEST driver caricato! \ n"); change_pidR = find_sym ("change_pid"); alloc_pidR = find_sym ("alloc_pid"); ...) static ssize_t device_read (file struct * filp, char * buffer, size_t length, loff_t * offset) (printk ("PID:% d. \ n", current-> pid); struct pid * newpid; newpid = alloc_pidR (task_active_pid_ns (current)); change_pidR (current , PIDTYPE_PID, newpid); printk ("nuovo PID:% d. \ N", corrente-> pid); ...)
Complimenti, lancio

Il mio genitore PID 299 Il mio PID 750 Il mio nuovo PID 751
PID cambiato! Il kernel ha assegnato automaticamente un PID gratuito al nostro programma. Ma è possibile utilizzare un PID che ha preso il sopravvento su un altro processo, come il PID 1? Aggiungi il codice dopo l'assegnazione

Newpid-> numeri.nr = 1;
Complimenti, lancio

Il mio genitore PID 314 Il mio PID 1172 Il mio nuovo PID 1
Otteniamo il vero PID 1!

Bash ha dato un errore in cui l'attivazione dell'attività su comando% n non funzionerà, ma tutte le altre funzioni funzionano correttamente.

Caratteristiche interessanti dei processi con PID modificato

PID 0: non si può uscire da invio

Newpid-> numeri.nr = 0;
Complimenti, lancio

Il mio genitore PID284 Il mio PID 1517 Il mio nuovo PID 0
Quindi il PID 0 non è così speciale? Siamo contenti, scrivi exit e...

Il nucleo sta cadendo! Il kernel ha definito il nostro compito come IDLE TASK e quando ha visto il completamento si è semplicemente bloccato. Apparentemente, prima della conclusione, il nostro programma dovrebbe restituire a se stesso il PID "normale".

Il processo invisibile

Complimenti, lancio

Il mio genitore PID296 Il mio PID 735 Il mio nuovo PID 12345
Vediamo cosa c'è in / proc

1 148 19 224 288 37 79 86 93 console fb kcore blocca partizioni scambia versione 10 149 2 226 29 4 8 87 acpi cpuinfo filesystem key-users meminfo sched_debug sys vmallocinfo 102 15 20 23 290 5 80 88 asound crypto fs keys misc schedstat sysrq- trigger vmstat 11 16 208 24 291 6 81 89 dispositivi buddyinfo interrupt kmsg moduli scsi sysvipc zoneinfo 12 17 21 25 296 7 82 9 bus diskstats iomem kpagecgroup mounts self thread-self 13 176 210 26 3 737 83 90 cgroups dma ioports kpagecount mtrr slabinfo timer_list 139 18 22 27 30 76 84 91 cmdline driver irq kpageflags net softirqs tty 14 182 222 28 31 78 85 92 config.gz execdomains kallsyms loadavg pagetypeinfo stat uptime
Come puoi vedere / proc non definisce il nostro processo, anche se abbiamo preso in prestito un PID gratuito. Anche il PID precedente non è in / proc, il che è molto strano. Potremmo trovarci in uno spazio dei nomi diverso e quindi non visibile al main / proc. Montiamo un nuovo / proc e vediamo cosa c'è dentro

1 14 18 210 25 291 738 81 9 dispositivi bus fs key-user locks pagetypeinfo softirqs timer_list 10 148 182 22 26 296 741 82 90 cgroups diskstats interrompe le chiavi meminfo partizioni stat tty 102 149 19 222 27 30 76 83 92 cmdline dma iomem kmsg misc sched_debug scambia uptime 11 15 2 224 28 37 78 84 93 driver config.gz ioports kpagecgroup moduli schedstat sys versione 12 16 20 226 288 4 79 85 console acpi execdomains irq kpagecount monta scsi sysrq-trigger vmallocinfo 13 17 208 23 29 6 8 86 asound cpuinfo fb ​​​​kallsyms kpageflags mtrr self sysvipc vmstat 139 176 21 24 290 7 80 87 buddyinfo crypto filesystem kcore loadavg net slabinfo thread-self zoneinfo
Come prima, il nostro processo non è presente, il che significa che siamo in un normale spazio dei nomi. Dai un'occhiata

Ps -e | grep bash
296 punti / 0 00:00:00 bash

Solo una bash, da cui abbiamo eseguito il programma. Né il PID precedente né quello attuale sono nell'elenco.