Imported reiserfsprogs-3.6.20
This commit is contained in:
Jeff Mahoney committed
1 parent
0ed773997f
commit
dac518d099
189 files changed
+43353
-29787
No files matched your search
@@ -0,0 +1,707 @@
|
||||
/*
|
||||
* Copyright 1996-2004 by Hans Reiser, licensing governed by
|
||||
* reiserfsprogs/README
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
#include "reiserfs/libreiserfs.h"
|
||||
#include "misc/malloc.h"
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
|
||||
static int is_bad_block (unsigned long block)
|
||||
{
|
||||
#ifdef IO_FAILURE_EMULATION
|
||||
|
||||
/* this array similates bad blocks on the device */
|
||||
unsigned long bad_blocks [] =
|
||||
{
|
||||
8208, 8209, 8210
|
||||
/*, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 18, 19*/
|
||||
};
|
||||
int i;
|
||||
|
||||
for (i = 0; i < sizeof (bad_blocks) / sizeof (bad_blocks[0]); i ++)
|
||||
if (bad_blocks [i] == block)
|
||||
return 1;
|
||||
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* All buffers are in double linked cycled list. If reiserfs_buffer_open found buffer with
|
||||
wanted block number in hash queue it moves buffer to the end of list. */
|
||||
|
||||
static int g_nr_buffers;
|
||||
|
||||
|
||||
static unsigned long buffers_memory;
|
||||
|
||||
/* create buffers until we spend this fraction of system memory, this
|
||||
** is a hard limit on the amount of buffer ram used
|
||||
*/
|
||||
#define BUFFER_MEMORY_FRACTION 10
|
||||
|
||||
/* number of bytes in local buffer cache before we start forcing syncs
|
||||
** of dirty data and reusing unused buffers instead of allocating new
|
||||
** ones. If a flush doesn't find reusable buffers, new ones are
|
||||
** still allocated up to the BUFFER_MEMORY_FRACTION percentage
|
||||
**
|
||||
*/
|
||||
#define BUFFER_SOFT_LIMIT (500 * 1024)
|
||||
static unsigned long buffer_soft_limit = BUFFER_SOFT_LIMIT;
|
||||
|
||||
|
||||
#define NR_HASH_QUEUES 4096
|
||||
static reiserfs_bh_t * g_a_hash_queues [NR_HASH_QUEUES];
|
||||
static reiserfs_bh_t * Buffer_list_head;
|
||||
static reiserfs_bh_t * g_free_buffers = NULL ;
|
||||
static reiserfs_bh_t * g_buffer_heads;
|
||||
static int buffer_hits = 0 ;
|
||||
static int buffer_misses = 0 ;
|
||||
static int buffer_reads = 0 ;
|
||||
static int buffer_writes = 0 ;
|
||||
|
||||
|
||||
|
||||
static void _show_buffers(reiserfs_bh_t **list, int dev, unsigned long size) {
|
||||
int all = 0;
|
||||
int dirty = 0;
|
||||
int in_use = 0; /* count != 0 */
|
||||
int free = 0;
|
||||
reiserfs_bh_t * next;
|
||||
|
||||
next = *list;
|
||||
if (!next)
|
||||
return ;
|
||||
|
||||
for (;;) {
|
||||
if (next->b_dev == dev && next->b_size == size) {
|
||||
all ++;
|
||||
if (next->b_count != 0) {
|
||||
in_use ++;
|
||||
}
|
||||
if (reiserfs_buffer_isdirty (next)) {
|
||||
dirty ++;
|
||||
}
|
||||
if (reiserfs_buffer_isclean (next) && next->b_count == 0) {
|
||||
free ++;
|
||||
}
|
||||
}
|
||||
next = next->b_next;
|
||||
if (next == *list)
|
||||
break;
|
||||
}
|
||||
|
||||
printf("show_buffers (dev %d, size %lu): free %d, count != 0 %d, dirty %d, "
|
||||
"all %d\n", dev, size, free, in_use, dirty, all);
|
||||
}
|
||||
|
||||
|
||||
static void show_buffers (int dev, int size)
|
||||
{
|
||||
_show_buffers(&Buffer_list_head, dev, size) ;
|
||||
_show_buffers(&g_free_buffers, dev, size) ;
|
||||
}
|
||||
|
||||
|
||||
static void insert_into_hash_queue (reiserfs_bh_t * bh)
|
||||
{
|
||||
int index = bh->b_blocknr % NR_HASH_QUEUES;
|
||||
|
||||
if (bh->b_hash_prev || bh->b_hash_next)
|
||||
misc_die ("insert_into_hash_queue: hash queue corrupted");
|
||||
|
||||
if (g_a_hash_queues[index]) {
|
||||
g_a_hash_queues[index]->b_hash_prev = bh;
|
||||
bh->b_hash_next = g_a_hash_queues[index];
|
||||
}
|
||||
g_a_hash_queues[index] = bh;
|
||||
}
|
||||
|
||||
|
||||
static void remove_from_hash_queue (reiserfs_bh_t * bh)
|
||||
{
|
||||
if (bh->b_hash_next == 0 &&
|
||||
bh->b_hash_prev == 0 &&
|
||||
bh != g_a_hash_queues[bh->b_blocknr % NR_HASH_QUEUES])
|
||||
{
|
||||
/* (b_dev == -1) ? */
|
||||
return;
|
||||
}
|
||||
|
||||
if (bh == g_a_hash_queues[bh->b_blocknr % NR_HASH_QUEUES]) {
|
||||
if (bh->b_hash_prev != 0)
|
||||
misc_die ("remove_from_hash_queue: hash queue corrupted");
|
||||
g_a_hash_queues[bh->b_blocknr % NR_HASH_QUEUES] = bh->b_hash_next;
|
||||
}
|
||||
if (bh->b_hash_next)
|
||||
bh->b_hash_next->b_hash_prev = bh->b_hash_prev;
|
||||
|
||||
if (bh->b_hash_prev)
|
||||
bh->b_hash_prev->b_hash_next = bh->b_hash_next;
|
||||
|
||||
bh->b_hash_prev = bh->b_hash_next = 0;
|
||||
}
|
||||
|
||||
|
||||
static void put_buffer_list_end (reiserfs_bh_t **list,
|
||||
reiserfs_bh_t * bh)
|
||||
{
|
||||
reiserfs_bh_t * last = 0;
|
||||
|
||||
if (bh->b_prev || bh->b_next)
|
||||
misc_die ("put_buffer_list_end: buffer list corrupted");
|
||||
|
||||
if (*list == 0) {
|
||||
bh->b_next = bh;
|
||||
bh->b_prev = bh;
|
||||
*list = bh;
|
||||
} else {
|
||||
last = (*list)->b_prev;
|
||||
|
||||
bh->b_next = last->b_next;
|
||||
bh->b_prev = last;
|
||||
last->b_next->b_prev = bh;
|
||||
last->b_next = bh;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void remove_from_buffer_list (reiserfs_bh_t **list,
|
||||
reiserfs_bh_t * bh)
|
||||
{
|
||||
if (bh == bh->b_next) {
|
||||
*list = 0;
|
||||
} else {
|
||||
bh->b_prev->b_next = bh->b_next;
|
||||
bh->b_next->b_prev = bh->b_prev;
|
||||
if (bh == *list)
|
||||
*list = bh->b_next;
|
||||
}
|
||||
|
||||
bh->b_next = bh->b_prev = 0;
|
||||
}
|
||||
|
||||
|
||||
static void put_buffer_list_head (reiserfs_bh_t **list,
|
||||
reiserfs_bh_t * bh)
|
||||
{
|
||||
put_buffer_list_end (list, bh);
|
||||
*list = bh;
|
||||
}
|
||||
|
||||
/*
|
||||
#include <sys/mman.h>
|
||||
|
||||
static size_t estimate_memory_amount (void)
|
||||
{
|
||||
size_t len = 1;
|
||||
size_t max = 0;
|
||||
void * addr;
|
||||
|
||||
while (len > 0) {
|
||||
addr = mmap (0, len, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
|
||||
if (addr == MAP_FAILED) {
|
||||
if (errno != ENOMEM)
|
||||
misc_die ("mmap failed: %s\n", strerror(errno));
|
||||
break;
|
||||
}
|
||||
if (mlock (addr, len) != 0) {
|
||||
if (errno == EPERM)
|
||||
misc_die ("No permission to run mlock");
|
||||
break;
|
||||
}
|
||||
|
||||
munlock (addr, len);
|
||||
munmap (addr, len);
|
||||
max = len;
|
||||
len *= 2;
|
||||
}
|
||||
|
||||
// * If we've looped, we don't want to return 0, we want to return the
|
||||
// * last successful len before we looped. In the event that mmap/mlock
|
||||
// * failed for len = 1, max will still be 0, so we don't get an invalid
|
||||
// * result
|
||||
return max;
|
||||
}
|
||||
*/
|
||||
|
||||
#define GROW_BUFFERS__NEW_BUFERS_PER_CALL 10
|
||||
|
||||
/* creates number of new buffers and insert them into head of buffer list */
|
||||
static int grow_buffers (int size)
|
||||
{
|
||||
int i;
|
||||
reiserfs_bh_t * bh, * tmp;
|
||||
|
||||
|
||||
/* get memory for array of buffer heads */
|
||||
bh = (reiserfs_bh_t *)misc_getmem (GROW_BUFFERS__NEW_BUFERS_PER_CALL *
|
||||
sizeof (reiserfs_bh_t) + sizeof (reiserfs_bh_t *));
|
||||
if (g_buffer_heads == 0)
|
||||
g_buffer_heads = bh;
|
||||
else {
|
||||
/* link new array to the end of array list */
|
||||
tmp = g_buffer_heads;
|
||||
while (*(reiserfs_bh_t **)(tmp + GROW_BUFFERS__NEW_BUFERS_PER_CALL) != 0)
|
||||
tmp = *(reiserfs_bh_t **)(tmp + GROW_BUFFERS__NEW_BUFERS_PER_CALL);
|
||||
*(reiserfs_bh_t **)(tmp + GROW_BUFFERS__NEW_BUFERS_PER_CALL) = bh;
|
||||
}
|
||||
|
||||
for (i = 0; i < GROW_BUFFERS__NEW_BUFERS_PER_CALL; i ++) {
|
||||
|
||||
tmp = bh + i;
|
||||
memset (tmp, 0, sizeof (reiserfs_bh_t));
|
||||
tmp->b_data = misc_getmem (size);
|
||||
if (tmp->b_data == 0)
|
||||
misc_die ("grow_buffers: no memory for new buffer data");
|
||||
tmp->b_dev = -1;
|
||||
tmp->b_size = size;
|
||||
put_buffer_list_head (&g_free_buffers, tmp);
|
||||
}
|
||||
buffers_memory += GROW_BUFFERS__NEW_BUFERS_PER_CALL * size;
|
||||
g_nr_buffers += GROW_BUFFERS__NEW_BUFERS_PER_CALL;
|
||||
return GROW_BUFFERS__NEW_BUFERS_PER_CALL;
|
||||
}
|
||||
|
||||
|
||||
reiserfs_bh_t *reiserfs_buffer_find (int dev,
|
||||
unsigned long block,
|
||||
unsigned long size)
|
||||
{
|
||||
reiserfs_bh_t * next;
|
||||
|
||||
next = g_a_hash_queues[block % NR_HASH_QUEUES];
|
||||
for (;;) {
|
||||
reiserfs_bh_t *tmp = next;
|
||||
if (!next)
|
||||
break;
|
||||
next = tmp->b_hash_next;
|
||||
if (tmp->b_blocknr != block || tmp->b_size != size || tmp->b_dev != dev)
|
||||
continue;
|
||||
next = tmp;
|
||||
break;
|
||||
}
|
||||
return next;
|
||||
}
|
||||
|
||||
|
||||
static reiserfs_bh_t * get_free_buffer (reiserfs_bh_t **list,
|
||||
unsigned long size)
|
||||
{
|
||||
reiserfs_bh_t * next;
|
||||
|
||||
next = *list;
|
||||
if (!next)
|
||||
return 0;
|
||||
|
||||
for (;;) {
|
||||
if (!next)
|
||||
misc_die ("get_free_buffer: buffer list is corrupted");
|
||||
if (next->b_count == 0 && reiserfs_buffer_isclean (next) && next->b_size == size) {
|
||||
remove_from_hash_queue (next);
|
||||
remove_from_buffer_list (list, next);
|
||||
return next;
|
||||
}
|
||||
next = next->b_next;
|
||||
if (next == *list)
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* to_write == 0 when all blocks have to be flushed. Otherwise - write only
|
||||
buffers with b_count == 0 */
|
||||
static int sync_buffers (reiserfs_bh_t **list, int dev, int to_write) {
|
||||
reiserfs_bh_t * next;
|
||||
int written = 0;
|
||||
|
||||
|
||||
restart:
|
||||
next = *list;
|
||||
if (!next)
|
||||
return 0;
|
||||
for (;;) {
|
||||
if (!next)
|
||||
misc_die ("sync_buffers: buffer list is corrupted");
|
||||
|
||||
if (next->b_dev == dev && reiserfs_buffer_isdirty (next) && reiserfs_buffer_uptodate (next)) {
|
||||
if ((to_write == 0 || next->b_count == 0) && !reiserfs_buffer_noflush (next)) {
|
||||
reiserfs_buffer_write (next);
|
||||
}
|
||||
}
|
||||
|
||||
/* if this buffer is reusable, put it onto the end of the free list */
|
||||
if (next->b_count == 0 && reiserfs_buffer_isclean(next)) {
|
||||
remove_from_hash_queue (next);
|
||||
remove_from_buffer_list (list, next);
|
||||
put_buffer_list_end (&g_free_buffers, next);
|
||||
written++ ;
|
||||
if (written == to_write)
|
||||
return written;
|
||||
goto restart;
|
||||
}
|
||||
if (to_write && written >= to_write)
|
||||
return written;
|
||||
|
||||
next = next->b_next;
|
||||
if (next == *list)
|
||||
break;
|
||||
}
|
||||
|
||||
return written;
|
||||
}
|
||||
|
||||
void reiserfs_buffer_flush_all (int dev) {
|
||||
if (dev == -1)
|
||||
misc_die ("reiserfs_buffer_flush_all: device is not specified");
|
||||
|
||||
sync_buffers (&Buffer_list_head, dev, 0/*all*/);
|
||||
buffer_soft_limit = BUFFER_SOFT_LIMIT;
|
||||
}
|
||||
|
||||
|
||||
reiserfs_bh_t * reiserfs_buffer_open (int dev, unsigned long block,
|
||||
unsigned long size)
|
||||
{
|
||||
reiserfs_bh_t * bh;
|
||||
|
||||
bh = reiserfs_buffer_find (dev, block, size);
|
||||
if (bh) {
|
||||
/* move the buffer to the end of list */
|
||||
|
||||
/*checkmem (bh->b_data, bh->b_size);*/
|
||||
|
||||
remove_from_buffer_list (&Buffer_list_head, bh);
|
||||
put_buffer_list_end (&Buffer_list_head, bh);
|
||||
bh->b_count ++;
|
||||
buffer_hits++ ;
|
||||
return bh;
|
||||
}
|
||||
buffer_misses++ ;
|
||||
|
||||
bh = get_free_buffer (&g_free_buffers, size);
|
||||
if (bh == NULL) {
|
||||
if (buffers_memory >= buffer_soft_limit) {
|
||||
if (sync_buffers (&Buffer_list_head, dev, 32) == 0) {
|
||||
grow_buffers(size);
|
||||
buffer_soft_limit = buffers_memory +
|
||||
GROW_BUFFERS__NEW_BUFERS_PER_CALL * size;
|
||||
}
|
||||
} else {
|
||||
if (grow_buffers(size) == 0)
|
||||
sync_buffers (&Buffer_list_head, dev, 32);
|
||||
}
|
||||
|
||||
bh = get_free_buffer (&g_free_buffers, size);
|
||||
if (bh == NULL) {
|
||||
show_buffers (dev, size);
|
||||
misc_die ("reiserfs_buffer_open: no free buffers after grow_buffers "
|
||||
"and refill (%d)", g_nr_buffers);
|
||||
}
|
||||
}
|
||||
|
||||
bh->b_count = 1;
|
||||
bh->b_dev = dev;
|
||||
bh->b_size = size;
|
||||
bh->b_blocknr = block;
|
||||
bh->b_end_io = NULL ;
|
||||
memset (bh->b_data, 0, size);
|
||||
misc_clear_bit(BH_Dirty, &bh->b_state);
|
||||
misc_clear_bit(BH_Uptodate, &bh->b_state);
|
||||
|
||||
put_buffer_list_end (&Buffer_list_head, bh);
|
||||
insert_into_hash_queue (bh);
|
||||
/*checkmem (bh->b_data, bh->b_size);*/
|
||||
|
||||
return bh;
|
||||
}
|
||||
|
||||
|
||||
void reiserfs_buffer_close (reiserfs_bh_t * bh)
|
||||
{
|
||||
if (bh == 0)
|
||||
return;
|
||||
|
||||
if (bh->b_count == 0)
|
||||
misc_die ("reiserfs_buffer_close: can not free a free buffer %lu", bh->b_blocknr);
|
||||
|
||||
/*checkmem (bh->b_data, misc_memsize (bh->b_data));*/
|
||||
|
||||
bh->b_count --;
|
||||
}
|
||||
|
||||
|
||||
void reiserfs_buffer_forget (reiserfs_bh_t * bh) {
|
||||
if (bh) {
|
||||
bh->b_state = 0;
|
||||
reiserfs_buffer_close (bh);
|
||||
remove_from_hash_queue (bh);
|
||||
remove_from_buffer_list(&Buffer_list_head, bh);
|
||||
put_buffer_list_head(&Buffer_list_head, bh);
|
||||
}
|
||||
}
|
||||
|
||||
/* Returns 0 on success; 1 - end of file; 0 - OK. */
|
||||
static int f_read(reiserfs_bh_t * bh)
|
||||
{
|
||||
unsigned long long offset;
|
||||
ssize_t bytes;
|
||||
|
||||
buffer_reads++ ;
|
||||
|
||||
offset = (unsigned long long)bh->b_size * bh->b_blocknr;
|
||||
if (lseek (bh->b_dev, offset, SEEK_SET) < 0)
|
||||
return -1;
|
||||
|
||||
bytes = read (bh->b_dev, bh->b_data, bh->b_size);
|
||||
|
||||
return bytes < 0 ? -1 : (bytes != (ssize_t)bh->b_size ? 1 : 0);
|
||||
}
|
||||
|
||||
#define check_hd_msg \
|
||||
"\nThe problem has occurred looks like a hardware problem. If you have\n" \
|
||||
"bad blocks, we advise you to get a new hard drive, because once you\n" \
|
||||
"get one bad block that the disk drive internals cannot hide from\n" \
|
||||
"your sight,the chances of getting more are generally said to become\n" \
|
||||
"much higher (precise statistics are unknown to us), and this disk\n" \
|
||||
"drive is probably not expensive enough for you to you to risk your\n" \
|
||||
"time and data on it. If you don't want to follow that follow that\n" \
|
||||
"advice then if you have just a few bad blocks, try writing to the\n" \
|
||||
"bad blocks and see if the drive remaps the bad blocks (that means\n" \
|
||||
"it takes a block it has in reserve and allocates it for use for\n" \
|
||||
"of that block number). If it cannot remap the block, use badblock\n" \
|
||||
"option (-B) with reiserfs utils to handle this block correctly.\n" \
|
||||
|
||||
reiserfs_bh_t *reiserfs_buffer_read (int dev, unsigned long block,
|
||||
unsigned long size)
|
||||
{
|
||||
reiserfs_bh_t * bh;
|
||||
int ret;
|
||||
|
||||
if (is_bad_block (block))
|
||||
return 0;
|
||||
|
||||
bh = reiserfs_buffer_open (dev, block, size);
|
||||
|
||||
/*checkmem (bh->b_data, misc_memsize(bh->b_data));*/
|
||||
|
||||
if (reiserfs_buffer_uptodate (bh))
|
||||
return bh;
|
||||
|
||||
ret = f_read(bh);
|
||||
|
||||
if (ret > 0) {
|
||||
misc_die ("%s: End of file, cannot read the block (%lu).\n",
|
||||
__FUNCTION__, block);
|
||||
} else if (ret < 0) {
|
||||
/* BAD BLOCK LIST SUPPORT
|
||||
* misc_die ("%s: Cannot read a block # %lu. Specify list of badblocks\n",*/
|
||||
|
||||
if (errno == EIO) {
|
||||
fprintf(stderr, check_hd_msg);
|
||||
misc_die ("%s: Cannot read the block (%lu): (%s).\n",
|
||||
__FUNCTION__, block, strerror(errno));
|
||||
} else {
|
||||
fprintf (stderr, "%s: Cannot read the block (%lu): (%s).\n",
|
||||
__FUNCTION__, block, strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
reiserfs_buffer_mkuptodate (bh, 0);
|
||||
return bh;
|
||||
}
|
||||
|
||||
/* for now - just make sure that bad blocks did not get here */
|
||||
int reiserfs_buffer_write (reiserfs_bh_t * bh)
|
||||
{
|
||||
off_t offset;
|
||||
long long bytes, size;
|
||||
|
||||
if (is_bad_block (bh->b_blocknr)) {
|
||||
fprintf (stderr, "reiserfs_buffer_write: bad block is going to be written: %lu\n",
|
||||
bh->b_blocknr);
|
||||
exit(8);
|
||||
}
|
||||
|
||||
if (!reiserfs_buffer_isdirty (bh) || !reiserfs_buffer_uptodate (bh))
|
||||
return 0;
|
||||
|
||||
buffer_writes++ ;
|
||||
if (bh->b_start_io)
|
||||
/* this is used by undo feature of reiserfsck */
|
||||
bh->b_start_io (bh->b_blocknr);
|
||||
|
||||
size = bh->b_size;
|
||||
offset = (off_t)size * bh->b_blocknr;
|
||||
|
||||
if (lseek (bh->b_dev, offset, SEEK_SET) == (long long int)-1){
|
||||
fprintf (stderr, "reiserfs_buffer_write: lseek to position %llu (block=%lu, dev=%d): %s\n",
|
||||
offset, bh->b_blocknr, bh->b_dev, strerror(errno));
|
||||
exit(8); /* File system errors left uncorrected */
|
||||
}
|
||||
|
||||
#ifdef ROLLBACK_READY
|
||||
if (s_rollback_file != NULL && bh->b_size == (unsigned long)rollback_blocksize) {
|
||||
struct stat buf;
|
||||
int position;
|
||||
struct block_handler block_h;
|
||||
|
||||
/*log previous content into the log*/
|
||||
if (!fstat (bh->b_dev, &buf)) {
|
||||
block_h.blocknr = bh->b_blocknr;
|
||||
block_h.device = buf.st_rdev;
|
||||
if (misc_bin_search(&block_h, rollback_blocks_array,
|
||||
rollback_blocks_number, sizeof (block_h),
|
||||
&position, blockdev_list_compare) != 1)
|
||||
{
|
||||
/*read initial data from the disk*/
|
||||
if (read(bh->b_dev, rollback_data, bh->b_size) == (long long)bh->b_size) {
|
||||
fwrite(&buf.st_rdev, sizeof (buf.st_rdev), 1, s_rollback_file);
|
||||
fwrite(&offset, sizeof (offset), 1, s_rollback_file);
|
||||
fwrite(rollback_data, rollback_blocksize, 1, s_rollback_file);
|
||||
fflush(s_rollback_file);
|
||||
blocklist__insert_in_position(&block_h, (void *)(&rollback_blocks_array),
|
||||
&rollback_blocks_number, sizeof(block_h), &position);
|
||||
|
||||
/*if you want to know what gets saved, uncomment it*/
|
||||
/* if (log_file != 0 && log_file != stdout) {
|
||||
fprintf (log_file, "rollback: block %lu of device %Lu was "
|
||||
"backed up\n", bh->b_blocknr, buf.st_rdev);
|
||||
}
|
||||
*/
|
||||
|
||||
} else {
|
||||
fprintf (stderr, "reiserfs_buffer_write: read (block=%lu, dev=%d): %s\n",
|
||||
bh->b_blocknr, bh->b_dev, strerror (errno));
|
||||
exit(8);
|
||||
}
|
||||
|
||||
if (lseek (bh->b_dev, offset, SEEK_SET) == (long long int)-1) {
|
||||
fprintf (stderr, "reiserfs_buffer_write: lseek to position %llu (block=%lu, "
|
||||
"dev=%d): %s\n", offset, bh->b_blocknr, bh->b_dev,
|
||||
strerror(errno));
|
||||
exit(8);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
fprintf (stderr, "reiserfs_buffer_write: fstat of (%d) returned -1: %s\n",
|
||||
bh->b_dev, strerror(errno));
|
||||
}
|
||||
} else if (s_rollback_file != NULL) {
|
||||
fprintf (stderr, "rollback: block (%lu) has the size different from "
|
||||
"the fs uses, block skipped\n", bh->b_blocknr);
|
||||
}
|
||||
#endif
|
||||
|
||||
bytes = write(bh->b_dev, bh->b_data, size);
|
||||
if (bytes != size) {
|
||||
fprintf (stderr, "reiserfs_buffer_write: write %lld bytes returned %lld (block=%ld, "
|
||||
"dev=%d): %s\n", size, bytes, bh->b_blocknr, bh->b_dev,
|
||||
strerror(errno));
|
||||
exit(8);
|
||||
}
|
||||
|
||||
reiserfs_buffer_mkclean (bh);
|
||||
|
||||
if (bh->b_end_io) {
|
||||
bh->b_end_io(bh, 1) ;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static int _check_and_free_buffer_list(reiserfs_bh_t *list) {
|
||||
reiserfs_bh_t *next = list ;
|
||||
int count = 0 ;
|
||||
if (!list)
|
||||
return 0 ;
|
||||
|
||||
for(;;) {
|
||||
if (next->b_count != 0)
|
||||
fprintf (stderr, "check_and_free_buffer_mem: not free buffer "
|
||||
"(%d, %ld, %ld, %d)\n", next->b_dev, next->b_blocknr,
|
||||
next->b_size, next->b_count);
|
||||
|
||||
if (reiserfs_buffer_isdirty (next) && reiserfs_buffer_uptodate (next))
|
||||
fprintf (stderr, "check_and_free_buffer_mem: dirty buffer "
|
||||
"(%d %lu) found\n", next->b_dev, next->b_blocknr);
|
||||
|
||||
misc_freemem (next->b_data);
|
||||
count++;
|
||||
next = next->b_next;
|
||||
if (next == list)
|
||||
break;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
void reiserfs_buffer_free_all (void) {
|
||||
int count = 0;
|
||||
reiserfs_bh_t * next ;
|
||||
|
||||
// printf("check and free buffer mem, hits %d misses %d reads %d writes %d\n",
|
||||
// buffer_hits, buffer_misses, buffer_reads, buffer_writes) ;
|
||||
/*sync_buffers (0, 0);*/
|
||||
|
||||
count = _check_and_free_buffer_list(Buffer_list_head);
|
||||
count += _check_and_free_buffer_list(g_free_buffers);
|
||||
|
||||
if (count != g_nr_buffers)
|
||||
misc_die ("check_and_free_buffer_mem: found %d buffers, must be %d",
|
||||
count, g_nr_buffers);
|
||||
|
||||
/* free buffer heads */
|
||||
while ((next = g_buffer_heads)) {
|
||||
g_buffer_heads = *(reiserfs_bh_t **)
|
||||
(next + GROW_BUFFERS__NEW_BUFERS_PER_CALL);
|
||||
|
||||
misc_freemem (next);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
static void _invalidate_buffer_list(reiserfs_bh_t *list, int dev)
|
||||
{
|
||||
reiserfs_bh_t * next;
|
||||
|
||||
if (!list)
|
||||
return;
|
||||
|
||||
next = list;
|
||||
|
||||
for (;;) {
|
||||
if (next->b_dev == dev) {
|
||||
if (reiserfs_buffer_isdirty (next) || next->b_count)
|
||||
fprintf (stderr, "invalidate_buffer_list: dirty "
|
||||
"buffer or used buffer (%d %lu) found\n",
|
||||
next->b_count, next->b_blocknr);
|
||||
|
||||
next->b_state = 0;
|
||||
remove_from_hash_queue (next);
|
||||
}
|
||||
|
||||
next = next->b_next;
|
||||
if (next == list)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* forget all buffers of the given device */
|
||||
void reiserfs_buffer_invalidate_all (int dev) {
|
||||
_invalidate_buffer_list(Buffer_list_head, dev) ;
|
||||
_invalidate_buffer_list(g_free_buffers, dev) ;
|
||||
}
|
||||
Reference in new issue
Block a user