Come eliminare automaticamente una directory quando viene ucciso un eseguibile

Molto spesso, eseguiamo un eseguibile che deve scrivere / leggere alcuni file temporanei. Generalmente creiamo una directory temporanea, eseguiamo lì l'eseguibile ed eliminiamo la directory quando lo script è terminato.

Voglio eliminare la directory anche se l'eseguibile viene ucciso. Ho cercato di avvolgerlo in:

#!/bin/bash
dir=$(mktemp -d /tmp/foo.XXXXXXX) && cd $dir && rm -rf $dir
/usr/local/bin/my_binary

Quando my_binarymuore, l'ultimo processo il kernel eliminerà la directory, poiché lo script è l'ultimo processo che lo tiene inode; ma non riesco a creare alcun file nella directory eliminata.

#!/bin/bash
dir=$(mktemp -d /tmp/foo.XXXXXXX) && cd $dir && rm -rf $dir
touch file.txt

uscite touch: file.txt: No such file or directory

Il meglio che potrei trovare è eliminare la directory temporanea quando il processo termina, catturando i segnali più comuni ed eseguire un processo di pulizia con cron:

#!/bin/bash
dir=$(mktemp -d /tmp/d.XXXXXX) && cd "$dir" || exit 99
trap 'rm -rf "$dir"' EXIT
/usr/local/bin/my_binary

Esiste un modo semplice per creare una directory davvero temporanea che viene eliminata automaticamente quando il file binario attuale muore, non importa quale?

Il tuo ultimo esempio è il più sicuro.

trap 'rm -rf "$dir"' EXIT

Questo verrà eseguito fintanto che la shell stessa sarà ancora funzionale. Fondamentalmente SIGKILL è l'unica cosa che non gestirà poiché la shell è forzatamente terminata.
(forse anche SIGSEGV, non ha provato, ma può essere catturato)

Se non lo lasci alla shell per ripulire dopo se stesso, l'unica altra alternativa possibile è che il kernel lo faccia. Questa non è normalmente una funzionalità del kernel, tuttavia c'è un trucco che puoi fare, ma ha i suoi problemi:

#!/bin/bash
mkdir /tmp/$$
mount -t tmpfs none /tmp/$$
cd /tmp/$$
umount -l /tmp/$$
rmdir /tmp/$$

do_stuff

Fondamentalmente crei un mount tmpfs e poi pigri smontalo. Una volta fatto, lo script verrà rimosso.
Il rovescio della medaglia, oltre ad essere eccessivamente complesso, è che se lo script muore per qualsiasi motivo prima dello smontaggio, non c'è un supporto in giro.
Questo utilizza anche tmpfs, che consumerà memoria. Ma potresti rendere il processo più complesso e utilizzare un filesystem loop e rimuovere il file che lo supporta dopo che è stato montato.

Alla fine trapè la cosa migliore in termini di semplicità e sicurezza e, a meno che la tua sceneggiatura non riceva regolarmente SIGKILL, resterei fedele.

È possibile utilizzare l' attesa integrata per attendere il completamento di un processo in background:

blah &
wait
rm -rf $DIR