Subversion Repositories or1k

/*

 *  linux/fs/sysv/balloc.c

 *

 *  minix/bitmap.c

 *  Copyright (C) 1991, 1992  Linus Torvalds

 *

 *  ext/freelists.c

 *  Copyright (C) 1992  Remy Card (card@masi.ibp.fr)

 *

 *  xenix/alloc.c

 *  Copyright (C) 1992  Doug Evans

 *

 *  coh/alloc.c

 *  Copyright (C) 1993  Pascal Haible, Bruno Haible

 *

 *  sysv/balloc.c

 *  Copyright (C) 1993  Bruno Haible

 *

 *  This file contains code for allocating/freeing blocks.

 */

#include <linux/fs.h>

#include <linux/sysv_fs.h>

#include <linux/locks.h>

/* We don't trust the value of

   sb->sv_sbd2->s_tfree = *sb->sv_free_blocks

   but we nevertheless keep it up to date. */

static inline u32 *get_chunk(struct super_block *sb, struct buffer_head *bh)

{

        char *bh_data = bh->b_data;

        if (sb->sv_type == FSTYPE_SYSV4)

                return (u32*)(bh_data+4);

        else

                return (u32*)(bh_data+2);

}

/* NOTE NOTE NOTE: nr is a block number _as_ _stored_ _on_ _disk_ */

void sysv_free_block(struct super_block * sb, u32 nr)

{

        struct buffer_head * bh;

        u32 *blocks = sb->sv_bcache;

        unsigned count;

        unsigned block = fs32_to_cpu(sb, nr);

        /*

         * This code does not work at all for AFS (it has a bitmap

         * free list).  As AFS is supposed to be read-only no one

         * should call this for an AFS filesystem anyway...

         */

        if (sb->sv_type == FSTYPE_AFS)

                return;

        if (block < sb->sv_firstdatazone || block >= sb->sv_nzones) {

                printk("sysv_free_block: trying to free block not in datazone\n");

                return;

        }

        lock_super(sb);

        count = fs16_to_cpu(sb, *sb->sv_bcache_count);

        if (count > sb->sv_flc_size) {

                printk("sysv_free_block: flc_count > flc_size\n");

                unlock_super(sb);

                return;

        }

        /* If the free list head in super-block is full, it is copied

         * into this block being freed, ditto if it's completely empty

         * (applies only on Coherent).

         */

        if (count == sb->sv_flc_size || count == 0) {

                block += sb->sv_block_base;

                bh = sb_getblk(sb, block);

                if (!bh) {

                        printk("sysv_free_block: getblk() failed\n");

                        unlock_super(sb);

                        return;

                }

                memset(bh->b_data, 0, sb->s_blocksize);

                *(u16*)bh->b_data = cpu_to_fs16(sb, count);

                memcpy(get_chunk(sb,bh), blocks, count * sizeof(sysv_zone_t));

                mark_buffer_dirty(bh);

                mark_buffer_uptodate(bh, 1);

                brelse(bh);

                count = 0;

        }

        sb->sv_bcache[count++] = nr;

        *sb->sv_bcache_count = cpu_to_fs16(sb, count);

        fs32_add(sb, sb->sv_free_blocks, 1);

        dirty_sb(sb);

        unlock_super(sb);

}

u32 sysv_new_block(struct super_block * sb)

{

        unsigned int block;

        u32 nr;

        struct buffer_head * bh;

        unsigned count;

        lock_super(sb);

        count = fs16_to_cpu(sb, *sb->sv_bcache_count);

        if (count == 0) /* Applies only to Coherent FS */

                goto Enospc;

        nr = sb->sv_bcache[--count];

        if (nr == 0)  /* Applies only to Xenix FS, SystemV FS */

                goto Enospc;

        block = fs32_to_cpu(sb, nr);

        *sb->sv_bcache_count = cpu_to_fs16(sb, count);

        if (block < sb->sv_firstdatazone || block >= sb->sv_nzones) {

                printk("sysv_new_block: new block %d is not in data zone\n",

                        block);

                goto Enospc;

        }

        if (count == 0) { /* the last block continues the free list */

                unsigned count;

                block += sb->sv_block_base;

                if (!(bh = sb_bread(sb, block))) {

                        printk("sysv_new_block: cannot read free-list block\n");

                        /* retry this same block next time */

                        *sb->sv_bcache_count = cpu_to_fs16(sb, 1);

                        goto Enospc;

                }

                count = fs16_to_cpu(sb, *(u16*)bh->b_data);

                if (count > sb->sv_flc_size) {

                        printk("sysv_new_block: free-list block with >flc_size entries\n");

                        brelse(bh);

                        goto Enospc;

                }

                *sb->sv_bcache_count = cpu_to_fs16(sb, count);

                memcpy(sb->sv_bcache, get_chunk(sb, bh),

                                count * sizeof(sysv_zone_t));

                brelse(bh);

        }

        /* Now the free list head in the superblock is valid again. */

        fs32_add(sb, sb->sv_free_blocks, -1);

        dirty_sb(sb);

        unlock_super(sb);

        return nr;

Enospc:

        unlock_super(sb);

        return 0;

}

unsigned long sysv_count_free_blocks(struct super_block * sb)

{

        int sb_count;

        int count;

        struct buffer_head * bh = NULL;

        u32 *blocks;

        unsigned block;

        int n;

        /*

         * This code does not work at all for AFS (it has a bitmap

         * free list).  As AFS is supposed to be read-only we just

         * lie and say it has no free block at all.

         */

        if (sb->sv_type == FSTYPE_AFS)

                return 0;

        lock_super(sb);

        sb_count = fs32_to_cpu(sb, *sb->sv_free_blocks);

        if (0)

                goto trust_sb;

        /* this causes a lot of disk traffic ... */

        count = 0;

        n = fs16_to_cpu(sb, *sb->sv_bcache_count);

        blocks = sb->sv_bcache;

        while (1) {

                if (n > sb->sv_flc_size)

                        goto E2big;

                block = 0;

                while (n && (block = blocks[--n]) != 0)

                        count++;

                if (block == 0)

                        break;

                block = fs32_to_cpu(sb, block);

                if (bh)

                        brelse(bh);

                if (block < sb->sv_firstdatazone || block >= sb->sv_nzones)

                        goto Einval;

                block += sb->sv_block_base;

                bh = sb_bread(sb, block);

                if (!bh)

                        goto Eio;

                n = fs16_to_cpu(sb, *(u16*)bh->b_data);

                blocks = get_chunk(sb, bh);

        }

        if (bh)

                brelse(bh);

        if (count != sb_count)

                goto Ecount;

done:

        unlock_super(sb);

        return count;

Einval:

        printk("sysv_count_free_blocks: new block %d is not in data zone\n",

                block);

        goto trust_sb;

Eio:

        printk("sysv_count_free_blocks: cannot read free-list block\n");

        goto trust_sb;

E2big:

        printk("sysv_count_free_blocks: >flc_size entries in free-list block\n");

        if (bh)

                brelse(bh);

trust_sb:

        count = sb_count;

        goto done;

Ecount:

        printk("sysv_count_free_blocks: free block count was %d, "

                "correcting to %d\n", sb_count, count);

        if (!(sb->s_flags & MS_RDONLY)) {

                *sb->sv_free_blocks = cpu_to_fs32(sb, count);

                dirty_sb(sb);

        }

        goto done;

}