ialloc.c

Go to the documentation of this file.

/*
 *  linux/fs/sysv/ialloc.c
 *
 *  minix/bitmap.c
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  ext/freelists.c
 *  Copyright (C) 1992  Remy Card ([email protected])
 *
 *  xenix/alloc.c
 *  Copyright (C) 1992  Doug Evans
 *
 *  coh/alloc.c
 *  Copyright (C) 1993  Pascal Haible, Bruno Haible
 *
 *  sysv/ialloc.c
 *  Copyright (C) 1993  Bruno Haible
 *
 *  This file contains code for allocating/freeing inodes.
 */

#include <linux/kernel.h>
#include <linux/stddef.h>
#include <linux/sched.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/buffer_head.h>
#include <linux/writeback.h>
#include "sysv.h"

/* We don't trust the value of
   sb->sv_sbd2->s_tinode = *sb->sv_sb_total_free_inodes
   but we nevertheless keep it up to date. */

/* An inode on disk is considered free if both i_mode == 0 and i_nlink == 0. */

/* return &sb->sv_sb_fic_inodes[i] = &sbd->s_inode[i]; */
static inline sysv_ino_t *
sv_sb_fic_inode(struct super_block * sb, unsigned int i)
{
    struct sysv_sb_info *sbi = SYSV_SB(sb);

    if (sbi->s_bh1 == sbi->s_bh2)
        return &sbi->s_sb_fic_inodes[i];
    else {
        /* 512 byte Xenix FS */
        unsigned int offset = offsetof(struct xenix_super_block, s_inode[i]);
        if (offset < 512)
            return (sysv_ino_t*)(sbi->s_sbd1 + offset);
        else
            return (sysv_ino_t*)(sbi->s_sbd2 + offset);
    }
}

struct sysv_inode *
sysv_raw_inode(struct super_block *sb, unsigned ino, struct buffer_head **bh)
{
    struct sysv_sb_info *sbi = SYSV_SB(sb);
    struct sysv_inode *res;
    int block = sbi->s_firstinodezone + sbi->s_block_base;

    block += (ino-1) >> sbi->s_inodes_per_block_bits;
    *bh = sb_bread(sb, block);
    if (!*bh)
        return NULL;
    res = (struct sysv_inode *)(*bh)->b_data;
    return res + ((ino-1) & sbi->s_inodes_per_block_1);
}

static int refill_free_cache(struct super_block *sb)
{
    struct sysv_sb_info *sbi = SYSV_SB(sb);
    struct buffer_head * bh;
    struct sysv_inode * raw_inode;
    int i = 0, ino;

    ino = SYSV_ROOT_INO+1;
    raw_inode = sysv_raw_inode(sb, ino, &bh);
    if (!raw_inode)
        goto out;
    while (ino <= sbi->s_ninodes) {
        if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0) {
            *sv_sb_fic_inode(sb,i++) = cpu_to_fs16(SYSV_SB(sb), ino);
            if (i == sbi->s_fic_size)
                break;
        }
        if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
            brelse(bh);
            raw_inode = sysv_raw_inode(sb, ino, &bh);
            if (!raw_inode)
                goto out;
        } else
            raw_inode++;
    }
    brelse(bh);
out:
    return i;
}

void sysv_free_inode(struct inode * inode)
{
    struct super_block *sb = inode->i_sb;
    struct sysv_sb_info *sbi = SYSV_SB(sb);
    unsigned int ino;
    struct buffer_head * bh;
    struct sysv_inode * raw_inode;
    unsigned count;

    sb = inode->i_sb;
    ino = inode->i_ino;
    if (ino <= SYSV_ROOT_INO || ino > sbi->s_ninodes) {
        printk("sysv_free_inode: inode 0,1,2 or nonexistent inode\n");
        return;
    }
    raw_inode = sysv_raw_inode(sb, ino, &bh);
    if (!raw_inode) {
        printk("sysv_free_inode: unable to read inode block on device "
               "%s\n", inode->i_sb->s_id);
        return;
    }
    mutex_lock(&sbi->s_lock);
    count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count);
    if (count < sbi->s_fic_size) {
        *sv_sb_fic_inode(sb,count++) = cpu_to_fs16(sbi, ino);
        *sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
    }
    fs16_add(sbi, sbi->s_sb_total_free_inodes, 1);
    dirty_sb(sb);
    memset(raw_inode, 0, sizeof(struct sysv_inode));
    mark_buffer_dirty(bh);
    mutex_unlock(&sbi->s_lock);
    brelse(bh);
}

struct inode * sysv_new_inode(const struct inode * dir, umode_t mode)
{
    struct super_block *sb = dir->i_sb;
    struct sysv_sb_info *sbi = SYSV_SB(sb);
    struct inode *inode;
    sysv_ino_t ino;
    unsigned count;
    struct writeback_control wbc = {
        .sync_mode = WB_SYNC_NONE
    };

    inode = new_inode(sb);
    if (!inode)
        return ERR_PTR(-ENOMEM);

    mutex_lock(&sbi->s_lock);
    count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count);
    if (count == 0 || (*sv_sb_fic_inode(sb,count-1) == 0)) {
        count = refill_free_cache(sb);
        if (count == 0) {
            iput(inode);
            mutex_unlock(&sbi->s_lock);
            return ERR_PTR(-ENOSPC);
        }
    }
    /* Now count > 0. */
    ino = *sv_sb_fic_inode(sb,--count);
    *sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
    fs16_add(sbi, sbi->s_sb_total_free_inodes, -1);
    dirty_sb(sb);
    inode_init_owner(inode, dir, mode);
    inode->i_ino = fs16_to_cpu(sbi, ino);
    inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
    inode->i_blocks = 0;
    memset(SYSV_I(inode)->i_data, 0, sizeof(SYSV_I(inode)->i_data));
    SYSV_I(inode)->i_dir_start_lookup = 0;
    insert_inode_hash(inode);
    mark_inode_dirty(inode);

    sysv_write_inode(inode, &wbc);  /* ensure inode not allocated again */
    mark_inode_dirty(inode);    /* cleared by sysv_write_inode() */
    /* That's it. */
    mutex_unlock(&sbi->s_lock);
    return inode;
}

unsigned long sysv_count_free_inodes(struct super_block * sb)
{
    struct sysv_sb_info *sbi = SYSV_SB(sb);
    struct buffer_head * bh;
    struct sysv_inode * raw_inode;
    int ino, count, sb_count;

    mutex_lock(&sbi->s_lock);

    sb_count = fs16_to_cpu(sbi, *sbi->s_sb_total_free_inodes);

    if (0)
        goto trust_sb;

    /* this causes a lot of disk traffic ... */
    count = 0;
    ino = SYSV_ROOT_INO+1;
    raw_inode = sysv_raw_inode(sb, ino, &bh);
    if (!raw_inode)
        goto Eio;
    while (ino <= sbi->s_ninodes) {
        if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0)
            count++;
        if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
            brelse(bh);
            raw_inode = sysv_raw_inode(sb, ino, &bh);
            if (!raw_inode)
                goto Eio;
        } else
            raw_inode++;
    }
    brelse(bh);
    if (count != sb_count)
        goto Einval;
out:
    mutex_unlock(&sbi->s_lock);
    return count;

Einval:
    printk("sysv_count_free_inodes: "
        "free inode count was %d, correcting to %d\n",
        sb_count, count);
    if (!(sb->s_flags & MS_RDONLY)) {
        *sbi->s_sb_total_free_inodes = cpu_to_fs16(SYSV_SB(sb), count);
        dirty_sb(sb);
    }
    goto out;

Eio:
    printk("sysv_count_free_inodes: unable to read inode table\n");
trust_sb:
    count = sb_count;
    goto out;
}