linux.c File Reference

#include <ext2fs.h>
#include <linux/jbd.h>
#include <linux/errno.h>

Include dependency graph for linux.c:

Go to the source code of this file.

Classes
struct	_EXT2_BUFFER_HEAD

Functions
void *	kzalloc (int size, int flags)
kmem_cache_t *	kmem_cache_create (const char *name, size_t size, size_t offset, unsigned long flags, kmem_cache_cb_t ctor)
int	kmem_cache_destroy (kmem_cache_t *kc)
void *	kmem_cache_alloc (kmem_cache_t *kc, int flags)
void	kmem_cache_free (kmem_cache_t *kc, void *p)
void	init_waitqueue_head (wait_queue_head_t *q)
struct __wait_queue *	wait_queue_create ()
void	wait_queue_destroy (struct __wait_queue *wait)
static void	__add_wait_queue (wait_queue_head_t *head, struct __wait_queue *new)
static void	__add_wait_queue_tail (wait_queue_head_t *head, struct __wait_queue *new)
static void	__remove_wait_queue (wait_queue_head_t *head, struct __wait_queue *old)
void	add_wait_queue (wait_queue_head_t *q, wait_queue_t *waiti)
void	add_wait_queue_exclusive (wait_queue_head_t *q, wait_queue_t *waiti)
void	remove_wait_queue (wait_queue_head_t *q, wait_queue_t *waiti)
void	prepare_to_wait (wait_queue_head_t *q, wait_queue_t *waiti, int state)
void	prepare_to_wait_exclusive (wait_queue_head_t *q, wait_queue_t *waiti, int state)
	EXPORT_SYMBOL (prepare_to_wait_exclusive)
void	finish_wait (wait_queue_head_t *q, wait_queue_t *waiti)
int	wake_up (wait_queue_head_t *queue)
int	ext2_init_bh ()
void	ext2_destroy_bh ()
struct buffer_head *	new_buffer_head ()
void	free_buffer_head (struct buffer_head *bh)
static struct buffer_head *	__buffer_head_search (struct rb_root *root, sector_t blocknr)
static int	buffer_head_blocknr_cmp (struct rb_node *a, struct rb_node *b)
static struct buffer_head *	buffer_head_search (struct block_device *bdev, sector_t blocknr)
static void	buffer_head_insert (struct block_device *bdev, struct buffer_head *bh)
void	buffer_head_remove (struct block_device *bdev, struct buffer_head *bh)
struct buffer_head *	get_block_bh_mdl (struct block_device *bdev, sector_t block, unsigned long size, int zero)
int	submit_bh_mdl (int rw, struct buffer_head *bh)
struct buffer_head *	get_block_bh_pin (struct block_device *bdev, sector_t block, unsigned long size, int zero)
int	submit_bh_pin (int rw, struct buffer_head *bh)
struct buffer_head *	get_block_bh (struct block_device *bdev, sector_t block, unsigned long size, int zero)
int	submit_bh (int rw, struct buffer_head *bh)
struct buffer_head *	__getblk (struct block_device *bdev, sector_t block, unsigned long size)
void	__brelse (struct buffer_head *bh)
void	__bforget (struct buffer_head *bh)
void	__lock_buffer (struct buffer_head *bh)
void	unlock_buffer (struct buffer_head *bh)
void	__wait_on_buffer (struct buffer_head *bh)
void	ll_rw_block (int rw, int nr, struct buffer_head *bhs[])
int	bh_submit_read (struct buffer_head *bh)
int	sync_dirty_buffer (struct buffer_head *bh)
void	mark_buffer_dirty (struct buffer_head *bh)
int	sync_blockdev (struct block_device *bdev)
struct buffer_head *	__find_get_block (struct block_device *bdev, sector_t block, unsigned long size)
ULONGLONG	bmap (struct inode *i, ULONGLONG b)
void	iget (struct inode *inode)
void	iput (struct inode *inode)
int	ext2_init_linux ()
void	ext2_destroy_linux ()

Variables
PEXT2_GLOBAL	Ext2Global
struct task_struct	current_task
struct task_struct *	current = &current_task
struct _EXT2_BUFFER_HEAD	g_jbh = {NULL, ATOMIC_INIT(0)}

Function Documentation

__add_wait_queue()

static void __add_wait_queue ( wait_queue_head_t *  head, struct __wait_queue *  new  )

inlinestatic

Definition at line 147 of file linux.c.

{
    list_add(&new->task_list, &head->task_list);
}

Referenced by add_wait_queue(), and prepare_to_wait().

__add_wait_queue_tail()

static void __add_wait_queue_tail ( wait_queue_head_t *  head, struct __wait_queue *  new  )

inlinestatic

Definition at line 155 of file linux.c.

{
    list_add_tail(&new->task_list, &head->task_list);
}

Referenced by add_wait_queue_exclusive(), and prepare_to_wait_exclusive().

__bforget()

void __bforget

(

struct buffer_head *

bh

)

Definition at line 843 of file linux.c.

{
    clear_buffer_dirty(bh);
    __brelse(bh);
}

Referenced by bforget(), and journal_forget().

__brelse()

void __brelse

(

struct buffer_head *

bh

)

Definition at line 808 of file linux.c.

{
    struct block_device *bdev = bh->b_bdev;
    PEXT2_VCB Vcb = (PEXT2_VCB)bdev->bd_priv;
 
    ASSERT(Vcb->Identifier.Type == EXT2VCB);
 
    /* write data in case it's dirty */
    while (buffer_dirty(bh)) {
        ll_rw_block(WRITE, 1, &bh);
    }
 
    ExAcquireResourceExclusiveLite(&bdev->bd_bh_lock, TRUE);
    if (atomic_dec_and_test(&bh->b_count)) {
        ASSERT(0 == atomic_read(&bh->b_count));
    } else {
        ExReleaseResourceLite(&bdev->bd_bh_lock);
        return;
    }
    KeQuerySystemTime(&bh->b_ts_drop);
#ifdef __REACTOS__
    if (!IsListEmpty(&bh->b_link))
#endif
    RemoveEntryList(&bh->b_link);
    InsertTailList(&Vcb->bd.bd_bh_free, &bh->b_link);
    KeClearEvent(&Vcb->bd.bd_bh_notify);
    ExReleaseResourceLite(&bdev->bd_bh_lock);
    KeSetEvent(&Ext2Global->bhReaper.Wait, 0, FALSE);
 
    DEBUG(DL_BH, ("brelse: cnt=%u size=%u blk=%10.10xh bh=%p ptr=%p\n",
                  atomic_read(&g_jbh.bh_count) - 1, bh->b_size,
                  bh->b_blocknr, bh, bh->b_data ));
}

Referenced by __bforget(), __dispose_buffer(), __journal_remove_journal_head(), add_dirent_to_buf(), brelse(), Ext2AddDotEntries(), Ext2GetInodeLba(), Ext2ScanDir(), ext3_bread(), ext4_check_descriptors(), journal_forget(), journal_put_journal_head(), and put_bh().

__buffer_head_search()

static struct buffer_head * __buffer_head_search ( struct rb_root *  root, sector_t  blocknr  )

static

Definition at line 373 of file linux.c.

{
    struct rb_node *new = root->rb_node;
 
    /* Figure out where to put new node */
    while (new) {
        struct buffer_head *bh =
            container_of(new, struct buffer_head, b_rb_node);
        s64 result = blocknr - bh->b_blocknr;
 
        if (result < 0)
            new = new->rb_left;
        else if (result > 0)
            new = new->rb_right;
        else
            return bh;
 
    }
 
    return NULL;
}

Referenced by buffer_head_search().

__find_get_block()

struct buffer_head * __find_get_block	(	struct block_device *	bdev,
		sector_t	block,
		unsigned long	size
	)

Definition at line 932 of file linux.c.

{
    return __getblk(bdev, block, size);
}

Referenced by sb_find_get_block().

__getblk()

struct buffer_head * __getblk	(	struct block_device *	bdev,
		sector_t	block,
		unsigned long	size
	)

Definition at line 799 of file linux.c.

{
    return get_block_bh(bdev, block, size, 0);
}

Referenced by __find_get_block(), do_one_pass(), journal_get_descriptor_buffer(), journal_init_inode(), jread(), and sb_bread().

__lock_buffer()

void __lock_buffer

(

struct buffer_head *

bh

)

Definition at line 849 of file linux.c.

{
}

Referenced by lock_buffer().

__remove_wait_queue()

static void __remove_wait_queue ( wait_queue_head_t *  head, struct __wait_queue *  old  )

inlinestatic

Definition at line 161 of file linux.c.

{
    list_del(&old->task_list);
}

Referenced by remove_wait_queue().

__wait_on_buffer()

void __wait_on_buffer

(

struct buffer_head *

bh

)

Definition at line 858 of file linux.c.

{
}

Referenced by wait_on_buffer().

add_wait_queue()

void add_wait_queue	(	wait_queue_head_t *	q,
		wait_queue_t *	waiti
	)

Definition at line 167 of file linux.c.

{
    unsigned long flags;
    struct __wait_queue *wait = *waiti;
 
    wait->flags &= ~WQ_FLAG_EXCLUSIVE;
    spin_lock_irqsave(&q->lock, flags);
    __add_wait_queue(q, wait);
    spin_unlock_irqrestore(&q->lock, flags);
}

add_wait_queue_exclusive()

void add_wait_queue_exclusive	(	wait_queue_head_t *	q,
		wait_queue_t *	waiti
	)

Definition at line 178 of file linux.c.

{
    unsigned long flags;
    struct __wait_queue *wait = *waiti;
 
    wait->flags |= WQ_FLAG_EXCLUSIVE;
    spin_lock_irqsave(&q->lock, flags);
    __add_wait_queue_tail(q, wait);
    spin_unlock_irqrestore(&q->lock, flags);
}

bh_submit_read()

int bh_submit_read

(

struct buffer_head *

bh

)

Definition at line 892 of file linux.c.

{
    ll_rw_block(READ, 1, &bh);
    return 0;
}

Referenced by Ext2FreeInode(), Ext2LoadBlock(), Ext2LoadBuffer(), Ext2NewBlock(), Ext2NewInode(), Ext2SaveBuffer(), Ext2ZeroBuffer(), ext3_bread(), and sb_bread().

bmap()

ULONGLONG bmap	(	struct inode *	i,
		ULONGLONG	b
	)

Definition at line 942 of file linux.c.

{
    ULONGLONG lcn = 0;
    struct super_block *s = i->i_sb;
 
    PEXT2_MCB  Mcb = (PEXT2_MCB)i->i_priv;
    PEXT2_VCB  Vcb = (PEXT2_VCB)s->s_priv;
    PEXT2_EXTENT extent = NULL;
    ULONGLONG  offset = (ULONGLONG)b;
    NTSTATUS   status;
 
    if (!Mcb || !Vcb) {
        goto errorout;
    }
 
    offset <<= BLOCK_BITS;
    status = Ext2BuildExtents(
                 NULL,
                 Vcb,
                 Mcb,
                 offset,
                 BLOCK_SIZE,
                 FALSE,
                 &extent
             );
 
    if (!NT_SUCCESS(status)) {
        goto errorout;
    }
 
    if (extent == NULL) {
        goto errorout;
    }
 
    lcn = (unsigned long)(extent->Lba >> BLOCK_BITS);
 
errorout:
 
    if (extent) {
        Ext2FreeExtent(extent);
    }
 
    return lcn;
}

Referenced by ext2_allocate_group_table(), and journal_bmap().

buffer_head_blocknr_cmp()

static int buffer_head_blocknr_cmp ( struct rb_node *  a, struct rb_node *  b  )

static

Definition at line 396 of file linux.c.

{
    struct buffer_head *a_bh, *b_bh;
    s64 result;
    a_bh = container_of(a, struct buffer_head, b_rb_node);
    b_bh = container_of(b, struct buffer_head, b_rb_node);
    result = a_bh->b_blocknr - b_bh->b_blocknr;
 
    if (result < 0)
        return -1;
    if (result > 0)
        return 1;
    return 0;
}

Referenced by buffer_head_insert().

buffer_head_insert()

static void buffer_head_insert ( struct block_device *  bdev, struct buffer_head *  bh  )

static

Definition at line 419 of file linux.c.

{
    rb_insert(&bdev->bd_bh_root, &bh->b_rb_node, buffer_head_blocknr_cmp);
}

Referenced by get_block_bh_mdl(), and get_block_bh_pin().

buffer_head_remove()

void buffer_head_remove	(	struct block_device *	bdev,
		struct buffer_head *	bh
	)

Definition at line 424 of file linux.c.

{
    rb_erase(&bh->b_rb_node, &bdev->bd_bh_root);
}

Referenced by Ext2DropBH(), and Ext2QueryUnusedBH().

buffer_head_search()

static struct buffer_head * buffer_head_search ( struct block_device *  bdev, sector_t  blocknr  )

static

Definition at line 411 of file linux.c.

{
    struct rb_root *root;
    root = &bdev->bd_bh_root;
    return __buffer_head_search(root, blocknr);
}

Referenced by get_block_bh_mdl(), and get_block_bh_pin().

EXPORT_SYMBOL()

EXPORT_SYMBOL

(

prepare_to_wait_exclusive

)

ext2_destroy_bh()

void ext2_destroy_bh

(

)

Definition at line 318 of file linux.c.

{
    if (g_jbh.bh_cache) {
        kmem_cache_destroy(g_jbh.bh_cache);
        g_jbh.bh_cache = NULL;
    }
}

Referenced by ext2_destroy_linux().

ext2_destroy_linux()

void ext2_destroy_linux

(

)

Definition at line 1019 of file linux.c.

{
    ext2_destroy_bh();
}

Referenced by DriverEntry().

ext2_init_bh()

int ext2_init_bh

(

)

Definition at line 300 of file linux.c.

{
    g_jbh.bh_count.counter = 0;
    g_jbh.bh_acount.counter = 0;
    g_jbh.bh_cache = kmem_cache_create(
                         "ext2_bh",   /* bh */
                         sizeof(struct buffer_head),
                         0,             /* offset */
                         SLAB_TEMPORARY,    /* flags */
                         NULL);         /* ctor */
    if (g_jbh.bh_cache == NULL) {
        printk(KERN_EMERG "JBD: failed to create handle cache\n");
        return -ENOMEM;
    }
    return 0;
}

Referenced by ext2_init_linux().

ext2_init_linux()

int ext2_init_linux

(

)

Definition at line 1004 of file linux.c.

{
    int rc = 0;
 
    rc = ext2_init_bh();
    if (rc != 0) {
        goto errorout;
    }
 
errorout:
 
    return rc;
}

Referenced by DriverEntry().

finish_wait()

void finish_wait	(	wait_queue_head_t *	q,
		wait_queue_t *	waiti
	)

Definition at line 250 of file linux.c.

{
    unsigned long flags;
    struct __wait_queue *wait = *waiti;
 
    __set_current_state(TASK_RUNNING);
    /*
     * We can check for list emptiness outside the lock
     * IFF:
     *  - we use the "careful" check that verifies both
     *    the next and prev pointers, so that there cannot
     *    be any half-pending updates in progress on other
     *    CPU's that we haven't seen yet (and that might
     *    still change the stack area.
     * and
     *  - all other users take the lock (ie we can only
     *    have _one_ other CPU that looks at or modifies
     *    the list).
     */
    if (!list_empty_careful(&wait->task_list)) {
        spin_lock_irqsave(&q->lock, flags);
        list_del_init(&wait->task_list);
        spin_unlock_irqrestore(&q->lock, flags);
    }
 
    /* free wait */
    wait_queue_destroy(wait);
}

free_buffer_head()

void free_buffer_head

(

struct buffer_head *

bh

)

Definition at line 346 of file linux.c.

{
    if (bh) {
        if (bh->b_mdl) {
 
            DEBUG(DL_BH, ("bh=%p mdl=%p (Flags:%xh VA:%p) released.\n", bh, bh->b_mdl,
                          bh->b_mdl->MdlFlags, bh->b_mdl->MappedSystemVa));
            if (IsFlagOn(bh->b_mdl->MdlFlags, MDL_MAPPED_TO_SYSTEM_VA)) {
                MmUnmapLockedPages(bh->b_mdl->MappedSystemVa, bh->b_mdl);
            }
            Ext2DestroyMdl(bh->b_mdl);
        }
        if (bh->b_bcb) {
            CcUnpinDataForThread(bh->b_bcb, (ERESOURCE_THREAD)bh | 0x3);
        }
 
        DEBUG(DL_BH, ("bh=%p freed.\n", bh));
        DEC_MEM_COUNT(PS_BUFF_HEAD, bh, sizeof(struct buffer_head));
        kmem_cache_free(g_jbh.bh_cache, bh);
        atomic_dec(&g_jbh.bh_count);
    }
}

Referenced by Ext2bhReaperThread(), Ext2DropBH(), get_block_bh_mdl(), and get_block_bh_pin().

get_block_bh()

struct buffer_head * get_block_bh	(	struct block_device *	bdev,
		sector_t	block,
		unsigned long	size,
		int	zero
	)

Definition at line 782 of file linux.c.

{
    return get_block_bh_pin(bdev, block, size, zero);
}

Referenced by __getblk(), sb_getblk(), and sb_getblk_zero().

get_block_bh_mdl()

struct buffer_head * get_block_bh_mdl	(	struct block_device *	bdev,
		sector_t	block,
		unsigned long	size,
		int	zero
	)

Definition at line 430 of file linux.c.

{
    PEXT2_VCB Vcb = bdev->bd_priv;
    LARGE_INTEGER offset;
    PVOID         bcb = NULL;
    PVOID         ptr = NULL;
 
    struct list_head *entry;
 
    /* allocate buffer_head and initialize it */
    struct buffer_head *bh = NULL, *tbh = NULL;
 
    /* check the block is valid or not */
    if (block >= TOTAL_BLOCKS) {
        DbgBreak();
        goto errorout;
    }
 
    /* search the bdev bh list */
    ExAcquireSharedStarveExclusive(&bdev->bd_bh_lock, TRUE);
    tbh = buffer_head_search(bdev, block);
    if (tbh) {
        bh = tbh;
        get_bh(bh);
        ExReleaseResourceLite(&bdev->bd_bh_lock);
        goto errorout;
    }
    ExReleaseResourceLite(&bdev->bd_bh_lock);
 
    bh = new_buffer_head();
    if (!bh) {
        goto errorout;
    }
    bh->b_bdev = bdev;
    bh->b_blocknr = block;
    bh->b_size = size;
    bh->b_data = NULL;
#ifdef __REACTOS__
    InitializeListHead(&bh->b_link);
#endif
 
again:
 
    offset.QuadPart = (s64) bh->b_blocknr;
    offset.QuadPart <<= BLOCK_BITS;
 
    if (zero) {
        /* PIN_EXCLUSIVE disabled, likely to deadlock with volume operations */
        if (!CcPreparePinWrite(Vcb->Volume,
                            &offset,
                            bh->b_size,
                            FALSE,
                            PIN_WAIT /* | PIN_EXCLUSIVE */,
                            &bcb,
                            &ptr)) {
            Ext2Sleep(100);
            goto again;
        }
    } else {
        if (!CcPinRead( Vcb->Volume,
                        &offset,
                        bh->b_size,
                        PIN_WAIT,
                        &bcb,
                        &ptr)) {
            Ext2Sleep(100);
            goto again;
        }
        set_buffer_uptodate(bh);
    }
 
    bh->b_mdl = Ext2CreateMdl(ptr, bh->b_size, IoModifyAccess);
    if (bh->b_mdl) {
        /* muse map the PTE to NonCached zone. journal recovery will
           access the PTE under spinlock: DISPATCH_LEVEL IRQL */
        bh->b_data = MmMapLockedPagesSpecifyCache(
                         bh->b_mdl, KernelMode, MmNonCached,
                         NULL,FALSE, HighPagePriority);
        /* bh->b_data = MmMapLockedPages(bh->b_mdl, KernelMode); */
    }
    if (!bh->b_mdl || !bh->b_data) {
        free_buffer_head(bh);
        bh = NULL;
        goto errorout;
    }
 
    get_bh(bh);
 
    DEBUG(DL_BH, ("getblk: Vcb=%p bhcount=%u block=%u bh=%p mdl=%p (Flags:%xh VA:%p)\n",
                  Vcb, atomic_read(&g_jbh.bh_count), block, bh, bh->b_mdl, bh->b_mdl->MdlFlags, bh->b_data));
 
    ExAcquireResourceExclusiveLite(&bdev->bd_bh_lock, TRUE);
    /* do search again here */
    tbh = buffer_head_search(bdev, block);
    if (tbh) {
        free_buffer_head(bh);
        bh = tbh;
        get_bh(bh);
        RemoveEntryList(&bh->b_link);
        InitializeListHead(&bh->b_link);
        ExReleaseResourceLite(&bdev->bd_bh_lock);
        goto errorout;
    } else {
        buffer_head_insert(bdev, bh);
    }
    ExReleaseResourceLite(&bdev->bd_bh_lock);
 
    /* we get it */
errorout:
 
    if (bcb)
        CcUnpinData(bcb);
 
    return bh;
}

get_block_bh_pin()

struct buffer_head * get_block_bh_pin	(	struct block_device *	bdev,
		sector_t	block,
		unsigned long	size,
		int	zero
	)

Definition at line 611 of file linux.c.

{
    PEXT2_VCB Vcb = bdev->bd_priv;
    LARGE_INTEGER offset;
 
    struct list_head *entry;
 
    /* allocate buffer_head and initialize it */
    struct buffer_head *bh = NULL, *tbh = NULL;
 
    /* check the block is valid or not */
    if (block >= TOTAL_BLOCKS) {
        DbgBreak();
        goto errorout;
    }
 
    /* search the bdev bh list */
    ExAcquireSharedStarveExclusive(&bdev->bd_bh_lock, TRUE);
    tbh = buffer_head_search(bdev, block);
    if (tbh) {
        bh = tbh;
        get_bh(bh);
        ExReleaseResourceLite(&bdev->bd_bh_lock);
        goto errorout;
    }
    ExReleaseResourceLite(&bdev->bd_bh_lock);
 
    bh = new_buffer_head();
    if (!bh) {
        goto errorout;
    }
    bh->b_bdev = bdev;
    bh->b_blocknr = block;
    bh->b_size = size;
    bh->b_data = NULL;
#ifdef __REACTOS__
    InitializeListHead(&bh->b_link);
#endif
 
again:
 
    offset.QuadPart = (s64) bh->b_blocknr;
    offset.QuadPart <<= BLOCK_BITS;
 
    if (zero) {
        if (!CcPreparePinWrite(Vcb->Volume,
                            &offset,
                            bh->b_size,
                            FALSE,
                            PIN_WAIT,
                            &bh->b_bcb,
#ifdef __REACTOS__
                            (PVOID *)&bh->b_data)) {
#else
                            &bh->b_data)) {
#endif
            Ext2Sleep(100);
            goto again;
        }
    } else {
        if (!CcPinRead( Vcb->Volume,
                        &offset,
                        bh->b_size,
                        PIN_WAIT,
                        &bh->b_bcb,
#ifdef __REACTOS__
                        (PVOID *)&bh->b_data)) {
#else
                        &bh->b_data)) {
#endif
            Ext2Sleep(100);
            goto again;
        }
        set_buffer_uptodate(bh);
    }
 
    if (bh->b_bcb)
        CcSetBcbOwnerPointer(bh->b_bcb, (PVOID)((ERESOURCE_THREAD)bh | 0x3));
 
    if (!bh->b_data) {
        free_buffer_head(bh);
        bh = NULL;
        goto errorout;
    }
    get_bh(bh);
 
    DEBUG(DL_BH, ("getblk: Vcb=%p bhcount=%u block=%u bh=%p ptr=%p.\n",
                  Vcb, atomic_read(&g_jbh.bh_count), block, bh, bh->b_data));
 
    ExAcquireResourceExclusiveLite(&bdev->bd_bh_lock, TRUE);
    /* do search again here */
    tbh = buffer_head_search(bdev, block);
    if (tbh) {
        get_bh(tbh);
        free_buffer_head(bh);
        bh = tbh;
        RemoveEntryList(&bh->b_link);
        InitializeListHead(&bh->b_link);
        ExReleaseResourceLite(&bdev->bd_bh_lock);
        goto errorout;
    } else {
        buffer_head_insert(bdev, bh);
    }
    ExReleaseResourceLite(&bdev->bd_bh_lock);
 
    /* we get it */
errorout:
 
    return bh;
}

Referenced by get_block_bh().

iget()

void iget

(

struct inode *

inode

)

Definition at line 987 of file linux.c.

{
    atomic_inc(&inode->i_count);
}

init_waitqueue_head()

void init_waitqueue_head

(

wait_queue_head_t *

q

)

Definition at line 115 of file linux.c.

{
    spin_lock_init(&q->lock);
    INIT_LIST_HEAD(&q->task_list);
}

Referenced by journal_init_common().

iput()

void iput

(

struct inode *

inode

)

Definition at line 992 of file linux.c.

{
    if (atomic_dec_and_test(&inode->i_count)) {
        kfree(inode);
    }
}

Referenced by Ext2RecoverJournal(), and journal_destroy().

kmem_cache_alloc()

void * kmem_cache_alloc	(	kmem_cache_t *	kc,
		int	flags
	)

Definition at line 92 of file linux.c.

{
    PVOID  ptr = NULL;
    ptr = ExAllocateFromNPagedLookasideList(&(kc->la));
    if (ptr) {
        atomic_inc(&kc->count);
        atomic_inc(&kc->acount);
    }
    return ptr;
}

Referenced by insert_revoke_hash(), journal_alloc_journal_head(), journal_init_revoke(), and new_buffer_head().

kmem_cache_create()

kmem_cache_t * kmem_cache_create	(	const char *	name,
		size_t	size,
		size_t	offset,
		unsigned long	flags,
		kmem_cache_cb_t	ctor
	)

Definition at line 48 of file linux.c.

{
    kmem_cache_t *kc = NULL;
 
    kc = kmalloc(sizeof(kmem_cache_t), GFP_KERNEL);
    if (kc == NULL) {
        goto errorout;
    }
 
    memset(kc, 0, sizeof(kmem_cache_t));
    ExInitializeNPagedLookasideList(
        &kc->la,
        NULL,
        NULL,
        0,
        size,
        'JBKC',
        0);
 
    kc->size = size;
    strncpy(kc->name, name, 31);
    kc->constructor = ctor;
 
errorout:
 
    return kc;
}

Referenced by ext2_init_bh(), Ext2InitializeVcb(), journal_init_handle_cache(), journal_init_journal_head_cache(), and journal_init_revoke_caches().

kmem_cache_destroy()

int kmem_cache_destroy

(

kmem_cache_t *

kc

)

Definition at line 82 of file linux.c.

{
    ASSERT(kc != NULL);
 
    ExDeleteNPagedLookasideList(&(kc->la));
    kfree(kc);
 
    return 0;
}

Referenced by ext2_destroy_bh(), Ext2DestroyVcb(), Ext2InitializeVcb(), journal_destroy_handle_cache(), journal_destroy_journal_head_cache(), journal_destroy_revoke_caches(), and journal_init_revoke_caches().

kmem_cache_free()

void kmem_cache_free	(	kmem_cache_t *	kc,
		void *	p
	)

Definition at line 103 of file linux.c.

{
    if (p) {
        atomic_dec(&kc->count);
        ExFreeToNPagedLookasideList(&(kc->la), p);
    }
}

Referenced by free_buffer_head(), journal_clear_revoke(), journal_destroy_revoke(), journal_free_journal_head(), journal_init_revoke(), and tcp_tw_put().

kzalloc()

void * kzalloc	(	int	size,
		int	flags
	)

Definition at line 34 of file linux.c.

{
    void *buffer = kmalloc(size, flags);
    if (buffer) {
        memset(buffer, 0, size);
    }
    return buffer;
}

Referenced by Ext2LoadGroup(), ext4_ext_split(), ext4_find_extent(), ext4_xattr_item_alloc(), and journal_init_common().

ll_rw_block()

void ll_rw_block	(	int	rw,
		int	nr,
		struct buffer_head *	bhs[]
	)

Definition at line 862 of file linux.c.

{
    int i;
 
    for (i = 0; i < nr; i++) {
 
        struct buffer_head *bh = bhs[i];
 
        if (rw == SWRITE)
            lock_buffer(bh);
        else if (test_set_buffer_locked(bh))
            continue;
 
        if (rw == WRITE || rw == SWRITE) {
            if (test_clear_buffer_dirty(bh)) {
                get_bh(bh);
                submit_bh(WRITE, bh);
                continue;
            }
        } else {
            if (!buffer_uptodate(bh)) {
                get_bh(bh);
                submit_bh(rw, bh);
                continue;
            }
        }
        unlock_buffer(bh);
    }
}

Referenced by __brelse(), bh_submit_read(), journal_get_superblock(), and journal_update_superblock().

mark_buffer_dirty()

void mark_buffer_dirty

(

struct buffer_head *

bh

)

Definition at line 914 of file linux.c.

{
    set_buffer_dirty(bh);
}

Referenced by __journal_temp_unlink_buffer(), do_one_pass(), Ext2CheckSetBlock(), Ext2FreeInode(), Ext2NewBlock(), Ext2NewInode(), Ext2SaveBlock(), Ext2SaveBuffer(), Ext2SaveGroup(), Ext2SetFileType(), Ext2ZeroBuffer(), ext4_init_block_bitmap(), ext4_init_inode_bitmap(), journal_convert_superblock_v1(), and journal_update_superblock().

new_buffer_head()

struct buffer_head * new_buffer_head

(

)

Definition at line 327 of file linux.c.

{
    struct buffer_head * bh = NULL;
    bh = kmem_cache_alloc(g_jbh.bh_cache, GFP_NOFS);
    if (bh) {
        atomic_inc(&g_jbh.bh_count);
        atomic_inc(&g_jbh.bh_acount);
 
        memset(bh, 0, sizeof(struct buffer_head));
        InitializeListHead(&bh->b_link);
        KeQuerySystemTime(&bh->b_ts_creat);
        DEBUG(DL_BH, ("bh=%p allocated.\n", bh));
        INC_MEM_COUNT(PS_BUFF_HEAD, bh, sizeof(struct buffer_head));
    }
 
    return bh;
}

Referenced by get_block_bh_mdl(), and get_block_bh_pin().

prepare_to_wait()

void prepare_to_wait	(	wait_queue_head_t *	q,
		wait_queue_t *	waiti,
		int	state
	)

Definition at line 212 of file linux.c.

{
    unsigned long flags;
    struct __wait_queue *wait = *waiti;
 
    wait->flags &= ~WQ_FLAG_EXCLUSIVE;
    spin_lock_irqsave(&q->lock, flags);
    if (list_empty(&wait->task_list))
        __add_wait_queue(q, wait);
    /*
     * don't alter the task state if this is just going to
     * queue an async wait queue callback
     */
    if (is_sync_wait(wait))
        set_current_state(state);
    spin_unlock_irqrestore(&q->lock, flags);
}

prepare_to_wait_exclusive()

void prepare_to_wait_exclusive	(	wait_queue_head_t *	q,
		wait_queue_t *	waiti,
		int	state
	)

Definition at line 231 of file linux.c.

{
    unsigned long flags;
    struct __wait_queue *wait = *waiti;
 
    wait->flags |= WQ_FLAG_EXCLUSIVE;
    spin_lock_irqsave(&q->lock, flags);
    if (list_empty(&wait->task_list))
        __add_wait_queue_tail(q, wait);
    /*
     * don't alter the task state if this is just going to
      * queue an async wait queue callback
     */
    if (is_sync_wait(wait))
        set_current_state(state);
    spin_unlock_irqrestore(&q->lock, flags);
}

remove_wait_queue()

void remove_wait_queue	(	wait_queue_head_t *	q,
		wait_queue_t *	waiti
	)

Definition at line 189 of file linux.c.

{
    unsigned long flags;
    struct __wait_queue *wait = *waiti;
 
    spin_lock_irqsave(&q->lock, flags);
    __remove_wait_queue(q, wait);
    spin_unlock_irqrestore(&q->lock, flags);
}

submit_bh()

int submit_bh	(	int	rw,
		struct buffer_head *	bh
	)

Definition at line 792 of file linux.c.

{
    return submit_bh_pin(rw, bh);
}

Referenced by ll_rw_block(), and sync_dirty_buffer().

submit_bh_mdl()

int submit_bh_mdl	(	int	rw,
		struct buffer_head *	bh
	)

Definition at line 551 of file linux.c.

{
    struct block_device *bdev = bh->b_bdev;
    PEXT2_VCB            Vcb  = bdev->bd_priv;
    PBCB                 Bcb;
    PVOID                Buffer;
    LARGE_INTEGER        Offset;
 
    ASSERT(Vcb->Identifier.Type == EXT2VCB);
    ASSERT(bh->b_data);
 
    if (rw == WRITE) {
 
        if (IsVcbReadOnly(Vcb)) {
            goto errorout;
        }
 
        SetFlag(Vcb->Volume->Flags, FO_FILE_MODIFIED);
        Offset.QuadPart = ((LONGLONG)bh->b_blocknr) << BLOCK_BITS;
 
        /* PIN_EXCLUSIVE disabled, likely to deadlock with volume operations */
        if (CcPreparePinWrite(
                    Vcb->Volume,
                    &Offset,
                    BLOCK_SIZE,
                    FALSE,
                    PIN_WAIT /* | PIN_EXCLUSIVE */,
                    &Bcb,
                    &Buffer )) {
#if 0
            if (memcmp(Buffer, bh->b_data, BLOCK_SIZE) != 0) {
                DbgBreak();
            }
            memmove(Buffer, bh->b_data, BLOCK_SIZE);
#endif
            CcSetDirtyPinnedData(Bcb, NULL);
            Ext2AddBlockExtent( Vcb, NULL,
                                (ULONG)bh->b_blocknr,
                                (ULONG)bh->b_blocknr,
                                (bh->b_size >> BLOCK_BITS));
            CcUnpinData(Bcb);
        } else {
 
            Ext2AddBlockExtent( Vcb, NULL,
                                (ULONG)bh->b_blocknr,
                                (ULONG)bh->b_blocknr,
                                (bh->b_size >> BLOCK_BITS));
        }
 
    } else {
    }
 
errorout:
 
    unlock_buffer(bh);
    put_bh(bh);
    return 0;
}

submit_bh_pin()

int submit_bh_pin	(	int	rw,
		struct buffer_head *	bh
	)

Definition at line 727 of file linux.c.

{
    struct block_device *bdev = bh->b_bdev;
    PEXT2_VCB            Vcb  = bdev->bd_priv;
    PVOID                Buffer;
    LARGE_INTEGER        Offset;
 
    ASSERT(Vcb->Identifier.Type == EXT2VCB);
    ASSERT(bh->b_data && bh->b_bcb);
 
    if (rw == WRITE) {
 
        if (IsVcbReadOnly(Vcb)) {
            goto errorout;
        }
 
        SetFlag(Vcb->Volume->Flags, FO_FILE_MODIFIED);
        Offset.QuadPart = ((LONGLONG)bh->b_blocknr) << BLOCK_BITS;
 
        CcSetDirtyPinnedData(bh->b_bcb, NULL);
        Ext2AddBlockExtent( Vcb, NULL,
                            (ULONG)bh->b_blocknr,
                            (ULONG)bh->b_blocknr,
                            (bh->b_size >> BLOCK_BITS));
    } else {
    }
 
errorout:
 
    unlock_buffer(bh);
    put_bh(bh);
    return 0;
}

Referenced by submit_bh().

sync_blockdev()

int sync_blockdev

(

struct block_device *

bdev

)

Definition at line 919 of file linux.c.

{
    PEXT2_VCB Vcb = (PEXT2_VCB) bdev->bd_priv;
    Ext2FlushVolume(NULL, Vcb, FALSE);
    return 0;
}

Referenced by Ext2RecoverJournal(), and journal_recover().

sync_dirty_buffer()

int sync_dirty_buffer

(

struct buffer_head *

bh

)

Definition at line 898 of file linux.c.

{
    int ret = 0;
 
    ASSERT(atomic_read(&bh->b_count) <= 1);
    lock_buffer(bh);
    if (test_clear_buffer_dirty(bh)) {
        get_bh(bh);
        ret = submit_bh(WRITE, bh);
        wait_on_buffer(bh);
    } else {
        unlock_buffer(bh);
    }
    return ret;
}

Referenced by journal_convert_superblock_v1(), and journal_update_superblock().

unlock_buffer()

void unlock_buffer

(

struct buffer_head *

bh

)

Definition at line 853 of file linux.c.

{
    clear_buffer_locked(bh);
}

Referenced by do_one_pass(), journal_get_descriptor_buffer(), ll_rw_block(), submit_bh_mdl(), submit_bh_pin(), and sync_dirty_buffer().

wait_queue_create()

struct __wait_queue * wait_queue_create

(

)

Definition at line 122 of file linux.c.

{
    struct __wait_queue * wait = NULL;
    wait = kmalloc(sizeof(struct __wait_queue), GFP_KERNEL);
    if (!wait) {
        return NULL;
    }
 
    memset(wait, 0, sizeof(struct __wait_queue));
    wait->flags = WQ_FLAG_AUTO_REMOVAL;
    wait->private = (void *)KeGetCurrentThread();
    INIT_LIST_HEAD(&wait->task_list);
    KeInitializeEvent(&(wait->event),
                      SynchronizationEvent,
                      FALSE);
 
    return wait;
}

wait_queue_destroy()

void wait_queue_destroy

(

struct __wait_queue *

wait

)

Definition at line 142 of file linux.c.

{
    kfree(wait);
}

Referenced by finish_wait().

wake_up()

int wake_up

(

wait_queue_head_t *

queue

)

Definition at line 279 of file linux.c.

{
    return 0; /* KeSetEvent(&wait->event, 0, FALSE); */
}

Referenced by __log_start_commit().

Variable Documentation

current

struct task_struct* current = &current_task

Definition at line 32 of file linux.c.

Referenced by _initterm(), _RTC_CheckStackVars2(), _svcauth_des(), apply_patch(), reverse_bidirectional_iterator< _BidirectionalIterator, _Tp,, _STLP_DFL_TYPE_PARAM >::base(), CcRosCreateVacb(), CcRosFlushDirtyPages(), CcRosFreeOneUnusedVacb(), CcRosGetVacb(), CcRosLookupVacb(), CcRosTraceCacheMap(), CcRosTrimCache(), cfgets(), check_access(), check_rr_dates(), check_sharing(), FxTagTracker::CheckForAbandondedTags(), chmc_section_lookup(), ConSrvConsoleProcessCtrlEvent(), ConSrvGetConsoleProcessList(), ConSrvSetConsoleProcessFocus(), context_set_pixel_format(), convertHexToHexCSV(), cs_txt(), ddraw_surface7_Flip(), DelOld(), DwDecodeSleb128(), DwDecodeUleb128(), EDIT_PaintText(), enable_allowed_controls(), enumx_Next(), enumx_Skip(), TTelnetHandler::escapeIAC(), FDICopy(), file_add(), FT_GlyphLoader_Add(), FT_GlyphLoader_Adjust_Points(), FT_GlyphLoader_Adjust_Subglyphs(), FT_GlyphLoader_CheckPoints(), FT_GlyphLoader_CheckSubGlyphs(), FT_GlyphLoader_Prepare(), FT_GlyphLoader_Rewind(), get_input_bytes(), HEXEDIT_PaintLines(), HUF_readCTable(), HUF_readDTableX1_wksp(), HUF_readDTableX2_wksp(), HUF_sort(), IMAPIPROP_GetValue(), insertIntoTree(), InsNew(), IPropData_fnGetPropList(), IPropData_fnRelease(), join_modify_update(), mallocspy_is_allocation_spyed(), MmFindRegion(), MsfsCreate(), MsfsCreateMailslot(), mystrrchr(), CExplorerBand::NavigateToPIDL(), np_enum(), reverse_bidirectional_iterator< _BidirectionalIterator, _Tp,, _STLP_DFL_TYPE_PARAM >::operator*(), reverse_bidirectional_iterator< _BidirectionalIterator, _Tp,, _STLP_DFL_TYPE_PARAM >::operator++(), reverse_bidirectional_iterator< _BidirectionalIterator, _Tp,, _STLP_DFL_TYPE_PARAM >::operator--(), ReadCommand(), RPCRT4_RemoveThreadContextHandle(), Save(), TScroller::ScrollBack(), set_parse_status(), SetPixelFormat(), settime_how(), skip_input_bytes(), Sort(), START_TEST(), surface_load_drawable(), SYSLINK_ParseText(), test_EM_GETHANDLE(), test_GetTimeZoneInformation(), test_locking(), test_media_event(), test_one(), test_PBM_STEPIT(), test_try_transform(), test_ZombifyActCtx(), TOOLTIPS_Show(), TransactedSnapshotImpl_FindNextChild(), triangulate(), TT_Process_Composite_Component(), UDFDOSName100(), UDFDOSName200(), UDFDOSName201(), validate_patch(), validate_state_table(), VARIANT_MakeDate(), wined3d_texture_load_location(), xdrrec_getbytes(), xdrrec_putbytes(), xmlParseAttValueComplex(), xmlStringLenDecodeEntities(), xsltAddKey(), xsltApplyStripSpaces(), xsltCompilePatternInternal(), ZSTD_buildSeqStore(), ZSTD_compressBlock_btultra2(), ZSTD_compressBlock_doubleFast_extDict_generic(), ZSTD_compressBlock_doubleFast_generic(), ZSTD_compressBlock_fast_dictMatchState_generic(), ZSTD_compressBlock_fast_extDict_generic(), ZSTD_compressBlock_fast_generic(), ZSTD_compressBlock_lazy_extDict_generic(), ZSTD_compressBlock_lazy_generic(), ZSTD_DUBT_findBestMatch(), ZSTD_DUBT_findBetterDictMatch(), ZSTD_fillDoubleHashTable(), ZSTD_fillHashTable(), ZSTD_HcFindBestMatch_generic(), ZSTD_insertBt1(), ZSTD_insertBtAndGetAllMatches(), ZSTD_insertDUBT1(), ZSTD_ldm_generateSequences_internal(), ZSTD_ldm_limitTableUpdate(), ZSTD_window_needOverflowCorrection(), and FxTagTracker::~FxTagTracker().

current_task

struct task_struct current_task

Initial value:

= {
     0,
     1,
     "current\0",
     NULL
}

Definition at line 26 of file linux.c.

Ext2Global

PEXT2_GLOBAL Ext2Global

extern

Definition at line 16 of file init.c.

Referenced by __brelse().

g_jbh

struct _EXT2_BUFFER_HEAD g_jbh = {NULL, ATOMIC_INIT(0)}

Referenced by __brelse(), ext2_destroy_bh(), ext2_init_bh(), free_buffer_head(), get_block_bh_mdl(), get_block_bh_pin(), and new_buffer_head().