pack.c

reiserfsprogs-3.6.19.tar.gz 源码 给有需要的人！

/*
 * Copyright 2000-2004 by Hans Reiser, licensing governed by 
 * reiserfsprogs/README
 */

#include "debugreiserfs.h"



/* counters for each kind of blocks */
int packed,
    packed_leaves,
    full_blocks,
    having_ih_array, /* blocks with broken block head */
    bad_leaves, /* failed to compress */
    internals,
    descs,
    others;

reiserfs_bitmap_t * what_to_pack;

/* these are to calculate compression */
unsigned long sent_bytes; /* how many bytes sent to stdout */
unsigned long had_to_be_sent; /* how many bytes were to be sent */


inline void set_pi_type( struct packed_item *pi, __u32 val )
{
    set_bit_field_XX (32, pi, val, 0, 2);
}


inline __u32 get_pi_type( const struct packed_item *pi )
{
    get_bit_field_XX (32, pi, 0, 2);
}


inline void set_pi_mask( struct packed_item *pi, __u32 val )
{
    set_bit_field_XX (32, pi, val, 2, 18);
}


__u32 get_pi_mask( const struct packed_item *pi )
{
    get_bit_field_XX (32, pi, 2, 18);
}


inline void set_pi_item_len( struct packed_item *pi, __u32 val )
{
    set_bit_field_XX (32, pi, val, 20, 12);
}


inline __u32 get_pi_item_len( const struct packed_item *pi )
{
    get_bit_field_XX (32, pi, 20, 12);
}


static void pack_ih (struct packed_item * pi, struct item_head * ih)
{
    __u32 v32;
    __u16 v16;

    /* send packed item head first */
    fwrite (pi, sizeof (*pi), 1, stdout);
    sent_bytes += sizeof (*pi);

    /* sen key components which are to be sent */
    if (get_pi_mask(pi) & DIR_ID) {
	v32 = get_key_dirid (&ih->ih_key);
	fwrite_le32 (&v32);
    }

    if (get_pi_mask(pi) & OBJECT_ID) {
	v32 = get_key_objectid (&ih->ih_key);
	fwrite_le32 (&v32);
    }

    if (get_pi_mask(pi) & OFFSET_BITS_64) {
	__u64 offset;

	offset = get_offset (&ih->ih_key);
	fwrite_le64 (&offset);
    }

    if (get_pi_mask(pi) & OFFSET_BITS_32) {
	__u32 offset;

	offset = get_offset (&ih->ih_key);
	fwrite_le32 (&offset);
    }

    if (get_pi_mask(pi) & IH_FREE_SPACE) {
	v16 = get_ih_entry_count (ih);
	fwrite_le16 (&v16);
    }

    if (get_pi_mask(pi) & IH_FORMAT) {
	/* fixme */
	fwrite16 (&ih->ih_format);
    }
}


static void pack_direct (struct packed_item * pi, struct buffer_head * bh, 
			 struct item_head * ih)
{
    if (get_ih_free_space (ih) != 0xffff)
	/* ih_free_space has unexpected value */
        set_pi_mask (pi, get_pi_mask (pi) | IH_FREE_SPACE);

    if (get_pi_mask(pi) & SAFE_LINK)
	set_key_dirid(&ih->ih_key, d32_get((__u32 *)B_I_PITEM (bh, ih), 0) );

    /* send key components which are to be sent */
    pack_ih (pi, ih);
}


/* if there is at least one extent longer than 2 - it is worth packing */
static int should_pack_indirect (__u32 * ind_item, int unfm_num)
{
    int i, len;

    for (i = 1, len = 1; i < unfm_num; i ++) {
	if ((d32_get(ind_item, i) == 0 && d32_get(ind_item, i - 1) == 0) ||
	    d32_get(ind_item, i) == d32_get(ind_item, i - 1) + 1) 
	{
	    len ++;
	    if (len > 2)
		return 1;
	} else {
	    /* sequence of blocks or hole broke */
	    len = 1;
	}
    }
    return 0;
}


/* indirect item can be either packed using "extents" (when it is
   worth doing) or be stored as is. Size of item in packed form is not
   stored. Unpacking will stop when full item length is reached */
static void pack_indirect (struct packed_item * pi, struct buffer_head * bh, 
			   struct item_head * ih)
{
    unsigned int i;
    __u32 * ind_item;
    __u16 len;


    if (get_ih_entry_count (ih))
        set_pi_mask (pi, get_pi_mask (pi) | IH_FREE_SPACE);

    ind_item = (__u32 *)B_I_PITEM (bh, ih);
    if (!should_pack_indirect (ind_item, I_UNFM_NUM (ih)))
        set_pi_mask (pi, get_pi_mask (pi) | WHOLE_INDIRECT);


    if (get_pi_mask(pi) & SAFE_LINK)
	set_key_dirid(&ih->ih_key, d32_get(ind_item, 0));

    pack_ih (pi, ih);

    if (get_pi_mask(pi) & SAFE_LINK)
        return;

    if (get_pi_mask(pi) & WHOLE_INDIRECT) {
	fwrite (ind_item, get_ih_item_len (ih), 1, stdout);
	sent_bytes += get_ih_item_len (ih);
	return;
    }

    fwrite32 (&ind_item [0]);

    for (i = 1, len = 1; i < I_UNFM_NUM (ih); i ++) {
	if ((d32_get(ind_item, i) == 0 && d32_get(ind_item, i - 1) == 0)  || 
	    d32_get(ind_item, i) == d32_get(ind_item, i - 1) + 1) 
	{
	    len ++;
	} else {
	    fwrite_le16 (&len);
	    fwrite32 ((char *)(ind_item + i));
	    len = 1;
	}
    }
    fwrite_le16 (&len);

    return;
}


/* directory item is packed:
   entry count - 16 bits
   for each entry
   	mask (8 bits) - it shows whether there are any of (deh_dir_id, gen counter, deh_state)
	entry length 16 bits
	entry itself
	deh_objectid - 32 bits
		maybe deh_dir_id (32 bits)
		maybe gencounter (16)
		maybe deh_state (16)
*/
static void pack_direntry (reiserfs_filsys_t * fs, struct packed_item * pi,
			   struct buffer_head * bh,
			   struct item_head * ih)
{
    int i;
    struct reiserfs_de_head * deh;
    struct packed_dir_entry pe;
    __u16 entry_count, gen_counter;


    set_pi_mask (pi, get_pi_mask (pi) | IH_ENTRY_COUNT);

    /* send item_head components which are to be sent */
    pack_ih (pi, ih);

    /* entry count is sent unconditionally */
    entry_count = get_ih_entry_count (ih);

    deh = B_I_DEH (bh, ih);
    for (i = 0; i < entry_count; i ++, deh ++) {
	pe.entrylen = entry_length (ih, deh, i);
	pe.mask = 0;
	if (get_deh_dirid (deh) != get_key_objectid (&ih->ih_key))
	    /* entry points to name of another directory, store deh_dir_id */
	    pe.mask |= HAS_DIR_ID;

	gen_counter = GET_GENERATION_NUMBER (get_deh_offset (deh));
	if (gen_counter != 0)
	    /* store generation counter if it is != 0 */
	    pe.mask |= HAS_GEN_COUNTER;

	if (get_deh_state (deh) != 4)
	    /* something unusual in deh_state. Store it */
	    pe.mask |= HAS_STATE;

	fwrite8 (&pe.mask);
	fwrite_le16 (&pe.entrylen);
	fwrite (name_in_entry (deh, i), pe.entrylen, 1, stdout);
	sent_bytes += pe.entrylen;
	fwrite32 (&(deh->deh2_objectid));
	
	if (pe.mask & HAS_DIR_ID)
	    fwrite32 (&deh->deh2_dir_id);

	if (pe.mask & HAS_GEN_COUNTER)
	    fwrite_le16 (&gen_counter);

	if (pe.mask & HAS_STATE)
	    fwrite16 (&deh->deh2_state);
    }
}


static void pack_stat_data (struct packed_item * pi, struct buffer_head * bh,
			    struct item_head * ih)
{
    if (get_ih_free_space (ih) != 0xffff)
	/* ih_free_space has unexpected value */
        set_pi_mask (pi, get_pi_mask (pi) | IH_FREE_SPACE);

    if (stat_data_v1 (ih)) {
	/* for old stat data: we take
	   mode - 16 bits
	   nlink - 16 bits
	   size - 32 bits
	   blocks/rdev - 32 bits
	   maybe first_direct byte 32 bits
	*/
	struct stat_data_v1 * sd_v1;

	sd_v1 = (struct stat_data_v1 *)B_I_PITEM (bh, ih);
	if (sd_v1->sd_first_direct_byte != 0xffffffff) /* ok if -1 */
            set_pi_mask (pi, get_pi_mask (pi) | WITH_SD_FIRST_DIRECT_BYTE);


	pack_ih (pi, ih);
	
	fwrite16 (&sd_v1->sd_mode);
	fwrite16 (&sd_v1->sd_nlink);
	fwrite32 (&sd_v1->sd_size);
	fwrite32 (&sd_v1->u.sd_blocks);

	if (get_pi_mask(pi) & WITH_SD_FIRST_DIRECT_BYTE)
	    fwrite32 (&sd_v1->sd_first_direct_byte);
    } else {
	/* for new stat data
	   mode - 16 bits
	   nlink in either 16 or 32 bits
	   size in either 32 or 64 bits
	   blocks - 32 bits
	*/
	struct stat_data * sd;
        /* these will maintain disk-order values */
	__u16 nlink16;
	__u32 nlink32, size32;
	__u64 size64;

	sd = (struct stat_data *)B_I_PITEM (bh, ih);
	if (sd_v2_nlink (sd) > 0xffff) {
            set_pi_mask (pi, get_pi_mask (pi) | NLINK_BITS_32);
	    nlink32 = sd->sd_nlink;
	} else {
            /* This is required to deal with big endian systems */
	    nlink16 = cpu_to_le16 ((__u16)sd_v2_nlink (sd));
	}
	if (sd_v2_size (sd) > 0xffffffff) {
            set_pi_mask (pi, get_pi_mask (pi) | SIZE_BITS_64);
	    size64 = sd->sd_size;
	} else {
            /* This is required to deal with big endian systems */
	    size32 = cpu_to_le32 ((__u32)sd_v2_size (sd));
	}


	pack_ih (pi, ih);

	fwrite16 (&sd->sd_mode);

	if (get_pi_mask (pi) & NLINK_BITS_32) {
	    fwrite32 (&nlink32);
	} else {
	    fwrite16 (&nlink16);	
	}

	if (get_pi_mask (pi) & SIZE_BITS_64) {
	    fwrite64 (&size64);
	} else {
	    fwrite32 (&size32);
	}
    
	fwrite32 (&sd->sd_blocks);
    }
}


static void pack_full_block (reiserfs_filsys_t * fs, struct buffer_head * bh)
{
    __u16 magic;
    __u32 block;


    magic = FULL_BLOCK_START_MAGIC;
    fwrite_le16 (&magic);

    block = bh->b_blocknr;
    fwrite_le32 (&block);
    
    fwrite (bh->b_data, fs->fs_blocksize, 1, stdout);

    sent_bytes += fs->fs_blocksize;
    had_to_be_sent += fs->fs_blocksize;

    full_blocks ++;
}


#if 0
/* unformatted node pointer is considered bad when it points either to blocks
   of journal, bitmap blocks, super block or is transparently out of range of
   disk block numbers */
static int check_unfm_ptr (reiserfs_filsys_t * fs, __u32 block)
{
    if (block >= SB_BLOCK_COUNT (fs))
        return 1;

    if (not_data_block (fs, block))