item_ops.c

ARM 嵌入式 系统 设计与实例开发 实验教材 二源码

/*
 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
 */

#include <linux/sched.h>
#include <linux/reiserfs_fs.h>

// this contains item handlers for old item types: sd, direct,
// indirect, directory

/* and where are the comments? how about saying where we can find an
   explanation of each item handler method? -Hans */

//////////////////////////////////////////////////////////////////////////////
// stat data functions
//
static int sd_bytes_number (struct item_head * ih, int block_size)
{
  return 0;
}

static void sd_decrement_key (struct cpu_key * key)
{
    key->on_disk_key.k_objectid --;
    set_cpu_key_k_type (key, TYPE_ANY);
    set_cpu_key_k_offset(key, (loff_t)(-1));
}

static int sd_is_left_mergeable (struct key * key, unsigned long bsize)
{
    return 0;
}



static char * print_time (time_t t)
{
    static char timebuf[256];

    sprintf (timebuf, "%ld", t);
    return timebuf;
}


static void sd_print_item (struct item_head * ih, char * item)
{
    printk ("\tmode | size | nlinks | first direct | mtime\n");
    if (stat_data_v1 (ih)) {
      	struct stat_data_v1 * sd = (struct stat_data_v1 *)item;

	printk ("\t0%-6o | %6u | %2u | %d | %s\n", sd_v1_mode(sd),
                sd_v1_size(sd), sd_v1_nlink(sd), sd_v1_first_direct_byte(sd),
                print_time( sd_v1_mtime(sd) ) );
    } else {
	struct stat_data * sd = (struct stat_data *)item;

	printk ("\t0%-6o | %6Lu | %2u | %d | %s\n", sd_v2_mode(sd),
            (unsigned long long)sd_v2_size(sd), sd_v2_nlink(sd),
            sd_v2_rdev(sd), print_time(sd_v2_mtime(sd)));
    }
}

static void sd_check_item (struct item_head * ih, char * item)
{
    // FIXME: type something here!
}


static int sd_create_vi (struct virtual_node * vn,
			 struct virtual_item * vi, 
			 int is_affected, 
			 int insert_size)
{
    vi->vi_index = TYPE_STAT_DATA;
    //vi->vi_type |= VI_TYPE_STAT_DATA;// not needed?
    return 0;
}


static int sd_check_left (struct virtual_item * vi, int free, 
			  int start_skip, int end_skip)
{
    if (start_skip || end_skip)
	BUG ();
    return -1;
}


static int sd_check_right (struct virtual_item * vi, int free)
{
    return -1;
}

static int sd_part_size (struct virtual_item * vi, int first, int count)
{
    if (count)
	BUG ();
    return 0;
}

static int sd_unit_num (struct virtual_item * vi)
{
    return vi->vi_item_len - IH_SIZE;
}


static void sd_print_vi (struct virtual_item * vi)
{
    reiserfs_warning ("STATDATA, index %d, type 0x%x, %h\n", 
		      vi->vi_index, vi->vi_type, vi->vi_ih);
}

struct item_operations stat_data_ops = {
    sd_bytes_number,
    sd_decrement_key,
    sd_is_left_mergeable,
    sd_print_item,
    sd_check_item,

    sd_create_vi,
    sd_check_left,
    sd_check_right,
    sd_part_size,
    sd_unit_num,
    sd_print_vi
};



//////////////////////////////////////////////////////////////////////////////
// direct item functions
//
static int direct_bytes_number (struct item_head * ih, int block_size)
{
  return ih_item_len(ih);
}


// FIXME: this should probably switch to indirect as well
static void direct_decrement_key (struct cpu_key * key)
{
    cpu_key_k_offset_dec (key);
    if (cpu_key_k_offset (key) == 0)
	set_cpu_key_k_type (key, TYPE_STAT_DATA);	
}


static int direct_is_left_mergeable (struct key * key, unsigned long bsize)
{
    int version = le_key_version (key);
    return ((le_key_k_offset (version, key) & (bsize - 1)) != 1);
}


static void direct_print_item (struct item_head * ih, char * item)
{
    int j = 0;

//    return;
    printk ("\"");
    while (j < ih_item_len(ih))
	printk ("%c", item[j++]);
    printk ("\"\n");
}


static void direct_check_item (struct item_head * ih, char * item)
{
    // FIXME: type something here!
}


static int direct_create_vi (struct virtual_node * vn,
			     struct virtual_item * vi, 
			     int is_affected, 
			     int insert_size)
{
    vi->vi_index = TYPE_DIRECT;
    //vi->vi_type |= VI_TYPE_DIRECT;
    return 0;
}

static int direct_check_left (struct virtual_item * vi, int free,
			      int start_skip, int end_skip)
{
    int bytes;

    bytes = free - free % 8;
    return bytes ?: -1;    
}


static int direct_check_right (struct virtual_item * vi, int free)
{
    return direct_check_left (vi, free, 0, 0);
}

static int direct_part_size (struct virtual_item * vi, int first, int count)
{
    return count;
}


static int direct_unit_num (struct virtual_item * vi)
{
    return vi->vi_item_len - IH_SIZE;
}


static void direct_print_vi (struct virtual_item * vi)
{
    reiserfs_warning ("DIRECT, index %d, type 0x%x, %h\n", 
		      vi->vi_index, vi->vi_type, vi->vi_ih);
}

struct item_operations direct_ops = {
    direct_bytes_number,
    direct_decrement_key,
    direct_is_left_mergeable,
    direct_print_item,
    direct_check_item,

    direct_create_vi,
    direct_check_left,
    direct_check_right,
    direct_part_size,
    direct_unit_num,
    direct_print_vi
};



//////////////////////////////////////////////////////////////////////////////
// indirect item functions
//

static int indirect_bytes_number (struct item_head * ih, int block_size)
{
  return ih_item_len(ih) / UNFM_P_SIZE * block_size; //- get_ih_free_space (ih);
}


// decrease offset, if it becomes 0, change type to stat data
static void indirect_decrement_key (struct cpu_key * key)
{
    cpu_key_k_offset_dec (key);
    if (cpu_key_k_offset (key) == 0)
	set_cpu_key_k_type (key, TYPE_STAT_DATA);
}


// if it is not first item of the body, then it is mergeable
static int indirect_is_left_mergeable (struct key * key, unsigned long bsize)
{
    int version = le_key_version (key);
    return (le_key_k_offset (version, key) != 1);
}


// printing of indirect item
static void start_new_sequence (__u32 * start, int * len, __u32 new)
{
    *start = new;
    *len = 1;
}


static int sequence_finished (__u32 start, int * len, __u32 new)
{
    if (start == INT_MAX)
	return 1;

    if (start == 0 && new == 0) {
	(*len) ++;
	return 0;
    }
    if (start != 0 && (start + *len) == new) {
	(*len) ++;
	return 0;
    }
    return 1;
}

static void print_sequence (__u32 start, int len)
{
    if (start == INT_MAX)
	return;

    if (len == 1)
	printk (" %d", start);
    else
	printk (" %d(%d)", start, len);
}


static void indirect_print_item (struct item_head * ih, char * item)
{
    int j;
    __u32 * unp, prev = INT_MAX;
    int num;

    unp = (__u32 *)item;

    if (ih_item_len(ih) % UNFM_P_SIZE)
	printk ("indirect_print_item: invalid item len");  

    printk ("%d pointers\n[ ", (int)I_UNFM_NUM (ih));
    for (j = 0; j < I_UNFM_NUM (ih); j ++) {
	if (sequence_finished (prev, &num, get_block_num(unp, j))) {
	    print_sequence (prev, num);
	    start_new_sequence (&prev, &num, get_block_num(unp, j));
	}
    }
    print_sequence (prev, num);
    printk ("]\n");
}

static void indirect_check_item (struct item_head * ih, char * item)
{
    // FIXME: type something here!
}


static int indirect_create_vi (struct virtual_node * vn,
			       struct virtual_item * vi, 
			       int is_affected, 
			       int insert_size)
{
    vi->vi_index = TYPE_INDIRECT;
    //vi->vi_type |= VI_TYPE_INDIRECT;
    return 0;
}

static int indirect_check_left (struct virtual_item * vi, int free,
				int start_skip, int end_skip)
{
    int bytes;

    bytes = free - free % UNFM_P_SIZE;
    return bytes ?: -1;    
}


static int indirect_check_right (struct virtual_item * vi, int free)
{
    return indirect_check_left (vi, free, 0, 0);
}



// return size in bytes of 'units' units. If first == 0 - calculate from the head (left), otherwise - from tail (right)
static int indirect_part_size (struct virtual_item * vi, int first, int units)