module.h

来自「可以在不启动LINUX的情况下直接访问EXT2和EXT3格式的磁盘」· C头文件 代码 · 共 1,378 行 · 第 1/3 页

{
    volatile unsigned char *ADDR;
    unsigned char mask;

    ADDR = (volatile unsigned char *) addr;
    ADDR += nr >> 3;
    mask = 1 << (nr & 0x07);
    *ADDR &= ~mask;
}

/**
 * test_and_clear_bit - Clear a bit and return its old value
 * @nr: Bit to clear
 * @addr: Address to count from
 *
 * This operation is atomic and cannot be reordered.
 * It also implies a memory barrier.
 */
static inline int test_and_clear_bit(int nr, volatile void *addr)
{
    int rc;
    unsigned char  mask;
    unsigned char *ADDR = (unsigned char *) addr;

    ADDR += nr >> 3;
    mask = 1 << (nr & 0x07);
    rc = ((mask & *ADDR) != 0);
    *ADDR &= (~mask);

    return rc;
}

/*
 *  test
 */
static int test_bit(int nr, volatile const void * addr)
{
    unsigned char mask;
    unsigned char *ADDR = (unsigned char *) addr;

    ADDR += nr >> 3;
    mask = 1 << (nr & 0x07);

    return ((mask & *ADDR) != 0);
}

/**
 * test_and_set_bit - Set a bit and return its old value
 * @nr: Bit to set
 * @addr: Address to count from
 *
 * This operation is atomic and cannot be reordered.
 * It also implies a memory barrier.
 */
static inline int test_and_set_bit(int nr, volatile void *addr)
{
    int rc;
    unsigned char  mask;
    unsigned char *ADDR = (unsigned char *) addr;

    ADDR += nr >> 3;
    mask = 1 << (nr & 0x07);
    rc = ((mask & *ADDR) != 0);
    *ADDR |= mask;

    return rc;
}


//
// list definition ...
//

#include <linux/list.h>


/*********************************************
 *  linux scheduler related structures      *
*********************************************/

//
// task structure
//

#define TASK_INTERRUPTIBLE      1
#define TASK_UNINTERRUPTIBLE    2

struct task_struct{
	pid_t pid;
  	pid_t tid;
	char comm[32];
    void * journal_info;
};

extern struct task_struct *current;

//
// scheduler routines
//


static inline cond_resched() {return FALSE;}
static inline need_resched() {return FALSE;}

#define yield()        do {} while(0)
#define might_sleep()  do {} while(0)

//
// mutex
//

typedef struct mutex {
   FAST_MUTEX  lock;
} mutex_t;

#define mutex_init(x)   ExInitializeFastMutex(&((x)->lock))
#define mutex_lock(x)   ExAcquireFastMutex(&((x)->lock))
#define mutex_unlock(x) ExReleaseFastMutex(&((x)->lock))


//
// wait_queue 
//


typedef PVOID wait_queue_t;

#define WQ_FLAG_EXCLUSIVE	    0x01
#define WQ_FLAG_AUTO_REMOVAL	0x02

struct __wait_queue {
	unsigned int    flags;
	void *          private;
    KEVENT          event;
	struct list_head task_list;
};


#define DEFINE_WAIT(name) \
	wait_queue_t name = (PVOID)wait_queue_create();

/*
struct wait_bit_key {
	void *flags;
	int bit_nr;
};

struct wait_bit_queue {
	struct wait_bit_key key;
	wait_queue_t wait;
};
*/

struct __wait_queue_head {
	spinlock_t lock;
	struct list_head task_list;
};
typedef struct __wait_queue_head wait_queue_head_t;

#define is_sync_wait(wait)  (TRUE)
#define set_current_state(state) do {} while(0)
#define __set_current_state(state)  do {} while(0)

void init_waitqueue_head(wait_queue_head_t *q);
int wake_up(wait_queue_head_t *queue);


/*
 * Waitqueues which are removed from the waitqueue_head at wakeup time
 */
struct __wait_queue * wait_queue_create();
void wait_queue_destroy(struct __wait_queue *);

void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state);
void prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state);
void finish_wait(wait_queue_head_t *q, wait_queue_t *wait);
int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);


//
// timer structure
//

struct timer_list {
	struct list_head entry;
	unsigned long expires;

	void (*function)(unsigned long);
	unsigned long data;

#ifdef CONFIG_TIMER_STATS
	void *start_site;
	char start_comm[16];
	int start_pid;
#endif
};


//
// kdev
//

#define NODEV           0

typedef struct block_device * kdev_t;

#define MINORBITS   8
#define MINORMASK   ((1U << MINORBITS) - 1)

#define MAJOR(dev)   ((unsigned int)((int)(dev) >> MINORBITS))
#define MINOR(dev)   ((unsigned int)((int)(dev) & MINORMASK))

static inline unsigned int kdev_t_to_nr(kdev_t dev) {
	/*return (unsigned int)(MAJOR(dev)<<8) | MINOR(dev);*/
    return 0;
} 

#define NODEV		0
#define MKDEV(ma,mi)	(((ma) << MINORBITS) | (mi)) 

static inline kdev_t to_kdev_t(int dev)
{
#if 0
	int major, minor;
#if 0
	major = (dev >> 16);
	if (!major) {
		major = (dev >> 8);
		minor = (dev & 0xff);
	} else
		minor = (dev & 0xffff);
#else
	major = (dev >> 8);
	minor = (dev & 0xff);
#endif
	return (kdev_t) MKDEV(major, minor);
#endif
    return 0;
} 


typedef struct kmem_cache kmem_cache_t;

struct block_device {

    unsigned long           bd_flags;   /* flags */
	atomic_t		        bd_count;   /* reference count */
    PDEVICE_OBJECT          bd_dev;     /* device object */
    ANSI_STRING             bd_name;    /* name in ansi string */
    DISK_GEOMETRY           bd_geo;     /* disk geometry */
    PARTITION_INFORMATION   bd_part;    /* partition information */
    void *                  bd_priv;    /* pointers to EXT2_VCB
                                           NULL if it's a journal dev */
    PFILE_OBJECT            bd_volume;  /* streaming object file */
    LARGE_MCB               bd_extents; /* dirty extents */

    spinlock_t              bd_bh_lock;    /**/
    kmem_cache_t *          bd_bh_cache;   /* memory cache for buffer_head */
    struct list_head        bd_bh_list;    /* buffer_head list header */
};

//
// page information
//

// vom trata paginile in felul urmator:
// alocam la sfarsitul structurii inca PAGE_SIZE octeti cand alocam o structura
// de tip pagina - acolo vor veni toate buffer-headurile
// deci -> page_address(page) = page + sizeof(page)
#define page_address(_page) ((char*)_page + sizeof(struct page))

typedef struct page {
//	struct list_head list;          /* ->mapping has some page lists. */
	struct address_space *mapping;  /* The inode (or ...) we belong to. */
	unsigned long index;            /* Our offset within mapping. */
#if 0
	struct page *next_hash;         /* Next page sharing our hash bucket in
                                       the pagecache hash table. */
#endif
	atomic_t count;                 /* Usage count, see below. */
	unsigned long flags;            /* atomic flags, some possibly
                                       updated asynchronously */
#if 0
	struct list_head lru;           /* Pageout list, eg. active_list;
                                       protected by pagemap_lru_lock !! */
	struct page **pprev_hash;       /* Complement to *next_hash. */
	struct buffer_head * buffers;   /* Buffer maps us to a disk block. */
#endif
} mem_map_t;

#define get_page(p) atomic_inc(&(p)->count)

#define PG_locked		 0	/* Page is locked. Don't touch. */
#define PG_error		 1
#define PG_referenced		 2
#define PG_uptodate		 3
#define PG_dirty		 4
#define PG_unused		 5
#define PG_lru			 6
#define PG_active		 7
#define PG_slab			 8
#define PG_skip			10
#define PG_highmem		11
#define PG_checked		12	/* kill me in 2.5.<early>. */
#define PG_arch_1		13
#define PG_reserved		14
#define PG_launder		15	/* written out by VM pressure.. */
#define PG_fs_1			16	/* Filesystem specific */

#ifndef arch_set_page_uptodate
#define arch_set_page_uptodate(page)
#endif

/* Make it prettier to test the above... */
#define UnlockPage(page)        unlock_page(page)
#define Page_Uptodate(page)     test_bit(PG_uptodate, &(page)->flags)
#define SetPageUptodate(page) \
	do {								\
		arch_set_page_uptodate(page);				\
		set_bit(PG_uptodate, &(page)->flags);			\
	} while (0)
#define ClearPageUptodate(page) clear_bit(PG_uptodate, &(page)->flags)
#define PageDirty(page)         test_bit(PG_dirty, &(page)->flags)
#define SetPageDirty(page)      set_bit(PG_dirty, &(page)->flags)
#define ClearPageDirty(page)    clear_bit(PG_dirty, &(page)->flags)
#define PageLocked(page)        test_bit(PG_locked, &(page)->flags)
#define LockPage(page)          set_bit(PG_locked, &(page)->flags)
#define TryLockPage(page)       test_and_set_bit(PG_locked, &(page)->flags)
#define PageChecked(page)       test_bit(PG_checked, &(page)->flags)
#define SetPageChecked(page)    set_bit(PG_checked, &(page)->flags)
#define ClearPageChecked(page)  clear_bit(PG_checked, &(page)->flags)
#define PageLaunder(page)       test_bit(PG_launder, &(page)->flags)
#define SetPageLaunder(page)    set_bit(PG_launder, &(page)->flags)
#define ClearPageLaunder(page)  clear_bit(PG_launder, &(page)->flags)
#define ClearPageArch1(page)    clear_bit(PG_arch_1, &(page)->flags)

#define PageError(page)		test_bit(PG_error, &(page)->flags)
#define SetPageError(page)	set_bit(PG_error, &(page)->flags)
#define ClearPageError(page)	clear_bit(PG_error, &(page)->flags)
#define PageReferenced(page)    test_bit(PG_referenced, &(page)->flags)
#define SetPageReferenced(page) set_bit(PG_referenced, &(page)->flags)
#define ClearPageReferenced(page)       clear_bit(PG_referenced, &(page)->flags)

#define PageActive(page)        test_bit(PG_active, &(page)->flags)
#define SetPageActive(page)     set_bit(PG_active, &(page)->flags)
#define ClearPageActive(page)   clear_bit(PG_active, &(page)->flags)


extern unsigned long __get_free_pages(unsigned int gfp_mask, unsigned int order);
#define __get_free_page(gfp_mask) \
		__get_free_pages((gfp_mask),0)

extern void __free_pages(struct page *page, unsigned int order);
extern void free_pages(unsigned long addr, unsigned int order);

#define __free_page(page) __free_pages((page), 0)
#define free_page(addr) free_pages((addr),0)

extern void truncate_inode_pages(struct address_space *, loff_t);

#define __GFP_HIGHMEM   0x02

#define __GFP_WAIT	0x10	/* Can wait and reschedule? */
#define __GFP_HIGH	0x20	/* Should access emergency pools? */
#define __GFP_IO	0x40	/* Can start low memory physical IO? */
#define __GFP_HIGHIO	0x80	/* Can start high mem physical IO? */
#define __GFP_FS	0x100	/* Can call down to low-level FS? */

#define GFP_ATOMIC	(__GFP_HIGH)
#define GFP_USER	(             __GFP_WAIT | __GFP_IO | __GFP_HIGHIO | __GFP_FS)
#define GFP_HIGHUSER    (             __GFP_WAIT | __GFP_IO | __GFP_HIGHIO | __GFP_FS | __GFP_HIGHMEM)
#define GFP_KERNEL	(__GFP_HIGH | __GFP_WAIT | __GFP_IO | __GFP_HIGHIO | __GFP_FS)
#define GFP_NOFS    0
#define __GFP_NOFAIL 0


#define KM_USER0 0

//
// buffer head definitions
//

enum bh_state_bits {
	BH_Uptodate,	        /* Contains valid data */
	BH_Dirty,	            /* Is dirty */
	BH_Lock,	            /* Is locked */
	BH_Req,		            /* Has been submitted for I/O */
	BH_Uptodate_Lock,       /* Used by the first bh in a page, to serialise
			                 * IO completion of other buffers in the page
			                 */

	BH_Mapped,	            /* Has a disk mapping */
	BH_New,		            /* Disk mapping was newly created by get_block */
	BH_Async_Read,	        /* Is under end_buffer_async_read I/O */
	BH_Async_Write,	        /* Is under end_buffer_async_write I/O */
	BH_Delay,	            /* Buffer is not yet allocated on disk */
	BH_Boundary,	        /* Block is followed by a discontiguity */
	BH_Write_EIO,	        /* I/O error on write */
	BH_Ordered,	            /* ordered write */
	BH_Eopnotsupp,	        /* operation not supported (barrier) */
	BH_Unwritten,	        /* Buffer is allocated on disk but not written */

	BH_PrivateStart,        /* not a state bit, but the first bit available
			                 * for private allocation by other entities
			                 */
};

#define PAGE_CACHE_SIZE  (PAGE_SIZE)
#define PAGE_CACHE_SHIFT (12)
#define MAX_BUF_PER_PAGE (PAGE_CACHE_SIZE / 512)

typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);

/*
 * Historically, a buffer_head was used to map a single block
 * within a page, and of course as the unit of I/O through the
 * filesystem and block layers.  Nowadays the basic I/O unit
 * is the bio, and buffer_heads are used for extracting block
 * mappings (via a get_block_t call), for tracking state within
 * a page (via a page_mapping) and for wrapping bio submission
 * for backward compatibility reasons (e.g. submit_bh).
 */
struct buffer_head {
	unsigned long b_state;		           /* buffer state bitmap (see above) */
	// struct buffer_head *b_this_page;    /* circular list of page's buffers */
	struct page *b_page;		           /* the page this bh is mapped to */

	// kdev_t b_dev;                       /* device (B_FREE = free) */
    struct block_device *b_bdev;           /* block device object */

	unsigned long b_blocknr;		       /* start block number */
	size_t        b_size;			       /* size of mapping */
	char *        b_data;			       /* pointer to data within the page */
	// bh_end_io_t *b_end_io;		       /* I/O completion */
 	void *b_private;		               /* reserved for b_end_io */
	// struct list_head b_assoc_buffers;   /* associated with another mapping */
	// struct address_space *b_assoc_map;  /* mapping this buffer is associated with */
	atomic_t b_count;		               /* users using this buffer_head */
    struct list_head b_list;               /* list entry */
};


/*
 * macro tricks to expand the set_buffer_foo(), clear_buffer_foo()
 * and buffer_foo() functions.
 */
#define BUFFER_FNS(bit, name)						\
static inline void set_buffer_##name(struct buffer_head *bh)		\
{									\
	set_bit(BH_##bit, &(bh)->b_state);				\
}									\
static inline void clear_buffer_##name(struct buffer_head *bh)		\
{									\
	clear_bit(BH_##bit, &(bh)->b_state);				\
}									\
static inline int buffer_##name(const struct buffer_head *bh)		\
{									\
	return test_bit(BH_##bit, &(bh)->b_state);			\
}