X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fpatches%2Ftesting%2Ffaketape.c;h=9284680b6635f8e531595253ef423a4023fdba3d;hb=4c89411092df8f48c412994c0a68bfd8a823067a;hp=c9196d9282f23c6d09be2954682bbb531c06339a;hpb=e041a87b48665e5fbce3582eb20503562ab2b969;p=bacula%2Fbacula diff --git a/bacula/patches/testing/faketape.c b/bacula/patches/testing/faketape.c index c9196d9282..9284680b66 100644 --- a/bacula/patches/testing/faketape.c +++ b/bacula/patches/testing/faketape.c @@ -26,18 +26,43 @@ Switzerland, email:ftf@fsfeurope.org. */ -#include "faketape.h" -#include -#include -#include +/* + +Device { + Name = Drive-1 # + Maximum File Size = 800M + Maximum Volume Size = 3G + Device Type = TAPE + Archive Device = /tmp/fake + Media Type = DLT-8000 + AutomaticMount = yes; # when device opened, read it + AlwaysOpen = yes; + RemovableMedia = yes; + RandomAccess = no; +} + + Block description : + + block { + int32 size; + void *data; + } + + EOF description : -static int tape_get(int fd, struct mtget *mt_get); -static int tape_op(int fd, struct mtop *mt_com); -static int tape_pos(int fd, struct mtpos *mt_pos); + EOF { + int32 size=0; + } -static int dbglevel = 0; + */ +#include "bacula.h" /* define 64bit file usage */ +#include "stored.h" +#include "faketape.h" + +static int dbglevel = 10; +#define FILE_OFFSET 30 faketape *ftape_list[FTAPE_MAX_DRIVE]; static faketape *get_tape(int fd) @@ -65,11 +90,22 @@ static bool put_tape(faketape *ftape) return true; } -int faketape_open(const char *pathname, int flags, int mode) +void faketape_debug(int level) { + dbglevel = level; +} + +/****************************************************************/ +/* theses function will replace open/read/write/close/ioctl + * in bacula core + */ +int faketape_open(const char *pathname, int flags) +{ + ASSERT(pathname != NULL); + int fd; faketape *tape = new faketape(); - fd = tape->open(pathname, flags, mode); + fd = tape->open(pathname, flags); if (fd > 0) { put_tape(tape); } @@ -112,34 +148,26 @@ int faketape_ioctl(int fd, unsigned long int request, ...) va_start(argp, request); -// switch (request) { -// case MTIOCTOP: - result = t->tape_op(va_arg(argp, mtop *)); -// break; - -// case MTIOCGET: -// result = tape_get(fd, va_arg(argp, mtget *)); -// break; -// -// case MTIOCPOS: -// result = tape_pos(fd, va_arg(argp, mtpos *)); -// break; -// -// default: -// errno = ENOTTY; -// result = -1; -// break; -// } - + if (request == MTIOCTOP) { + result = t->tape_op(va_arg(argp, mtop *)); + } else if (request == MTIOCGET) { + result = t->tape_get(va_arg(argp, mtget *)); + } else if (request == MTIOCPOS) { + result = t->tape_pos(va_arg(argp, mtpos *)); + } else { + errno = ENOTTY; + result = -1; + } va_end(argp); return result; } +/****************************************************************/ + int faketape::tape_op(struct mtop *mt_com) { int result=0; - struct stat statp; switch (mt_com->mt_op) { @@ -158,32 +186,11 @@ int faketape::tape_op(struct mtop *mt_com) break; case MTFSF: /* Forward space over mt_count filemarks. */ - /* we are already at EOT */ - if (current_file > max_file) { - atEOF = true; - errno = EIO; - result = -1; - } - - /* we are at the last file */ - if (current_file == max_file) { - current_file++; - atEOF = true; - } - + result = fsf(mt_com->mt_count); break; case MTBSF: /* Backward space over mt_count filemarks. */ - current_file = current_file - mt_op->mt_count; - if (current_file < 0) { - current_file = 0; - errno = EIO; - result = -1; - } - atEOD = false; - atEOF = false; - atEOM = false; - open_file(); + result = bsf(mt_com->mt_count); break; case MTFSR: /* Forward space over mt_count records (tape blocks). */ @@ -194,45 +201,34 @@ int faketape::tape_op(struct mtop *mt_com) file number = 1 block number = 1 - mt: /dev/lto2: Erreur d'entrée/sortie + mt: /dev/lto2: Erreur d'entree/sortie file number = 2 block number = 0 */ /* tester si on se trouve a la fin du fichier */ - fseek(cur_fd, SEEK_CUR, tape_info.block_size*mt_op->mt_count); + result = fsr(mt_com->mt_count); break; case MTBSR: /* Backward space over mt_count records (tape blocks). */ - -/* - file number = 1 - block number = -1 - - mt: /dev/lto2: Erreur d'entrée/sortie - - file number = 0 - block number = -1 -*/ - - fstat(cur_file, &statp); - off_t cur_pos = lseek(cur_fd, 0, SEEK_CUR); - - fseek(cur_fd, SEEK_CUR, tape_info.block_size*mt_op->mt_count); + result = bsr(mt_com->mt_count); break; case MTWEOF: /* Write mt_count filemarks. */ + result = weof(mt_com->mt_count); break; case MTREW: /* Rewind. */ - atEOF = atEOD = atEOM = false; + Dmsg0(dbglevel, "rewind faketape\n"); + atEOF = atEOD = false; + atBOT = true; current_file = 0; - open_file(); + current_block = 0; + seek_file(); break; case MTOFFL: /* put tape offline */ - // check if can_read/can_write - result = 0; + result = offline(); break; case MTRETEN: /* Re-tension tape. */ @@ -255,19 +251,25 @@ int faketape::tape_op(struct mtop *mt_com) block number = -1 */ /* Can be at EOM */ - atEOF = true; - current_block = -1; - /* Ne pas creer le fichier si on est a la fin */ + atBOT = false; + atEOF = false; + atEOD = true; + atEOT = false; + current_file = last_file; + current_block = -1; + seek_file(); break; - case MTERASE: + case MTERASE: /* not used by bacula */ atEOD = true; atEOF = false; atEOT = false; + current_file = 0; current_block = -1; - delete_files(current_file); + seek_file(); + truncate_file(); break; case MTSETBLK: @@ -309,114 +311,107 @@ int faketape::tape_op(struct mtop *mt_com) case MTMKPART: break; } -// -// switch (result) { -// case NO_ERROR: -// case -1: /* Error has already been translated into errno */ -// break; -// -// default: -// case ERROR_FILEMARK_DETECTED: -// errno = EIO; -// break; -// -// case ERROR_END_OF_MEDIA: -// errno = EIO; -// break; -// -// case ERROR_NO_DATA_DETECTED: -// errno = EIO; -// break; -// -// case ERROR_NO_MEDIA_IN_DRIVE: -// errno = ENOMEDIUM; -// break; -// -// case ERROR_INVALID_HANDLE: -// case ERROR_ACCESS_DENIED: -// case ERROR_LOCK_VIOLATION: -// errno = EBADF; -// break; -// } -// + return result == 0 ? 0 : -1; } int faketape::tape_get(struct mtget *mt_get) { - return 0; -} + int density = 1; + int block_size = 1024; -int faketape::tape_pos(struct mtpos *mt_pos) -{ - return 0; -} + mt_get->mt_type = MT_ISSCSI2; + mt_get->mt_blkno = current_block; + mt_get->mt_fileno = current_file; -int faketape::delete_files(int startfile) -{ - int cur,max=0; - char *p; - POOL_MEM tmp; - DIR *fp_dir; - struct dirent *dir; - struct stat statp; + mt_get->mt_resid = -1; +// pos_info.PartitionBlockValid ? pos_info.Partition : (ULONG)-1; - fp_dir = opendir(this->volume); - if (!fp_dir) { - this->max_file=0; - this->size = 0; - return -1; + /* TODO */ + mt_get->mt_dsreg = + ((density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK) | + ((block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK); + + + mt_get->mt_gstat = 0x00010000; /* Immediate report mode.*/ + + if (atEOF) { + mt_get->mt_gstat |= 0x80000000; // GMT_EOF } - this->size = 0; + if (atBOT) { + mt_get->mt_gstat |= 0x40000000; // GMT_BOT + } + if (atEOT) { + mt_get->mt_gstat |= 0x20000000; // GMT_EOT + } - /* search for all digit file */ - while ((dir = readdir (fp_dir)) != NULL) - { - Mmsg(tmp, "%s/%s", this->volume, dir->d_name); - cur = 0; - /* check if d_name contains only digits */ - for(p = dir->d_name; *p && isdigit(*p); p++) - { - cur *= 10; - cur += *p; - } - if (!*p && cur) { - if (cur >= startfile) { /* remove it */ - unlink(tmp); - } else { - if (lstat(tmp.c_str(), &statp) == 0) { - this->size += statp.st_size; - } - max = (max > cur)?max:cur; - } - } + if (atEOD) { + mt_get->mt_gstat |= 0x08000000; // GMT_EOD + } + + if (0) { //WriteProtected) { + mt_get->mt_gstat |= 0x04000000; // GMT_WR_PROT + } + + if (online) { + mt_get->mt_gstat |= 0x01000000; // GMT_ONLINE + } else { + mt_get->mt_gstat |= 0x00040000; // GMT_DR_OPEN + } + mt_get->mt_erreg = 0; + + return 0; +} + +int faketape::tape_pos(struct mtpos *mt_pos) +{ + if (current_block >= 0) { + mt_pos->mt_blkno = current_block; + return 0; } - closedir(fp_dir); - this->max_file = max; - return max; + return -1; +} + +/* + * This function try to emulate the append only behavior + * of a tape. When you wrote something, data after the + * current position are discarded. + */ +int faketape::truncate_file() +{ + Dmsg2(dbglevel, "truncate %i:%i\n", current_file, current_block); + ftruncate(fd, lseek(fd, 0, SEEK_CUR)); + last_file = current_file; + atEOD=true; + return 0; } faketape::faketape() { - fd = 0; - atEOF = 0; - atEOM = 0; + fd = -1; + + atEOF = false; + atBOT = false; + atEOT = false; + atEOD = false; + online = false; + inplace = false; + needEOF = false; + + file_size = 0; + last_file = 0; current_file = 0; - current_block = 0; - max_file = 0; + current_block = -1; + current_pos = 0; + + max_block = 1024*1024*1024*1024*8; - volume = get_pool_memory(PM_NAME); - cur_file = get_pool_memory(PM_NAME); - cur_info = get_pool_memory(PM_NAME); } faketape::~faketape() { - free_pool_memory(volume); - free_pool_memory(cur_file); - free_pool_memory(cur_info); } int faketape::get_fd() @@ -424,192 +419,436 @@ int faketape::get_fd() return this->fd; } +/* + * TODO: check if after a write op, and other tape op put a EOF + */ int faketape::write(const void *buffer, unsigned int count) { - ASSERT(cur_fd > 0); - if (current_block == -1) { - open_file(); + ASSERT(current_file >= 0); + ASSERT(count > 0); + ASSERT(buffer); + + unsigned int nb; + Dmsg3(dbglevel, "write len=%i %i:%i\n", count, current_file,current_block); + + if (atEOT) { + Dmsg0(dbglevel, "write nothing, EOT !\n"); + errno = ENOSPC; + return -1; + } + + if (!inplace) { + seek_file(); + } + + if (!atEOD) { /* if not at the end of the data */ + truncate_file(); } - /* remove all file > current_file */ - return ::write(cur_fd, buffer, count); + + if (current_block != -1) { + current_block++; + } + + atBOT = false; + atEOF = false; + atEOD = true; /* End of data */ + + needEOF = true; /* next operation need EOF mark */ + +// if ((count + file_size) > max_size) { +// Dmsg2(dbglevel, +// "EOT writing only %i of %i requested\n", +// max_size - file_size, count); +// count = max_size - file_size; +// atEOT = true; +// } + + uint32_t size = count; + ::write(fd, &size, sizeof(uint32_t)); + nb = ::write(fd, buffer, count); + + file_size += sizeof(uint32_t) + nb; + + if (nb != count) { + atEOT = true; + Dmsg2(dbglevel, + "Not enough space writing only %i of %i requested\n", + nb, count); + } + + return nb; } -int faketape::close() +int faketape::weof(int count) { - ASSERT(cur_fd > 0); - ::close(cur_fd); - ::close(fd); + ASSERT(current_file >= 0); + Dmsg3(dbglevel, "Writing EOF %i:%i last=%i\n", + current_file, current_block,last_file); + if (atEOT) { + errno = ENOSPC; + current_block = -1; + return -1; + } + needEOF = false; + truncate_file(); /* nothing after this point */ + + /* TODO: check this */ + current_file += count; + current_block = 0; + + uint32_t c=0; + seek_file(); + ::write(fd, &c, sizeof(uint32_t)); + seek_file(); + + atEOD = false; + atBOT = false; + atEOF = true; return 0; } -int faketape::read(void *buffer, unsigned int count) -{ - ASSERT(cur_fd > 0); - if (current_block == -1) { - open_file(); +int faketape::fsf(int count) +{ + ASSERT(current_file >= 0); + ASSERT(fd >= 0); +/* + * 1 0 -> fsf -> 2 0 -> fsf -> 2 -1 + */ + check_eof(); + + int ret; + if (atEOT) { + current_block = -1; + return -1; + } + + atBOT = atEOF = false; + Dmsg3(dbglevel+1, "fsf %i+%i <= %i\n", current_file, count, last_file); + + if ((current_file + count) <= last_file) { + current_file += count; + current_block = 0; + ret = 0; + } else { + Dmsg0(dbglevel, "Try to FSF after EOT\n"); + current_file = last_file ; + current_block = -1; + atEOD=true; + ret = -1; } - return ::read(cur_fd, buffer, count); + seek_file(); + return ret; } -int faketape::read_volinfo() +int faketape::fsr(int count) { - struct stat statp; - memset(&tape_info, 0, sizeof(FTAPE_FORMAT)); - - Dmsg2(0, "Info %p %p\n", cur_info, volume); - Mmsg(cur_info, "%s/info", volume); - fd = ::open(cur_info, O_CREAT | O_RDWR | O_BINARY, 0640); + ASSERT(current_file >= 0); + ASSERT(fd >= 0); - if (fd < 0) { + int i,nb, ret=0; + off_t where=0; + uint32_t s; + Dmsg3(dbglevel, "fsr %i:%i count=%i\n", current_file,current_block, count); + + check_eof(); + + if (atEOT) { + errno = EIO; + current_block = -1; return -1; } - - fstat(cur_info, &statp); - - /* read volume info */ - int nb = ::read(fd, &tape_info, sizeof(FTAPE_FORMAT)); - if (nb != sizeof(FTAPE_FORMAT)) { /* new tape ? */ - Dmsg1(dbglevel, "Initialize %s\n", volume); - tape_info.version = 1; - tape_info.block_max = 2000000; - tape_info.block_size = statp.st_blksize; - tape_info.max_file_mark = 2000; - - lseek(fd, SEEK_SET, 0); - nb = ::write(fd, &tape_info, sizeof(FTAPE_FORMAT)); - - if (nb != sizeof(FTAPE_FORMAT)) { - ::close(fd); - return -1; + + if (atEOD) { + errno = EIO; + return -1; + } + + atBOT = atEOF = false; + + /* check all block record */ + for(i=0; (i < count) && !atEOF ; i++) { + nb = ::read(fd, &s, sizeof(uint32_t)); /* get size of next block */ + if (nb == sizeof(uint32_t) && s) { + current_block++; + where = lseek(fd, s, SEEK_CUR); /* seek after this block */ + } else { + Dmsg4(dbglevel, "read EOF %i:%i nb=%i s=%i\n", + current_file, current_block, nb,s); + errno = EIO; + ret = -1; + if (current_file < last_file) { + current_block = 0; + current_file++; + seek_file(); + } + atEOF = true; /* stop the loop */ } } - Dmsg0(dbglevel, "read_volinfo OK\n"); - find_maxfile(); + find_maxfile(); /* refresh stats */ - return fd; + if (where == file_size) { + atEOD = true; + } + return ret; } -int faketape::open(const char *pathname, int uflags, int umode) +int faketape::bsr(int count) { - Dmsg3(dbglevel, "faketape::open(%s, %i, %i)\n", pathname, uflags, umode); - pm_strcpy(volume, pathname); + Dmsg2(dbglevel, "bsr current_block=%i count=%i\n", + current_block, count); - struct stat statp; - if (lstat(volume, &statp) != 0) { - Dmsg1(dbglevel, "Can't stat on %s\n", volume); - return -1; + ASSERT(current_file >= 0); + ASSERT(count == 1); + ASSERT(fd >= 0); + + check_eof(); + + if (!count) { + return 0; } - if (!S_ISDIR(statp.st_mode)) { - Dmsg1(dbglevel, "%s is not a directory\n", volume); - errno = EACCES; + int ret=0; + int last_f=0; + int last_b=0; + + off_t last=-1, last2=-1; + off_t orig = lseek(fd, 0, SEEK_CUR); + int orig_f = current_file; + int orig_b = current_block; + + current_block=0; + seek_file(); + + do { + if (!atEOF) { + last2 = last; + last = lseek(fd, 0, SEEK_CUR); + last_f = current_file; + last_b = current_block; + Dmsg5(dbglevel, "EOF=%i last=%lli orig=%lli %i:%i\n", + atEOF, last, orig, current_file, current_block); + } + ret = fsr(1); + } while ((lseek(fd, 0, SEEK_CUR) < orig) && (ret == 0)); + + if (last2 > 0 && atEOF) { /* we take the previous position */ + lseek(fd, last2, SEEK_SET); + current_file = last_f; + current_block = last_b - 1; + Dmsg3(dbglevel, "set offset2=%lli %i:%i\n", + last, current_file, current_block); + + } else if (last > 0) { + lseek(fd, last, SEEK_SET); + current_file = last_f; + current_block = last_b; + Dmsg3(dbglevel, "set offset=%lli %i:%i\n", + last, current_file, current_block); + } else { + lseek(fd, orig, SEEK_SET); + current_file = orig_f; + current_block = orig_b; return -1; } - /* open volume descriptor and get this->fd */ - if (read_volinfo() < 0) { - return -1; + Dmsg2(dbglevel, "bsr %i:%i\n", current_file, current_block); + atEOT = atEOF = atEOD = false; + + return 0; +} + +int faketape::bsf(int count) +{ + ASSERT(current_file >= 0); + Dmsg3(dbglevel, "bsf %i:%i count=%i\n", current_file, current_block, count); + int ret = 0; + + check_eof(); + atBOT = atEOF = atEOT = atEOD = false; + + if (current_file - count < 0) { + current_file = 0; + current_block = 0; + atBOT = true; + errno = EIO; + ret = -1; + } else { + current_file = current_file - count + 1; + current_block = -1; + seek_file(); + current_file--; + /* go just before last EOF */ + lseek(fd, lseek(fd, 0, SEEK_CUR) - sizeof(uint32_t), SEEK_SET); } + return ret; +} - current_block=-1; +/* + * Put faketape in offline mode + */ +int faketape::offline() +{ + close(); + + atEOF = false; /* End of file */ + atEOT = false; /* End of tape */ + atEOD = false; /* End of data */ + atBOT = false; /* Begin of tape */ + + current_file = -1; + current_block = -1; + last_file = -1; + return 0; +} - return fd; +int faketape::close() +{ + check_eof(); + ::close(fd); + fd = -1; + return 0; } +/* + **rb + **status + * EOF Bacula status: file=2 block=0 + * Device status: EOF ONLINE IM_REP_EN file=2 block=0 + **rb + **status + * EOD EOF Bacula status: file=2 block=0 + * Device status: EOD ONLINE IM_REP_EN file=2 block=-1 + * + */ -int faketape::find_maxfile() +int faketape::read(void *buffer, unsigned int count) { - int max=0; - int cur; - char *p; - POOL_MEM tmp; - DIR *fp_dir; - struct dirent *dir; - struct stat statp; + ASSERT(current_file >= 0); + unsigned int nb; + uint32_t s; + + Dmsg2(dbglevel, "read %i:%i\n", current_file, current_block); - fp_dir = opendir(this->volume); - if (!fp_dir) { - max_file=0; - return -1; + if (atEOT || atEOD) { + return 0; } - this->size = 0; + if (atEOF) { + current_file++; + current_block=0; + inplace = false; + atEOF = false; + } - /* search for all digit file */ - while ((dir = readdir (fp_dir)) != NULL) - { - Mmsg(tmp, "%s/%s", this->volume, dir->d_name); - if (lstat(tmp.c_str(), &statp) == 0) { - this->size += statp.st_size; - } else { - Dmsg1(dbglevel, "Can't stat %s\n", tmp.c_str()); - } - cur = 0; - /* TODO: compute size */ - for(p = dir->d_name; *p && isdigit(*p); p++) - { - cur *= 10; - cur += *p; - } - if (!*p && cur) { - max = (max > cur)?max:cur; - } + if (!inplace) { + seek_file(); } - closedir(fp_dir); - this->max_file = max; - return max; + atEOD = atBOT = false; + current_block++; + + nb = ::read(fd, &s, sizeof(uint32_t)); + if (nb <= 0) { + atEOF = true; + return 0; + } + if (s > count) { /* not enough buffer to read block */ + Dmsg2(dbglevel, "Need more buffer to read next block %i > %i\n",s,count); + lseek(fd, s, SEEK_CUR); + errno = ENOMEM; + return -1; + } + if (!s) { /* EOF */ + atEOF = true; + lseek(fd, lseek(fd, 0, SEEK_CUR) - sizeof(uint32_t), SEEK_SET); + return 0; + } + nb = ::read(fd, buffer, s); + if (s != nb) { + atEOF = true; + if (current_file == last_file) { + atEOD = true; + current_block = -1; + } + Dmsg0(dbglevel, "EOF during reading\n"); + } + return nb; } -int faketape::open_file() +int faketape::open(const char *pathname, int uflags) { - if (cur_fd) { - ::close(cur_fd); + Dmsg2(dbglevel, "faketape::open(%s, %i)\n", pathname, uflags); + + struct stat statp; + if (stat(pathname, &statp) != 0) { + Dmsg1(dbglevel, "Can't stat on %s\n", pathname); + return -1; } - Mmsg(cur_file, "%s/%i", volume, current_file); - cur_fd = ::open(cur_file, O_CREAT | O_RDWR | O_BINARY, 0640); - if (cur_fd < 0) { + fd = ::open(pathname, O_CREAT | O_RDWR | O_LARGEFILE, 0700); + if (fd < 0) { + return -1; + } + + /* open volume descriptor and get this->fd */ + if (find_maxfile() < 0) { return -1; } - current_block = 0; - max_file = (max_file > current_file)?max_file:current_file; - return cur_fd; + current_block = 0; + current_file = 0; + needEOF = false; + online = inplace = true; + atBOT = true; + atEOT = atEOD = false; + return fd; } -void faketape::dump() +/* + * read volume to get the last file number + */ +int faketape::find_maxfile() { - Dmsg1(dbglevel, "max_file=%i\n", max_file); - Dmsg1(dbglevel, "current_file=%i\n", current_file); - Dmsg1(dbglevel, "volume=%s\n", volume); - Dmsg1(dbglevel, "cur_info=%s\n", cur_info); - Dmsg1(dbglevel, "cur_file=%s\n", cur_file); - Dmsg1(dbglevel, "size=%i\n", size); + struct stat statp; + if (fstat(fd, &statp) != 0) { + return 0; + } + last_file = statp.st_size>>FILE_OFFSET; + file_size = statp.st_size; + + current_pos = lseek(fd, 0, SEEK_CUR); /* get current position */ + Dmsg3(dbglevel+1, "last_file=%i file_size=%u current_pos=%i\n", + last_file, file_size, current_pos); + + return last_file; } -#ifdef TEST - -int main() +int faketape::seek_file() { - int fd; - printf("Starting FakeTape\n"); + ASSERT(current_file >= 0); + Dmsg2(dbglevel, "seek_file %i:%i\n", current_file, current_block); - mkdir("/tmp/fake", 0777); - fd = faketape_open("/tmp/fake", O_CREAT | O_RDWR | O_BINARY, 0666); - if (fd < 0) { - perror("open ERR"); - return 1; + off_t pos = ((off_t)current_file)<dump(); - - faketape_close(fd); + last_file = (last_file > current_file)?last_file:current_file; + if (current_block > 0) { + fsr(current_block); + } + inplace = true; return 0; } -#endif +void faketape::dump() +{ + Dmsg0(dbglevel+1, "===================\n"); + Dmsg2(dbglevel, "file:block = %i:%i\n", current_file, current_block); + Dmsg1(dbglevel+1, "last_file=%i\n", last_file); + Dmsg1(dbglevel+1, "file_size=%i\n", file_size); + Dmsg4(dbglevel+1, "EOF=%i EOT=%i EOD=%i BOT=%i\n", + atEOF, atEOT, atEOD, atBOT); +}