Técnicas para manejar lecturas cortas/escrituras con scatter-gather?

Question

Dispersión-recopilar - readv()/writev()/preadv()/pwritev() - lecturas/escrituras un número variable de estructuras iovec en una sola llamada al sistema. Básicamente lee/escribe cada buffer de forma secuencial desde el 0 ° iovec hasta el N °. Sin embargo, según la documentación, también puede devolver menos en las llamadas de lectura/escritura de lo solicitado. Me preguntaba si existe una forma estándar/mejor práctica/elegante para manejar esa situación.

Si sólo estamos manejando un grupo de buffers de caracteres o similar, esto no es un gran problema. Pero una de las sutilezas es usar scatter-gather para estructuras y/o variables discretas como elementos individuales de iovec. ¿Cómo se maneja la situación en la que readv/writev solo lee/escribe una parte de una estructura o la mitad de una larga o algo así?

A continuación se muestra un código artificial de lo que quiero decir:

int fd; 

struct iovec iov[3]; 

long aLong = 74775767; 
int aInt = 949; 
char aBuff[100]; //filled from where ever 

ssize_t bytesWritten = 0; 
ssize_t bytesToWrite = 0; 

iov[0].iov_base = &aLong; 
iov[0].iov_len = sizeof(aLong); 
bytesToWrite += iov[0].iov_len; 

iov[1].iov_base = &aInt; 
iov[1].iov_len = sizeof(aInt); 
bytesToWrite += iov[1].iov_len; 

iov[2].iov_base = &aBuff; 
iov[2].iov_len = sizeof(aBuff); 
bytesToWrite += iov[2].iov_len; 

bytesWritten = writev(fd, iov, 3); 

if (bytesWritten == -1) 
{ 
    //handle error 
} 

if (bytesWritten < bytesToWrite) 
    //how to gracefully continue?......... 

Answer 1

utilizar un bucle como el siguiente para avanzar en la iov parcialmente procesada-:

for (;;) { 
    written = writev(fd, iov+cur, count-cur); 
    if (written < 0) goto error; 
    while (cur < count && written >= iov[cur].iov_len) 
     written -= iov[cur++].iov_len; 
    if (cur == count) break; 
    iov[cur].iov_base = (char *)iov[cur].iov_base + written; 
    iov[cur].iov_len -= written; 
} 

Tenga en cuenta que si no se comprueba para cur < count va a leer más allá del final de iov que puede contener cero.

Answer 2

escritura Vectored escribirá todos los datos que ha proporcionado con una llamada a la función "writev". Así, el octeto escrito siempre será igual al número total de bytes proporcionados como entrada. esto es lo que yo entiendo

Por favor, corríjanme si me equivoco

Answer 3

AFAICS las funciones de lectura/escritura con vectores funcionan de la misma WRT corto lee/escribe como los normales. Es decir, recuperas el número de bytes leídos/escritos, pero esto podría apuntar al centro de una estructura, al igual que con read()/write(). No hay garantía de que los posibles "puntos de interrupción" (a falta de un término mejor) coincidan con los límites del vector. Desafortunadamente, las funciones de IO vectorizado no ofrecen más ayuda para lidiar con lecturas cortas/escrituras que las funciones normales de IO. De hecho, es más complicado ya que necesita mapear el recuento de bytes en un elemento de vector IO y compensarlo dentro del elemento.

También tenga en cuenta que la idea de usar vectored IO para estructuras individuales o elementos de datos podría no funcionar tan bien; el valor máximo permitido para el argumento iovcnt (IOV_MAX) suele ser bastante pequeño, algo así como 1024 o más. Entonces, si sus datos son contiguos en la memoria, simplemente páselos como un solo elemento en lugar de dividirlos artificialmente.