Return to network_solaris_sendfilev.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src

1.4.33

    1: #include "network_backends.h"
    2: 
    3: #ifdef USE_SOLARIS_SENDFILEV
    4: 
    5: #include "network.h"
    6: #include "fdevent.h"
    7: #include "log.h"
    8: #include "stat_cache.h"
    9: 
   10: #include <sys/types.h>
   11: #include <sys/socket.h>
   12: #include <sys/stat.h>
   13: #include <sys/time.h>
   14: #include <sys/resource.h>
   15: 
   16: #include <netinet/in.h>
   17: #include <netinet/tcp.h>
   18: 
   19: #include <errno.h>
   20: #include <fcntl.h>
   21: #include <unistd.h>
   22: #include <netdb.h>
   23: #include <string.h>
   24: #include <stdlib.h>
   25: #include <limits.h>
   26: 
   27: #ifndef UIO_MAXIOV
   28: # define UIO_MAXIOV IOV_MAX
   29: #endif
   30: 
   31: /**
   32:  * a very simple sendfilev() interface for solaris which can be optimised a lot more
   33:  * as solaris sendfilev() supports 'sending everythin in one syscall()'
   34:  *
   35:  * If you want such an interface and need the performance, just give me an account on
   36:  * a solaris box.
   37:  *   - jan@kneschke.de
   38:  */
   39: 
   40: 
   41: int network_write_chunkqueue_solarissendfilev(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes) {
   42: 	chunk *c;
   43: 
   44: 	for(c = cq->first; (max_bytes > 0) && (NULL != c); c = c->next) {
   45: 		int chunk_finished = 0;
   46: 
   47: 		switch(c->type) {
   48: 		case MEM_CHUNK: {
   49: 			char * offset;
   50: 			off_t toSend;
   51: 			ssize_t r;
   52: 
   53: 			size_t num_chunks, i;
   54: 			struct iovec chunks[UIO_MAXIOV];
   55: 			chunk *tc;
   56: 
   57: 			size_t num_bytes = 0;
   58: 
   59: 			/* we can't send more then SSIZE_MAX bytes in one chunk */
   60: 
   61: 			/* build writev list
   62: 			 *
   63: 			 * 1. limit: num_chunks < UIO_MAXIOV
   64: 			 * 2. limit: num_bytes < SSIZE_MAX
   65: 			 */
   66: 			for(num_chunks = 0, tc = c; tc && tc->type == MEM_CHUNK && num_chunks < UIO_MAXIOV; num_chunks++, tc = tc->next);
   67: 
   68: 			for(tc = c, i = 0; i < num_chunks; tc = tc->next, i++) {
   69: 				if (tc->mem->used == 0) {
   70: 					chunks[i].iov_base = tc->mem->ptr;
   71: 					chunks[i].iov_len  = 0;
   72: 				} else {
   73: 					offset = tc->mem->ptr + tc->offset;
   74: 					toSend = tc->mem->used - 1 - tc->offset;
   75: 
   76: 					chunks[i].iov_base = offset;
   77: 
   78: 					/* protect the return value of writev() */
   79: 					if (toSend > max_bytes ||
   80: 					    (off_t) num_bytes + toSend > max_bytes) {
   81: 						chunks[i].iov_len = max_bytes - num_bytes;
   82: 
   83: 						num_chunks = i + 1;
   84: 						break;
   85: 					} else {
   86: 						chunks[i].iov_len = toSend;
   87: 					}
   88: 
   89: 					num_bytes += toSend;
   90: 				}
   91: 			}
   92: 
   93: 			if ((r = writev(fd, chunks, num_chunks)) < 0) {
   94: 				switch (errno) {
   95: 				case EAGAIN:
   96: 				case EINTR:
   97: 					r = 0;
   98: 					break;
   99: 				case EPIPE:
  100: 				case ECONNRESET:
  101: 					return -2;
  102: 				default:
  103: 					log_error_write(srv, __FILE__, __LINE__, "ssd",
  104: 							"writev failed:", strerror(errno), fd);
  105: 
  106: 					return -1;
  107: 				}
  108: 			}
  109: 
  110: 			/* check which chunks have been written */
  111: 			cq->bytes_out += r;
  112: 
  113: 			for(i = 0, tc = c; i < num_chunks; i++, tc = tc->next) {
  114: 				if (r >= (ssize_t)chunks[i].iov_len) {
  115: 					/* written */
  116: 					r -= chunks[i].iov_len;
  117: 					tc->offset += chunks[i].iov_len;
  118: 
  119: 					if (chunk_finished) {
  120: 						/* skip the chunks from further touches */
  121: 						c = c->next;
  122: 					} else {
  123: 						/* chunks_written + c = c->next is done in the for()*/
  124: 						chunk_finished = 1;
  125: 					}
  126: 				} else {
  127: 					/* partially written */
  128: 
  129: 					tc->offset += r;
  130: 					chunk_finished = 0;
  131: 
  132: 					break;
  133: 				}
  134: 			}
  135: 
  136: 			break;
  137: 		}
  138: 		case FILE_CHUNK: {
  139: 			ssize_t r;
  140: 			off_t offset, toSend;
  141: 			size_t written;
  142: 			sendfilevec_t fvec;
  143: 			stat_cache_entry *sce = NULL;
  144: 			int ifd;
  145: 
  146: 			if (HANDLER_ERROR == stat_cache_get_entry(srv, con, c->file.name, &sce)) {
  147: 				log_error_write(srv, __FILE__, __LINE__, "sb",
  148: 						strerror(errno), c->file.name);
  149: 				return -1;
  150: 			}
  151: 
  152: 			offset = c->file.start + c->offset;
  153: 			toSend = c->file.length - c->offset;
  154: 			if (toSend > max_bytes) toSend = max_bytes;
  155: 
  156: 			if (offset > sce->st.st_size) {
  157: 				log_error_write(srv, __FILE__, __LINE__, "sb", "file was shrinked:", c->file.name);
  158: 
  159: 				return -1;
  160: 			}
  161: 
  162: 			if (-1 == (ifd = open(c->file.name->ptr, O_RDONLY))) {
  163: 				log_error_write(srv, __FILE__, __LINE__, "ss", "open failed: ", strerror(errno));
  164: 
  165: 				return -1;
  166: 			}
  167: 
  168: 			fvec.sfv_fd = ifd;
  169: 			fvec.sfv_flag = 0;
  170: 			fvec.sfv_off = offset;
  171: 			fvec.sfv_len = toSend;
  172: 
  173: 			/* Solaris sendfilev() */
  174: 			if (-1 == (r = sendfilev(fd, &fvec, 1, &written))) {
  175: 				if (errno != EAGAIN) {
  176: 					log_error_write(srv, __FILE__, __LINE__, "ssd", "sendfile: ", strerror(errno), errno);
  177: 
  178: 					close(ifd);
  179: 					return -1;
  180: 				}
  181: 
  182: 				r = 0;
  183: 			}
  184: 
  185: 			close(ifd);
  186: 			c->offset += written;
  187: 			cq->bytes_out += written;
  188: 			max_bytes -= written;
  189: 
  190: 			if (c->offset == c->file.length) {
  191: 				chunk_finished = 1;
  192: 			}
  193: 
  194: 			break;
  195: 		}
  196: 		default:
  197: 
  198: 			log_error_write(srv, __FILE__, __LINE__, "ds", c, "type not known");
  199: 
  200: 			return -1;
  201: 		}
  202: 
  203: 		if (!chunk_finished) {
  204: 			/* not finished yet */
  205: 
  206: 			break;
  207: 		}
  208: 	}
  209: 
  210: 	return 0;
  211: }
  212: 
  213: #endif