Come verificare lo stato di avanzamento di cp?

È possibile verificare lo stato di avanzamento del processo cp? Alcuni processi rispondono a vari segnali KILL in modo da poter controllare qual è il loro stato. So che posso eseguire cp con il parametro -v ma cosa succede se ho dimenticato di farlo, cp è in esecuzione da molto tempo e voglio sapere quale file viene copiato o quanti sono già stati copiati.

Sì, eseguendo stat sul file di destinazione e sul file locale e ottenendo una dimensione del file,

vale a dire stat -c "%s" /bin/ls

E ottieni la percentuale di dati copiati confrontando i due valori, tutto qui

In un'implementazione molto semplice che sarà simile a questa:

function cpstat()
{
  local pid="${1:-$(pgrep -xn cp)}" src dst
  [[ "$pid" ]] || return
  while [[ -f "/proc/$pid/fd/3" ]]; do
    read src dst < <(stat -L --printf '%s ' "/proc/$pid/fd/"{3,4})
    (( src )) || break
    printf 'cp %d%%\r' $((dst*100/src))
    sleep 1
  done
  echo
}

Nelle versioni recenti di Mac OS X puoi semplicemente premere CTRL+ Tper vedere i progressi. Dalla pagina man OSX 10.6 per cp (1) :

 "If cp receives a SIGINFO (see the status argument for stty(1)) signal,
 the current input and output file and the percentage complete will be
 written to the standard output."

Colpire CTRL+ Tequivale a segnalare l'attuale processo con SIGINFO su macchine BSD, incluso OSX.

Questo funziona anche con dd (1) .

Non penso che Linux abbia questo meccanismo SIGINFO e non vedo nulla nella pagina man di GNU per cp (1) sui segnali che possono essere usati per riportare i progressi.

Quando stai copiando molti file du -s /path/to/destinationo find /path/to/destination | wc -lti dà un'idea di quanto è già stato fatto.

È possibile scoprire con quale file viene copiato il punto in lsof -p1234cui 1234 è l'ID del processo cp. In molti sistemi, pgrep -x cpriporta gli ID di processo di tutti i processi in esecuzione denominati cp. Questo potrebbe non essere molto utile poiché l'ordine in cui vengono copiati i file all'interno di una determinata directory è essenzialmente imprevedibile (in una grande directory sotto Linux, te ls --sort=nonelo dirò; con un albero di directory, prova find).

lsof -p1234ti dice anche quanti byte cpha già letto e scritto per il file corrente, nella OFFSETcolonna.

Sotto Linux, ci sono statistiche sull'utilizzo degli I / O /proc/$pid/io(di nuovo, utilizzare il PID del cpprocesso per $pidf). Il rcharvalore è il numero totale di byte letti dal processo ed wcharè il numero di byte scritti dal processo. Ciò include non solo i dati nei file ma anche i metadati nelle directory. Puoi confrontare quella cifra con la cifra approssimativa ottenuta con du /path/to/source(che conta solo i dati del file). read_bytese write_bytesinclude solo ciò che è stato letto o scritto dalla memoria, ovvero esclude la diagnostica del terminale e i dati già nella cache o ancora nei buffer.

Uno strumento relativamente nuovo che fa esattamente questo è il progresso (precedentemente cv [coreutils viewer]).

Che cos'è?

Questo strumento può essere descritto come un comando Tiny, Dirty, solo Linux e OSX-Solo C che cerca i comandi di base coreutils (cp, mv, dd, tar, gzip / gunzip, cat, ecc.) Attualmente in esecuzione sul sistema e visualizza la percentuale di dati copiati.

Come funziona?

Cerca semplicemente /proci comandi interessanti, quindi cerca le directory fde fdinfotrova i file aperti e cerca le posizioni, e riporta lo stato del file più grande.

Uno dei miei trucchi preferiti per questo (sotto Linux) è scoprire il PID del cpprocesso (usando ps | grep cpo simili), e poi guardare dentro /proc/$PID/fd/e /proc/$PID/fdinfo/.

$ cp -r y z
^Z
$ ls -l /proc/8614/fd
lrwx------ 1 jander jander 64 Aug  2 15:21 0 -> /dev/pts/4
lrwx------ 1 jander jander 64 Aug  2 15:21 1 -> /dev/pts/4
lrwx------ 1 jander jander 64 Aug  2 15:20 2 -> /dev/pts/4
lr-x------ 1 jander jander 64 Aug  2 15:21 3 -> /home/jander/y/foo.tgz
l-wx------ 1 jander jander 64 Aug  2 15:21 4 -> /home/jander/z/foo.tgz

Questo ti mostrerà quali file ha aperto il processo. Se vuoi vedere fino a che punto è il processo ...

$ cat /proc/8614/fdinfo/3
pos:    105381888
flags:  0500000

il posparametro è la posizione del puntatore di lettura (o scrittura), in byte.

Ci sono alcune cose che puoi fare. Potresti collegarti stracead esso per vedere cosa sta facendo (l'output potrebbe essere abbondante!):

strace -p [pid di cp]

oppure potresti lsofdirti quali file ha attualmente aperto:

lsof -p [pid of cp]

Se stai eseguendo un grande ricorsivo cp, potresti usare pwdxper ottenere l'attuale directory di lavoro, che potrebbe darti un'idea di come sta andando:

pwdx [pid of cp]

Mentre il PO ha specificamente menzionato la capacità di vedere come sta procedendo il comando "cp", bisogna dire che altre utilità sono migliori per questo particolare problema.

Per esempio:

rsync -avP FROM TO

mostrerà l'avanzamento della copia del file / cartella FROM nel file TO / FOLDER.

# rsync -avP Video.mp4  /run/media/user1/3.8G/

sending incremental file list
Video.mp4
    565,170,046 100%   51.23MB/s    0:00:10 (xfr#1, to-chk=0/1)

sent 565,308,115 bytes  received 134 bytes  5,210,214.28 bytes/sec
total size is 565,170,046  speedup is 1.00

E rsync ti dirà quanto viene copiato (e la velocità di trasferimento) lungo il percorso. Funziona per singoli file o cartelle sia sullo stesso computer che attraverso la rete.

Quello che puoi fare è controllare i file a destinazione.

Se i tuoi comandi cp sono simili cp -a <my_source> <my_dest_folder>, verificherei quali file sono già stati copiati <my_dest_folder>e ogni dimensione del file, in modo da poter vedere i progressi. Se <my_source>è un po 'complesso (diversi livelli di directory), un piccolo script sarebbe in grado di controllare lo stato. Sebbene un tale script potrebbe consumare un po 'di I / O che non verrebbe utilizzato dal cpprocesso.

Questo strumento è un comando di utilità Linux che cerca i comandi base di coreutils (cp, mv, dd, tar, gzip / gunzip, cat, ecc.) Attualmente in esecuzione sul sistema e visualizza la percentuale di dati copiati:

https://github.com/Xfennec/cv

Vorrei aggiungere cpvun piccolo wrapper per pvquello che ho scritto che imita l'utilizzo di cp.

Semplice e utile

Puoi ottenerlo qui

Puoi anche usare pipeviewer .

for f in *; do
  pv $f > destination/$f
done

Utilizzare pv -d:

-d PID[:FD], --watchfd PID[:FD]
Invece di trasferire i dati, guarda il descrittore FDdi file del processo PIDe mostra i suoi progressi. […] Se PIDviene specificato solo un , allora quel processo sarà guardato, e tutti i normali file e dispositivi di blocco che si apriranno verranno mostrati con una barra di avanzamento. Il pvprocesso terminerà quando il processo PIDtermina.

^{( fonte )}

Scopri il PID del tuo running cp( pidof cp), diciamo che è 12345; quindi semplicemente

pv -d 12345

Appunti:

• Esegui pvcome lo stesso utente che esegue cp(o come root).
• Poiché copiare significa leggere un file e scrivere sull'altro, aspettati di vedere due file monitorati alla volta.
• Se cpal momento sta elaborando file di piccole dimensioni, probabilmente non li vedrai tutti nell'output (un file di piccole dimensioni potrebbe chiudersi troppo velocemente per pvpoterlo raccogliere). Eppure alcuni appariranno, quindi anche allora sarai in grado di dire cosa cpsuccede.
• pv -d "$(pidof cp)"può funzionare; ma se ce n'è più di uno in cpesecuzione, non funzionerà. C'è quello pidof -sche restituisce al massimo un PID, ma non puoi essere sicuro che apparterrà al cpprocesso giusto se ce ne sono molti.

È possibile inviare un segnale al processo:

kill -SIGUSR1 pid

È ancora più utile creare uno script che esegue il polling fino a quando non si preme Ctrl-C o il processo termina:

while [ : ] ; do kill -SIGUSR1 $1 && sleep 1m || exit ; done

Funziona per dd. Non funziona per cp . Forse devi usare un altro segnale. Una volta ho provato SIGINFO, ma non sembra esistere più sulla piattaforma Intel.