revoke.c File Reference

#include "jfs_user.h"
#include <linux/log2.h>

Include dependency graph for revoke.c:

Go to the source code of this file.

Classes
struct	jbd_revoke_record_s
struct	jbd_revoke_table_s

Functions
static int	hash (journal_t *journal, unsigned long block)
static int	insert_revoke_hash (journal_t *journal, unsigned long blocknr, tid_t seq)
static struct jbd_revoke_record_s *	find_revoke_record (journal_t *journal, unsigned long blocknr)
int __init	journal_init_revoke_caches (void)
void	journal_destroy_revoke_caches (void)
int	journal_init_revoke (journal_t *journal, int hash_size)
void	journal_destroy_revoke (journal_t *journal)
int	journal_set_revoke (journal_t *journal, unsigned long blocknr, tid_t sequence)
int	journal_test_revoke (journal_t *journal, unsigned long blocknr, tid_t sequence)
void	journal_clear_revoke (journal_t *journal)

Variables
static struct kmem_cache *	revoke_record_cache = NULL
static struct kmem_cache *	revoke_table_cache = NULL

Function Documentation

find_revoke_record()

static struct jbd_revoke_record_s * find_revoke_record ( journal_t *  journal, unsigned long  blocknr  )

static

Definition at line 149 of file revoke.c.

{
    struct list_head *hash_list;
    struct jbd_revoke_record_s *record;
 
    hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];
 
    jbd_lock(&journal->j_revoke_lock);
    record = (struct jbd_revoke_record_s *) hash_list->next;
    while (&(record->hash) != hash_list) {
        if (record->blocknr == blocknr) {
            jbd_unlock(&journal->j_revoke_lock);
            return record;
        }
        record = (struct jbd_revoke_record_s *) record->hash.next;
    }
    jbd_unlock(&journal->j_revoke_lock);
    return NULL;
}

Referenced by journal_set_revoke(), and journal_test_revoke().

hash()

static int hash ( journal_t *  journal, unsigned long  block  )

inlinestatic

Definition at line 109 of file revoke.c.

{
    struct jbd_revoke_table_s *table = journal->j_revoke;
    int hash_shift = table->hash_shift;
 
    return ((block << (hash_shift - 6)) ^
            (block >> 13) ^
            (block << (hash_shift - 12))) & (table->hash_size - 1);
}

insert_revoke_hash()

static int insert_revoke_hash ( journal_t *  journal, unsigned long  blocknr, tid_t  seq  )

static

Definition at line 119 of file revoke.c.

{
    struct list_head *hash_list;
    struct jbd_revoke_record_s *record;
 
repeat:
    record = (struct jbd_revoke_record_s *)
             kmem_cache_alloc(revoke_record_cache, GFP_NOFS);
    if (!record)
        goto oom;
 
    record->sequence = seq;
    record->blocknr = blocknr;
    hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];
    jbd_lock(&journal->j_revoke_lock);
    list_add(&record->hash, hash_list);
    jbd_unlock(&journal->j_revoke_lock);
    return 0;
 
oom:
    if (!journal_oom_retry)
        return -ENOMEM;
    jbd_debug(1, "ENOMEM in %s, retrying\n", __FUNCTION__);
    yield();
    goto repeat;
}

Referenced by journal_set_revoke().

journal_clear_revoke()

void journal_clear_revoke

(

journal_t *

journal

)

Definition at line 689 of file revoke.c.

{
    int i;
    struct list_head *hash_list;
    struct jbd_revoke_record_s *record;
    struct jbd_revoke_table_s *revoke;
 
    revoke = journal->j_revoke;
 
    for (i = 0; i < revoke->hash_size; i++) {
        hash_list = &revoke->hash_table[i];
        while (!list_empty(hash_list)) {
            record = (struct jbd_revoke_record_s*) hash_list->next;
            list_del(&record->hash);
            kmem_cache_free(revoke_record_cache, record);
        }
    }
}

Referenced by journal_recover().

journal_destroy_revoke()

void journal_destroy_revoke

(

journal_t *

journal

)

Definition at line 271 of file revoke.c.

{
    struct jbd_revoke_table_s *table;
    struct list_head *hash_list;
    int i;
 
    table = journal->j_revoke_table[0];
    if (!table)
        return;
 
    for (i=0; i<table->hash_size; i++) {
        hash_list = &table->hash_table[i];
        J_ASSERT (list_empty(hash_list));
    }
 
    kfree(table->hash_table);
    kmem_cache_free(revoke_table_cache, table);
    journal->j_revoke = NULL;
 
    table = journal->j_revoke_table[1];
    if (!table)
        return;
 
    for (i=0; i<table->hash_size; i++) {
        hash_list = &table->hash_table[i];
        J_ASSERT (list_empty(hash_list));
    }
 
    kfree(table->hash_table);
    kmem_cache_free(revoke_table_cache, table);
    journal->j_revoke = NULL;
}

Referenced by journal_destroy(), and journal_init_inode().

journal_destroy_revoke_caches()

void journal_destroy_revoke_caches

(

void

)

Definition at line 191 of file revoke.c.

{
    kmem_cache_destroy(revoke_record_cache);
    revoke_record_cache = NULL;
    kmem_cache_destroy(revoke_table_cache);
    revoke_table_cache = NULL;
}

Referenced by journal_destroy_caches().

journal_init_revoke()

int journal_init_revoke	(	journal_t *	journal,
		int	hash_size
	)

Definition at line 201 of file revoke.c.

{
    int shift, tmp;
 
    J_ASSERT (journal->j_revoke_table[0] == NULL);
 
    shift = 0;
    tmp = hash_size;
    while ((tmp >>= 1UL) != 0UL)
        shift++;
 
    journal->j_revoke_table[0] = kmem_cache_alloc(revoke_table_cache, GFP_KERNEL);
    if (!journal->j_revoke_table[0])
        return -ENOMEM;
    journal->j_revoke = journal->j_revoke_table[0];
 
    /* Check that the hash_size is a power of two */
    J_ASSERT(is_power_of_2(hash_size));
 
    journal->j_revoke->hash_size = hash_size;
 
    journal->j_revoke->hash_shift = shift;
 
    journal->j_revoke->hash_table =
        kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL);
    if (!journal->j_revoke->hash_table) {
        kmem_cache_free(revoke_table_cache, journal->j_revoke_table[0]);
        journal->j_revoke = NULL;
        return -ENOMEM;
    }
 
    for (tmp = 0; tmp < hash_size; tmp++)
        INIT_LIST_HEAD(&journal->j_revoke->hash_table[tmp]);
 
    journal->j_revoke_table[1] = kmem_cache_alloc(revoke_table_cache, GFP_KERNEL);
    if (!journal->j_revoke_table[1]) {
        kfree(journal->j_revoke_table[0]->hash_table);
        kmem_cache_free(revoke_table_cache, journal->j_revoke_table[0]);
        return -ENOMEM;
    }
 
    journal->j_revoke = journal->j_revoke_table[1];
 
    /* Check that the hash_size is a power of two */
    J_ASSERT(is_power_of_2(hash_size));
 
    journal->j_revoke->hash_size = hash_size;
 
    journal->j_revoke->hash_shift = shift;
 
    journal->j_revoke->hash_table =
        kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL);
    if (!journal->j_revoke->hash_table) {
        kfree(journal->j_revoke_table[0]->hash_table);
        kmem_cache_free(revoke_table_cache, journal->j_revoke_table[0]);
        kmem_cache_free(revoke_table_cache, journal->j_revoke_table[1]);
        journal->j_revoke = NULL;
        return -ENOMEM;
    }
 
    for (tmp = 0; tmp < hash_size; tmp++)
        INIT_LIST_HEAD(&journal->j_revoke->hash_table[tmp]);
 
    jbd_lock_init(&journal->j_revoke_lock);
 
    return 0;
}

Referenced by journal_init_common().

journal_init_revoke_caches()

int __init journal_init_revoke_caches

(

void

)

Definition at line 170 of file revoke.c.

{
    revoke_record_cache = kmem_cache_create("revoke_record",
                                            sizeof(struct jbd_revoke_record_s),
                                            0,
                                            SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY,
                                            NULL);
    if (revoke_record_cache == 0)
        return -ENOMEM;
 
    revoke_table_cache = kmem_cache_create("revoke_table",
                                           sizeof(struct jbd_revoke_table_s),
                                           0, SLAB_TEMPORARY, NULL);
    if (revoke_table_cache == 0) {
        kmem_cache_destroy(revoke_record_cache);
        revoke_record_cache = NULL;
        return -ENOMEM;
    }
    return 0;
}

Referenced by journal_init_caches().

journal_set_revoke()

int journal_set_revoke	(	journal_t *	journal,
		unsigned long	blocknr,
		tid_t	sequence
	)

Definition at line 646 of file revoke.c.

{
    struct jbd_revoke_record_s *record;
 
    record = find_revoke_record(journal, blocknr);
    if (record) {
        /* If we have multiple occurrences, only record the
         * latest sequence number in the hashed record */
        if (tid_gt(sequence, record->sequence))
            record->sequence = sequence;
        return 0;
    }
    return insert_revoke_hash(journal, blocknr, sequence);
}

Referenced by scan_revoke_records().

journal_test_revoke()

int journal_test_revoke	(	journal_t *	journal,
		unsigned long	blocknr,
		tid_t	sequence
	)

Definition at line 670 of file revoke.c.

{
    struct jbd_revoke_record_s *record;
 
    record = find_revoke_record(journal, blocknr);
    if (!record)
        return 0;
    if (tid_gt(sequence, record->sequence))
        return 0;
    return 1;
}

Referenced by do_one_pass().

Variable Documentation

revoke_record_cache

struct kmem_cache* revoke_record_cache = NULL

static

Definition at line 73 of file revoke.c.

Referenced by insert_revoke_hash(), journal_clear_revoke(), journal_destroy_revoke_caches(), and journal_init_revoke_caches().

revoke_table_cache

struct kmem_cache* revoke_table_cache = NULL

static

Definition at line 74 of file revoke.c.

Referenced by journal_destroy_revoke(), journal_destroy_revoke_caches(), journal_init_revoke(), and journal_init_revoke_caches().