[PATCH 1/2] CNFSv4: move to 4K blocksize (inn-CURRENT)
"Miquel van Smoorenburg"
list-inn-workers at news.cistron.nl
Wed Nov 26 09:58:23 UTC 2008
inn-CURRENT-cnfs-4K.patch
diff -ruN t/inn-CURRENT-20081125/frontends/cnfsheadconf.in inn-CURRENT-20081125/frontends/cnfsheadconf.in
--- t/inn-CURRENT-20081125/frontends/cnfsheadconf.in 2008-11-25 11:01:10.000000000 +0100
+++ inn-CURRENT-20081125/frontends/cnfsheadconf.in 2008-11-26 09:32:07.509345924 +0100
@@ -238,9 +238,9 @@
my($CNFSNASIZ)=16;
my($CNFSPASIZ)=64;
my($CNFSLASIZ)=16;
- my($headerlength) = 2 * $CNFSMASIZ + 2 * $CNFSNASIZ + $CNFSPASIZ + (5 * $CNFSLASIZ);
+ my($headerlength) = 2 * $CNFSMASIZ + 2 * $CNFSNASIZ + $CNFSPASIZ + (6 * $CNFSLASIZ);
my($buff, @entries, $e);
- my($magic, $name, $path, $lena, $freea, $updatea, $cyclenuma, $metaname, $orderinmeta, $currentbuff);
+ my($magic, $name, $path, $lena, $freea, $updatea, $cyclenuma, $metaname, $orderinmeta, $currentbuff, $blksza);
if ($opt_w) {
if(! open(BUFF, "+< $buffpath") ) {
@@ -260,7 +260,7 @@
exit(1);
}
- ($magic, $name, $path, $lena, $freea, $updatea, $cyclenuma, $metaname, $orderinmeta, $currentbuff) = unpack("a8 a16 a64 a16 a16 a16 a16 a16 a16 a8", $buff);
+ ($magic, $name, $path, $lena, $freea, $updatea, $cyclenuma, $metaname, $orderinmeta, $currentbuff, $blksza) = unpack("a8 a16 a64 a16 a16 a16 a16 a16 a16 a8 a16", $buff);
if(!$magic) {
print STDERR "Error while unpacking header ...\n";
@@ -271,6 +271,7 @@
my($free) = bhex($freea);
my($update) = hex($updatea);
my($cyclenum) = hex($cyclenuma) - 1;
+ my($blksz) = ($magic =~ m/^CBuf4/) ? hex($blksza) : 512;
my ($nupdate_str, $nago_str) = &make_time ($update);
@@ -283,7 +284,8 @@
print(" Meta $metaname, order: ");
printf("%d", $orderinmeta);
print(", current: $currentbuff");
-
+ print(", blocksize: $blksz");
+
print "\n Newest: $nupdate_str, $nago_str ago\n";
if ($opt_w) {
@@ -332,6 +334,7 @@
$currentbuff = sprintf("%0.8s", $in);
}
$buff = pack("a8 a16 a64 a16 a16 a16 a16 a16 a16 a8", $magic, $name, $path, $lena, $freea, $updatea, $cyclenuma, $metaname, $orderinmeta, $currentbuff);
+ $buff .= pack("a16", $blksza) if ($magic =~ m/^CBuf4/);
seek(BUFF, 0, 0);
if(! syswrite(BUFF, $buff, $headerlength) ) {
print STDERR "Cannot write $headerlength bytes to file $buffpath...\n";
diff -ruN t/inn-CURRENT-20081125/frontends/cnfsstat.in inn-CURRENT-20081125/frontends/cnfsstat.in
--- t/inn-CURRENT-20081125/frontends/cnfsstat.in 2008-11-25 11:01:10.000000000 +0100
+++ inn-CURRENT-20081125/frontends/cnfsstat.in 2008-11-26 09:32:07.509345924 +0100
@@ -415,7 +415,7 @@
my($CNFSNASIZ)=16;
my($CNFSPASIZ)=64;
my($CNFSLASIZ)=16;
- my($headerlength) = $CNFSMASIZ + $CNFSNASIZ + $CNFSPASIZ + (4 * $CNFSLASIZ);
+ my($headerlength) = 2 * $CNFSMASIZ + 2 * $CNFSNASIZ + $CNFSPASIZ + (6 * $CNFSLASIZ);
my($buff, @entries, $e);
my($magic, $name, $path, $lena, $freea, $updatea, $cyclenuma);
@@ -431,8 +431,9 @@
exit(1);
}
- ($magic, $name, $path, $lena, $freea, $updatea, $cyclenuma) =
- unpack("a8 a16 a64 a16 a16 a16 a16", $buff);
+ ($magic, $name, $path, $lena, $freea, $updatea, $cyclenuma, $metaname,
+ $orderinmeta, $currentbuff, $blksza) =
+ unpack("a8 a16 a64 a16 a16 a16 a16 a16 a16 a8 a16", $buff);
if(!$magic) {
print STDERR "Error while unpacking header ...\n";
@@ -443,11 +444,12 @@
my($free) = bhex($freea);
my($update) = hex($updatea);
my($cyclenum) = hex($cyclenuma) - 1;
+ my($blksz) = ($magic =~ m/^CBuf4/) ? hex($blksza) : 512;
if ($opt_a) {
my $pagesize = 16384;
- my $minartoffset = int($len / (512 * 8)) + 512;
+ my $minartoffset = int($len / ($blksz * 8)) + 512;
# Align upwards:
$minartoffset = ($minartoffset + $pagesize) & ~($pagesize - 1);
@@ -480,7 +482,7 @@
}
# Just in case we chopped Message-ID in two, use the end
# at the front in next iteration.
- $buff = substr ($buff, -512);
+ $buff = substr ($buff, -$blksz);
} while ($sentinel -= $pagesize > 0);
}
diff -ruN t/inn-CURRENT-20081125/storage/cnfs/cnfs-private.h inn-CURRENT-20081125/storage/cnfs/cnfs-private.h
--- t/inn-CURRENT-20081125/storage/cnfs/cnfs-private.h 2008-11-25 11:01:10.000000000 +0100
+++ inn-CURRENT-20081125/storage/cnfs/cnfs-private.h 2008-11-26 09:32:07.509345924 +0100
@@ -20,10 +20,12 @@
#define CNFS_MAGICV1 "Cycbuff" /* CNFSMASIZ bytes */
#define CNFS_MAGICV2 "CBuf1" /* CNFSMASIZ bytes */
#define CNFS_MAGICV3 "CBuf3" /* CNFSMASIZ bytes */
-#define CNFS_BLOCKSIZE 512 /* Unit block size we'll work with */
+#define CNFS_MAGICV4 "CBuf4" /* CNFSMASIZ bytes */
+#define CNFS_DFL_BLOCKSIZE 4096 /* Unit block size we'll work with */
+#define CNFS_MAX_BLOCKSIZE 16384 /* Max unit block size */
/* Amount of data stored at beginning of CYCBUFF before the bitfield */
-#define CNFS_BEFOREBITF (1 * CNFS_BLOCKSIZE)
+#define CNFS_BEFOREBITF 512 /* Rounded up to CNFS_HDR_PAGESIZE */
struct metacycbuff; /* Definition comes below */
@@ -49,6 +51,7 @@
storage */
bool needflush; /* true if CYCBUFFEXTERN is needed to be
flushed */
+ int blksz; /* Blocksize */
struct _CYCBUFF *next;
bool currentbuff; /* true if this cycbuff is currently used */
char metaname[CNFSNASIZ];/* Symbolic name of meta */
@@ -70,6 +73,7 @@
char metaname[CNFSNASIZ];
char orderinmeta[CNFSLASIZ];
char currentbuff[CNFSMASIZ];
+ char blksza[CNFSLASIZ]; /* ASCII version of blksz */
} CYCBUFFEXTERN;
#define METACYCBUFF_UPDATE 25
diff -ruN t/inn-CURRENT-20081125/storage/cnfs/cnfs.c inn-CURRENT-20081125/storage/cnfs/cnfs.c
--- t/inn-CURRENT-20081125/storage/cnfs/cnfs.c 2008-11-25 11:01:10.000000000 +0100
+++ inn-CURRENT-20081125/storage/cnfs/cnfs.c 2008-11-26 10:49:26.216839954 +0100
@@ -61,9 +61,9 @@
static int refresh_interval = REFRESH_INTERVAL;
static TOKEN CNFSMakeToken(char *cycbuffname, off_t offset,
- uint32_t cycnum, STORAGECLASS class) {
+ int blksz, uint32_t cycnum, STORAGECLASS class) {
TOKEN token;
- int32_t int32;
+ uint32_t uint32;
/*
** XXX We'll assume that TOKENSIZE is 16 bytes and that we divvy it
@@ -73,10 +73,10 @@
token.type = TOKEN_CNFS;
token.class = class;
memcpy(token.token, cycbuffname, CNFSMAXCYCBUFFNAME);
- int32 = htonl(offset / CNFS_BLOCKSIZE);
- memcpy(&token.token[8], &int32, sizeof(int32));
- int32 = htonl(cycnum);
- memcpy(&token.token[12], &int32, sizeof(int32));
+ uint32 = htonl(offset / blksz);
+ memcpy(&token.token[8], &uint32, sizeof(uint32));
+ uint32 = htonl(cycnum);
+ memcpy(&token.token[12], &uint32, sizeof(uint32));
return token;
}
@@ -85,20 +85,20 @@
*/
static bool CNFSBreakToken(TOKEN token, char *cycbuffname,
- off_t *offset, uint32_t *cycnum) {
- int32_t int32;
+ uint32_t *blk, uint32_t *cycnum) {
+ uint32_t uint32;
- if (cycbuffname == NULL || offset == NULL || cycnum == NULL) {
+ if (cycbuffname == NULL || blk == NULL || cycnum == NULL) {
warn("CNFS: BreakToken: invalid argument: %s", cycbuffname);
SMseterror(SMERR_INTERNAL, "BreakToken: invalid argument");
return false;
}
memcpy(cycbuffname, token.token, CNFSMAXCYCBUFFNAME);
*(cycbuffname + CNFSMAXCYCBUFFNAME) = '\0'; /* Just to be paranoid */
- memcpy(&int32, &token.token[8], sizeof(int32));
- *offset = (off_t)ntohl(int32) * (off_t)CNFS_BLOCKSIZE;
- memcpy(&int32, &token.token[12], sizeof(int32));
- *cycnum = ntohl(int32);
+ memcpy(&uint32, &token.token[8], sizeof(uint32));
+ *blk = ntohl(uint32);
+ memcpy(&uint32, &token.token[12], sizeof(uint32));
+ *cycnum = ntohl(uint32);
return true;
}
@@ -188,9 +188,12 @@
return false;
}
memset(&rpx, 0, sizeof(CYCBUFFEXTERN));
- if (cycbuff->magicver == 3) {
+ if (cycbuff->magicver == 3 || cycbuff->magicver == 4) {
cycbuff->updated = time(NULL);
- strncpy(rpx.magic, CNFS_MAGICV3, strlen(CNFS_MAGICV3));
+ if (cycbuff->magicver == 3)
+ strncpy(rpx.magic, CNFS_MAGICV3, strlen(CNFS_MAGICV3));
+ else
+ strncpy(rpx.magic, CNFS_MAGICV4, strlen(CNFS_MAGICV4));
strncpy(rpx.name, cycbuff->name, CNFSNASIZ);
strncpy(rpx.path, cycbuff->path, CNFSPASIZ);
/* Don't use sprintf() directly ... the terminating '\0' causes grief */
@@ -205,6 +208,7 @@
} else {
strncpy(rpx.currentbuff, "FALSE", CNFSMASIZ);
}
+ strncpy(rpx.blksza, CNFSofft2hex(cycbuff->blksz, true), CNFSLASIZ);
memcpy(cycbuff->bitfield, &rpx, sizeof(CYCBUFFEXTERN));
msync(cycbuff->bitfield, cycbuff->minartoffset, MS_ASYNC);
cycbuff->needflush = false;
@@ -326,8 +330,7 @@
static bool CNFSparse_part_line(char *l) {
char *p;
struct stat sb;
- off_t len, minartoffset;
- int tonextblock;
+ off_t len;
CYCBUFF *cycbuff, *tmp;
/* Symbolic cnfs partition name */
@@ -384,16 +387,7 @@
cycbuff->next = (CYCBUFF *)NULL;
cycbuff->needflush = false;
cycbuff->bitfield = NULL;
- /*
- ** The minimum article offset will be the size of the bitfield itself,
- ** len / (blocksize * 8), plus however many additional blocks the CYCBUFF
- ** external header occupies ... then round up to the next block.
- */
- minartoffset =
- cycbuff->len / (CNFS_BLOCKSIZE * 8) + CNFS_BEFOREBITF;
- tonextblock = CNFS_HDR_PAGESIZE - (minartoffset & (CNFS_HDR_PAGESIZE - 1));
- cycbuff->minartoffset = minartoffset + tonextblock;
-
+ cycbuff->minartoffset = 0;
if (cycbufftab == (CYCBUFF *)NULL)
cycbufftab = cycbuff;
else {
@@ -542,7 +536,9 @@
char buf[64];
CYCBUFFEXTERN *rpx;
int fd;
+ int tonextblock;
off_t tmpo;
+ off_t minartoffset;
bool oneshot;
/*
@@ -571,7 +567,7 @@
}
}
errno = 0;
- cycbuff->bitfield = mmap(NULL, cycbuff->minartoffset,
+ cycbuff->bitfield = mmap(NULL, CNFS_HDR_PAGESIZE,
SMopenmode ? (PROT_READ | PROT_WRITE) : PROT_READ,
MAP_SHARED, cycbuff->fd, 0);
if (cycbuff->bitfield == MAP_FAILED || errno != 0) {
@@ -586,8 +582,14 @@
** & buggy & particularly icky & unupdated. Use at your own risk. :-)
*/
rpx = (CYCBUFFEXTERN *)cycbuff->bitfield;
+ cycbuff->magicver = 0;
if (strncmp(rpx->magic, CNFS_MAGICV3, strlen(CNFS_MAGICV3)) == 0) {
cycbuff->magicver = 3;
+ cycbuff->blksz = 512;
+ }
+ if (strncmp(rpx->magic, CNFS_MAGICV4, strlen(CNFS_MAGICV4)) == 0)
+ cycbuff->magicver = 4;
+ if (cycbuff->magicver >= 3) {
if (strncmp(rpx->name, cycbuff->name, CNFSNASIZ) != 0) {
warn("CNFS: Mismatch 3: read %s for cycbuff %s", rpx->name,
cycbuff->name);
@@ -621,20 +623,57 @@
cycbuff->currentbuff = true;
} else
cycbuff->currentbuff = false;
+ if (cycbuff->magicver > 3) {
+ strncpy(buf, rpx->blksza, CNFSLASIZ);
+ buf[CNFSLASIZ] = '\0';
+ cycbuff->blksz = CNFShex2offt(buf);
+ }
+ if (cycbuff->blksz < 512 || cycbuff->blksz > CNFS_MAX_BLOCKSIZE ||
+ 2 * (cycbuff->blksz / 2) != cycbuff->blksz) {
+ warn("CNFS: Invalid: read 0x%s blocksize for cycbuff %s",
+ CNFSofft2hex(cycbuff->blksz, false), cycbuff->path);
+ return false;
+ }
} else {
notice("CNFS: no magic cookie found for cycbuff %s, initializing",
cycbuff->name);
- cycbuff->magicver = 3;
+ cycbuff->magicver = 4;
cycbuff->free = cycbuff->minartoffset;
cycbuff->updated = 0;
cycbuff->cyclenum = 1;
cycbuff->currentbuff = true;
cycbuff->order = 0; /* to indicate this is newly added cycbuff */
cycbuff->needflush = true;
+ cycbuff->blksz = CNFS_DFL_BLOCKSIZE;
+ cycbuff->free = 0;
memset(cycbuff->metaname, '\0', CNFSLASIZ);
- if (!CNFSflushhead(cycbuff))
- return false;
}
+ /*
+ ** The minimum article offset will be the size of the bitfield itself,
+ ** len / (blocksize * 8), plus however many additional blocks the CYCBUFF
+ ** external header occupies ... then round up to the next block.
+ */
+ minartoffset = cycbuff->len / (cycbuff->blksz * 8) + CNFS_BEFOREBITF;
+ tonextblock = CNFS_HDR_PAGESIZE - (minartoffset & (CNFS_HDR_PAGESIZE - 1));
+ cycbuff->minartoffset = minartoffset + tonextblock;
+
+ munmap(cycbuff->bitfield, CNFS_HDR_PAGESIZE);
+ errno = 0;
+ cycbuff->bitfield = mmap(NULL, cycbuff->minartoffset,
+ SMopenmode ? (PROT_READ | PROT_WRITE) : PROT_READ,
+ MAP_SHARED, cycbuff->fd, 0);
+ if (cycbuff->bitfield == MAP_FAILED || errno != 0) {
+ warn("CNFS: CNFSinitdisks: mmap for %s offset %d len %ld failed: %m",
+ cycbuff->path, 0, (long) cycbuff->minartoffset);
+ cycbuff->bitfield = NULL;
+ return false;
+ }
+
+ if (cycbuff->free == 0)
+ cycbuff->free = cycbuff->minartoffset;
+ if (cycbuff->needflush && !CNFSflushhead(cycbuff))
+ return false;
+
if (oneshot)
break;
}
@@ -908,13 +947,13 @@
bufoff, bufmin, bufmax);
return 0;
}
- if (offset % CNFS_BLOCKSIZE != 0) {
+ if (offset % cycbuff->blksz != 0) {
SMseterror(SMERR_INTERNAL, NULL);
warn("CNFS: CNFSsetusedbitbyrp: offset %s not on %d-byte block"
- " boundary", CNFSofft2hex(offset, false), CNFS_BLOCKSIZE);
+ " boundary", CNFSofft2hex(offset, false), cycbuff->blksz);
return 0;
}
- blocknum = offset / CNFS_BLOCKSIZE;
+ blocknum = offset / cycbuff->blksz;
longoffset = blocknum / (longsize * 8);
bitoffset = blocknum % (longsize * 8);
where = (ULONG *)cycbuff->bitfield + (CNFS_BEFOREBITF / longsize)
@@ -1053,7 +1092,7 @@
METACYCBUFF *metacycbuff = NULL;
int i;
static char buf[1024];
- static char alignbuf[CNFS_BLOCKSIZE];
+ static char alignbuf[CNFS_MAX_BLOCKSIZE];
char *artcycbuffname;
off_t artoffset, middle;
uint32_t artcyclenum;
@@ -1093,18 +1132,18 @@
/* cycbuff->free should have already been aligned by the last write, but
realign it just to be sure. */
- tonextblock = CNFS_BLOCKSIZE - (cycbuff->free & (CNFS_BLOCKSIZE - 1));
- if (tonextblock != CNFS_BLOCKSIZE)
+ tonextblock = cycbuff->blksz - (cycbuff->free & (cycbuff->blksz - 1));
+ if (tonextblock != cycbuff->blksz)
cycbuff->free += tonextblock;
/* Article too big? */
- if (cycbuff->len - cycbuff->free < CNFS_BLOCKSIZE + 1)
+ if (cycbuff->len - cycbuff->free < cycbuff->blksz + 1)
left = 0;
else
- left = cycbuff->len - cycbuff->free - CNFS_BLOCKSIZE - 1;
+ left = cycbuff->len - cycbuff->free - cycbuff->blksz - 1;
if ((off_t) article.len > left) {
- for (middle = cycbuff->free ;middle < cycbuff->len - CNFS_BLOCKSIZE - 1;
- middle += CNFS_BLOCKSIZE) {
+ for (middle = cycbuff->free ;middle < cycbuff->len - cycbuff->blksz - 1;
+ middle += cycbuff->blksz) {
CNFSUsedBlock(cycbuff, middle, true, false);
}
if (innconf->nfswriter) {
@@ -1112,8 +1151,13 @@
}
cycbuff->free = cycbuff->minartoffset;
cycbuff->cyclenum++;
- if (cycbuff->cyclenum == 0)
- cycbuff->cyclenum += 2; /* cnfs_next() needs this */
+ if (cycbuff->magicver <= 3) {
+ if (cycbuff->cyclenum == 0)
+ cycbuff->cyclenum += 2; /* cnfs_next() needs this */
+ } else {
+ if ((cycbuff->cyclenum & 0xFFFFFF) == 0) /* 24 bits max */
+ cycbuff->cyclenum = 2; /* cnfs_next() needs this */
+ }
cycbuff->needflush = true;
if (metacycbuff->metamode == INTERLEAVE) {
CNFSflushhead(cycbuff); /* Flush, just for giggles */
@@ -1176,10 +1220,11 @@
iov[i].iov_len = article.iov[i-1].iov_len;
totlen += iov[i].iov_len;
}
- if ((totlen & (CNFS_BLOCKSIZE - 1)) != 0) {
- /* Want to xwritev an exact multiple of CNFS_BLOCKSIZE */
+ if ((totlen & (cycbuff->blksz - 1)) != 0) {
+ /* Want to xwritev an exact multiple of cycbuff->blksz */
iov[i].iov_base = alignbuf;
- iov[i].iov_len = CNFS_BLOCKSIZE - (totlen & (CNFS_BLOCKSIZE - 1));
+ iov[i].iov_len = cycbuff->blksz -
+ (totlen & (cycbuff->blksz - 1));
totlen += iov[i].iov_len;
i++;
}
@@ -1208,21 +1253,23 @@
}
}
CNFSUsedBlock(cycbuff, artoffset, true, true);
- for (middle = artoffset + CNFS_BLOCKSIZE; middle < cycbuff->free;
- middle += CNFS_BLOCKSIZE) {
+ for (middle = artoffset + cycbuff->blksz; middle < cycbuff->free;
+ middle += cycbuff->blksz) {
CNFSUsedBlock(cycbuff, middle, true, false);
}
if (innconf->nfswriter) {
cnfs_mapcntl(NULL, 0, MS_ASYNC);
}
if (!SMpreopen) CNFSshutdowncycbuff(cycbuff);
- return CNFSMakeToken(artcycbuffname, artoffset, artcyclenum, class);
+ return CNFSMakeToken(artcycbuffname, artoffset,
+ cycbuff->blksz, artcyclenum, class);
}
ARTHANDLE *cnfs_retrieve(const TOKEN token, const RETRTYPE amount) {
char cycbuffname[9];
off_t offset;
uint32_t cycnum;
+ uint32_t block;
CYCBUFF *cycbuff;
ARTHANDLE *art;
CNFSARTHEADER cah;
@@ -1238,7 +1285,7 @@
SMseterror(SMERR_INTERNAL, NULL);
return NULL;
}
- if (! CNFSBreakToken(token, cycbuffname, &offset, &cycnum)) {
+ if (! CNFSBreakToken(token, cycbuffname, &block, &cycnum)) {
/* SMseterror() should have already been called */
return NULL;
}
@@ -1247,7 +1294,7 @@
if (!nomessage) {
warn("CNFS: cnfs_retrieve: token %s: bogus cycbuff name:"
" %s:0x%s:%d", TokenToText(token), cycbuffname,
- CNFSofft2hex(offset, false), cycnum);
+ CNFSofft2hex(block, false), cycnum);
nomessage = true;
}
return NULL;
@@ -1257,6 +1304,7 @@
warn("CNFS: cycbuff '%s' initialization fail", cycbuff->name);
return NULL;
}
+ offset = (off_t)block * cycbuff->blksz;
if (! CNFSArtMayBeHere(cycbuff, offset, cycnum)) {
SMseterror(SMERR_NOENT, NULL);
if (!SMpreopen) CNFSshutdowncycbuff(cycbuff);
@@ -1310,7 +1358,7 @@
plusoffset = sizeof(oldCNFSARTHEADER)-sizeof(CNFSARTHEADER);
}
#endif /* OLD_CNFS */
- if (offset > cycbuff->len - CNFS_BLOCKSIZE - (off_t) ntohl(cah.size) - 1) {
+ if (offset > cycbuff->len - cycbuff->blksz - (off_t) ntohl(cah.size) - 1) {
if (!SMpreopen) {
SMseterror(SMERR_UNDEFINED, "CNFSARTHEADER size overflow");
warn("CNFS: could not match article size token %s %s:0x%s:%d: %ld",
@@ -1321,7 +1369,7 @@
return NULL;
}
CNFSReadFreeAndCycle(cycbuff);
- if (offset > cycbuff->len - CNFS_BLOCKSIZE - (off_t) ntohl(cah.size) - 1) {
+ if (offset > cycbuff->len - cycbuff->blksz - (off_t) ntohl(cah.size) - 1) {
SMseterror(SMERR_UNDEFINED, "CNFSARTHEADER size overflow");
warn("CNFS: could not match article size token %s %s:0x%s:%d: %ld",
TokenToText(token), cycbuffname, CNFSofft2hex(offset, false),
@@ -1455,13 +1503,14 @@
char cycbuffname[9];
off_t offset;
uint32_t cycnum;
+ uint32_t block;
CYCBUFF *cycbuff;
if (token.type != TOKEN_CNFS) {
SMseterror(SMERR_INTERNAL, NULL);
return false;
}
- if (! CNFSBreakToken(token, cycbuffname, &offset, &cycnum)) {
+ if (! CNFSBreakToken(token, cycbuffname, &block, &cycnum)) {
SMseterror(SMERR_INTERNAL, NULL);
/* SMseterror() should have already been called */
return false;
@@ -1475,6 +1524,7 @@
warn("CNFS: cycbuff '%s' initialization fail", cycbuff->name);
return false;
}
+ offset = (off_t)block * cycbuff->blksz;
if (! (cycnum == cycbuff->cyclenum ||
(cycnum == cycbuff->cyclenum - 1 && offset > cycbuff->free) ||
(cycnum + 1 == 0 && cycbuff->cyclenum == 2 && offset > cycbuff->free))) {
@@ -1561,19 +1611,19 @@
}
}
if (!priv.rollover) {
- for (middle = priv.offset ;middle < cycbuff->len - CNFS_BLOCKSIZE - 1;
- middle += CNFS_BLOCKSIZE) {
+ for (middle = priv.offset ;middle < cycbuff->len - cycbuff->blksz - 1;
+ middle += cycbuff->blksz) {
if (CNFSUsedBlock(cycbuff, middle, false, false) != 0)
break;
}
- if (middle >= cycbuff->len - CNFS_BLOCKSIZE - 1) {
+ if (middle >= cycbuff->len - cycbuff->blksz - 1) {
priv.rollover = true;
middle = cycbuff->minartoffset;
}
break;
} else {
for (middle = priv.offset ;middle < cycbuff->free;
- middle += CNFS_BLOCKSIZE) {
+ middle += cycbuff->blksz) {
if (CNFSUsedBlock(cycbuff, middle, false, false) != 0)
break;
}
@@ -1614,8 +1664,8 @@
*private = priv;
private->cycbuff = cycbuff;
private->offset = middle;
- if (cycbuff->len - cycbuff->free < (off_t) ntohl(cah.size) + CNFS_BLOCKSIZE + 1) {
- private->offset += CNFS_BLOCKSIZE;
+ if (cycbuff->len - cycbuff->free < (off_t) ntohl(cah.size) + cycbuff->blksz + 1) {
+ private->offset += cycbuff->blksz;
art->data = NULL;
art->len = 0;
art->token = NULL;
@@ -1623,11 +1673,11 @@
return art;
}
/* check the bitmap to ensure cah.size is not broken */
- blockfudge = (sizeof(cah) + plusoffset + ntohl(cah.size)) % CNFS_BLOCKSIZE;
- limit = private->offset + sizeof(cah) + plusoffset + ntohl(cah.size) - blockfudge + CNFS_BLOCKSIZE;
+ blockfudge = (sizeof(cah) + plusoffset + ntohl(cah.size)) % cycbuff->blksz;
+ limit = private->offset + sizeof(cah) + plusoffset + ntohl(cah.size) - blockfudge + cycbuff->blksz;
if (offset < cycbuff->free) {
- for (middle = offset + CNFS_BLOCKSIZE; (middle < cycbuff->free) && (middle < limit);
- middle += CNFS_BLOCKSIZE) {
+ for (middle = offset + cycbuff->blksz; (middle < cycbuff->free) && (middle < limit);
+ middle += cycbuff->blksz) {
if (CNFSUsedBlock(cycbuff, middle, false, false) != 0)
/* Bitmap set. This article assumes to be broken */
break;
@@ -1641,8 +1691,8 @@
return art;
}
} else {
- for (middle = offset + CNFS_BLOCKSIZE; (middle < cycbuff->len) && (middle < limit);
- middle += CNFS_BLOCKSIZE) {
+ for (middle = offset + cycbuff->blksz; (middle < cycbuff->len) && (middle < limit);
+ middle += cycbuff->blksz) {
if (CNFSUsedBlock(cycbuff, middle, false, false) != 0)
/* Bitmap set. This article assumes to be broken */
break;
@@ -1667,10 +1717,12 @@
}
private->offset += (off_t) ntohl(cah.size) + sizeof(cah) + plusoffset;
- tonextblock = CNFS_BLOCKSIZE - (private->offset & (CNFS_BLOCKSIZE - 1));
+ tonextblock = cycbuff->blksz - (private->offset & (cycbuff->blksz - 1));
private->offset += (off_t) tonextblock;
art->arrived = ntohl(cah.arrived);
- token = CNFSMakeToken(cycbuff->name, offset, (offset > cycbuff->free) ? cycbuff->cyclenum - 1 : cycbuff->cyclenum, cah.class);
+ token = CNFSMakeToken(cycbuff->name, offset, cycbuff->blksz,
+ (offset > cycbuff->free) ? cycbuff->cyclenum - 1 : cycbuff->cyclenum,
+ cah.class);
art->token = &token;
offset += sizeof(cah) + plusoffset;
if (innconf->articlemmap) {
--
The From: and Reply-To: addresses are internal news2mail gateway addresses.
Reply to the list or to "Miquel van Smoorenburg" <miquels at cistron.nl>
More information about the inn-workers
mailing list