From 54bdd9a15d2e130c76f76ca322af56b306d02078 Mon Sep 17 00:00:00 2001 From: Lukas Larsson Date: Wed, 9 Nov 2011 11:52:14 +0100 Subject: Implement blocking calls for sendfile Move sendfile data to invoke data instead of file_descr. Remove usage of ready_output when doing a send. If told to send 0 bytes, file_sendfile now sends the entire file for linux. --- erts/emulator/drivers/common/efile_drv.c | 206 +++++++++++++++---------------- erts/emulator/drivers/unix/unix_efile.c | 31 +++-- 2 files changed, 124 insertions(+), 113 deletions(-) (limited to 'erts/emulator/drivers') diff --git a/erts/emulator/drivers/common/efile_drv.c b/erts/emulator/drivers/common/efile_drv.c index b14f5844b2..4ed6aa4891 100644 --- a/erts/emulator/drivers/common/efile_drv.c +++ b/erts/emulator/drivers/common/efile_drv.c @@ -76,6 +76,11 @@ #define FILE_OPT_DELAYED_WRITE 0 #define FILE_OPT_READ_AHEAD 1 +#define FILE_SENDFILE_OFFSET 0x10 +#define FILE_SENDFILE_NBYTES 0x08 +#define FILE_SENDFILE_NODISKIO 0x4 +#define FILE_SENDFILE_MNOWAIT 0x2 +#define FILE_SENDFILE_SYNC 0x1 /* IPREAD variants */ @@ -218,7 +223,6 @@ typedef unsigned char uchar; static ErlDrvData file_start(ErlDrvPort port, char* command); static int file_init(void); static void file_stop(ErlDrvData); -static void file_ready_output(ErlDrvData data, ErlDrvEvent event); static void file_output(ErlDrvData, char* buf, int len); static int file_control(ErlDrvData, unsigned int command, char* buf, int len, char **rbuf, int rlen); @@ -226,7 +230,6 @@ static void file_timeout(ErlDrvData); static void file_outputv(ErlDrvData, ErlIOVec*); static void file_async_ready(ErlDrvData, ErlDrvThreadData); static void file_flush(ErlDrvData); -static void file_stop_select(ErlDrvEvent event, void* _); @@ -256,18 +259,6 @@ typedef struct { ErlDrvPDL q_mtx; /* Mutex for the driver queue, known by the emulator. Also used for mutual exclusion when accessing field(s) below. */ size_t write_buffered; - ErlDrvTermData caller; /* recipient of sync reply */ - /* sendfile call state to retry/resume on event */ - int command; /* same as d->command. for sendfile. TODO: this seems wrong */ - struct { - int eagain; - int out_fd; - /* TODO: Use Sint64 instead? What about 32-bit off_t linux */ - off_t offset; - size_t count; - size_t chunksize; - ErlDrvSInt64 written; - } sendfile; } file_descriptor; @@ -279,7 +270,7 @@ struct erl_drv_entry efile_driver_entry = { file_stop, NULL, NULL, - file_ready_output, + NULL, "efile", NULL, NULL, @@ -296,7 +287,7 @@ struct erl_drv_entry efile_driver_entry = { ERL_DRV_FLAG_USE_PORT_LOCKING, NULL, NULL, - file_stop_select + NULL }; @@ -415,6 +406,18 @@ struct t_data Sint64 length; int advise; } fadvise; +#ifdef HAVE_SENDFILE + struct { + int out_fd; + off_t offset; + size_t nbytes; + int flags; + int hdr_cnt; /* number of header iovecs */ + struct iovec *headers; /* pointer to header iovecs */ + int trl_cnt; /* number of trailer iovecs */ + struct iovec *trailers; /* pointer to trailer iovecs */ + } sendfile; +#endif } c; char b[1]; }; @@ -1710,71 +1713,27 @@ static void invoke_fadvise(void *data) d->result_ok = efile_fadvise(&d->errInfo, fd, offset, length, advise); } - - -static void do_sendfile(file_descriptor *desc); -static void file_ready_output(ErlDrvData data, ErlDrvEvent event) -{ - file_descriptor* d = (file_descriptor*) data; - - switch (d->command) { - case FILE_SENDFILE: - driver_select(d->port, (ErlDrvEvent)d->sendfile.out_fd, - ERL_DRV_WRITE, 0); - do_sendfile(d); - break; - default: - break; - } -} - -static void file_stop_select(ErlDrvEvent event, void* _) -{ - /* TODO: close socket? */ +static void free_sendfile(void *data) { + EF_FREE(data); } static void invoke_sendfile(void *data) { - ((struct t_data *)data)->again = 0; -} - -static void do_sendfile(file_descriptor *d) -{ - int fd = d->fd; - int out_fd = d->sendfile.out_fd; - off_t offset = d->sendfile.offset; - size_t count = d->sendfile.count; - size_t chunksize = count < d->sendfile.chunksize - ? count : d->sendfile.chunksize; - int result_ok = 0; - Efile_error errInfo; - - result_ok = efile_sendfile(&errInfo, fd, out_fd, &offset, &chunksize); - - if (result_ok) { - d->sendfile.offset += chunksize; - d->sendfile.written += chunksize; - d->sendfile.count -= chunksize; - if (d->sendfile.count > 0) { - driver_select(d->port, (ErlDrvEvent)d->sendfile.out_fd, - ERL_DRV_USE|ERL_DRV_WRITE, 1); - } else { - printf("==> sendfile DONE eagain=%d\n", d->sendfile.eagain); - reply_Uint(d, d->sendfile.written); - } - } else if (errInfo.posix_errno == EAGAIN || errInfo.posix_errno == EINTR) { - if (chunksize > 0) { - d->sendfile.offset += chunksize; - d->sendfile.written += chunksize; - d->sendfile.count -= chunksize; - } - d->sendfile.eagain++; + struct t_data *d = (struct t_data *) data; + int fd = (int)d->fd; + int out_fd = (int) d->c.sendfile.out_fd; + off_t offset = (off_t) d->c.sendfile.offset; + size_t nbytes = (size_t) d->c.sendfile.nbytes; + + d->result_ok = efile_sendfile(&d->errInfo, fd, out_fd, offset, &nbytes); + d->c.sendfile.offset = offset; + d->c.sendfile.nbytes = nbytes; + d->again = 0; - driver_select(d->port, (ErlDrvEvent)d->sendfile.out_fd, - ERL_DRV_USE|ERL_DRV_WRITE, 1); + if (d->result_ok) { + printf("==> sendfile DONE nbytes=%d\n", d->c.sendfile.nbytes); } else { - printf("==> sendfile ERROR %s\n", erl_errno_id(errInfo.posix_errno)); - ef_send_posix_error(d, d->caller, errInfo.posix_errno); + printf("==> sendfile ERROR %s\n", erl_errno_id(d->errInfo.posix_errno)); } } @@ -2190,9 +2149,12 @@ file_async_ready(ErlDrvData e, ErlDrvThreadData data) free_preadv(data); break; case FILE_SENDFILE: - driver_select(desc->port, (ErlDrvEvent)desc->sendfile.out_fd, - ERL_DRV_USE|ERL_DRV_WRITE, 1); - free_data(data); + if (!d->result_ok) { + reply_error(desc, &d->errInfo); + } else { + reply_Sint64(desc, d->c.sendfile.nbytes); + } + free_sendfile(data); break; default: abort(); @@ -3334,37 +3296,71 @@ file_outputv(ErlDrvData e, ErlIOVec *ev) { goto done; } /* case FILE_OPT_DELAYED_WRITE: */ } ASSERT(0); goto done; /* case FILE_SETOPT: */ - case FILE_SENDFILE: - { + case FILE_SENDFILE: { + struct t_data *d; - d = EF_SAFE_ALLOC(sizeof(struct t_data)); - d->fd = desc->fd; - d->command = command; - d->invoke = invoke_sendfile; - d->free = free_data; - d->level = 2; - desc->sendfile.out_fd = get_int32((uchar*) buf); - /* TODO: are off_t and size_t 64bit on all platforms? - off_t is 32bit on win32 msvc. maybe configurable in msvc. - Maybe use '#if SIZEOF_SIZE_T == 4'? */ - desc->sendfile.offset = get_int64(((uchar*) buf) - + sizeof(Sint32)); - desc->sendfile.count = get_int64(((uchar*) buf) - + sizeof(Sint32) - + sizeof(Sint64)); - desc->sendfile.chunksize = get_int64(((uchar*) buf) - + sizeof(Sint32) - + 2*sizeof(Sint64)); - desc->sendfile.written = 0; - desc->sendfile.eagain = 0; - /* TODO: shouldn't d->command be enough? */ - desc->command = command; - desc->caller = driver_caller(desc->port); + Uint32 out_fd, offsetH, offsetL, nbytesH, nbytesL; + char flags; + + /* DestFD:32, Offset:64, Bytes:64, + ChunkSize:64, + (get_bit(Nodiskio)):1, + (get_bit(MNowait)):1, + (get_bit(Sync)):1,0:5, + (encode_hdtl(Headers))/binary, + (encode_hdtl(Trailers))/binary */ + if (ev->size < 1 + 1 + 5 * sizeof(Uint32) + sizeof(char) + || !EV_GET_UINT32(ev, &out_fd, &p, &q) + || !EV_GET_CHAR(ev, &flags, &p, &q) + || !EV_GET_UINT32(ev, &offsetH, &p, &q) + || !EV_GET_UINT32(ev, &offsetL, &p, &q) + || !EV_GET_UINT32(ev, &nbytesH, &p, &q) + || !EV_GET_UINT32(ev, &nbytesL, &p, &q)) { + /* Buffer has wrong length to contain all the needed values */ + reply_posix_error(desc, EINVAL); goto done; } - + + d = EF_SAFE_ALLOC(sizeof(struct t_data)); + d->fd = desc->fd; + d->command = command; + d->invoke = invoke_sendfile; + d->free = free_sendfile; + d->level = 2; + + d->c.sendfile.out_fd = (int) out_fd; + d->c.sendfile.flags = (int) flags; + +#if SIZEOF_OFF_T == 4 + if (offsetH != 0) { + reply_posix_error(desc, EINVAL); + goto done; + } + d->c.sendfile.offset = (off_t) offsetT; +#else + d->c.sendfile.offset = ((off_t) offsetH << 32) | offsetL; +#endif + +#if SIZEOF_SIZE_T == 4 + if (nbytesH != 0) { + reply_posix_error(desc, EINVAL); + goto done; + } + d->c.sendfile.nbytes = (size_t) nbytesT; +#else + d->c.sendfile.nbytes = ((size_t) nbytesH << 32) | nbytesL; +#endif + + printf("sendfile(nbytes => %d, offset => %d, flags => %x)\r\n",d->c.sendfile.nbytes,d->c.sendfile.offset, d->c.sendfile.flags); + + /* Do HEADER TRAILER stuff by calculating pointer places, not by copying data! */ + + cq_enq(desc, d); + goto done; + } /* case FILE_SENDFILE: */ + } /* switch(command) */ - + if (lseek_flush_read(desc, &err) < 0) { reply_posix_error(desc, err); goto done; diff --git a/erts/emulator/drivers/unix/unix_efile.c b/erts/emulator/drivers/unix/unix_efile.c index 8b612164da..05c2f1fce9 100644 --- a/erts/emulator/drivers/unix/unix_efile.c +++ b/erts/emulator/drivers/unix/unix_efile.c @@ -1471,19 +1471,34 @@ efile_fadvise(Efile_error* errInfo, int fd, Sint64 offset, #ifdef HAVE_SENDFILE int efile_sendfile(Efile_error* errInfo, int in_fd, int out_fd, - off_t offset, size_t *ret_nbytes) + off_t offset, size_t *nbytes) { #if defined(__linux__) || (defined(__sun) && defined(__SVR4)) - ssize_t retval; - do { - retval = sendfile(out_fd, in_fd, &offset, *ret_nbytes); - } while (retval == -1 && (errno == EINTR || errno == EAGAIN)); - *ret_nbytes = retval; + ssize_t retval, nbytes_sent = 0; + if (*nbytes == 0) { + *nbytes = (1 << 20) - 1; + do { + retval = sendfile(out_fd, in_fd, &offset, *nbytes); + nbytes_sent += retval; + printf("retval: %d, errno: %d, offset: %d, nbytes: %d\r\n", retval, errno, offset,*nbytes); + } while ((retval == -1 && errno == EINTR) + || (retval > 0 && errno == EAGAIN)); + } else { + do { + retval = sendfile(out_fd, in_fd, &offset, *nbytes); + if (retval > 0) { + nbytes_sent += retval; + *nbytes -= retval; + } + } while ((retval == -1 && errno == EINTR) + || (*nbytes > 0 && errno == EAGAIN)); + } + *nbytes = nbytes_sent; return check_error(retval == -1 ? -1 : 0, errInfo); #elif defined(DARWIN) - off_t len = *ret_nbytes; + off_t len = *nbytes; int retval = sendfile(in_fd, out_fd, *offset, &len, NULL, 0); - *ret_nbytes = len; + *nbytes = len; return check_error(retval, errInfo); #elif defined(__FreeBSD__) || defined(__DragonFly__) off_t len = 0; -- cgit v1.2.3