X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=server-src%2Fchunker.c;h=6f81ad2b1cd9ef12cfdcf24ee2d156a3fde131cb;hb=d28952249e392eb31bc8eecc53f6c477f30c617b;hp=bf802f9b99bcdf2c47f97a7f98905e904a6a62c8;hpb=fd48f3e498442f0cbff5f3606c7c403d0566150e;p=debian%2Famanda diff --git a/server-src/chunker.c b/server-src/chunker.c index bf802f9..6f81ad2 100644 --- a/server-src/chunker.c +++ b/server-src/chunker.c @@ -1,6 +1,7 @@ /* * Amanda, The Advanced Maryland Automatic Network Disk Archiver * Copyright (c) 1991-1999 University of Maryland at College Park + * Copyright (c) 2007-2012 Zmanda, Inc. All Rights Reserved. * All Rights Reserved. * * Permission to use, copy, modify, distribute, and sell this software and its @@ -43,12 +44,7 @@ #include "util.h" #include "holding.h" #include "timestamp.h" - -#define chunker_debug(i, ...) do { \ - if ((i) <= debug_chunker) { \ - dbprintf(__VA_ARGS__); \ - } \ -} while (0) +#include "sockaddr-util.h" #ifndef SEEK_SET #define SEEK_SET 0 @@ -102,9 +98,14 @@ static ssize_t write_tapeheader(int, dumpfile_t *); static void databuf_init(struct databuf *, int, char *, off_t, off_t); static int databuf_flush(struct databuf *); -static int startup_chunker(char *, off_t, off_t, struct databuf *, int *); -static int do_chunk(int, struct databuf *, int); +static int startup_chunker(char *, off_t, off_t, struct databuf *, int *, int *); +static int do_chunk(int, struct databuf *, int, int); +/* we use a function pointer for full_write, so that we can "shim" in + * full_write_with_fake_enospc for testing */ +static size_t (*db_full_write)(int fd, const void *buf, size_t count); +static size_t full_write_with_fake_enospc(int fd, const void *buf, size_t count); +static off_t fake_enospc_at_byte = -1; int main( @@ -123,6 +124,7 @@ main( config_overrides_t *cfg_ovr = NULL; char *cfg_opt = NULL; char *m; + int header_socket; int data_socket; /* @@ -189,6 +191,18 @@ main( log_add(L_INFO, "%s pid %ld", get_pname(), (long)getpid()); error(_("Didn't get START command")); } + free_cmdargs(cmdargs); + + /* set up a fake ENOSPC for testing purposes. Note that this counts + * headers as well as data written to disk. */ + if (getenv("CHUNKER_FAKE_ENOSPC_AT")) { + char *env = getenv("CHUNKER_FAKE_ENOSPC_AT"); + fake_enospc_at_byte = (off_t)atoi(env); /* these values are never > MAXINT */ + db_full_write = full_write_with_fake_enospc; + g_debug("will trigger fake ENOSPC at byte %d", (int)fake_enospc_at_byte); + } else { + db_full_write = full_write; + } /* do {*/ cmdargs = getcmd(); @@ -296,13 +310,13 @@ main( } if ((header_fd = startup_chunker(filename, use, chunksize, &db, - &data_socket)) < 0) { + &header_socket, &data_socket)) < 0) { q = quote_string(vstrallocf(_("[chunker startup failed: %s]"), errstr)); putresult(TRYAGAIN, "%s %s\n", handle, q); error("startup_chunker failed: %s", errstr); } command_in_transit = NULL; - if (header_fd >= 0 && do_chunk(header_fd, &db, data_socket)) { + if (header_fd >= 0 && do_chunk(header_fd, &db, header_socket, data_socket)) { char kb_str[NUM_STR_SIZE]; char kps_str[NUM_STR_SIZE]; double rt; @@ -318,6 +332,7 @@ main( m = vstrallocf("[%s]", errstr); q = quote_string(m); amfree(m); + free_cmdargs(cmdargs); if(command_in_transit != NULL) { cmdargs = command_in_transit; command_in_transit = NULL; @@ -418,6 +433,7 @@ startup_chunker( off_t use, off_t chunksize, struct databuf * db, + int *headersocket, int *datasocket) { int header_fd, outfd; @@ -426,6 +442,9 @@ startup_chunker( int header_socket, data_socket; int result; struct addrinfo *res; + struct addrinfo *res_addr; + sockaddr_union *addr = NULL; + sockaddr_union data_addr; header_port = 0; data_port = 0; @@ -434,10 +453,26 @@ startup_chunker( gai_strerror(result)); return -1; } - header_socket = stream_server(res->ai_family, &header_port, 0, + for (res_addr = res; res_addr != NULL; res_addr = res_addr->ai_next) { + g_debug("ra: %s\n", str_sockaddr((sockaddr_union*)res_addr->ai_addr)); + if (res_addr->ai_family == AF_INET) { + addr = (sockaddr_union *)res_addr->ai_addr; + break; + } + } + if (!addr) { + addr = (sockaddr_union *)res->ai_addr; + g_debug("addr: %s\n", str_sockaddr(addr)); + } + + header_socket = stream_server(SU_GET_FAMILY(addr), &header_port, 0, STREAM_BUFSIZE, 0); - data_socket = stream_server(res->ai_family, &data_port, 0, + data_socket = stream_server(SU_GET_FAMILY(addr), &data_port, 0, STREAM_BUFSIZE, 0); + copy_sockaddr(&data_addr, addr); + + SU_SET_PORT(&data_addr, data_port); + if (res) freeaddrinfo(res); if (header_socket < 0) { @@ -452,7 +487,7 @@ startup_chunker( return -1; } - putresult(PORT, "%d 127.0.0.1:%d\n", header_port, data_port); + putresult(PORT, "%d %s\n", header_port, str_sockaddr(&data_addr)); header_fd = stream_accept(header_socket, CONNECT_TIMEOUT, 0, STREAM_BUFSIZE); @@ -463,7 +498,6 @@ startup_chunker( aclose(data_socket); return -1; } - aclose(header_socket); tmp_filename = vstralloc(filename, ".tmp", NULL); pc = strrchr(tmp_filename, '/'); @@ -493,6 +527,7 @@ startup_chunker( amfree(tmp_filename); databuf_init(db, outfd, filename, use, chunksize); db->filename_seq++; + *headersocket = header_socket; *datasocket = data_socket; return header_fd; } @@ -501,6 +536,7 @@ static int do_chunk( int header_fd, struct databuf * db, + int header_socket, int data_socket) { size_t nread; @@ -519,6 +555,8 @@ do_chunk( * chunk code will rewrite it. */ nread = full_read(header_fd, header_buf, SIZEOF(header_buf)); + aclose(header_fd); + aclose(header_socket); if (nread != sizeof(header_buf)) { if(errno != 0) { errstr = vstrallocf(_("cannot read header: %s"), strerror(errno)); @@ -556,7 +594,6 @@ do_chunk( aclose(data_socket); return 0; } - aclose(data_socket); /* * We've written the file header. Now, just write data until the @@ -567,12 +604,16 @@ do_chunk( db->datain += nread; while(db->dataout < db->datain) { if(!databuf_flush(db)) { + aclose(data_fd); + aclose(data_socket); return 0; } } } while(db->dataout < db->datain) { if(!databuf_flush(db)) { + aclose(data_fd); + aclose(data_socket); return 0; } } @@ -580,6 +621,8 @@ do_chunk( dumpsize += (off_t)1; /* count partial final KByte */ filesize += (off_t)1; } + aclose(data_fd); + aclose(data_socket); return 1; } @@ -780,10 +823,14 @@ databuf_flush( aclose(newfd); if(save_errno == ENOSPC) { + if (unlink(tmp_filename) < 0) { + g_debug("could not delete '%s'; ignoring", tmp_filename); + } putresult(NO_ROOM, "%s %lld\n", handle, (long long)(db->use+db->split_size-dumpsize)); db->use = (off_t)0; /* force RQ_MORE DISK */ db->split_size = dumpsize; + file.type = save_type; continue; } m = vstrallocf(_("write_tapeheader file %s: %s"), @@ -864,7 +911,7 @@ databuf_flush( * Write out the buffer */ size_to_write = (size_t)(db->datain - db->dataout); - written = full_write(db->fd, db->dataout, size_to_write); + written = db_full_write(db->fd, db->dataout, size_to_write); if (written > 0) { db->dataout += written; dumpbytes += (off_t)written; @@ -927,7 +974,7 @@ write_tapeheader( if (!buffer) /* this shouldn't happen */ error(_("header does not fit in %zd bytes"), (size_t)DISK_BLOCK_BYTES); - written = full_write(outfd, buffer, DISK_BLOCK_BYTES); + written = db_full_write(outfd, buffer, DISK_BLOCK_BYTES); amfree(buffer); if(written == DISK_BLOCK_BYTES) return 0; @@ -937,3 +984,41 @@ write_tapeheader( return (ssize_t)-1; } + +static size_t +full_write_with_fake_enospc( + int fd, + const void *buf, + size_t count) +{ + size_t rc; + + //g_debug("HERE %zd %zd", count, (size_t)fake_enospc_at_byte); + + if (count <= (size_t)fake_enospc_at_byte) { + fake_enospc_at_byte -= count; + return full_write(fd, buf, count); + } + + /* if we get here, the caller has requested a size that is less + * than fake_enospc_at_byte. */ + count = fake_enospc_at_byte; + g_debug("returning fake ENOSPC"); + + if (fake_enospc_at_byte) { + rc = full_write(fd, buf, fake_enospc_at_byte); + if (rc == (size_t)fake_enospc_at_byte) { + /* full_write succeeded, so fake a failure */ + errno = ENOSPC; + } + } else { + /* no bytes to write; just fake an error */ + errno = ENOSPC; + rc = 0; + } + + /* switch back to calling full_write directly */ + fake_enospc_at_byte = -1; + db_full_write = full_write; + return rc; +}