Changeset View
Changeset View
Standalone View
Standalone View
head/sys/boot/common/bcache.c
/*- | /*- | ||||
* Copyright (c) 1998 Michael Smith <msmith@freebsd.org> | * Copyright (c) 1998 Michael Smith <msmith@freebsd.org> | ||||
* Copyright 2015 Toomas Soome <tsoome@me.com> | |||||
* All rights reserved. | * All rights reserved. | ||||
* | * | ||||
* Redistribution and use in source and binary forms, with or without | * Redistribution and use in source and binary forms, with or without | ||||
* modification, are permitted provided that the following conditions | * modification, are permitted provided that the following conditions | ||||
* are met: | * are met: | ||||
* 1. Redistributions of source code must retain the above copyright | * 1. Redistributions of source code must retain the above copyright | ||||
* notice, this list of conditions and the following disclaimer. | * notice, this list of conditions and the following disclaimer. | ||||
* 2. Redistributions in binary form must reproduce the above copyright | * 2. Redistributions in binary form must reproduce the above copyright | ||||
Show All 9 Lines | |||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||||
* SUCH DAMAGE. | * SUCH DAMAGE. | ||||
*/ | */ | ||||
#include <sys/cdefs.h> | #include <sys/cdefs.h> | ||||
#include <sys/param.h> | |||||
__FBSDID("$FreeBSD$"); | __FBSDID("$FreeBSD$"); | ||||
/* | /* | ||||
* Simple LRU block cache | * Simple hashed block cache | ||||
*/ | */ | ||||
#include <sys/stdint.h> | #include <sys/stdint.h> | ||||
#include <stand.h> | #include <stand.h> | ||||
#include <string.h> | #include <string.h> | ||||
#include <bitstring.h> | #include <strings.h> | ||||
#include "bootstrap.h" | #include "bootstrap.h" | ||||
/* #define BCACHE_DEBUG */ | /* #define BCACHE_DEBUG */ | ||||
#ifdef BCACHE_DEBUG | #ifdef BCACHE_DEBUG | ||||
#define BCACHE_TIMEOUT 10 | |||||
# define DEBUG(fmt, args...) printf("%s: " fmt "\n" , __func__ , ## args) | # define DEBUG(fmt, args...) printf("%s: " fmt "\n" , __func__ , ## args) | ||||
#else | #else | ||||
#define BCACHE_TIMEOUT 2 | |||||
# define DEBUG(fmt, args...) | # define DEBUG(fmt, args...) | ||||
#endif | #endif | ||||
struct bcachectl | struct bcachectl | ||||
{ | { | ||||
daddr_t bc_blkno; | daddr_t bc_blkno; | ||||
time_t bc_stamp; | |||||
int bc_count; | int bc_count; | ||||
}; | }; | ||||
static struct bcachectl *bcache_ctl; | /* | ||||
static caddr_t bcache_data; | * bcache per device node. cache is allocated on device first open and freed | ||||
static bitstr_t *bcache_miss; | * on last close, to save memory. The issue there is the size; biosdisk | ||||
static u_int bcache_nblks; | * supports up to 31 (0x1f) devices. Classic setup would use single disk | ||||
static u_int bcache_blksize; | * to boot from, but this has changed with zfs. | ||||
static u_int bcache_hits, bcache_misses, bcache_ops, bcache_bypasses; | */ | ||||
static u_int bcache_flushes; | struct bcache { | ||||
struct bcachectl *bcache_ctl; | |||||
caddr_t bcache_data; | |||||
u_int bcache_nblks; | |||||
size_t ra; | |||||
}; | |||||
static u_int bcache_total_nblks; /* set by bcache_init */ | |||||
static u_int bcache_blksize; /* set by bcache_init */ | |||||
static u_int bcache_numdev; /* set by bcache_add_dev */ | |||||
/* statistics */ | |||||
static u_int bcache_units; /* number of devices with cache */ | |||||
static u_int bcache_unit_nblks; /* nblocks per unit */ | |||||
static u_int bcache_hits; | |||||
static u_int bcache_misses; | |||||
static u_int bcache_ops; | |||||
static u_int bcache_bypasses; | |||||
static u_int bcache_bcount; | static u_int bcache_bcount; | ||||
static u_int bcache_rablks; | |||||
static void bcache_invalidate(daddr_t blkno); | #define BHASH(bc, blkno) ((blkno) & ((bc)->bcache_nblks - 1)) | ||||
static void bcache_insert(caddr_t buf, daddr_t blkno); | #define BCACHE_LOOKUP(bc, blkno) \ | ||||
static int bcache_lookup(caddr_t buf, daddr_t blkno); | ((bc)->bcache_ctl[BHASH((bc), (blkno))].bc_blkno != (blkno)) | ||||
#define BCACHE_READAHEAD 256 | |||||
#define BCACHE_MINREADAHEAD 32 | |||||
static void bcache_invalidate(struct bcache *bc, daddr_t blkno); | |||||
static void bcache_insert(struct bcache *bc, daddr_t blkno); | |||||
static void bcache_free_instance(struct bcache *bc); | |||||
/* | /* | ||||
* Initialise the cache for (nblks) of (bsize). | * Initialise the cache for (nblks) of (bsize). | ||||
*/ | */ | ||||
int | void | ||||
bcache_init(u_int nblks, size_t bsize) | bcache_init(u_int nblks, size_t bsize) | ||||
{ | { | ||||
/* discard any old contents */ | /* set up control data */ | ||||
if (bcache_data != NULL) { | bcache_total_nblks = nblks; | ||||
free(bcache_data); | |||||
bcache_data = NULL; | |||||
free(bcache_ctl); | |||||
} | |||||
/* Allocate control structures */ | |||||
bcache_nblks = nblks; | |||||
bcache_blksize = bsize; | bcache_blksize = bsize; | ||||
bcache_data = malloc(bcache_nblks * bcache_blksize); | |||||
bcache_ctl = (struct bcachectl *)malloc(bcache_nblks * sizeof(struct bcachectl)); | |||||
bcache_miss = bit_alloc((bcache_nblks + 1) / 2); | |||||
if ((bcache_data == NULL) || (bcache_ctl == NULL) || (bcache_miss == NULL)) { | |||||
if (bcache_miss) | |||||
free(bcache_miss); | |||||
if (bcache_ctl) | |||||
free(bcache_ctl); | |||||
if (bcache_data) | |||||
free(bcache_data); | |||||
bcache_data = NULL; | |||||
return(ENOMEM); | |||||
} | } | ||||
return(0); | |||||
} | |||||
/* | /* | ||||
* Flush the cache | * add number of devices to bcache. we have to divide cache space | ||||
* between the devices, so bcache_add_dev() can be used to set up the | |||||
* number. The issue is, we need to get the number before actual allocations. | |||||
* bcache_add_dev() is supposed to be called from device init() call, so the | |||||
* assumption is, devsw dv_init is called for plain devices first, and | |||||
* for zfs, last. | |||||
*/ | */ | ||||
void | void | ||||
bcache_flush(void) | bcache_add_dev(int devices) | ||||
{ | { | ||||
bcache_numdev += devices; | |||||
} | |||||
void * | |||||
bcache_allocate(void) | |||||
{ | |||||
u_int i; | u_int i; | ||||
struct bcache *bc = malloc(sizeof (struct bcache)); | |||||
int disks = bcache_numdev; | |||||
bcache_flushes++; | if (disks == 0) | ||||
disks = 1; /* safe guard */ | |||||
if (bc == NULL) { | |||||
errno = ENOMEM; | |||||
return (bc); | |||||
} | |||||
/* | |||||
* the bcache block count must be power of 2 for hash function | |||||
*/ | |||||
i = fls(disks) - 1; /* highbit - 1 */ | |||||
if (disks > (1 << i)) /* next power of 2 */ | |||||
i++; | |||||
bc->bcache_nblks = bcache_total_nblks >> i; | |||||
bcache_unit_nblks = bc->bcache_nblks; | |||||
bc->bcache_data = malloc(bc->bcache_nblks * bcache_blksize); | |||||
if (bc->bcache_data == NULL) { | |||||
/* dont error out yet. fall back to 32 blocks and try again */ | |||||
bc->bcache_nblks = 32; | |||||
bc->bcache_data = malloc(bc->bcache_nblks * bcache_blksize); | |||||
} | |||||
bc->bcache_ctl = malloc(bc->bcache_nblks * sizeof(struct bcachectl)); | |||||
if ((bc->bcache_data == NULL) || (bc->bcache_ctl == NULL)) { | |||||
bcache_free_instance(bc); | |||||
errno = ENOMEM; | |||||
return(NULL); | |||||
} | |||||
/* Flush the cache */ | /* Flush the cache */ | ||||
for (i = 0; i < bcache_nblks; i++) { | for (i = 0; i < bc->bcache_nblks; i++) { | ||||
bcache_ctl[i].bc_count = -1; | bc->bcache_ctl[i].bc_count = -1; | ||||
bcache_ctl[i].bc_blkno = -1; | bc->bcache_ctl[i].bc_blkno = -1; | ||||
} | } | ||||
bcache_units++; | |||||
bc->ra = BCACHE_READAHEAD; /* optimistic read ahead */ | |||||
return (bc); | |||||
} | } | ||||
void | |||||
bcache_free(void *cache) | |||||
{ | |||||
struct bcache *bc = cache; | |||||
if (bc == NULL) | |||||
return; | |||||
bcache_free_instance(bc); | |||||
bcache_units--; | |||||
} | |||||
/* | /* | ||||
* Handle a write request; write directly to the disk, and populate the | * Handle a write request; write directly to the disk, and populate the | ||||
* cache with the new values. | * cache with the new values. | ||||
*/ | */ | ||||
static int | static int | ||||
write_strategy(void *devdata, int unit, int rw, daddr_t blk, size_t size, | write_strategy(void *devdata, int rw, daddr_t blk, size_t offset, | ||||
char *buf, size_t *rsize) | size_t size, char *buf, size_t *rsize) | ||||
{ | { | ||||
struct bcache_devdata *dd = (struct bcache_devdata *)devdata; | struct bcache_devdata *dd = (struct bcache_devdata *)devdata; | ||||
struct bcache *bc = dd->dv_cache; | |||||
daddr_t i, nblk; | daddr_t i, nblk; | ||||
int err; | |||||
nblk = size / bcache_blksize; | nblk = size / bcache_blksize; | ||||
/* Invalidate the blocks being written */ | /* Invalidate the blocks being written */ | ||||
for (i = 0; i < nblk; i++) { | for (i = 0; i < nblk; i++) { | ||||
bcache_invalidate(blk + i); | bcache_invalidate(bc, blk + i); | ||||
} | } | ||||
/* Write the blocks */ | /* Write the blocks */ | ||||
err = dd->dv_strategy(dd->dv_devdata, rw, blk, size, buf, rsize); | return (dd->dv_strategy(dd->dv_devdata, rw, blk, offset, size, buf, rsize)); | ||||
/* Populate the block cache with the new data */ | |||||
if (err == 0) { | |||||
for (i = 0; i < nblk; i++) { | |||||
bcache_insert(buf + (i * bcache_blksize),blk + i); | |||||
} | } | ||||
} | |||||
return err; | |||||
} | |||||
/* | /* | ||||
* Handle a read request; fill in parts of the request that can | * Handle a read request; fill in parts of the request that can | ||||
* be satisfied by the cache, use the supplied strategy routine to do | * be satisfied by the cache, use the supplied strategy routine to do | ||||
* device I/O and then use the I/O results to populate the cache. | * device I/O and then use the I/O results to populate the cache. | ||||
*/ | */ | ||||
static int | static int | ||||
read_strategy(void *devdata, int unit, int rw, daddr_t blk, size_t size, | read_strategy(void *devdata, int rw, daddr_t blk, size_t offset, | ||||
char *buf, size_t *rsize) | size_t size, char *buf, size_t *rsize) | ||||
{ | { | ||||
struct bcache_devdata *dd = (struct bcache_devdata *)devdata; | struct bcache_devdata *dd = (struct bcache_devdata *)devdata; | ||||
int p_size, result; | struct bcache *bc = dd->dv_cache; | ||||
daddr_t p_blk, i, j, nblk; | size_t i, nblk, p_size, r_size, complete, ra; | ||||
int result; | |||||
daddr_t p_blk; | |||||
caddr_t p_buf; | caddr_t p_buf; | ||||
if (bc == NULL) { | |||||
errno = ENODEV; | |||||
return (-1); | |||||
} | |||||
if (rsize != NULL) | |||||
*rsize = 0; | |||||
nblk = size / bcache_blksize; | nblk = size / bcache_blksize; | ||||
if ((nblk == 0 && size != 0) || offset != 0) | |||||
nblk++; | |||||
result = 0; | result = 0; | ||||
complete = 1; | |||||
/* Satisfy any cache hits up front */ | /* Satisfy any cache hits up front, break on first miss */ | ||||
for (i = 0; i < nblk; i++) { | for (i = 0; i < nblk; i++) { | ||||
if (bcache_lookup(buf + (bcache_blksize * i), blk + i)) { | if (BCACHE_LOOKUP(bc, (daddr_t)(blk + i))) { | ||||
bit_set(bcache_miss, i); /* cache miss */ | bcache_misses += (nblk - i); | ||||
bcache_misses++; | complete = 0; | ||||
if (nblk - i > BCACHE_MINREADAHEAD && bc->ra > BCACHE_MINREADAHEAD) | |||||
cperciva: I understand where the second part comes from -- if `bc->ra` is already the minimum allowed… | |||||
tsoomeAuthorUnsubmitted Done Inline ActionsI *think* the idea was to try to avioid reducing readahead when we got most blocks from cache, but did miss few. That is, we reduce readahead in case the significant number of blocks is missing. tsoome: I *think* the idea was to try to avioid reducing readahead when we got most blocks from cache… | |||||
bc->ra >>= 1; /* reduce read ahead */ | |||||
break; | |||||
} else { | } else { | ||||
bit_clear(bcache_miss, i); /* cache hit */ | |||||
bcache_hits++; | bcache_hits++; | ||||
} | } | ||||
} | } | ||||
/* Go back and fill in any misses XXX optimise */ | if (complete) { /* whole set was in cache, return it */ | ||||
p_blk = -1; | if (bc->ra < BCACHE_READAHEAD) | ||||
p_buf = NULL; | bc->ra <<= 1; /* increase read ahead */ | ||||
p_size = 0; | bcopy(bc->bcache_data + (bcache_blksize * BHASH(bc, blk)) + offset, | ||||
for (i = 0; i < nblk; i++) { | buf, size); | ||||
if (bit_test(bcache_miss, i)) { | |||||
/* miss, add to pending transfer */ | |||||
if (p_blk == -1) { | |||||
p_blk = blk + i; | |||||
p_buf = buf + (bcache_blksize * i); | |||||
p_size = 1; | |||||
} else { | |||||
p_size++; | |||||
} | |||||
} else if (p_blk != -1) { | |||||
/* hit, complete pending transfer */ | |||||
result = dd->dv_strategy(dd->dv_devdata, rw, p_blk, p_size * bcache_blksize, p_buf, NULL); | |||||
if (result != 0) | |||||
goto done; | goto done; | ||||
for (j = 0; j < p_size; j++) | |||||
bcache_insert(p_buf + (j * bcache_blksize), p_blk + j); | |||||
p_blk = -1; | |||||
} | } | ||||
/* | |||||
* Fill in any misses. From check we have i pointing to first missing | |||||
* block, read in all remaining blocks + readahead. | |||||
* We have space at least for nblk - i before bcache wraps. | |||||
*/ | |||||
p_blk = blk + i; | |||||
p_buf = bc->bcache_data + (bcache_blksize * BHASH(bc, p_blk)); | |||||
r_size = bc->bcache_nblks - BHASH(bc, p_blk); /* remaining blocks */ | |||||
p_size = MIN(r_size, nblk - i); /* read at least those blocks */ | |||||
ra = bc->bcache_nblks - BHASH(bc, p_blk + p_size); | |||||
if (ra != bc->bcache_nblks) { /* do we have RA space? */ | |||||
ra = MIN(bc->ra, ra); | |||||
p_size += ra; | |||||
} | } | ||||
if (p_blk != -1) { | |||||
/* pending transfer left */ | /* invalidate bcache */ | ||||
result = dd->dv_strategy(dd->dv_devdata, rw, p_blk, p_size * bcache_blksize, p_buf, NULL); | for (i = 0; i < p_size; i++) { | ||||
if (result != 0) | bcache_invalidate(bc, p_blk + i); | ||||
goto done; | |||||
for (j = 0; j < p_size; j++) | |||||
bcache_insert(p_buf + (j * bcache_blksize), p_blk + j); | |||||
} | } | ||||
r_size = 0; | |||||
result = dd->dv_strategy(dd->dv_devdata, rw, p_blk, 0, | |||||
p_size * bcache_blksize, p_buf, &r_size); | |||||
if (result) | |||||
goto done; | |||||
r_size /= bcache_blksize; | |||||
for (i = 0; i < r_size; i++) | |||||
bcache_insert(bc, p_blk + i); | |||||
bcache_rablks += ra; | |||||
bcopy(bc->bcache_data + (bcache_blksize * BHASH(bc, blk)) + offset, buf, | |||||
size); | |||||
done: | done: | ||||
if ((result == 0) && (rsize != NULL)) | if ((result == 0) && (rsize != NULL)) | ||||
*rsize = size; | *rsize = size; | ||||
return(result); | return(result); | ||||
} | } | ||||
/* | /* | ||||
* Requests larger than 1/2 the cache size will be bypassed and go | * Requests larger than 1/2 cache size will be bypassed and go | ||||
* directly to the disk. XXX tune this. | * directly to the disk. XXX tune this. | ||||
*/ | */ | ||||
int | int | ||||
bcache_strategy(void *devdata, int unit, int rw, daddr_t blk, size_t size, | bcache_strategy(void *devdata, int rw, daddr_t blk, size_t offset, | ||||
char *buf, size_t *rsize) | size_t size, char *buf, size_t *rsize) | ||||
{ | { | ||||
static int bcache_unit = -1; | |||||
struct bcache_devdata *dd = (struct bcache_devdata *)devdata; | struct bcache_devdata *dd = (struct bcache_devdata *)devdata; | ||||
struct bcache *bc = dd->dv_cache; | |||||
u_int bcache_nblks = 0; | |||||
int nblk, cblk, ret; | |||||
size_t csize, isize, total; | |||||
bcache_ops++; | bcache_ops++; | ||||
if(bcache_unit != unit) { | if (bc != NULL) | ||||
bcache_flush(); | bcache_nblks = bc->bcache_nblks; | ||||
bcache_unit = unit; | |||||
} | |||||
/* bypass large requests, or when the cache is inactive */ | /* bypass large requests, or when the cache is inactive */ | ||||
if ((bcache_data == NULL) || ((size * 2 / bcache_blksize) > bcache_nblks)) { | if (bc == NULL || | ||||
(offset == 0 && ((size * 2 / bcache_blksize) > bcache_nblks))) { | |||||
DEBUG("bypass %d from %d", size / bcache_blksize, blk); | DEBUG("bypass %d from %d", size / bcache_blksize, blk); | ||||
bcache_bypasses++; | bcache_bypasses++; | ||||
return(dd->dv_strategy(dd->dv_devdata, rw, blk, size, buf, rsize)); | return (dd->dv_strategy(dd->dv_devdata, rw, blk, offset, size, buf, | ||||
rsize)); | |||||
} | } | ||||
/* normalize offset */ | |||||
while (offset >= bcache_blksize) { | |||||
blk++; | |||||
offset -= bcache_blksize; | |||||
} | |||||
switch (rw) { | switch (rw) { | ||||
case F_READ: | case F_READ: | ||||
return read_strategy(devdata, unit, rw, blk, size, buf, rsize); | nblk = size / bcache_blksize; | ||||
if (offset || (size != 0 && nblk == 0)) | |||||
nblk++; /* read at least one block */ | |||||
ret = 0; | |||||
total = 0; | |||||
while(size) { | |||||
cblk = bcache_nblks - BHASH(bc, blk); /* # of blocks left */ | |||||
cblk = MIN(cblk, nblk); | |||||
if (size <= bcache_blksize) | |||||
csize = size; | |||||
else { | |||||
csize = cblk * bcache_blksize; | |||||
if (offset) | |||||
csize -= (bcache_blksize - offset); | |||||
} | |||||
ret = read_strategy(devdata, rw, blk, offset, | |||||
csize, buf+total, &isize); | |||||
if (ret != 0) | |||||
return (ret); | |||||
blk += (offset+isize) / bcache_blksize; | |||||
offset = 0; | |||||
total += isize; | |||||
size -= isize; | |||||
nblk = size / bcache_blksize; | |||||
} | |||||
if (rsize) | |||||
*rsize = total; | |||||
return (ret); | |||||
case F_WRITE: | case F_WRITE: | ||||
return write_strategy(devdata, unit, rw, blk, size, buf, rsize); | return write_strategy(devdata, rw, blk, offset, size, buf, rsize); | ||||
} | } | ||||
return -1; | return -1; | ||||
} | } | ||||
/* | /* | ||||
* Insert a block into the cache. Retire the oldest block to do so, if required. | * Free allocated bcache instance | ||||
* | |||||
* XXX the LRU algorithm will fail after 2^31 blocks have been transferred. | |||||
*/ | */ | ||||
static void | static void | ||||
bcache_insert(caddr_t buf, daddr_t blkno) | bcache_free_instance(struct bcache *bc) | ||||
{ | { | ||||
time_t now; | if (bc != NULL) { | ||||
int cand, ocount; | if (bc->bcache_ctl) | ||||
u_int i; | free(bc->bcache_ctl); | ||||
if (bc->bcache_data) | |||||
time(&now); | free(bc->bcache_data); | ||||
cand = 0; /* assume the first block */ | free(bc); | ||||
ocount = bcache_ctl[0].bc_count; | |||||
/* find the oldest block */ | |||||
for (i = 1; i < bcache_nblks; i++) { | |||||
if (bcache_ctl[i].bc_blkno == blkno) { | |||||
/* reuse old entry */ | |||||
cand = i; | |||||
break; | |||||
} | } | ||||
if (bcache_ctl[i].bc_count < ocount) { | |||||
ocount = bcache_ctl[i].bc_count; | |||||
cand = i; | |||||
} | } | ||||
} | |||||
DEBUG("insert blk %d -> %d @ %d # %d", blkno, cand, now, bcache_bcount); | |||||
bcopy(buf, bcache_data + (bcache_blksize * cand), bcache_blksize); | |||||
bcache_ctl[cand].bc_blkno = blkno; | |||||
bcache_ctl[cand].bc_stamp = now; | |||||
bcache_ctl[cand].bc_count = bcache_bcount++; | |||||
} | |||||
/* | /* | ||||
* Look for a block in the cache. Blocks more than BCACHE_TIMEOUT seconds old | * Insert a block into the cache. | ||||
* may be stale (removable media) and thus are discarded. Copy the block out | |||||
* if successful and return zero, or return nonzero on failure. | |||||
*/ | */ | ||||
static int | static void | ||||
bcache_lookup(caddr_t buf, daddr_t blkno) | bcache_insert(struct bcache *bc, daddr_t blkno) | ||||
{ | { | ||||
time_t now; | u_int cand; | ||||
u_int i; | |||||
time(&now); | cand = BHASH(bc, blkno); | ||||
for (i = 0; i < bcache_nblks; i++) | DEBUG("insert blk %llu -> %u # %d", blkno, cand, bcache_bcount); | ||||
/* cache hit? */ | bc->bcache_ctl[cand].bc_blkno = blkno; | ||||
if ((bcache_ctl[i].bc_blkno == blkno) && ((bcache_ctl[i].bc_stamp + BCACHE_TIMEOUT) >= now)) { | bc->bcache_ctl[cand].bc_count = bcache_bcount++; | ||||
bcopy(bcache_data + (bcache_blksize * i), buf, bcache_blksize); | |||||
DEBUG("hit blk %d <- %d (now %d then %d)", blkno, i, now, bcache_ctl[i].bc_stamp); | |||||
return(0); | |||||
} | } | ||||
return(ENOENT); | |||||
} | |||||
/* | /* | ||||
* Invalidate a block from the cache. | * Invalidate a block from the cache. | ||||
*/ | */ | ||||
static void | static void | ||||
bcache_invalidate(daddr_t blkno) | bcache_invalidate(struct bcache *bc, daddr_t blkno) | ||||
{ | { | ||||
u_int i; | u_int i; | ||||
for (i = 0; i < bcache_nblks; i++) { | i = BHASH(bc, blkno); | ||||
if (bcache_ctl[i].bc_blkno == blkno) { | if (bc->bcache_ctl[i].bc_blkno == blkno) { | ||||
bcache_ctl[i].bc_count = -1; | bc->bcache_ctl[i].bc_count = -1; | ||||
bcache_ctl[i].bc_blkno = -1; | bc->bcache_ctl[i].bc_blkno = -1; | ||||
DEBUG("invalidate blk %d", blkno); | DEBUG("invalidate blk %llu", blkno); | ||||
break; | |||||
} | } | ||||
} | } | ||||
} | |||||
#ifndef BOOT2 | |||||
COMMAND_SET(bcachestat, "bcachestat", "get disk block cache stats", command_bcache); | COMMAND_SET(bcachestat, "bcachestat", "get disk block cache stats", command_bcache); | ||||
static int | static int | ||||
command_bcache(int argc, char *argv[]) | command_bcache(int argc, char *argv[]) | ||||
{ | { | ||||
u_int i; | if (argc != 1) { | ||||
command_errmsg = "wrong number of arguments"; | |||||
for (i = 0; i < bcache_nblks; i++) { | return(CMD_ERROR); | ||||
printf("%08jx %04x %04x|", (uintmax_t)bcache_ctl[i].bc_blkno, (unsigned int)bcache_ctl[i].bc_stamp & 0xffff, bcache_ctl[i].bc_count & 0xffff); | |||||
if (((i + 1) % 4) == 0) | |||||
printf("\n"); | |||||
} | } | ||||
printf("\n%d ops %d bypasses %d hits %d misses %d flushes\n", bcache_ops, bcache_bypasses, bcache_hits, bcache_misses, bcache_flushes); | |||||
printf("\ncache blocks: %d\n", bcache_total_nblks); | |||||
printf("cache blocksz: %d\n", bcache_blksize); | |||||
printf("cache readahead: %d\n", bcache_rablks); | |||||
printf("unit cache blocks: %d\n", bcache_unit_nblks); | |||||
printf("cached units: %d\n", bcache_units); | |||||
printf("%d ops %d bypasses %d hits %d misses\n", bcache_ops, | |||||
bcache_bypasses, bcache_hits, bcache_misses); | |||||
return(CMD_OK); | return(CMD_OK); | ||||
} | } | ||||
#endif |
I understand where the second part comes from -- if bc->ra is already the minimum allowed value, we don't want to reduce it further. But why do we avoid decreasing the read-ahead when nblk - i is too small?