¿Cómo verificar el progreso de ejecutar cp?

¿Es posible verificar el progreso de la ejecución del proceso de cp? Algunos procesos responden a varias señales de KILL para que pueda verificar cuál es su estado. Sé que puedo ejecutar cp con el parámetro -v, pero qué pasa si olvido hacerlo, cp se ejecuta durante mucho tiempo y quiero saber qué archivo se está copiando o cuántos ya se copiaron.

Sí, al ejecutar stat en el archivo de destino y el archivo local, y obtener un tamaño de archivo,

es decir stat -c "%s" /bin/ls

Y obtienes el porcentaje de datos copiados al comparar los dos valores, eso es todo

En una implementación muy básica que se verá así:

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
}

En las versiones recientes de Mac OS X, puede presionar CTRL+ Tpara ver el progreso. Desde la página de manual de OSX 10.6 para 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."

Golpear CTRL+ Tes equivalente a señalar el proceso actual con SIGINFO en máquinas BSD-ish, incluido OSX.

Esto funciona para dd (1) también.

No creo que Linux tenga este mecanismo SIGINFO, y no veo nada en la página de manual de GNU para cp (1) sobre las señales que se pueden usar para informar el progreso.

Cuando está copiando muchos archivos, du -s /path/to/destinationo find /path/to/destination | wc -lle da una idea de cuánto se ha hecho.

Puede averiguar qué archivo se está copiando lsof -p1234donde 1234 es la ID del proceso cp. En muchos sistemas, pgrep -x cpinforma los ID de proceso de todos los procesos en ejecución nombrados cp. Esto puede no ser muy útil ya que el orden en que se copian los archivos dentro de un directorio dado es esencialmente impredecible (en un directorio grande en Linux, ls --sort=nonese lo dirá; con un árbol de directorios, intente find).

lsof -p1234también le dice cuántos bytes cpya ha leído y escrito para el archivo actual, en la OFFSETcolumna.

En Linux, hay estadísticas de uso de E / S en /proc/$pid/io(nuevamente, use el PID del cpproceso para $pidf). El rcharvalor es el número total de bytes que el proceso ha leído, y wchares el número de bytes que el proceso ha escrito. Esto incluye no solo datos en archivos sino también metadatos en directorios. Puede comparar esa cifra con la cifra aproximada obtenida con du /path/to/source(que solo cuenta los datos del archivo). read_bytesy write_bytessolo incluye lo que se ha leído o escrito del almacenamiento, es decir, excluye el diagnóstico del terminal y los datos que ya están en la memoria caché o que todavía están en las memorias intermedias.

Una herramienta relativamente nueva que hace exactamente eso es el progreso (anteriormente cv [coreutils viewer]).

¿Qué es?

Esta herramienta se puede describir como un comando Tiny, Dirty, Linux-and-OSX-Only C que busca los comandos básicos de coreutils (cp, mv, dd, tar, gzip / gunzip, cat, etc.) que se ejecutan actualmente en su sistema y muestra el porcentaje de datos copiados.

¿Como funciona?

Simplemente busca /proccomandos interesantes y luego mira directorios fdy fdinfobusca archivos abiertos y busca posiciones, e informa el estado del archivo más grande.

Uno de mis trucos favoritos para esto (en Linux) es encontrar el PID del cpproceso (usando ps | grep cpo similar), y luego buscar /proc/$PID/fd/y /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

Esto le mostrará qué archivos ha abierto el proceso. Si quieres ver qué tan lejos del proceso está el archivo ...

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

El posparámetro es la posición del puntero de lectura (o escritura), en bytes.

Hay algunas cosas que puedes hacer. Puede adjuntarlo stracepara ver qué está haciendo (¡la salida puede ser copiosa!):

strace -p [pid de cp]

o podría lsofdecirle qué archivos tiene abiertos actualmente:

lsof -p [pid de cp]

Si está ejecutando un gran recursivo cp, puede usarlo pwdxpara obtener el directorio de trabajo actual, que puede darle una idea de cómo está funcionando:

pwdx [pid de cp]

Si bien el OP ha mencionado específicamente la capacidad de ver cómo progresa el comando "cp", hay que decir que otras utilidades son mejores para este problema en particular.

Por ejemplo:

rsync -avP FROM TO

mostrará el progreso de copiar el archivo / carpeta FROM al archivo / FOLDER TO.

# 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

Y rsync le dirá cuánto se copia (y la velocidad de transferencia) en el camino. Funciona para archivos o carpetas individuales en la misma máquina o en la red.

Lo que puede hacer es verificar los archivos en el destino.

Si sus comandos cp son similares cp -a <my_source> <my_dest_folder>, verificaría en qué archivos ya están copiados <my_dest_folder>y cada tamaño de archivo, para que pueda ver el progreso. Si el <my_source>es un poco complejo (varias capas de directorios), entonces un pequeño script podría verificar el estado. Aunque dicho script podría consumir un poco de E / S que el cpproceso no utilizaría .

Esta herramienta es un comando de utilidad de Linux que busca los comandos básicos de coreutils (cp, mv, dd, tar, gzip / gunzip, cat, etc.) que se ejecutan actualmente en su sistema y muestra el porcentaje de datos copiados:

https://github.com/Xfennec/cv

Me gustaría agregar cpvun pequeño contenedor para pveso que escribí que imita el uso de cp.

Simple y útil

Puedes conseguirlo aquí

También puede usar pipeviewer .

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

Uso pv -d:

-d PID[:FD], --watchfd PID[:FD]
En lugar de transferir datos, mire el descriptor FDde archivo del proceso PIDy muestre su progreso. […] Si solo PIDse especifica un, entonces ese proceso será observado, y todos los archivos normales y dispositivos de bloque que abra se mostrarán con una barra de progreso. El pvproceso se cerrará cuando PIDfinalice el proceso .

^{( fuente )}

Descubra el PID de su ejecución cp( pidof cp), digamos que es 12345; entonces simplemente

pv -d 12345

Notas:

• Ejecutar pvcomo el mismo usuario que ejecuta cp(o como root).
• Como copiar significa leer un archivo y escribir en el otro, espere ver dos archivos monitoreados a la vez.
• Si cpestá procesando archivos pequeños en este momento, probablemente no los verá a todos en la salida (un archivo pequeño puede cerrarse demasiado rápido para que pvpueda recogerlo). Sin embargo, aparecerán algunos, así que incluso entonces podrás decir qué cphace.
• pv -d "$(pidof cp)"podría funcionar; pero si hay más de uno cpcorriendo, no funcionará. Hay uno pidof -sque devuelve como máximo un PID, pero no puede estar seguro de que pertenecerá al cpproceso correcto si hay muchos.

Puede enviar una señal al proceso:

kill -SIGUSR1 pid

Es aún más útil crear un script que sondee hasta que presione Ctrl-C o el proceso finalice:

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

Funciona para dd. No funciona para cp . Quizás tengas que usar otra señal. Una vez probé SIGINFO, pero ya no parece existir en la plataforma Intel.