lkml.org 
[lkml]   [2002]   [Apr]   [29]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[PATCH] sysvfs updates

    You can import this changeset into BK by piping this whole message to:
    '| bk receive [path to repository]' or apply the patch as usual.

    ===================================================================


    ChangeSet@1.548, 2002-04-29 13:03:14+02:00, hch@sb.bsdonline.org
    Merge 2.5.11 into sysvfs development tree

    ChangeSet@1.531.7.2, 2002-04-19 17:34:40+02:00, hch@sb.bsdonline.org
    sysvfs: V7 uses 512 byte blocks, not 1Kb.

    ChangeSet@1.531.7.1, 2002-04-18 21:08:51+02:00, hch@sb.bsdonline.org
    Merge sb.bsdonline.org://repo/linux-2.5
    into sb.bsdonline.org:/repo/linux-2.5-sysvfs

    ChangeSet@1.456.6.1, 2002-04-10 21:47:01+02:00, hch@sb.bsdonline.org
    Merge sb.bsdonline.org:/repo/linux-2.5
    into sb.bsdonline.org:/repo/linux-2.5-sysvfs

    ChangeSet@1.369.130.1, 2002-04-08 18:14:21+02:00, hch@sb.bsdonline.org
    Merge hkernel@hkernel.bkbits.net:linux-2.5-sysvfs
    into sb.bsdonline.org:/repo/linux-2.5-sysvfs

    ChangeSet@1.369.115.1, 2002-04-04 18:43:00+02:00, hch@sb.bsdonline.org
    Merge sb.bsdonline.org:/repo/linux-2.5
    into sb.bsdonline.org:/repo/linux-2.5-sysvfs

    ChangeSet@1.369.97.5, 2002-04-03 20:25:37+02:00, hch@sb.bsdonline.org
    Replace BKL for chain locking with sysvfs-private rwlock.

    ChangeSet@1.369.97.4, 2002-04-03 15:56:37+02:00, hch@sb.bsdonline.org
    Sanitize definition of sysvfs dinode.

    ChangeSet@1.369.97.3, 2002-04-03 15:50:44+02:00, hch@sb.bsdonline.org
    Move sysvfs incore data from include/linux/sysv_fs.h to fs/sysv/sysv.h.

    ChangeSet@1.369.97.2, 2002-04-03 15:17:25+02:00, hch@sb.bsdonline.org
    Make sysvfs use sb->u.generic_sbp.

    ChangeSet@1.369.97.1, 2002-04-03 14:20:55+02:00, hch@sb.bsdonline.org
    Access sysvfs superblock fields through SYSV_SB() abstraction.



    b/fs/sysv/balloc.c | 76 +++++-----
    b/fs/sysv/dir.c | 19 +-
    b/fs/sysv/file.c | 3
    b/fs/sysv/ialloc.c | 70 +++++----
    b/fs/sysv/inode.c | 116 ++++++++-------
    b/fs/sysv/itree.c | 54 ++++---
    b/fs/sysv/namei.c | 9 -
    b/fs/sysv/super.c | 327 +++++++++++++++++++++++----------------------
    b/fs/sysv/symlink.c | 3
    b/fs/sysv/sysv.h | 236 ++++++++++++++++++++++++++++++++
    b/include/linux/fs.h | 2
    b/include/linux/sysv_fs.h | 228 +------------------------------
    include/linux/sysv_fs_i.h | 18 --
    include/linux/sysv_fs_sb.h | 89 ------------
    14 files changed, 608 insertions, 642 deletions


    diff -Nru a/fs/sysv/balloc.c b/fs/sysv/balloc.c
    --- a/fs/sysv/balloc.c Mon Apr 29 13:12:01 2002
    +++ b/fs/sysv/balloc.c Mon Apr 29 13:12:01 2002
    @@ -19,9 +19,8 @@
    * This file contains code for allocating/freeing blocks.
    */

    -#include <linux/fs.h>
    -#include <linux/sysv_fs.h>
    #include <linux/locks.h>
    +#include "sysv.h"

    /* We don't trust the value of
    sb->sv_sbd2->s_tfree = *sb->sv_free_blocks
    @@ -31,7 +30,7 @@
    {
    char *bh_data = bh->b_data;

    - if (sb->sv_type == FSTYPE_SYSV4)
    + if (SYSV_SB(sb)->s_type == FSTYPE_SYSV4)
    return (u32*)(bh_data+4);
    else
    return (u32*)(bh_data+2);
    @@ -41,28 +40,29 @@

    void sysv_free_block(struct super_block * sb, u32 nr)
    {
    + struct sysv_sb_info * sbi = SYSV_SB(sb);
    struct buffer_head * bh;
    - u32 *blocks = sb->sv_bcache;
    + u32 *blocks = sbi->s_bcache;
    unsigned count;
    - unsigned block = fs32_to_cpu(sb, nr);
    + unsigned block = fs32_to_cpu(sbi, 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)
    + if (sbi->s_type == FSTYPE_AFS)
    return;

    - if (block < sb->sv_firstdatazone || block >= sb->sv_nzones) {
    + if (block < sbi->s_firstdatazone || block >= sbi->s_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);
    + count = fs16_to_cpu(sbi, *sbi->s_bcache_count);

    - if (count > sb->sv_flc_size) {
    + if (count > sbi->s_flc_size) {
    printk("sysv_free_block: flc_count > flc_size\n");
    unlock_super(sb);
    return;
    @@ -71,8 +71,8 @@
    * 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;
    + if (count == sbi->s_flc_size || count == 0) {
    + block += sbi->s_block_base;
    bh = sb_getblk(sb, block);
    if (!bh) {
    printk("sysv_free_block: getblk() failed\n");
    @@ -80,42 +80,43 @@
    return;
    }
    memset(bh->b_data, 0, sb->s_blocksize);
    - *(u16*)bh->b_data = cpu_to_fs16(sb, count);
    + *(u16*)bh->b_data = cpu_to_fs16(sbi, 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;
    + sbi->s_bcache[count++] = nr;

    - *sb->sv_bcache_count = cpu_to_fs16(sb, count);
    - fs32_add(sb, sb->sv_free_blocks, 1);
    + *sbi->s_bcache_count = cpu_to_fs16(sbi, count);
    + fs32_add(sbi, sbi->s_free_blocks, 1);
    dirty_sb(sb);
    unlock_super(sb);
    }

    u32 sysv_new_block(struct super_block * sb)
    {
    + struct sysv_sb_info *sbi = SYSV_SB(sb);
    unsigned int block;
    u32 nr;
    struct buffer_head * bh;
    unsigned count;

    lock_super(sb);
    - count = fs16_to_cpu(sb, *sb->sv_bcache_count);
    + count = fs16_to_cpu(sbi, *sbi->s_bcache_count);

    if (count == 0) /* Applies only to Coherent FS */
    goto Enospc;
    - nr = sb->sv_bcache[--count];
    + nr = sbi->s_bcache[--count];
    if (nr == 0) /* Applies only to Xenix FS, SystemV FS */
    goto Enospc;

    - block = fs32_to_cpu(sb, nr);
    + block = fs32_to_cpu(sbi, nr);

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

    - if (block < sb->sv_firstdatazone || block >= sb->sv_nzones) {
    + if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) {
    printk("sysv_new_block: new block %d is not in data zone\n",
    block);
    goto Enospc;
    @@ -124,26 +125,26 @@
    if (count == 0) { /* the last block continues the free list */
    unsigned count;

    - block += sb->sv_block_base;
    + block += sbi->s_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);
    + *sbi->s_bcache_count = cpu_to_fs16(sbi, 1);
    goto Enospc;
    }
    - count = fs16_to_cpu(sb, *(u16*)bh->b_data);
    - if (count > sb->sv_flc_size) {
    + count = fs16_to_cpu(sbi, *(u16*)bh->b_data);
    + if (count > sbi->s_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),
    + *sbi->s_bcache_count = cpu_to_fs16(sbi, count);
    + memcpy(sbi->s_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);
    + fs32_add(sbi, sbi->s_free_blocks, -1);
    dirty_sb(sb);
    unlock_super(sb);
    return nr;
    @@ -155,6 +156,7 @@

    unsigned long sysv_count_free_blocks(struct super_block * sb)
    {
    + struct sysv_sb_info * sbi = SYSV_SB(sb);
    int sb_count;
    int count;
    struct buffer_head * bh = NULL;
    @@ -167,21 +169,21 @@
    * 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)
    + if (sbi->s_type == FSTYPE_AFS)
    return 0;

    lock_super(sb);
    - sb_count = fs32_to_cpu(sb, *sb->sv_free_blocks);
    + sb_count = fs32_to_cpu(sbi, *sbi->s_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;
    + n = fs16_to_cpu(sbi, *sbi->s_bcache_count);
    + blocks = sbi->s_bcache;
    while (1) {
    - if (n > sb->sv_flc_size)
    + if (n > sbi->s_flc_size)
    goto E2big;
    block = 0;
    while (n && (block = blocks[--n]) != 0)
    @@ -189,17 +191,17 @@
    if (block == 0)
    break;

    - block = fs32_to_cpu(sb, block);
    + block = fs32_to_cpu(sbi, block);
    if (bh)
    brelse(bh);

    - if (block < sb->sv_firstdatazone || block >= sb->sv_nzones)
    + if (block < sbi->s_firstdatazone || block >= sbi->s_nzones)
    goto Einval;
    - block += sb->sv_block_base;
    + block += sbi->s_block_base;
    bh = sb_bread(sb, block);
    if (!bh)
    goto Eio;
    - n = fs16_to_cpu(sb, *(u16*)bh->b_data);
    + n = fs16_to_cpu(sbi, *(u16*)bh->b_data);
    blocks = get_chunk(sb, bh);
    }
    if (bh)
    @@ -228,7 +230,7 @@
    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);
    + *sbi->s_free_blocks = cpu_to_fs32(sbi, count);
    dirty_sb(sb);
    }
    goto done;
    diff -Nru a/fs/sysv/dir.c b/fs/sysv/dir.c
    --- a/fs/sysv/dir.c Mon Apr 29 13:12:01 2002
    +++ b/fs/sysv/dir.c Mon Apr 29 13:12:01 2002
    @@ -13,9 +13,8 @@
    * SystemV/Coherent directory handling functions
    */

    -#include <linux/fs.h>
    -#include <linux/sysv_fs.h>
    #include <linux/pagemap.h>
    +#include "sysv.h"

    static int sysv_readdir(struct file *, void *, filldir_t);

    @@ -104,7 +103,8 @@

    over = filldir(dirent, name, strnlen(name,SYSV_NAMELEN),
    (n<<PAGE_CACHE_SHIFT) | offset,
    - fs16_to_cpu(sb, de->inode), DT_UNKNOWN);
    + fs16_to_cpu(SYSV_SB(sb), de->inode),
    + DT_UNKNOWN);
    if (over) {
    dir_put_page(page);
    goto done;
    @@ -228,7 +228,7 @@
    goto out_unlock;
    memcpy (de->name, name, namelen);
    memset (de->name + namelen, 0, SYSV_DIRSIZE - namelen - 2);
    - de->inode = cpu_to_fs16(inode->i_sb, inode->i_ino);
    + de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino);
    err = dir_commit_chunk(page, from, to);
    dir->i_mtime = dir->i_ctime = CURRENT_TIME;
    mark_inode_dirty(dir);
    @@ -280,10 +280,10 @@
    memset(base, 0, PAGE_CACHE_SIZE);

    de = (struct sysv_dir_entry *) base;
    - de->inode = cpu_to_fs16(inode->i_sb, inode->i_ino);
    + de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino);
    strcpy(de->name,".");
    de++;
    - de->inode = cpu_to_fs16(inode->i_sb, dir->i_ino);
    + de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), dir->i_ino);
    strcpy(de->name,"..");

    err = dir_commit_chunk(page, 0, 2 * SYSV_DIRSIZE);
    @@ -321,7 +321,8 @@
    if (de->name[0] != '.')
    goto not_empty;
    if (!de->name[1]) {
    - if (de->inode == cpu_to_fs16(sb, inode->i_ino))
    + if (de->inode == cpu_to_fs16(SYSV_SB(sb),
    + inode->i_ino))
    continue;
    goto not_empty;
    }
    @@ -350,7 +351,7 @@
    err = page->mapping->a_ops->prepare_write(NULL, page, from, to);
    if (err)
    BUG();
    - de->inode = cpu_to_fs16(inode->i_sb, inode->i_ino);
    + de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino);
    err = dir_commit_chunk(page, from, to);
    UnlockPage(page);
    dir_put_page(page);
    @@ -377,7 +378,7 @@
    ino_t res = 0;

    if (de) {
    - res = fs16_to_cpu(dentry->d_sb, de->inode);
    + res = fs16_to_cpu(SYSV_SB(dentry->d_sb), de->inode);
    dir_put_page(page);
    }
    return res;
    diff -Nru a/fs/sysv/file.c b/fs/sysv/file.c
    --- a/fs/sysv/file.c Mon Apr 29 13:12:01 2002
    +++ b/fs/sysv/file.c Mon Apr 29 13:12:01 2002
    @@ -13,8 +13,7 @@
    * SystemV/Coherent regular file handling primitives
    */

    -#include <linux/fs.h>
    -#include <linux/sysv_fs.h>
    +#include "sysv.h"

    /*
    * We have mostly NULLs here: the current defaults are OK for
    diff -Nru a/fs/sysv/ialloc.c b/fs/sysv/ialloc.c
    --- a/fs/sysv/ialloc.c Mon Apr 29 13:12:01 2002
    +++ b/fs/sysv/ialloc.c Mon Apr 29 13:12:01 2002
    @@ -20,12 +20,11 @@
    */

    #include <linux/kernel.h>
    -#include <linux/fs.h>
    -#include <linux/sysv_fs.h>
    #include <linux/stddef.h>
    #include <linux/stat.h>
    #include <linux/string.h>
    #include <linux/locks.h>
    +#include "sysv.h"

    /* We don't trust the value of
    sb->sv_sbd2->s_tinode = *sb->sv_sb_total_free_inodes
    @@ -37,33 +36,38 @@
    static inline sysv_ino_t *
    sv_sb_fic_inode(struct super_block * sb, unsigned int i)
    {
    - if (sb->sv_bh1 == sb->sv_bh2)
    - return &sb->sv_sb_fic_inodes[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*)(sb->sv_sbd1 + offset);
    + return (sysv_ino_t*)(sbi->s_sbd1 + offset);
    else
    - return (sysv_ino_t*)(sb->sv_sbd2 + offset);
    + 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 = sb->sv_firstinodezone + sb->sv_block_base;
    - block += (ino-1) >> sb->sv_inodes_per_block_bits;
    + 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) & sb->sv_inodes_per_block_1);
    + 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;
    @@ -72,13 +76,13 @@
    raw_inode = sysv_raw_inode(sb, ino, &bh);
    if (!raw_inode)
    goto out;
    - while (ino <= sb->sv_ninodes) {
    + 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(sb, ino);
    - if (i == sb->sv_fic_size)
    + *sv_sb_fic_inode(sb,i++) = cpu_to_fs16(SYSV_SB(sb), ino);
    + if (i == sbi->s_fic_size)
    break;
    }
    - if ((ino++ & sb->sv_inodes_per_block_1) == 0) {
    + if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
    brelse(bh);
    raw_inode = sysv_raw_inode(sb, ino, &bh);
    if (!raw_inode)
    @@ -93,7 +97,8 @@

    void sysv_free_inode(struct inode * inode)
    {
    - struct super_block * sb;
    + 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;
    @@ -101,7 +106,7 @@

    sb = inode->i_sb;
    ino = inode->i_ino;
    - if (ino <= SYSV_ROOT_INO || ino > sb->sv_ninodes) {
    + if (ino <= SYSV_ROOT_INO || ino > sbi->s_ninodes) {
    printk("sysv_free_inode: inode 0,1,2 or nonexistent inode\n");
    return;
    }
    @@ -113,12 +118,12 @@
    return;
    }
    lock_super(sb);
    - count = fs16_to_cpu(sb, *sb->sv_sb_fic_count);
    - if (count < sb->sv_fic_size) {
    - *sv_sb_fic_inode(sb,count++) = cpu_to_fs16(sb, ino);
    - *sb->sv_sb_fic_count = cpu_to_fs16(sb, count);
    + 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(sb, sb->sv_sb_total_free_inodes, 1);
    + 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);
    @@ -128,18 +133,18 @@

    struct inode * sysv_new_inode(const struct inode * dir, mode_t mode)
    {
    - struct inode * inode;
    - struct super_block * sb;
    + struct super_block *sb = dir->i_sb;
    + struct sysv_sb_info *sbi = SYSV_SB(sb);
    + struct inode *inode;
    u16 ino;
    unsigned count;

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

    lock_super(sb);
    - count = fs16_to_cpu(sb, *sb->sv_sb_fic_count);
    + 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) {
    @@ -150,8 +155,8 @@
    }
    /* Now count > 0. */
    ino = *sv_sb_fic_inode(sb,--count);
    - *sb->sv_sb_fic_count = cpu_to_fs16(sb, count);
    - fs16_add(sb, sb->sv_sb_total_free_inodes, -1);
    + *sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
    + fs16_add(sbi, sbi->s_sb_total_free_inodes, -1);
    dirty_sb(sb);

    if (dir->i_mode & S_ISGID) {
    @@ -162,7 +167,7 @@
    inode->i_gid = current->fsgid;

    inode->i_uid = current->fsuid;
    - inode->i_ino = fs16_to_cpu(sb, ino);
    + inode->i_ino = fs16_to_cpu(sbi, ino);
    inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
    inode->i_blocks = inode->i_blksize = 0;
    memset(SYSV_I(inode)->i_data, 0, sizeof(SYSV_I(inode)->i_data));
    @@ -180,13 +185,14 @@

    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;

    lock_super(sb);

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

    if (0)
    goto trust_sb;
    @@ -197,10 +203,10 @@
    raw_inode = sysv_raw_inode(sb, ino, &bh);
    if (!raw_inode)
    goto Eio;
    - while (ino <= sb->sv_ninodes) {
    + while (ino <= sbi->s_ninodes) {
    if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0)
    count++;
    - if ((ino++ & sb->sv_inodes_per_block_1) == 0) {
    + if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
    brelse(bh);
    raw_inode = sysv_raw_inode(sb, ino, &bh);
    if (!raw_inode)
    @@ -220,7 +226,7 @@
    "free inode count was %d, correcting to %d\n",
    sb_count, count);
    if (!(sb->s_flags & MS_RDONLY)) {
    - *sb->sv_sb_total_free_inodes = cpu_to_fs16(sb, count);
    + *sbi->s_sb_total_free_inodes = cpu_to_fs16(SYSV_SB(sb), count);
    dirty_sb(sb);
    }
    goto out;
    diff -Nru a/fs/sysv/inode.c b/fs/sysv/inode.c
    --- a/fs/sysv/inode.c Mon Apr 29 13:12:01 2002
    +++ b/fs/sysv/inode.c Mon Apr 29 13:12:01 2002
    @@ -21,56 +21,68 @@
    * the superblock.
    */

    -#include <linux/fs.h>
    -#include <linux/sysv_fs.h>
    #include <linux/locks.h>
    #include <linux/smp_lock.h>
    #include <linux/highuid.h>
    #include <linux/slab.h>
    #include <linux/init.h>
    #include <asm/byteorder.h>
    +#include "sysv.h"

    /* This is only called on sync() and umount(), when s_dirt=1. */
    static void sysv_write_super(struct super_block *sb)
    {
    + struct sysv_sb_info *sbi = SYSV_SB(sb);
    + unsigned long time = CURRENT_TIME, old_time;
    +
    lock_kernel();
    - if (!(sb->s_flags & MS_RDONLY)) {
    - /* If we are going to write out the super block,
    - then attach current time stamp.
    - But if the filesystem was marked clean, keep it clean. */
    - unsigned long time = CURRENT_TIME;
    - unsigned long old_time = fs32_to_cpu(sb, *sb->sv_sb_time);
    - if (sb->sv_type == FSTYPE_SYSV4)
    - if (*sb->sv_sb_state == cpu_to_fs32(sb, 0x7c269d38 - old_time))
    - *sb->sv_sb_state = cpu_to_fs32(sb, 0x7c269d38 - time);
    - *sb->sv_sb_time = cpu_to_fs32(sb, time);
    - mark_buffer_dirty(sb->sv_bh2);
    + if (sb->s_flags & MS_RDONLY)
    + goto clean;
    +
    + /*
    + * If we are going to write out the super block,
    + * then attach current time stamp.
    + * But if the filesystem was marked clean, keep it clean.
    + */
    + old_time = fs32_to_cpu(sbi, *sbi->s_sb_time);
    + if (sbi->s_type == FSTYPE_SYSV4) {
    + if (*sbi->s_sb_state == cpu_to_fs32(sbi, 0x7c269d38 - old_time))
    + *sbi->s_sb_state = cpu_to_fs32(sbi, 0x7c269d38 - time);
    + *sbi->s_sb_time = cpu_to_fs32(sbi, time);
    + mark_buffer_dirty(sbi->s_bh2);
    }
    +clean:
    sb->s_dirt = 0;
    unlock_kernel();
    }

    static void sysv_put_super(struct super_block *sb)
    {
    + struct sysv_sb_info *sbi = SYSV_SB(sb);
    +
    if (!(sb->s_flags & MS_RDONLY)) {
    /* XXX ext2 also updates the state here */
    - mark_buffer_dirty(sb->sv_bh1);
    - if (sb->sv_bh1 != sb->sv_bh2)
    - mark_buffer_dirty(sb->sv_bh2);
    + mark_buffer_dirty(sbi->s_bh1);
    + if (sbi->s_bh1 != sbi->s_bh2)
    + mark_buffer_dirty(sbi->s_bh2);
    }

    - brelse(sb->sv_bh1);
    - if (sb->sv_bh1 != sb->sv_bh2)
    - brelse(sb->sv_bh2);
    + brelse(sbi->s_bh1);
    + if (sbi->s_bh1 != sbi->s_bh2)
    + brelse(sbi->s_bh2);
    +
    + kfree(sbi);
    }

    static int sysv_statfs(struct super_block *sb, struct statfs *buf)
    {
    + struct sysv_sb_info *sbi = SYSV_SB(sb);
    +
    buf->f_type = sb->s_magic;
    buf->f_bsize = sb->s_blocksize;
    - buf->f_blocks = sb->sv_ndatazones;
    + buf->f_blocks = sbi->s_ndatazones;
    buf->f_bavail = buf->f_bfree = sysv_count_free_blocks(sb);
    - buf->f_files = sb->sv_ninodes;
    + buf->f_files = sbi->s_ninodes;
    buf->f_ffree = sysv_count_free_inodes(sb);
    buf->f_namelen = SYSV_NAMELEN;
    return 0;
    @@ -79,15 +91,15 @@
    /*
    * NXI <-> N0XI for PDP, XIN <-> XIN0 for le32, NIX <-> 0NIX for be32
    */
    -static inline void read3byte(struct super_block *sb,
    +static inline void read3byte(struct sysv_sb_info *sbi,
    unsigned char * from, unsigned char * to)
    {
    - if (sb->sv_bytesex == BYTESEX_PDP) {
    + if (sbi->s_bytesex == BYTESEX_PDP) {
    to[0] = from[0];
    to[1] = 0;
    to[2] = from[1];
    to[3] = from[2];
    - } else if (sb->sv_bytesex == BYTESEX_LE) {
    + } else if (sbi->s_bytesex == BYTESEX_LE) {
    to[0] = from[0];
    to[1] = from[1];
    to[2] = from[2];
    @@ -100,14 +112,14 @@
    }
    }

    -static inline void write3byte(struct super_block *sb,
    +static inline void write3byte(struct sysv_sb_info *sbi,
    unsigned char * from, unsigned char * to)
    {
    - if (sb->sv_bytesex == BYTESEX_PDP) {
    + if (sbi->s_bytesex == BYTESEX_PDP) {
    to[0] = from[0];
    to[1] = from[2];
    to[2] = from[3];
    - } else if (sb->sv_bytesex == BYTESEX_LE) {
    + } else if (sbi->s_bytesex == BYTESEX_LE) {
    to[0] = from[0];
    to[1] = from[1];
    to[2] = from[2];
    @@ -146,6 +158,7 @@
    static void sysv_read_inode(struct inode *inode)
    {
    struct super_block * sb = inode->i_sb;
    + struct sysv_sb_info * sbi = SYSV_SB(sb);
    struct buffer_head * bh;
    struct sysv_inode * raw_inode;
    struct sysv_inode_info * si;
    @@ -153,7 +166,7 @@
    dev_t rdev = 0;

    ino = inode->i_ino;
    - if (!ino || ino > sb->sv_ninodes) {
    + if (!ino || ino > sbi->s_ninodes) {
    printk("Bad inode number on dev %s: %d is out of range\n",
    inode->i_sb->s_id, ino);
    goto bad_inode;
    @@ -165,23 +178,23 @@
    goto bad_inode;
    }
    /* SystemV FS: kludge permissions if ino==SYSV_ROOT_INO ?? */
    - inode->i_mode = fs16_to_cpu(sb, raw_inode->i_mode);
    - inode->i_uid = (uid_t)fs16_to_cpu(sb, raw_inode->i_uid);
    - inode->i_gid = (gid_t)fs16_to_cpu(sb, raw_inode->i_gid);
    - inode->i_nlink = fs16_to_cpu(sb, raw_inode->i_nlink);
    - inode->i_size = fs32_to_cpu(sb, raw_inode->i_size);
    - inode->i_atime = fs32_to_cpu(sb, raw_inode->i_atime);
    - inode->i_mtime = fs32_to_cpu(sb, raw_inode->i_mtime);
    - inode->i_ctime = fs32_to_cpu(sb, raw_inode->i_ctime);
    + inode->i_mode = fs16_to_cpu(sbi, raw_inode->i_mode);
    + inode->i_uid = (uid_t)fs16_to_cpu(sbi, raw_inode->i_uid);
    + inode->i_gid = (gid_t)fs16_to_cpu(sbi, raw_inode->i_gid);
    + inode->i_nlink = fs16_to_cpu(sbi, raw_inode->i_nlink);
    + inode->i_size = fs32_to_cpu(sbi, raw_inode->i_size);
    + inode->i_atime = fs32_to_cpu(sbi, raw_inode->i_atime);
    + inode->i_mtime = fs32_to_cpu(sbi, raw_inode->i_mtime);
    + inode->i_ctime = fs32_to_cpu(sbi, raw_inode->i_ctime);
    inode->i_blocks = inode->i_blksize = 0;

    si = SYSV_I(inode);
    for (block = 0; block < 10+1+1+1; block++)
    - read3byte(sb, &raw_inode->i_a.i_addb[3*block],
    - (unsigned char*)&si->i_data[block]);
    + read3byte(sbi, &raw_inode->i_data[3*block],
    + (u8 *)&si->i_data[block]);
    brelse(bh);
    if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
    - rdev = (u16)fs32_to_cpu(sb, si->i_data[0]);
    + rdev = (u16)fs32_to_cpu(sbi, si->i_data[0]);
    si->i_dir_start_lookup = 0;
    sysv_set_inode(inode, rdev);
    return;
    @@ -194,13 +207,14 @@
    static struct buffer_head * sysv_update_inode(struct inode * inode)
    {
    struct super_block * sb = inode->i_sb;
    + struct sysv_sb_info * sbi = SYSV_SB(sb);
    struct buffer_head * bh;
    struct sysv_inode * raw_inode;
    struct sysv_inode_info * si;
    unsigned int ino, block;

    ino = inode->i_ino;
    - if (!ino || ino > sb->sv_ninodes) {
    + if (!ino || ino > sbi->s_ninodes) {
    printk("Bad inode number on dev %s: %d is out of range\n",
    inode->i_sb->s_id, ino);
    return 0;
    @@ -211,21 +225,21 @@
    return 0;
    }

    - raw_inode->i_mode = cpu_to_fs16(sb, inode->i_mode);
    - raw_inode->i_uid = cpu_to_fs16(sb, fs_high2lowuid(inode->i_uid));
    - raw_inode->i_gid = cpu_to_fs16(sb, fs_high2lowgid(inode->i_gid));
    - raw_inode->i_nlink = cpu_to_fs16(sb, inode->i_nlink);
    - raw_inode->i_size = cpu_to_fs32(sb, inode->i_size);
    - raw_inode->i_atime = cpu_to_fs32(sb, inode->i_atime);
    - raw_inode->i_mtime = cpu_to_fs32(sb, inode->i_mtime);
    - raw_inode->i_ctime = cpu_to_fs32(sb, inode->i_ctime);
    + raw_inode->i_mode = cpu_to_fs16(sbi, inode->i_mode);
    + raw_inode->i_uid = cpu_to_fs16(sbi, fs_high2lowuid(inode->i_uid));
    + raw_inode->i_gid = cpu_to_fs16(sbi, fs_high2lowgid(inode->i_gid));
    + raw_inode->i_nlink = cpu_to_fs16(sbi, inode->i_nlink);
    + raw_inode->i_size = cpu_to_fs32(sbi, inode->i_size);
    + raw_inode->i_atime = cpu_to_fs32(sbi, inode->i_atime);
    + raw_inode->i_mtime = cpu_to_fs32(sbi, inode->i_mtime);
    + raw_inode->i_ctime = cpu_to_fs32(sbi, inode->i_ctime);

    si = SYSV_I(inode);
    if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
    - si->i_data[0] = cpu_to_fs32(sb, kdev_t_to_nr(inode->i_rdev));
    + si->i_data[0] = cpu_to_fs32(sbi, kdev_t_to_nr(inode->i_rdev));
    for (block = 0; block < 10+1+1+1; block++)
    - write3byte(sb, (unsigned char*)&si->i_data[block],
    - &raw_inode->i_a.i_addb[3*block]);
    + write3byte(sbi, (u8 *)&si->i_data[block],
    + &raw_inode->i_data[3*block]);
    mark_buffer_dirty(bh);
    return bh;
    }
    diff -Nru a/fs/sysv/itree.c b/fs/sysv/itree.c
    --- a/fs/sysv/itree.c Mon Apr 29 13:12:01 2002
    +++ b/fs/sysv/itree.c Mon Apr 29 13:12:01 2002
    @@ -5,10 +5,8 @@
    * AV, Sep--Dec 2000
    */

    -#include <linux/fs.h>
    -#include <linux/sysv_fs.h>
    #include <linux/locks.h>
    -#include <linux/smp_lock.h>
    +#include "sysv.h"

    enum {DIRECT = 10, DEPTH = 4}; /* Have triple indirect */

    @@ -24,9 +22,10 @@
    static int block_to_path(struct inode *inode, long block, int offsets[DEPTH])
    {
    struct super_block *sb = inode->i_sb;
    - int ptrs_bits = sb->sv_ind_per_block_bits;
    - unsigned long indirect_blocks = sb->sv_ind_per_block,
    - double_blocks = sb->sv_ind_per_block_2;
    + struct sysv_sb_info *sbi = SYSV_SB(sb);
    + int ptrs_bits = sbi->s_ind_per_block_bits;
    + unsigned long indirect_blocks = sbi->s_ind_per_block,
    + double_blocks = sbi->s_ind_per_block_2;
    int n = 0;

    if (block < 0) {
    @@ -51,9 +50,9 @@
    return n;
    }

    -static inline int block_to_cpu(struct super_block *sb, u32 nr)
    +static inline int block_to_cpu(struct sysv_sb_info *sbi, u32 nr)
    {
    - return sb->sv_block_base + fs32_to_cpu(sb, nr);
    + return sbi->s_block_base + fs32_to_cpu(sbi, nr);
    }

    typedef struct {
    @@ -62,6 +61,8 @@
    struct buffer_head *bh;
    } Indirect;

    +static rwlock_t pointers_lock = RW_LOCK_UNLOCKED;
    +
    static inline void add_chain(Indirect *p, struct buffer_head *bh, u32 *v)
    {
    p->key = *(p->p = v);
    @@ -91,23 +92,26 @@
    struct buffer_head *bh;

    *err = 0;
    - add_chain (chain, NULL, SYSV_I(inode)->i_data + *offsets);
    + add_chain(chain, NULL, SYSV_I(inode)->i_data + *offsets);
    if (!p->key)
    goto no_block;
    while (--depth) {
    - int block = block_to_cpu(sb, p->key);
    + int block = block_to_cpu(SYSV_SB(sb), p->key);
    bh = sb_bread(sb, block);
    if (!bh)
    goto failure;
    + read_lock(&pointers_lock);
    if (!verify_chain(chain, p))
    goto changed;
    add_chain(++p, bh, (u32*)bh->b_data + *++offsets);
    + read_unlock(&pointers_lock);
    if (!p->key)
    - goto no_block;
    + goto no_block;
    }
    return NULL;

    changed:
    + read_unlock(&pointers_lock);
    brelse(bh);
    *err = -EAGAIN;
    goto no_block;
    @@ -138,7 +142,7 @@
    * Get buffer_head for parent block, zero it out and set
    * the pointer to new one, then send parent to disk.
    */
    - parent = block_to_cpu(inode->i_sb, branch[n-1].key);
    + parent = block_to_cpu(SYSV_SB(inode->i_sb), branch[n-1].key);
    bh = sb_getblk(inode->i_sb, parent);
    lock_buffer(bh);
    memset(bh->b_data, 0, blocksize);
    @@ -166,12 +170,14 @@
    int num)
    {
    int i;
    - /* Verify that place we are splicing to is still there and vacant */

    + /* Verify that place we are splicing to is still there and vacant */
    + write_lock(&pointers_lock);
    if (!verify_chain(chain, where-1) || *where->p)
    goto changed;
    -
    *where->p = where->key;
    + write_unlock(&pointers_lock);
    +
    inode->i_ctime = CURRENT_TIME;

    /* had we spliced it onto indirect block? */
    @@ -185,6 +191,7 @@
    return 0;

    changed:
    + write_unlock(&pointers_lock);
    for (i = 1; i < num; i++)
    bforget(where[i].bh);
    for (i = 0; i < num; i++)
    @@ -205,14 +212,14 @@
    if (depth == 0)
    goto out;

    - lock_kernel();
    reread:
    partial = get_branch(inode, depth, offsets, chain, &err);

    /* Simplest case - block found, no allocation needed */
    if (!partial) {
    got_it:
    - map_bh(bh_result, sb, block_to_cpu(sb, chain[depth-1].key));
    + map_bh(bh_result, sb, block_to_cpu(SYSV_SB(sb),
    + chain[depth-1].key));
    /* Clean up and exit */
    partial = chain+depth-1; /* the whole chain */
    goto cleanup;
    @@ -225,7 +232,6 @@
    brelse(partial->bh);
    partial--;
    }
    - unlock_kernel();
    out:
    return err;
    }
    @@ -277,6 +283,8 @@
    *top = 0;
    for (k = depth; k > 1 && !offsets[k-1]; k--)
    ;
    +
    + write_lock(&pointers_lock);
    partial = get_branch(inode, k, offsets, chain, &err);
    if (!partial)
    partial = chain + k-1;
    @@ -284,8 +292,10 @@
    * If the branch acquired continuation since we've looked at it -
    * fine, it should all survive and (new) top doesn't belong to us.
    */
    - if (!partial->key && *partial->p)
    + if (!partial->key && *partial->p) {
    + write_unlock(&pointers_lock);
    goto no_top;
    + }
    for (p=partial; p>chain && all_zeroes((u32*)p->bh->b_data,p->p); p--)
    ;
    /*
    @@ -300,8 +310,9 @@
    *top = *p->p;
    *p->p = 0;
    }
    + write_unlock(&pointers_lock);

    - while(partial > p) {
    + while (partial > p) {
    brelse(partial->bh);
    partial--;
    }
    @@ -333,7 +344,7 @@
    if (!nr)
    continue;
    *p = 0;
    - block = block_to_cpu(sb, nr);
    + block = block_to_cpu(SYSV_SB(sb), nr);
    bh = sb_bread(sb, block);
    if (!bh)
    continue;
    @@ -372,8 +383,6 @@
    if (n == 0)
    return;

    - lock_kernel();
    -
    if (n == 1) {
    free_data(inode, i_data+offsets[0], i_data + DIRECT);
    goto do_indirects;
    @@ -412,7 +421,6 @@
    sysv_sync_inode (inode);
    else
    mark_inode_dirty(inode);
    - unlock_kernel();
    }

    static int sysv_writepage(struct page *page)
    diff -Nru a/fs/sysv/namei.c b/fs/sysv/namei.c
    --- a/fs/sysv/namei.c Mon Apr 29 13:12:01 2002
    +++ b/fs/sysv/namei.c Mon Apr 29 13:12:01 2002
    @@ -12,10 +12,9 @@
    * Copyright (C) 1997, 1998 Krzysztof G. Baranowski
    */

    -#include <linux/fs.h>
    -#include <linux/sysv_fs.h>
    #include <linux/pagemap.h>
    #include <linux/smp_lock.h>
    +#include "sysv.h"

    static inline void inc_count(struct inode *inode)
    {
    @@ -138,7 +137,7 @@
    {
    struct inode *inode = old_dentry->d_inode;

    - if (inode->i_nlink >= inode->i_sb->sv_link_max)
    + if (inode->i_nlink >= SYSV_SB(inode->i_sb)->s_link_max)
    return -EMLINK;

    inode->i_ctime = CURRENT_TIME;
    @@ -153,7 +152,7 @@
    struct inode * inode;
    int err = -EMLINK;

    - if (dir->i_nlink >= dir->i_sb->sv_link_max)
    + if (dir->i_nlink >= SYSV_SB(dir->i_sb)->s_link_max)
    goto out;
    inc_count(dir);

    @@ -271,7 +270,7 @@
    } else {
    if (dir_de) {
    err = -EMLINK;
    - if (new_dir->i_nlink >= new_dir->i_sb->sv_link_max)
    + if (new_dir->i_nlink >= SYSV_SB(new_dir->i_sb)->s_link_max)
    goto out_dir;
    }
    inc_count(old_inode);
    diff -Nru a/fs/sysv/super.c b/fs/sysv/super.c
    --- a/fs/sysv/super.c Mon Apr 29 13:12:01 2002
    +++ b/fs/sysv/super.c Mon Apr 29 13:12:01 2002
    @@ -21,10 +21,9 @@
    */

    #include <linux/module.h>
    -
    -#include <linux/fs.h>
    -#include <linux/sysv_fs.h>
    #include <linux/init.h>
    +#include <linux/slab.h>
    +#include "sysv.h"

    /*
    * The following functions try to recognize specific filesystems.
    @@ -44,10 +43,10 @@
    JAN_1_1980 = (10*365 + 2) * 24 * 60 * 60
    };

    -static void detected_xenix(struct super_block *sb)
    +static void detected_xenix(struct sysv_sb_info *sbi)
    {
    - struct buffer_head *bh1 = sb->sv_bh1;
    - struct buffer_head *bh2 = sb->sv_bh2;
    + struct buffer_head *bh1 = sbi->s_bh1;
    + struct buffer_head *bh2 = sbi->s_bh2;
    struct xenix_super_block * sbd1;
    struct xenix_super_block * sbd2;

    @@ -59,152 +58,153 @@
    sbd2 = (struct xenix_super_block *) (bh2->b_data - 512);
    }

    - sb->sv_link_max = XENIX_LINK_MAX;
    - sb->sv_fic_size = XENIX_NICINOD;
    - sb->sv_flc_size = XENIX_NICFREE;
    - sb->sv_sbd1 = (char *) sbd1;
    - sb->sv_sbd2 = (char *) sbd2;
    - sb->sv_sb_fic_count = &sbd1->s_ninode;
    - sb->sv_sb_fic_inodes = &sbd1->s_inode[0];
    - sb->sv_sb_total_free_inodes = &sbd2->s_tinode;
    - sb->sv_bcache_count = &sbd1->s_nfree;
    - sb->sv_bcache = &sbd1->s_free[0];
    - sb->sv_free_blocks = &sbd2->s_tfree;
    - sb->sv_sb_time = &sbd2->s_time;
    - sb->sv_firstdatazone = fs16_to_cpu(sb, sbd1->s_isize);
    - sb->sv_nzones = fs32_to_cpu(sb, sbd1->s_fsize);
    + sbi->s_link_max = XENIX_LINK_MAX;
    + sbi->s_fic_size = XENIX_NICINOD;
    + sbi->s_flc_size = XENIX_NICFREE;
    + sbi->s_sbd1 = (char *)sbd1;
    + sbi->s_sbd2 = (char *)sbd2;
    + sbi->s_sb_fic_count = &sbd1->s_ninode;
    + sbi->s_sb_fic_inodes = &sbd1->s_inode[0];
    + sbi->s_sb_total_free_inodes = &sbd2->s_tinode;
    + sbi->s_bcache_count = &sbd1->s_nfree;
    + sbi->s_bcache = &sbd1->s_free[0];
    + sbi->s_free_blocks = &sbd2->s_tfree;
    + sbi->s_sb_time = &sbd2->s_time;
    + sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd1->s_isize);
    + sbi->s_nzones = fs32_to_cpu(sbi, sbd1->s_fsize);
    }

    -static void detected_sysv4(struct super_block *sb)
    +static void detected_sysv4(struct sysv_sb_info *sbi)
    {
    struct sysv4_super_block * sbd;
    - struct buffer_head *bh1 = sb->sv_bh1;
    - struct buffer_head *bh2 = sb->sv_bh2;
    + struct buffer_head *bh1 = sbi->s_bh1;
    + struct buffer_head *bh2 = sbi->s_bh2;

    if (bh1 == bh2)
    sbd = (struct sysv4_super_block *) (bh1->b_data + BLOCK_SIZE/2);
    else
    sbd = (struct sysv4_super_block *) bh2->b_data;

    - sb->sv_link_max = SYSV_LINK_MAX;
    - sb->sv_fic_size = SYSV_NICINOD;
    - sb->sv_flc_size = SYSV_NICFREE;
    - sb->sv_sbd1 = (char *) sbd;
    - sb->sv_sbd2 = (char *) sbd;
    - sb->sv_sb_fic_count = &sbd->s_ninode;
    - sb->sv_sb_fic_inodes = &sbd->s_inode[0];
    - sb->sv_sb_total_free_inodes = &sbd->s_tinode;
    - sb->sv_bcache_count = &sbd->s_nfree;
    - sb->sv_bcache = &sbd->s_free[0];
    - sb->sv_free_blocks = &sbd->s_tfree;
    - sb->sv_sb_time = &sbd->s_time;
    - sb->sv_sb_state = &sbd->s_state;
    - sb->sv_firstdatazone = fs16_to_cpu(sb, sbd->s_isize);
    - sb->sv_nzones = fs32_to_cpu(sb, sbd->s_fsize);
    -}
    -
    -static void detected_sysv2(struct super_block *sb)
    -{
    - struct sysv2_super_block * sbd;
    - struct buffer_head *bh1 = sb->sv_bh1;
    - struct buffer_head *bh2 = sb->sv_bh2;
    + sbi->s_link_max = SYSV_LINK_MAX;
    + sbi->s_fic_size = SYSV_NICINOD;
    + sbi->s_flc_size = SYSV_NICFREE;
    + sbi->s_sbd1 = (char *)sbd;
    + sbi->s_sbd2 = (char *)sbd;
    + sbi->s_sb_fic_count = &sbd->s_ninode;
    + sbi->s_sb_fic_inodes = &sbd->s_inode[0];
    + sbi->s_sb_total_free_inodes = &sbd->s_tinode;
    + sbi->s_bcache_count = &sbd->s_nfree;
    + sbi->s_bcache = &sbd->s_free[0];
    + sbi->s_free_blocks = &sbd->s_tfree;
    + sbi->s_sb_time = &sbd->s_time;
    + sbi->s_sb_state = &sbd->s_state;
    + sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd->s_isize);
    + sbi->s_nzones = fs32_to_cpu(sbi, sbd->s_fsize);
    +}
    +
    +static void detected_sysv2(struct sysv_sb_info *sbi)
    +{
    + struct sysv2_super_block *sbd;
    + struct buffer_head *bh1 = sbi->s_bh1;
    + struct buffer_head *bh2 = sbi->s_bh2;

    if (bh1 == bh2)
    sbd = (struct sysv2_super_block *) (bh1->b_data + BLOCK_SIZE/2);
    else
    sbd = (struct sysv2_super_block *) bh2->b_data;

    - sb->sv_link_max = SYSV_LINK_MAX;
    - sb->sv_fic_size = SYSV_NICINOD;
    - sb->sv_flc_size = SYSV_NICFREE;
    - sb->sv_sbd1 = (char *) sbd;
    - sb->sv_sbd2 = (char *) sbd;
    - sb->sv_sb_fic_count = &sbd->s_ninode;
    - sb->sv_sb_fic_inodes = &sbd->s_inode[0];
    - sb->sv_sb_total_free_inodes = &sbd->s_tinode;
    - sb->sv_bcache_count = &sbd->s_nfree;
    - sb->sv_bcache = &sbd->s_free[0];
    - sb->sv_free_blocks = &sbd->s_tfree;
    - sb->sv_sb_time = &sbd->s_time;
    - sb->sv_sb_state = &sbd->s_state;
    - sb->sv_firstdatazone = fs16_to_cpu(sb, sbd->s_isize);
    - sb->sv_nzones = fs32_to_cpu(sb, sbd->s_fsize);
    + sbi->s_link_max = SYSV_LINK_MAX;
    + sbi->s_fic_size = SYSV_NICINOD;
    + sbi->s_flc_size = SYSV_NICFREE;
    + sbi->s_sbd1 = (char *)sbd;
    + sbi->s_sbd2 = (char *)sbd;
    + sbi->s_sb_fic_count = &sbd->s_ninode;
    + sbi->s_sb_fic_inodes = &sbd->s_inode[0];
    + sbi->s_sb_total_free_inodes = &sbd->s_tinode;
    + sbi->s_bcache_count = &sbd->s_nfree;
    + sbi->s_bcache = &sbd->s_free[0];
    + sbi->s_free_blocks = &sbd->s_tfree;
    + sbi->s_sb_time = &sbd->s_time;
    + sbi->s_sb_state = &sbd->s_state;
    + sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd->s_isize);
    + sbi->s_nzones = fs32_to_cpu(sbi, sbd->s_fsize);
    }

    -static void detected_coherent(struct super_block *sb)
    +static void detected_coherent(struct sysv_sb_info *sbi)
    {
    struct coh_super_block * sbd;
    - struct buffer_head *bh1 = sb->sv_bh1;
    + struct buffer_head *bh1 = sbi->s_bh1;

    sbd = (struct coh_super_block *) bh1->b_data;

    - sb->sv_link_max = COH_LINK_MAX;
    - sb->sv_fic_size = COH_NICINOD;
    - sb->sv_flc_size = COH_NICFREE;
    - sb->sv_sbd1 = (char *) sbd;
    - sb->sv_sbd2 = (char *) sbd;
    - sb->sv_sb_fic_count = &sbd->s_ninode;
    - sb->sv_sb_fic_inodes = &sbd->s_inode[0];
    - sb->sv_sb_total_free_inodes = &sbd->s_tinode;
    - sb->sv_bcache_count = &sbd->s_nfree;
    - sb->sv_bcache = &sbd->s_free[0];
    - sb->sv_free_blocks = &sbd->s_tfree;
    - sb->sv_sb_time = &sbd->s_time;
    - sb->sv_firstdatazone = fs16_to_cpu(sb, sbd->s_isize);
    - sb->sv_nzones = fs32_to_cpu(sb, sbd->s_fsize);
    + sbi->s_link_max = COH_LINK_MAX;
    + sbi->s_fic_size = COH_NICINOD;
    + sbi->s_flc_size = COH_NICFREE;
    + sbi->s_sbd1 = (char *)sbd;
    + sbi->s_sbd2 = (char *)sbd;
    + sbi->s_sb_fic_count = &sbd->s_ninode;
    + sbi->s_sb_fic_inodes = &sbd->s_inode[0];
    + sbi->s_sb_total_free_inodes = &sbd->s_tinode;
    + sbi->s_bcache_count = &sbd->s_nfree;
    + sbi->s_bcache = &sbd->s_free[0];
    + sbi->s_free_blocks = &sbd->s_tfree;
    + sbi->s_sb_time = &sbd->s_time;
    + sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd->s_isize);
    + sbi->s_nzones = fs32_to_cpu(sbi, sbd->s_fsize);
    }

    -static void detected_v7(struct super_block *sb)
    +static void detected_v7(struct sysv_sb_info *sbi)
    {
    - struct buffer_head *bh2 = sb->sv_bh2;
    + struct buffer_head *bh2 = sbi->s_bh2;
    struct v7_super_block *sbd = (struct v7_super_block *)bh2->b_data;

    - sb->sv_link_max = V7_LINK_MAX;
    - sb->sv_fic_size = V7_NICINOD;
    - sb->sv_flc_size = V7_NICFREE;
    - sb->sv_sbd1 = (char *)sbd;
    - sb->sv_sbd2 = (char *)sbd;
    - sb->sv_sb_fic_count = &sbd->s_ninode;
    - sb->sv_sb_fic_inodes = &sbd->s_inode[0];
    - sb->sv_sb_total_free_inodes = &sbd->s_tinode;
    - sb->sv_bcache_count = &sbd->s_nfree;
    - sb->sv_bcache = &sbd->s_free[0];
    - sb->sv_free_blocks = &sbd->s_tfree;
    - sb->sv_sb_time = &sbd->s_time;
    - sb->sv_firstdatazone = fs16_to_cpu(sb, sbd->s_isize);
    - sb->sv_nzones = fs32_to_cpu(sb, sbd->s_fsize);
    + sbi->s_link_max = V7_LINK_MAX;
    + sbi->s_fic_size = V7_NICINOD;
    + sbi->s_flc_size = V7_NICFREE;
    + sbi->s_sbd1 = (char *)sbd;
    + sbi->s_sbd2 = (char *)sbd;
    + sbi->s_sb_fic_count = &sbd->s_ninode;
    + sbi->s_sb_fic_inodes = &sbd->s_inode[0];
    + sbi->s_sb_total_free_inodes = &sbd->s_tinode;
    + sbi->s_bcache_count = &sbd->s_nfree;
    + sbi->s_bcache = &sbd->s_free[0];
    + sbi->s_free_blocks = &sbd->s_tfree;
    + sbi->s_sb_time = &sbd->s_time;
    + sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd->s_isize);
    + sbi->s_nzones = fs32_to_cpu(sbi, sbd->s_fsize);
    }

    -static int detect_xenix (struct super_block *sb, struct buffer_head *bh)
    +static int detect_xenix(struct sysv_sb_info *sbi, struct buffer_head *bh)
    {
    - struct xenix_super_block * sbd = (struct xenix_super_block *)bh->b_data;
    + struct xenix_super_block *sbd = (struct xenix_super_block *)bh->b_data;
    if (sbd->s_magic == cpu_to_le32(0x2b5544))
    - sb->sv_bytesex = BYTESEX_LE;
    + sbi->s_bytesex = BYTESEX_LE;
    else if (sbd->s_magic == cpu_to_be32(0x2b5544))
    - sb->sv_bytesex = BYTESEX_BE;
    + sbi->s_bytesex = BYTESEX_BE;
    else
    return 0;
    if (sbd->s_type > 2 || sbd->s_type < 1)
    return 0;
    - sb->sv_type = FSTYPE_XENIX;
    + sbi->s_type = FSTYPE_XENIX;
    return sbd->s_type;
    }

    -static int detect_sysv (struct super_block *sb, struct buffer_head *bh)
    +static int detect_sysv(struct sysv_sb_info *sbi, struct buffer_head *bh)
    {
    + struct super_block *sb = sbi->s_sb;
    /* All relevant fields are at the same offsets in R2 and R4 */
    struct sysv4_super_block * sbd;

    sbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2);
    if (sbd->s_magic == cpu_to_le32(0xfd187e20))
    - sb->sv_bytesex = BYTESEX_LE;
    + sbi->s_bytesex = BYTESEX_LE;
    else if (sbd->s_magic == cpu_to_be32(0xfd187e20))
    - sb->sv_bytesex = BYTESEX_BE;
    + sbi->s_bytesex = BYTESEX_BE;
    else
    return 0;

    - if (fs16_to_cpu(sb, sbd->s_nfree) == 0xffff) {
    - sb->sv_type = FSTYPE_AFS;
    + if (fs16_to_cpu(sbi, sbd->s_nfree) == 0xffff) {
    + sbi->s_type = FSTYPE_AFS;
    if (!(sb->s_flags & MS_RDONLY)) {
    printk("SysV FS: SCO EAFS on %s detected, "
    "forcing read-only mode.\n",
    @@ -214,11 +214,11 @@
    return sbd->s_type;
    }

    - if (fs32_to_cpu(sb, sbd->s_time) < JAN_1_1980) {
    + if (fs32_to_cpu(sbi, sbd->s_time) < JAN_1_1980) {
    /* this is likely to happen on SystemV2 FS */
    if (sbd->s_type > 3 || sbd->s_type < 1)
    return 0;
    - sb->sv_type = FSTYPE_SYSV2;
    + sbi->s_type = FSTYPE_SYSV2;
    return sbd->s_type;
    }
    if ((sbd->s_type > 3 || sbd->s_type < 1) &&
    @@ -236,11 +236,11 @@
    sb->s_flags |= MS_RDONLY;
    }

    - sb->sv_type = FSTYPE_SYSV4;
    + sbi->s_type = FSTYPE_SYSV4;
    return sbd->s_type >= 0x10 ? (sbd->s_type >> 4) : sbd->s_type;
    }

    -static int detect_coherent (struct super_block *sb, struct buffer_head *bh)
    +static int detect_coherent(struct sysv_sb_info *sbi, struct buffer_head *bh)
    {
    struct coh_super_block * sbd;

    @@ -248,21 +248,21 @@
    if ((memcmp(sbd->s_fname,"noname",6) && memcmp(sbd->s_fname,"xxxxx ",6))
    || (memcmp(sbd->s_fpack,"nopack",6) && memcmp(sbd->s_fpack,"xxxxx\n",6)))
    return 0;
    - sb->sv_bytesex = BYTESEX_PDP;
    - sb->sv_type = FSTYPE_COH;
    + sbi->s_bytesex = BYTESEX_PDP;
    + sbi->s_type = FSTYPE_COH;
    return 1;
    }

    -static int detect_sysv_odd(struct super_block *sb, struct buffer_head *bh)
    +static int detect_sysv_odd(struct sysv_sb_info *sbi, struct buffer_head *bh)
    {
    - int size = detect_sysv(sb, bh);
    + int size = detect_sysv(sbi, bh);

    return size>2 ? 0 : size;
    }

    static struct {
    int block;
    - int (*test)(struct super_block *, struct buffer_head *);
    + int (*test)(struct sysv_sb_info *, struct buffer_head *);
    } flavours[] = {
    {1, detect_xenix},
    {0, detect_sysv},
    @@ -281,7 +281,7 @@
    [FSTYPE_AFS] "AFS",
    };

    -static void (*flavour_setup[])(struct super_block *) = {
    +static void (*flavour_setup[])(struct sysv_sb_info *) = {
    [FSTYPE_XENIX] detected_xenix,
    [FSTYPE_SYSV4] detected_sysv4,
    [FSTYPE_SYSV2] detected_sysv2,
    @@ -292,34 +292,35 @@

    static int complete_read_super(struct super_block *sb, int silent, int size)
    {
    + struct sysv_sb_info *sbi = SYSV_SB(sb);
    struct inode *root_inode;
    - char *found = flavour_names[sb->sv_type];
    + char *found = flavour_names[sbi->s_type];
    u_char n_bits = size+8;
    int bsize = 1 << n_bits;
    int bsize_4 = bsize >> 2;

    - sb->sv_firstinodezone = 2;
    + sbi->s_firstinodezone = 2;

    - flavour_setup[sb->sv_type](sb);
    + flavour_setup[sbi->s_type](sbi);

    - sb->sv_truncate = 1;
    - sb->sv_ndatazones = sb->sv_nzones - sb->sv_firstdatazone;
    - sb->sv_inodes_per_block = bsize >> 6;
    - sb->sv_inodes_per_block_1 = (bsize >> 6)-1;
    - sb->sv_inodes_per_block_bits = n_bits-6;
    - sb->sv_ind_per_block = bsize_4;
    - sb->sv_ind_per_block_2 = bsize_4*bsize_4;
    - sb->sv_toobig_block = 10 + bsize_4 * (1 + bsize_4 * (1 + bsize_4));
    - sb->sv_ind_per_block_bits = n_bits-2;
    + sbi->s_truncate = 1;
    + sbi->s_ndatazones = sbi->s_nzones - sbi->s_firstdatazone;
    + sbi->s_inodes_per_block = bsize >> 6;
    + sbi->s_inodes_per_block_1 = (bsize >> 6)-1;
    + sbi->s_inodes_per_block_bits = n_bits-6;
    + sbi->s_ind_per_block = bsize_4;
    + sbi->s_ind_per_block_2 = bsize_4*bsize_4;
    + sbi->s_toobig_block = 10 + bsize_4 * (1 + bsize_4 * (1 + bsize_4));
    + sbi->s_ind_per_block_bits = n_bits-2;

    - sb->sv_ninodes = (sb->sv_firstdatazone - sb->sv_firstinodezone)
    - << sb->sv_inodes_per_block_bits;
    + sbi->s_ninodes = (sbi->s_firstdatazone - sbi->s_firstinodezone)
    + << sbi->s_inodes_per_block_bits;

    if (!silent)
    printk("VFS: Found a %s FS (block size = %ld) on device %s\n",
    found, sb->s_blocksize, sb->s_id);

    - sb->s_magic = SYSV_MAGIC_BASE + sb->sv_type;
    + sb->s_magic = SYSV_MAGIC_BASE + sbi->s_type;
    /* set up enough so that it can read an inode */
    sb->s_op = &sysv_sops;
    root_inode = iget(sb,SYSV_ROOT_INO);
    @@ -333,7 +334,7 @@
    printk("SysV FS: get root dentry failed\n");
    return 0;
    }
    - if (sb->sv_truncate)
    + if (sbi->s_truncate)
    sb->s_root->d_op = &sysv_dentry_operations;
    sb->s_flags |= MS_RDONLY;
    sb->s_dirt = 1;
    @@ -342,30 +343,39 @@

    static int sysv_fill_super(struct super_block *sb, void *data, int silent)
    {
    - struct buffer_head *bh1;
    - struct buffer_head *bh = NULL;
    + struct buffer_head *bh1, *bh = NULL;
    + struct sysv_sb_info *sbi;
    unsigned long blocknr;
    - int size = 0;
    - int i;
    + int size = 0, i;

    if (1024 != sizeof (struct xenix_super_block))
    - panic("Xenix FS: bad super-block size");
    - if ((512 != sizeof (struct sysv4_super_block))
    - || (512 != sizeof (struct sysv2_super_block)))
    - panic("SystemV FS: bad super-block size");
    + panic("Xenix FS: bad superblock size");
    + if (512 != sizeof (struct sysv4_super_block))
    + panic("SystemV FS: bad superblock size");
    + if (512 != sizeof (struct sysv2_super_block))
    + panic("SystemV FS: bad superblock size");
    if (500 != sizeof (struct coh_super_block))
    - panic("Coherent FS: bad super-block size");
    + panic("Coherent FS: bad superblock size");
    if (64 != sizeof (struct sysv_inode))
    - panic("sysv fs: bad i-node size");
    + panic("sysv fs: bad inode size");
    +
    + sbi = kmalloc(sizeof(struct sysv_sb_info), GFP_KERNEL);
    + if (!sbi)
    + return -ENOMEM;
    + memset(sbi, 0, sizeof(struct sysv_sb_info));
    +
    + sbi->s_sb = sb;
    + sbi->s_block_base = 0;
    + sb->u.generic_sbp = sbi;
    +
    sb_set_blocksize(sb, BLOCK_SIZE);
    - sb->sv_block_base = 0;

    for (i = 0; i < sizeof(flavours)/sizeof(flavours[0]) && !size; i++) {
    brelse(bh);
    bh = sb_bread(sb, flavours[i].block);
    if (!bh)
    continue;
    - size = flavours[i].test(sb, bh);
    + size = flavours[i].test(SYSV_SB(sb), bh);
    }

    if (!size)
    @@ -393,8 +403,8 @@
    }

    if (bh && bh1) {
    - sb->sv_bh1 = bh1;
    - sb->sv_bh2 = bh;
    + sbi->s_bh1 = bh1;
    + sbi->s_bh2 = bh;
    if (complete_read_super(sb, silent, size))
    return 0;
    }
    @@ -404,6 +414,7 @@
    sb_set_blocksize(sb, BLOCK_SIZE);
    printk("oldfs: cannot read superblock\n");
    failed:
    + kfree(sbi);
    return -EINVAL;

    Eunknown:
    @@ -422,6 +433,7 @@

    static int v7_fill_super(struct super_block *sb, void *data, int silent)
    {
    + struct sysv_sb_info *sbi;
    struct buffer_head *bh, *bh2 = NULL;
    struct v7_super_block *v7sb;
    struct sysv_inode *v7i;
    @@ -431,9 +443,17 @@
    if (64 != sizeof (struct sysv_inode))
    panic("sysv fs: bad i-node size");

    - sb->sv_type = FSTYPE_V7;
    - sb->sv_bytesex = BYTESEX_PDP;
    -
    + sbi = kmalloc(sizeof(struct sysv_sb_info), GFP_KERNEL);
    + if (!sbi)
    + return -ENOMEM;
    + memset(sbi, 0, sizeof(struct sysv_sb_info));
    +
    + sbi->s_sb = sb;
    + sbi->s_block_base = 0;
    + sbi->s_type = FSTYPE_V7;
    + sbi->s_bytesex = BYTESEX_PDP;
    + sb->u.generic_sbp = sbi;
    +
    sb_set_blocksize(sb, 512);

    if ((bh = sb_bread(sb, 1)) == NULL) {
    @@ -445,9 +465,9 @@

    /* plausibility check on superblock */
    v7sb = (struct v7_super_block *) bh->b_data;
    - if (fs16_to_cpu(sb,v7sb->s_nfree) > V7_NICFREE ||
    - fs16_to_cpu(sb,v7sb->s_ninode) > V7_NICINOD ||
    - fs32_to_cpu(sb,v7sb->s_time) == 0)
    + if (fs16_to_cpu(sbi, v7sb->s_nfree) > V7_NICFREE ||
    + fs16_to_cpu(sbi, v7sb->s_ninode) > V7_NICINOD ||
    + fs32_to_cpu(sbi, v7sb->s_time) == 0)
    goto failed;

    /* plausibility check on root inode: it is a directory,
    @@ -455,20 +475,21 @@
    if ((bh2 = sb_bread(sb, 2)) == NULL)
    goto failed;
    v7i = (struct sysv_inode *)(bh2->b_data + 64);
    - if ((fs16_to_cpu(sb,v7i->i_mode) & ~0777) != S_IFDIR ||
    - (fs32_to_cpu(sb,v7i->i_size) == 0) ||
    - (fs32_to_cpu(sb,v7i->i_size) & 017) != 0)
    + if ((fs16_to_cpu(sbi, v7i->i_mode) & ~0777) != S_IFDIR ||
    + (fs32_to_cpu(sbi, v7i->i_size) == 0) ||
    + (fs32_to_cpu(sbi, v7i->i_size) & 017) != 0)
    goto failed;
    brelse(bh2);

    - sb->sv_bh1 = bh;
    - sb->sv_bh2 = bh;
    + sbi->s_bh1 = bh;
    + sbi->s_bh2 = bh;
    if (complete_read_super(sb, silent, 1))
    return 0;

    failed:
    brelse(bh2);
    brelse(bh);
    + kfree(sbi);
    return -EINVAL;
    }

    diff -Nru a/fs/sysv/symlink.c b/fs/sysv/symlink.c
    --- a/fs/sysv/symlink.c Mon Apr 29 13:12:01 2002
    +++ b/fs/sysv/symlink.c Mon Apr 29 13:12:01 2002
    @@ -5,8 +5,7 @@
    * Aug 2001, Christoph Hellwig (hch@infradead.org)
    */

    -#include <linux/fs.h>
    -#include <linux/sysv_fs.h>
    +#include "sysv.h"

    static int sysv_readlink(struct dentry *dentry, char *buffer, int buflen)
    {
    diff -Nru a/fs/sysv/sysv.h b/fs/sysv/sysv.h
    --- /dev/null Wed Dec 31 16:00:00 1969
    +++ b/fs/sysv/sysv.h Mon Apr 29 13:12:01 2002
    @@ -0,0 +1,236 @@
    +#ifndef _SYSV_H
    +#define _SYSV_H
    +
    +#include <linux/fs.h>
    +#include <linux/sysv_fs.h>
    +
    +/*
    + * SystemV/V7/Coherent super-block data in memory
    + *
    + * The SystemV/V7/Coherent superblock contains dynamic data (it gets modified
    + * while the system is running). This is in contrast to the Minix and Berkeley
    + * filesystems (where the superblock is never modified). This affects the
    + * sync() operation: we must keep the superblock in a disk buffer and use this
    + * one as our "working copy".
    + */
    +
    +struct sysv_sb_info {
    + struct super_block *s_sb; /* VFS superblock */
    + int s_type; /* file system type: FSTYPE_{XENIX|SYSV|COH} */
    + char s_bytesex; /* bytesex (le/be/pdp) */
    + char s_truncate; /* if 1: names > SYSV_NAMELEN chars are truncated */
    + /* if 0: they are disallowed (ENAMETOOLONG) */
    + nlink_t s_link_max; /* max number of hard links to a file */
    + unsigned int s_inodes_per_block; /* number of inodes per block */
    + unsigned int s_inodes_per_block_1; /* inodes_per_block - 1 */
    + unsigned int s_inodes_per_block_bits; /* log2(inodes_per_block) */
    + unsigned int s_ind_per_block; /* number of indirections per block */
    + unsigned int s_ind_per_block_bits; /* log2(ind_per_block) */
    + unsigned int s_ind_per_block_2; /* ind_per_block ^ 2 */
    + unsigned int s_toobig_block; /* 10 + ipb + ipb^2 + ipb^3 */
    + unsigned int s_block_base; /* physical block number of block 0 */
    + unsigned short s_fic_size; /* free inode cache size, NICINOD */
    + unsigned short s_flc_size; /* free block list chunk size, NICFREE */
    + /* The superblock is kept in one or two disk buffers: */
    + struct buffer_head *s_bh1;
    + struct buffer_head *s_bh2;
    + /* These are pointers into the disk buffer, to compensate for
    + different superblock layout. */
    + char * s_sbd1; /* entire superblock data, for part 1 */
    + char * s_sbd2; /* entire superblock data, for part 2 */
    + u16 *s_sb_fic_count; /* pointer to s_sbd->s_ninode */
    + u16 *s_sb_fic_inodes; /* pointer to s_sbd->s_inode */
    + u16 *s_sb_total_free_inodes; /* pointer to s_sbd->s_tinode */
    + u16 *s_bcache_count; /* pointer to s_sbd->s_nfree */
    + u32 *s_bcache; /* pointer to s_sbd->s_free */
    + u32 *s_free_blocks; /* pointer to s_sbd->s_tfree */
    + u32 *s_sb_time; /* pointer to s_sbd->s_time */
    + u32 *s_sb_state; /* pointer to s_sbd->s_state, only FSTYPE_SYSV */
    + /* We keep those superblock entities that don't change here;
    + this saves us an indirection and perhaps a conversion. */
    + u32 s_firstinodezone; /* index of first inode zone */
    + u32 s_firstdatazone; /* same as s_sbd->s_isize */
    + u32 s_ninodes; /* total number of inodes */
    + u32 s_ndatazones; /* total number of data zones */
    + u32 s_nzones; /* same as s_sbd->s_fsize */
    + u16 s_namelen; /* max length of dir entry */
    +};
    +
    +/*
    + * SystemV/V7/Coherent FS inode data in memory
    + */
    +struct sysv_inode_info {
    + u32 i_data[13];
    + u32 i_dir_start_lookup;
    + struct inode vfs_inode;
    +};
    +
    +
    +static inline struct sysv_inode_info *SYSV_I(struct inode *inode)
    +{
    + return list_entry(inode, struct sysv_inode_info, vfs_inode);
    +}
    +
    +static inline struct sysv_sb_info *SYSV_SB(struct super_block *sb)
    +{
    + return sb->u.generic_sbp;
    +}
    +
    +
    +/* identify the FS in memory */
    +enum {
    + FSTYPE_NONE = 0,
    + FSTYPE_XENIX,
    + FSTYPE_SYSV4,
    + FSTYPE_SYSV2,
    + FSTYPE_COH,
    + FSTYPE_V7,
    + FSTYPE_AFS,
    + FSTYPE_END,
    +};
    +
    +#define SYSV_MAGIC_BASE 0x012FF7B3
    +
    +#define XENIX_SUPER_MAGIC (SYSV_MAGIC_BASE+FSTYPE_XENIX)
    +#define SYSV4_SUPER_MAGIC (SYSV_MAGIC_BASE+FSTYPE_SYSV4)
    +#define SYSV2_SUPER_MAGIC (SYSV_MAGIC_BASE+FSTYPE_SYSV2)
    +#define COH_SUPER_MAGIC (SYSV_MAGIC_BASE+FSTYPE_COH)
    +
    +
    +/* Admissible values for i_nlink: 0.._LINK_MAX */
    +enum {
    + XENIX_LINK_MAX = 126, /* ?? */
    + SYSV_LINK_MAX = 126, /* 127? 251? */
    + V7_LINK_MAX = 126, /* ?? */
    + COH_LINK_MAX = 10000,
    +};
    +
    +
    +static inline void dirty_sb(struct super_block *sb)
    +{
    + struct sysv_sb_info *sbi = SYSV_SB(sb);
    +
    + mark_buffer_dirty(sbi->s_bh1);
    + if (sbi->s_bh1 != sbi->s_bh2)
    + mark_buffer_dirty(sbi->s_bh2);
    + sb->s_dirt = 1;
    +}
    +
    +
    +/* ialloc.c */
    +extern struct sysv_inode *sysv_raw_inode(struct super_block *, unsigned,
    + struct buffer_head **);
    +extern struct inode * sysv_new_inode(const struct inode *, mode_t);
    +extern void sysv_free_inode(struct inode *);
    +extern unsigned long sysv_count_free_inodes(struct super_block *);
    +
    +/* balloc.c */
    +extern u32 sysv_new_block(struct super_block *);
    +extern void sysv_free_block(struct super_block *, u32);
    +extern unsigned long sysv_count_free_blocks(struct super_block *);
    +
    +/* itree.c */
    +extern void sysv_truncate(struct inode *);
    +
    +/* inode.c */
    +extern void sysv_write_inode(struct inode *, int);
    +extern int sysv_sync_inode(struct inode *);
    +extern int sysv_sync_file(struct file *, struct dentry *, int);
    +extern void sysv_set_inode(struct inode *, dev_t);
    +
    +/* dir.c */
    +extern struct sysv_dir_entry *sysv_find_entry(struct dentry *, struct page **);
    +extern int sysv_add_link(struct dentry *, struct inode *);
    +extern int sysv_delete_entry(struct sysv_dir_entry *, struct page *);
    +extern int sysv_make_empty(struct inode *, struct inode *);
    +extern int sysv_empty_dir(struct inode *);
    +extern void sysv_set_link(struct sysv_dir_entry *, struct page *,
    + struct inode *);
    +extern struct sysv_dir_entry *sysv_dotdot(struct inode *, struct page **);
    +extern ino_t sysv_inode_by_name(struct dentry *);
    +
    +
    +extern struct inode_operations sysv_file_inode_operations;
    +extern struct inode_operations sysv_dir_inode_operations;
    +extern struct inode_operations sysv_fast_symlink_inode_operations;
    +extern struct file_operations sysv_file_operations;
    +extern struct file_operations sysv_dir_operations;
    +extern struct address_space_operations sysv_aops;
    +extern struct super_operations sysv_sops;
    +extern struct dentry_operations sysv_dentry_operations;
    +
    +
    +enum {
    + BYTESEX_LE,
    + BYTESEX_PDP,
    + BYTESEX_BE,
    +};
    +
    +static inline u32 PDP_swab(u32 x)
    +{
    +#ifdef __LITTLE_ENDIAN
    + return ((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16);
    +#else
    +#ifdef __BIG_ENDIAN
    + return ((x & 0xff00ff) << 8) | ((x & 0xff00ff00) >> 8);
    +#else
    +#error BYTESEX
    +#endif
    +#endif
    +}
    +
    +static inline u32 fs32_to_cpu(struct sysv_sb_info *sbi, u32 n)
    +{
    + if (sbi->s_bytesex == BYTESEX_PDP)
    + return PDP_swab(n);
    + else if (sbi->s_bytesex == BYTESEX_LE)
    + return le32_to_cpu(n);
    + else
    + return be32_to_cpu(n);
    +}
    +
    +static inline u32 cpu_to_fs32(struct sysv_sb_info *sbi, u32 n)
    +{
    + if (sbi->s_bytesex == BYTESEX_PDP)
    + return PDP_swab(n);
    + else if (sbi->s_bytesex == BYTESEX_LE)
    + return cpu_to_le32(n);
    + else
    + return cpu_to_be32(n);
    +}
    +
    +static inline u32 fs32_add(struct sysv_sb_info *sbi, u32 *n, int d)
    +{
    + if (sbi->s_bytesex == BYTESEX_PDP)
    + return *n = PDP_swab(PDP_swab(*n)+d);
    + else if (sbi->s_bytesex == BYTESEX_LE)
    + return *n = cpu_to_le32(le32_to_cpu(*n)+d);
    + else
    + return *n = cpu_to_be32(be32_to_cpu(*n)+d);
    +}
    +
    +static inline u16 fs16_to_cpu(struct sysv_sb_info *sbi, u16 n)
    +{
    + if (sbi->s_bytesex != BYTESEX_BE)
    + return le16_to_cpu(n);
    + else
    + return be16_to_cpu(n);
    +}
    +
    +static inline u16 cpu_to_fs16(struct sysv_sb_info *sbi, u16 n)
    +{
    + if (sbi->s_bytesex != BYTESEX_BE)
    + return cpu_to_le16(n);
    + else
    + return cpu_to_be16(n);
    +}
    +
    +static inline u16 fs16_add(struct sysv_sb_info *sbi, u16 *n, int d)
    +{
    + if (sbi->s_bytesex != BYTESEX_BE)
    + return *n = cpu_to_le16(le16_to_cpu(*n)+d);
    + else
    + return *n = cpu_to_be16(be16_to_cpu(*n)+d);
    +}
    +
    +#endif /* _SYSV_H */
    diff -Nru a/include/linux/fs.h b/include/linux/fs.h
    --- a/include/linux/fs.h Mon Apr 29 13:12:01 2002
    +++ b/include/linux/fs.h Mon Apr 29 13:12:01 2002
    @@ -679,7 +679,6 @@

    #include <linux/ext3_fs_sb.h>
    #include <linux/hpfs_fs_sb.h>
    -#include <linux/sysv_fs_sb.h>
    #include <linux/ufs_fs_sb.h>
    #include <linux/romfs_fs_sb.h>
    #include <linux/adfs_fs_sb.h>
    @@ -723,7 +722,6 @@
    union {
    struct ext3_sb_info ext3_sb;
    struct hpfs_sb_info hpfs_sb;
    - struct sysv_sb_info sysv_sb;
    struct ufs_sb_info ufs_sb;
    struct romfs_sb_info romfs_sb;
    struct adfs_sb_info adfs_sb;
    diff -Nru a/include/linux/sysv_fs.h b/include/linux/sysv_fs.h
    --- a/include/linux/sysv_fs.h Mon Apr 29 13:12:01 2002
    +++ b/include/linux/sysv_fs.h Mon Apr 29 13:12:01 2002
    @@ -1,69 +1,21 @@
    #ifndef _LINUX_SYSV_FS_H
    #define _LINUX_SYSV_FS_H

    -/*
    - * The SystemV/Coherent filesystem constants/structures/macros
    - */
    -
    -
    -/* This code assumes
    - - sizeof(short) = 2, sizeof(int) = 4, sizeof(long) = 4,
    - - alignof(short) = 2, alignof(long) = 4.
    -*/
    -
    -#ifdef __GNUC__
    -#define __packed2__ __attribute__ ((packed, aligned(2)))
    +#if defined(__GNUC__)
    +# define __packed2__ __attribute__((packed, aligned(2)))
    #else
    -#error I want gcc!
    +>> I want to scream! <<
    #endif

    -#include <linux/stat.h> /* declares S_IFLNK etc. */
    -#include <linux/sched.h> /* declares wake_up() */
    -#include <linux/sysv_fs_sb.h> /* defines the sv_... shortcuts */
    -
    -/* temporary hack. */
    -#include <linux/sysv_fs_i.h>
    -static inline struct sysv_inode_info *SYSV_I(struct inode *inode)
    -{
    - /* I think list_entry should have a more descriptive name.. --hch */
    - return list_entry(inode, struct sysv_inode_info, vfs_inode);
    -}
    -/* end temporary hack. */
    -
    -
    -/* Layout on disk */
    -/* ============== */
    -
    -static inline u32 PDP_swab(u32 x)
    -{
    -#ifdef __LITTLE_ENDIAN
    - return ((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16);
    -#else
    -#ifdef __BIG_ENDIAN
    - return ((x & 0xff00ff) << 8) | ((x & 0xff00ff00) >> 8);
    -#else
    -#error BYTESEX
    -#endif
    -#endif
    -}

    /* inode numbers are 16 bit */
    -
    typedef u16 sysv_ino_t;

    /* Block numbers are 24 bit, sometimes stored in 32 bit.
    On Coherent FS, they are always stored in PDP-11 manner: the least
    - significant 16 bits come last.
    -*/
    -
    + significant 16 bits come last. */
    typedef u32 sysv_zone_t;

    -/* Among the blocks ... */
    -/* Xenix FS, Coherent FS: block 0 is the boot block, block 1 the super-block.
    - SystemV FS: block 0 contains both the boot sector and the super-block. */
    -/* The first inode zone is sb->sv_firstinodezone (1 or 2). */
    -
    -/* Among the inodes ... */
    /* 0 is non-existent */
    #define SYSV_BADBL_INO 1 /* inode of bad blocks file */
    #define SYSV_ROOT_INO 2 /* inode of root directory */
    @@ -101,7 +53,8 @@

    };

    -/* SystemV FS comes in two variants:
    +/*
    + * SystemV FS comes in two variants:
    * sysv2: System V Release 2 (e.g. Microport), structure elements aligned(2).
    * sysv4: System V Release 4 (e.g. Consensys), structure elements aligned(4).
    */
    @@ -223,51 +176,21 @@
    };

    /* SystemV/Coherent inode data on disk */
    -
    struct sysv_inode {
    u16 i_mode;
    u16 i_nlink;
    u16 i_uid;
    u16 i_gid;
    u32 i_size;
    - union { /* directories, regular files, ... */
    - unsigned char i_addb[3*(10+1+1+1)+1]; /* zone numbers: max. 10 data blocks,
    - * then 1 indirection block,
    - * then 1 double indirection block,
    - * then 1 triple indirection block.
    - * Then maybe a "file generation number" ??
    - */
    - /* named pipes on Coherent */
    - struct {
    - char p_addp[30];
    - s16 p_pnc;
    - s16 p_prx;
    - s16 p_pwx;
    - } i_p;
    - } i_a;
    + u8 i_data[3*(10+1+1+1)];
    + u8 i_gen;
    u32 i_atime; /* time of last access */
    u32 i_mtime; /* time of last modification */
    u32 i_ctime; /* time of creation */
    };

    -/* Admissible values for i_nlink: 0.._LINK_MAX */
    -enum {
    - XENIX_LINK_MAX = 126, /* ?? */
    - SYSV_LINK_MAX = 126, /* 127? 251? */
    - V7_LINK_MAX = 126, /* ?? */
    - COH_LINK_MAX = 10000,
    -};
    -
    -/* The number of inodes per block is
    - sb->sv_inodes_per_block = block_size / sizeof(struct sysv_inode) */
    -/* The number of indirect pointers per block is
    - sb->sv_ind_per_block = block_size / sizeof(u32) */
    -
    -
    /* SystemV/Coherent directory entry on disk */
    -
    #define SYSV_NAMELEN 14 /* max size of name in struct sysv_dir_entry */
    -
    struct sysv_dir_entry {
    sysv_ino_t inode;
    char name[SYSV_NAMELEN]; /* up to 14 characters, the rest are zeroes */
    @@ -275,137 +198,4 @@

    #define SYSV_DIRSIZE sizeof(struct sysv_dir_entry) /* size of every directory entry */

    -
    -/* Operations */
    -/* ========== */
    -
    -/* identify the FS in memory */
    -enum {
    - FSTYPE_NONE = 0,
    - FSTYPE_XENIX,
    - FSTYPE_SYSV4,
    - FSTYPE_SYSV2,
    - FSTYPE_COH,
    - FSTYPE_V7,
    - FSTYPE_AFS,
    - FSTYPE_END,
    -};
    -
    -#define SYSV_MAGIC_BASE 0x012FF7B3
    -
    -#define XENIX_SUPER_MAGIC (SYSV_MAGIC_BASE+FSTYPE_XENIX)
    -#define SYSV4_SUPER_MAGIC (SYSV_MAGIC_BASE+FSTYPE_SYSV4)
    -#define SYSV2_SUPER_MAGIC (SYSV_MAGIC_BASE+FSTYPE_SYSV2)
    -#define COH_SUPER_MAGIC (SYSV_MAGIC_BASE+FSTYPE_COH)
    -
    -#ifdef __KERNEL__
    -
    -enum {
    - BYTESEX_LE,
    - BYTESEX_PDP,
    - BYTESEX_BE,
    -};
    -
    -/*
    - * Function prototypes
    - */
    -
    -extern struct inode * sysv_new_inode(const struct inode *, mode_t);
    -extern void sysv_free_inode(struct inode *);
    -extern unsigned long sysv_count_free_inodes(struct super_block *);
    -extern u32 sysv_new_block(struct super_block *);
    -extern void sysv_free_block(struct super_block *, u32);
    -extern unsigned long sysv_count_free_blocks(struct super_block *);
    -
    -extern void sysv_truncate(struct inode *);
    -
    -extern void sysv_write_inode(struct inode *, int);
    -extern int sysv_sync_inode(struct inode *);
    -extern int sysv_sync_file(struct file *, struct dentry *, int);
    -extern void sysv_set_inode(struct inode *, dev_t);
    -
    -extern struct sysv_dir_entry *sysv_find_entry(struct dentry*, struct page**);
    -extern int sysv_add_link(struct dentry*, struct inode*);
    -extern int sysv_delete_entry(struct sysv_dir_entry*, struct page*);
    -extern int sysv_make_empty(struct inode*, struct inode*);
    -extern int sysv_empty_dir(struct inode*);
    -extern void sysv_set_link(struct sysv_dir_entry*, struct page*, struct inode*);
    -extern struct sysv_dir_entry *sysv_dotdot(struct inode*, struct page**);
    -extern ino_t sysv_inode_by_name(struct dentry*);
    -
    -extern struct inode_operations sysv_file_inode_operations;
    -extern struct inode_operations sysv_dir_inode_operations;
    -extern struct inode_operations sysv_fast_symlink_inode_operations;
    -extern struct file_operations sysv_file_operations;
    -extern struct file_operations sysv_dir_operations;
    -extern struct address_space_operations sysv_aops;
    -extern struct super_operations sysv_sops;
    -extern struct dentry_operations sysv_dentry_operations;
    -
    -extern struct sysv_inode *sysv_raw_inode(struct super_block *, unsigned, struct buffer_head **);
    -
    -static inline void dirty_sb(struct super_block *sb)
    -{
    - mark_buffer_dirty(sb->sv_bh1);
    - if (sb->sv_bh1 != sb->sv_bh2)
    - mark_buffer_dirty(sb->sv_bh2);
    - sb->s_dirt = 1;
    -}
    -
    -static inline u32 fs32_to_cpu(struct super_block *sb, u32 n)
    -{
    - if (sb->sv_bytesex == BYTESEX_PDP)
    - return PDP_swab(n);
    - else if (sb->sv_bytesex == BYTESEX_LE)
    - return le32_to_cpu(n);
    - else
    - return be32_to_cpu(n);
    -}
    -
    -static inline u32 cpu_to_fs32(struct super_block *sb, u32 n)
    -{
    - if (sb->sv_bytesex == BYTESEX_PDP)
    - return PDP_swab(n);
    - else if (sb->sv_bytesex == BYTESEX_LE)
    - return cpu_to_le32(n);
    - else
    - return cpu_to_be32(n);
    -}
    -
    -static inline u32 fs32_add(struct super_block *sb, u32 *n, int d)
    -{
    - if (sb->sv_bytesex == BYTESEX_PDP)
    - return *n = PDP_swab(PDP_swab(*n)+d);
    - else if (sb->sv_bytesex == BYTESEX_LE)
    - return *n = cpu_to_le32(le32_to_cpu(*n)+d);
    - else
    - return *n = cpu_to_be32(be32_to_cpu(*n)+d);
    -}
    -
    -static inline u16 fs16_to_cpu(struct super_block *sb, u16 n)
    -{
    - if (sb->sv_bytesex != BYTESEX_BE)
    - return le16_to_cpu(n);
    - else
    - return be16_to_cpu(n);
    -}
    -
    -static inline u16 cpu_to_fs16(struct super_block *sb, u16 n)
    -{
    - if (sb->sv_bytesex != BYTESEX_BE)
    - return cpu_to_le16(n);
    - else
    - return cpu_to_be16(n);
    -}
    -
    -static inline u16 fs16_add(struct super_block *sb, u16 *n, int d)
    -{
    - if (sb->sv_bytesex != BYTESEX_BE)
    - return *n = cpu_to_le16(le16_to_cpu(*n)+d);
    - else
    - return *n = cpu_to_be16(be16_to_cpu(*n)+d);
    -}
    -
    -#endif /* __KERNEL__ */
    -
    -#endif
    +#endif /* _LINUX_SYSV_FS_H */
    diff -Nru a/include/linux/sysv_fs_i.h b/include/linux/sysv_fs_i.h
    --- a/include/linux/sysv_fs_i.h Mon Apr 29 13:12:01 2002
    +++ /dev/null Wed Dec 31 16:00:00 1969
    @@ -1,18 +0,0 @@
    -#ifndef _SYSV_FS_I
    -#define _SYSV_FS_I
    -
    -/*
    - * SystemV/V7/Coherent FS inode data in memory
    - */
    -struct sysv_inode_info {
    - u32 i_data[10+1+1+1]; /* zone numbers: max. 10 data blocks,
    - * then 1 indirection block,
    - * then 1 double indirection block,
    - * then 1 triple indirection block.
    - */
    - u32 i_dir_start_lookup;
    - struct inode vfs_inode;
    -};
    -
    -#endif
    -
    diff -Nru a/include/linux/sysv_fs_sb.h b/include/linux/sysv_fs_sb.h
    --- a/include/linux/sysv_fs_sb.h Mon Apr 29 13:12:01 2002
    +++ /dev/null Wed Dec 31 16:00:00 1969
    @@ -1,89 +0,0 @@
    -#ifndef _SYSV_FS_SB
    -#define _SYSV_FS_SB
    -
    -/*
    - * SystemV/V7/Coherent super-block data in memory
    - * The SystemV/V7/Coherent superblock contains dynamic data (it gets modified
    - * while the system is running). This is in contrast to the Minix and Berkeley
    - * filesystems (where the superblock is never modified). This affects the
    - * sync() operation: we must keep the superblock in a disk buffer and use this
    - * one as our "working copy".
    - */
    -
    -struct sysv_sb_info {
    - int s_type; /* file system type: FSTYPE_{XENIX|SYSV|COH} */
    - char s_bytesex; /* bytesex (le/be/pdp) */
    - char s_truncate; /* if 1: names > SYSV_NAMELEN chars are truncated */
    - /* if 0: they are disallowed (ENAMETOOLONG) */
    - nlink_t s_link_max; /* max number of hard links to a file */
    - unsigned int s_inodes_per_block; /* number of inodes per block */
    - unsigned int s_inodes_per_block_1; /* inodes_per_block - 1 */
    - unsigned int s_inodes_per_block_bits; /* log2(inodes_per_block) */
    - unsigned int s_ind_per_block; /* number of indirections per block */
    - unsigned int s_ind_per_block_bits; /* log2(ind_per_block) */
    - unsigned int s_ind_per_block_2; /* ind_per_block ^ 2 */
    - unsigned int s_toobig_block; /* 10 + ipb + ipb^2 + ipb^3 */
    - unsigned int s_block_base; /* physical block number of block 0 */
    - unsigned short s_fic_size; /* free inode cache size, NICINOD */
    - unsigned short s_flc_size; /* free block list chunk size, NICFREE */
    - /* The superblock is kept in one or two disk buffers: */
    - struct buffer_head *s_bh1;
    - struct buffer_head *s_bh2;
    - /* These are pointers into the disk buffer, to compensate for
    - different superblock layout. */
    - char * s_sbd1; /* entire superblock data, for part 1 */
    - char * s_sbd2; /* entire superblock data, for part 2 */
    - u16 *s_sb_fic_count; /* pointer to s_sbd->s_ninode */
    - u16 *s_sb_fic_inodes; /* pointer to s_sbd->s_inode */
    - u16 *s_sb_total_free_inodes; /* pointer to s_sbd->s_tinode */
    - u16 *s_bcache_count; /* pointer to s_sbd->s_nfree */
    - u32 *s_bcache; /* pointer to s_sbd->s_free */
    - u32 *s_free_blocks; /* pointer to s_sbd->s_tfree */
    - u32 *s_sb_time; /* pointer to s_sbd->s_time */
    - u32 *s_sb_state; /* pointer to s_sbd->s_state, only FSTYPE_SYSV */
    - /* We keep those superblock entities that don't change here;
    - this saves us an indirection and perhaps a conversion. */
    - u32 s_firstinodezone; /* index of first inode zone */
    - u32 s_firstdatazone; /* same as s_sbd->s_isize */
    - u32 s_ninodes; /* total number of inodes */
    - u32 s_ndatazones; /* total number of data zones */
    - u32 s_nzones; /* same as s_sbd->s_fsize */
    - u16 s_namelen; /* max length of dir entry */
    -};
    -/* The field s_toobig_block is currently unused. */
    -
    -/* sv_ == u.sysv_sb.s_ */
    -#define sv_type u.sysv_sb.s_type
    -#define sv_bytesex u.sysv_sb.s_bytesex
    -#define sv_truncate u.sysv_sb.s_truncate
    -#define sv_link_max u.sysv_sb.s_link_max
    -#define sv_inodes_per_block u.sysv_sb.s_inodes_per_block
    -#define sv_inodes_per_block_1 u.sysv_sb.s_inodes_per_block_1
    -#define sv_inodes_per_block_bits u.sysv_sb.s_inodes_per_block_bits
    -#define sv_ind_per_block u.sysv_sb.s_ind_per_block
    -#define sv_ind_per_block_bits u.sysv_sb.s_ind_per_block_bits
    -#define sv_ind_per_block_2 u.sysv_sb.s_ind_per_block_2
    -#define sv_toobig_block u.sysv_sb.s_toobig_block
    -#define sv_block_base u.sysv_sb.s_block_base
    -#define sv_fic_size u.sysv_sb.s_fic_size
    -#define sv_flc_size u.sysv_sb.s_flc_size
    -#define sv_bh1 u.sysv_sb.s_bh1
    -#define sv_bh2 u.sysv_sb.s_bh2
    -#define sv_sbd1 u.sysv_sb.s_sbd1
    -#define sv_sbd2 u.sysv_sb.s_sbd2
    -#define sv_sb_fic_count u.sysv_sb.s_sb_fic_count
    -#define sv_sb_fic_inodes u.sysv_sb.s_sb_fic_inodes
    -#define sv_sb_total_free_inodes u.sysv_sb.s_sb_total_free_inodes
    -#define sv_bcache_count u.sysv_sb.s_bcache_count
    -#define sv_bcache u.sysv_sb.s_bcache
    -#define sv_free_blocks u.sysv_sb.s_free_blocks
    -#define sv_sb_time u.sysv_sb.s_sb_time
    -#define sv_sb_state u.sysv_sb.s_sb_state
    -#define sv_firstinodezone u.sysv_sb.s_firstinodezone
    -#define sv_firstdatazone u.sysv_sb.s_firstdatazone
    -#define sv_ninodes u.sysv_sb.s_ninodes
    -#define sv_ndatazones u.sysv_sb.s_ndatazones
    -#define sv_nzones u.sysv_sb.s_nzones
    -#define sv_namelen u.sysv_sb.s_namelen
    -
    -#endif
    ===================================================================

    This BitKeeper patch contains the following changesets:
    1.547..1.548
    ## Wrapped with gzip_uu ##


    begin 664 bkpatch9031
    M'XL(`($JS3P``^Q<:7/;1M+^3/Z*25R5E62)P@QN*G)L67*BLBV[+,>;5+++
    MPC$042(!%@#JR#+[V]_N&9``2("'5K3]ID);A("9[NGIZ>.9`WI"?DYYTFWU
    MO7[["?DI3K-N*W4[;NK'T2",>"=.KJ#@0QQ#P6'"1_$A/![?';".?I#>IS=!
    MVH;R]T[F]<D-3])NBW;4V9/L?L2[K0]G/_[\YL6'=OOXF+SL.]$5O^09.3YN
    M9W%RXPS\]+F3]0=QU,D2)TJ'/',Z7CR<S*I.F*(P^*=34U5T8T(-13,G'O4I
    M=33*?85IEJ$5W/KQD"_GI5*+VAK0333#8F;[E(#4AMVQS0XE"CM4M$-%)53K
    M,J6KZT\5UE44`CIZ/J\;\M0F!TK[A#QN5UZV/?+"\WB:$JEDDHY'/'$'L7=-
    M@I!#0R3K)_'XJD\N?[W\U+L\V=DECIM"LUX60OOMUT333:JVWQ<J;Q]L^&FW
    M%4=I/R,C',SZG@7I(4IX*.3K>$7_;,52%;@U;6WB,UNQ?:JXONEIOAK4JK*>
    ME09CQ8"?,J&ZP7009KFFITS"*/9Y61Y3M55K0FU552>^I084#,"W3,=25\E3
    M857(HQBZI:PMCQ\F-=)8F@G?IN6:/E4#5?&HY6G+I2DQ*NE&-52Z4I8P\@9C
    MGTL/%MQZ0=J#EOH5P31EHANF;4X,REQN^P'S#=MT6+U<JY@60D*73?8P(6LD
    MU%%UNAH8W`M4V_$U2[?X!B(NRL<,0U/7-S!G`-Y8-Z86\++,P'`55>>:K9E^
    M8*^PL`JODD2699GK^5^8)9S7^9^A:A/34YEENB"AIQJ^;:V0ILRJ)(QM:N;:
    MZG$;U6.8RL36=8]9CFX&.K.9MUP>MT$["M4U:VV!(F?(P[J`H%L4[,AGCN&R
    MP/(4W??K8WT]JY(\ELZ,=KN6="X!3(GTB0S2I?S#2OE'[U*SRY;G'VU;^>>M
    M<\VGV6><PJ_NP;-QYXI'/`D]</"1S#&&\9?(,2HU&9UHILK6C^G;S#%2'L74
    M[:\S9$KYF&%;F^:=!=%4&\Q05R'?*-RV+-\,`M]PN;&.9'5"0?+2K?7]$(G0
    M#]&02WZH5OQ05[J:MM0/J;HU1XQO9HX(O8\33GPG<TB0Q$/2,%`@!IG9.GQU
    M^NBMNJT!A'H,;_T:<J2JPP5,4%%6F^!G24M2($.C]OII:5NX4,I"%5-;C9GK
    M(5Q8!PNI;DV8YD(D899A.+;IF@WC=A)FKSF'*'OH\P'/N'_8@5\.2MS_.\^H
    M[),00R'Z*<P&Z9='<F'=\QU7&`#BB>?I'M=4U51]Q[:]%;BGCA.&.&4-U/HY
    M4$;>,]W05GO@5J#^BB%%[O^=8U0=4I!>I70#C+W-!"NUJ9F*\16@#R&,IFE,
    M6U.8^R%PO2Z)PQ1*-6VB,JJ`WSN*RZ@>4%]S#=4T5QE^A5DAD`Y.M/YH!>&@
    M=K!`,(CU/+`4!@&$,H,[*SRQS*D4Z>'SP&"V;3`D`[\*%O'E9VO3M&@9=`,0
    M!$3:1.*#$@C2JB#(Z*KF4A#$MH6!+ITHS,(_`/GP(,1?XXC$P105^=*[)<+1
    MZ.=$.%N-4`8F06KI7ZO5HWS4H+:YB:%!/)K(82H9FEX8&E-@RKO*T.BV#.T#
    M'PT<CY.3UV]($"?$ZSMA1'#=-8RNR&V8]7.C.Q@EX8V3<9+<8FF'Y-9G?J[9
    M\#9CB,5TE4TT2S64=K&N/N+1U3A<H64-_E%%U?2)`B%(F0TRI7JQMJX1:G4U
    M%<;WRXSR6YY<X8I&M<'NW`8'5`PCF$BMJC?="`GKM;QB[6=]JO),=0.J4FC?
    MA*KPT_6IT&XDE0GN`/,@36V_?1#U]D/X9UJ5T*@!J,Z&;IF&W6X[UZ/A\S_"
    M$8K0<<:+:C#`=PQF3&!2;+'">U2E\!X+O0<WI^B7])[^-4\B/GB>7SONM1MF
    M:2?B67?!,[;D2*A;%>&N,+37Q&"6OK[!5:G_,@9G04;6*/@10SC:3H:#YQGW
    M^C:.S((28+)``9;#W,.P;4N8&\27CC$S-JH01KN:V56^J+%]J5`ME,GH1%H6
    M9GC;6M_"JM1_%0NC"F!:`_(73.8T>V-\0`U&P>(`.6(:%":GJ[13[+Q3"TU.
    ML;KZ5V9RG\?FA'I-A4ZDK;TF3,4%Q35M;H[Z+V-S%L);#88-)MGKSFLED4XG
    M4H.%I4WWV*A-J-E5M:[VA7"HM(PN^63B%EM*=,J(>P^3"G'2(]TG49P1^MKM
    M"#-@]'&FME]RL8O:5%<UF#=JJJ6H[4T.[6C0+-.IIDZ8KEGY>&IF/I8,4)'=
    MU5F7*@>*B6.YA/56)Y!!>$?<)+[F$0%$%(](YD`\R4C6=S)R!0.:\(-I^3T\
    MY>3EITLRQ*"#PVR`<A]GF'G"[YZ+[X[WQ\RWTG@<^8?#T1CF:3-G%<NS#,(&
    M919,W1S'5G1+MV$BY['`,9;I<BEC.69,L29P8],'C#>CN)B%.GD[/]Y,Z2IV
    MEZGKC+>RC?$NC](EN8%8#]/<=DJNX&<`/[YS$_K#Y[=..!@[G?YH`#_U/344
    M4\%IFH*?!XSX_Z)7Z4?65*\0$V%BKL($8VE,W-YVI\B^4I=Y@LU7^?@-'\2C
    M(8_`EQ+.UTZHU32P+I4(5+B2*N+N:Z+:MD[73L-5ZK_`@B2S*40#*K9,V*9G
    M$K8%"T`H$:<F%`#IFELG6ULWFVE(LU4\@'!\/+<%CT=>+_@MP>V-[EQ9^Q/1
    M&F#-0W8ZA5,K"T<8EL.<K<1(C\RV#47'23TZ/IQ3!R9"%1UG[OD'LM#57XAR
    M9S'ZD*CYN/JF&^J;J<9V@N@K0H4"<>?Z'3E(;L5_Z/&".C?7V;D"2-1H/PF#
    MR.<!Z8GCQS^UGXB-&3Z[_QUJ2*\EWQ=N^VSAZ6Q?X1F0'.ZUR1ZYO$\S/OQT
    M^,D\?!GW`;Y`O!<@\D">?Q:'7\(($-,P3NZ!`HD^`HQJ))1T7AQE3AA!(KF/
    MG&'H248[(8`RGJ5D&/MA$'(?N=WVT5(1FJ6")PE3DHRC*(RN=CO0%MSB_TCP
    M3)PTP_,V6/UM&`'Z<R*?G/#DF@\XRB?L7C)*R<XM2B9Y%[(!MPC26S*38MJ,
    M$P3<R_"T-T=.Z7WD[>R2&`@=W`3KDEM.AF,0X!I<;(%K1!SBA^DU<<?`)Q&"
    MX5F^#%@CNQA&S$E)/$[(M[=Q(O8XO'AT_VT'2@]A1-(L&7N9R,"]U.V%41"3
    M_[1;T\?85$^VM8<'`(Y:AWODTZO+LA#`IP5IO$7D)^WA2P%'+:PIXD&N8?&J
    M`'EU^?'7]V>]__QR=G'^RP1M:?+RW4]_"B9>WTD*+CA-2OF=:#'_G>P,^*'+
    M#T?^:+>&`F2./"?C@B0,".T2/&.1DF?R#/W%B[=G;\XN<,LG`<7C(.44ON"&
    M'TFI=%'3]Z(.J!</`MU"I9TS9/'QW;LW[RY^E!*@MU_W,C(30MP/'2DW7$DT
    M'KHP,C$D8R?Q"9:G:$V.U`XR&4=I>!5!`Z!&P41DYK0W4[Y@5C"2Q8C_23$$
    M*YGTJ%3,W&-R0.B:#'#]5_`8Q%=L9[YXMXF+7^[(?$_\,.'BC88U^N,OD<7?
    M3)`>RY51>D;^35@]:1;';GA5[@)5R%,2CESY_6^67]5Z^EQD)Y6V.>K?IZ'G
    M#/+>%NJ0]TJ52=J/$W#%7H"G<L,_)(L`@(D<2N(Y'D8%*-DG%^<OSR_>G38P
    M&,PSD.T-0@@O7G\<71=<7GTX.Q-<#F7HK8:R:S[*,/A@>(D3DMW&Y2B4=@5E
    M'D/DLUZ?.S[&$+=/CYK+V-&T10ABZ'VC&'0(+.5$`<-?J:%]]"/(H",>I;A3
    M&\1)&\,!1-A@(3L,G/MXG'5F<0.B8^&UJ>M3.;!`!199)L0LLB_VBD<.Z)$V
    M<F!K<LB-C!JD]!'A58RQ!]/L3-J)[#SV4C1P\"SM17+0@<.4LI&1=-`CTL!I
    MQJA>E"S.G$$/S605HVP9)U>8YZI."6L4#%36FB=N)"M3S34KY):+;(WDV1)Z
    M5$`X;&X:"YM)TVR:ANIH1>D^.,_@?IH/,3]-W>V??)KKX[1B1FA86<A3N=`$
    M2/,?Z+:('0E"CB-A^YCY2>K<<#S4#WB@'&(%/`!V?6<$18AM\(T^?)NLKBL8
    M<9)4#NX?X.EB_($;Y&$(5:(LCT!8NH0#FK]@@+U+(2,C)"G,$&-./764&Q[2
    M"7-<S('U=-,6ZTD%+!3%#>0%Z8*T02$M-0KH@3ACP*.C_$&>^N')5=87388)
    M#E]RCZ1_'BV%PH"NI%H7</!A!:Z)2C/$AH[3"GM(\QM5_W54/`D3M+@DZPWB
    M^'H\*J*O8-"Z"?)0<"0%0TP(T!/W/G`F0QJ:W!.0ZGRGS(OLB<MN&^1)>#9.
    M(I%;>J+G$B_L-_#;)S,Y=D&0I5),<>K>],W(6K3JEL58>+=%MH'#0$(?'2N0
    M*[5"^;G&4>$<S`;5F_OIQ;N+,W),E/W9$P%DBUL42:O>LN(6H&YQ\\DL?G_Q
    MZK*X.;LXW9=C,9UTB8Z^??'C^<O>R8O+LU9+N5,H>_7*/%%+M80HO<N?WY]]
    MD)5;.W.$3\M"[U;8:VL1BII50K8V(2L(01$5LD8ZJ+@[':@7_C!,T]`%U`RS
    MZ3&X+Z;4L"<P>)<HG4[OS?G%:^#R2WGHI%JF):WC%F7&/CKW#S\(1Q8MUQ13
    M9OY`F$YEK4]FP1P_"VRP2V4NN-"[7^]2-W'H8TC([L$4EUEOK=6G;@@F.+-]
    M=Q>;:`V=!!"FQ%."-92$&+$`<$&-%LQJ2D_(-\=D=@?CTEI&SY`>/2@5)=`X
    M+;M/_IJ$4/D=Y+IHT<5!:/P]<6[E?6V?]\D4L>[C7*P.(NZ!)-4V<O:RK8A/
    M^4-J@^Q4K;./<V_>RPH>8ASD`L4,YLP%M*+R#$X/8IA$"RH!:LH0J;9?NS+<
    M$W=149AZ9I*+ZDT<ZB5N)ME'WNL*+W'24N'SE="2[(4HTUGTHNHDJ5QFKB6]
    M3<*L7O'[B/B+#N!,2KK!?>2M&*EJ79QE3ZO*&?<L!_EY2IYKJQ`OY5F#<#Z_
    M$98D>BA>S6FP?TR_>3-RW'#**1/B@A3Y@Y$#B&ZOKD..[XL%AD;29EW(-SJJ
    M+<\+."=!#9>A<PT\AJ/L?D$C*R409-A<X\!5%5_NZ`I)RP%C@>NRT?#C#/XW
    M]:5F(.)>!;JX]P+ZS8_'KHSZ-:&J-UO92W,_!I/LS1?51KD%4NS,PR@#!U!9
    M_E;(2A9"PEJQ-Z1!>9M)P+83G@+0'CG>(JT3CQ8H9*":KYG6U)3CLBC0_.-\
    MV'+@</+KQ[/+,X`.9_O%S?O3]Z6[D[,\Q5<3/,9UJ-A+;QUW!V_N,)T_"0.Q
    MH@XPX>/'-P+GG;^XF&'4G9T[\AU1[@+X[)+OOR?4V"63RF/$%+ODV3,L.FH_
    MX8.4%UQ/SG]L9JDH.5.KRA.?YSRM@B5/$D!6>2?A%J:0P?2RB,VQ@T&JLEX6
    M][S1N.*S9=0B<A*)!+(IPY%\<??XF)24C)@D[\5,DQ$"$920+"=_<U:B'O!"
    MLAF#HMB=*Z[O'I1B)>SE5]:]7#+L95WW\F)W6KQD],`!5_1M+Q*9DO@;]W$O
    M`M0XZ^CLE[UH]ZG_D%X+?N6NET>YPK6>1NC#K:&IT0\U0#_46,.ZH6;C\']3
    M].2D:IX%ZUKSK!;7RS<S3VH\MGPS)0/K9?:5%R_1WPK[@FHK[:M)R*HY@"AE
    MK:YE#D#CUM!@=V3<PS6=?.\3D5YY\W^*C8^/VX]]/*%]$R;Q\R$P[(S2<8?[
    MXP8^%%\+59F-YU%L0^Q6&PM_Z&K%(4A*#NRO\R]=R3]-T[#3G2OB`5O=I\PD
    M:ON<V41;?ZZ->YUDE"6IV((BLWETS?94:0\&YUVMZ5)L/N%JH!5@UH_'[H`O
    MK]AC1^U372.T?2Z^JWZ'8LIJZZ7E9!>8&8(9?A<K9](#9SM8Y&DUV2,#(`91
    M;`NIQ7>K-6L>A*^(45+F/AD=/+OF]TA,-06IY:75&CEB+;2!5D#6@V=A3S!Q
    MP4"]_F_1`?U7)^?&J%`+7IA8W!CUW/Z.V^\!Q!P/,D#X[GZS6'(K6+P9^)O/
    M1UE_RAE9JZJ.K.4%JJWNI-#.\J,H2_\D$SJSN>'1$_!EMA5?/L^/=T!OG0'!
    M91F>"!<5[R,_OHM:,(#G$)IH<;+D6WFVY=M-=5I^<1IU:BV\D\J6Z]0F!W0[
    M6OV?WDJ5KW$^ONIMM',#/2B/++)-F`%/=V5[N>U_^&?OS;N7KWL_7^#E[!1G
    M1*>V<$'QW<*%"]&G'?&]3RY^?O-FG^1["'+9'_U9;'D\)7MQ$*0\2\%OSJE"
    MA:,E8&JBO9WO*LW+.EI19QS5USJEB@AO\@*>>Q5G,8$9O=S61RM39.!;RL00
    M48X:-D86/`W#$[EYX(!>Q"#>RJWK=#0(/1P^:`7WY+)P,,`]!BC"?;@;QW,@
    MPN'2L5P%:VK09*)!4\4&9=4FZ7Z'>I;HW?)ZITPQH=8I8Z(SS,3._+Y"$``F
    MHC)<F$1GW^!V=N@,1!`GWWU']F8/1KLX@UXA!O`2R>)/"*<*6T-L58SSN;RT
    MY"&NG;Q-\HR(1D]54P<!3S6*`7K#$%%^+QI#A+UP:'IEV*5;"1`_H<F(5PC\
    M=DC61(4:8]36;<68,(W9&H8*<7+U[4,9/'Z,H3)14S%8+3=!C`YY&A-F^7BM
    M?,5D382]T;LM2Q!VA8^*;[,Q/%1O4#RX*LZ#LDTAMF:`@:A?*<J6?X"UZ3RI
    M5,9#QE@3<4-\YXE$;H#Q#+`P]WMW/`KO&N$IP%(-P].YKF#<J=L6P@VMTGY6
    MTP$CM\_*U1`]&Q!UM/8Y1`R*4P!9-#W"!Y6K>X='LRK3LUBS*OG!JU*-P6(-
    M/%15U,`S1U"Z(X\2[8HC2.5"5BUDY<+BH!!4^@Y)B[-!"_7RHQ*EBN+);\J_
    M*E47#OSD%*PXXU/4+Q_KJ8B`]//5RA6PO-)R:0>JTF"547X>IRK2D)='I'32
    MA!Q7EVQPCC+K.X[*;D$H3WL(BKE9S4SDG.+4%-E2?-<:,MJNMLR0+8J&;+''
    M-V0+7(1)",-8G257=KEK#5F>D5UBQ],*J\QXF14O->)U;7AC$U[3@E<9\)KV
    MN])\%ZUW>F:L5$&>(=O(OC<V[[)UEU;N%JVZ>=5[_IP"Z\T=9/`;C?BAMDXI
    MI!(=C%VE>/W;V/\V]DV-_92J$G>J6E,P]_+S>,OB.55-R04O:UKY*=6H`!T4
    M%^UJ44?Y*%&M]6*%9<:;E_]MNX]NNY_!,G5I4WHC7KXQE]JD;DMZN]DF%T-J
    M#H1I(Q(NG7^K-4DH7V:1LOAO@_S_:)`2]M(R[A6[=,(>5\S>9F=IYBP0#=62
    M*_[B,C54P6T!0J`E-%?8=?L'SURQ=HCB6G*]3%Q:L]&8;BB7]I-%99D&+&UY
    MY1-967J6)3U+UL77VJ!B^6`M5K55455<%G6&:GJ`RH"?5M+5G)8*G_Z_ZHZT
    MMVWD^MG^%=P6""0[=CA#SI!T'".[55*XNW&"9--NFPT('92M6CY@24Z+"OO;
    M^P[>-V5KZ^X"HB-QWLR\>3/S[K<8D8J/T,N/)CQ(4K^=\J,)#]+4*,:@#E'N
    M&J0)K*(ZVA-]-.-'?BW_@1;EN/O^[2>RW+"6D1XA['("Q7W0-XZ-OWQ_Y@M?
    M>*Y)ZC\I!0&0(CV5;%?DC8R=6;2B_*A^U<97;5I1?A17M)%;J-D(4I%8*!7+
    MA56X_S#X\+)BD'#?XQ#9?,>/<J+S;VJ-\#5#9$4Q/<BV%Y[K&8)&$*2[&TA-
    M1C)^T/N]/9C/LE_>>7G/K'1F0YZ;Y]-Z>]/Y\/YF=8>^@JO;+U\K0`/Q`56<
    MRNS.:3+R#J3'N*1'&.TUQ?PG>&*&'5-PZ9?4@GPE%;5@%;5(D50VD`9`2'K3
    MXC?QL9.=31HHXI65W\KPX'UAP2.F@]#WEIVRX\,]#H!)#H7PP#\PRBZ.I&DA
    M//25,:*U/CDQ=/5K/MWDR9O]`U'S<F@YOZ8_#C)@)\6N?;OB!5\FK^P57DT'
    M;2)Z,&(S?,G8,WJB\I_]?E5_V7'3(@HT-L"BZ-3>O8Y9B%X9LG-K$-,%.K0<
    M'QMU2,,>)1W5_`C=\J^&Y[`O7N7C1&!**4(BV[5FV[6.#M<<&<$=8]G==HJE
    MF>#A@<$H"=]"I)?BAQ(/`K@-J*'+#=EA(#Q0PGVP^#+[>H@G1M:4SJ>+Y=$%
    M9'EDB8H[(%&+-0G)=T0B%R]W3VW9;5ZVA9;/4]M2,*_*667/X;\Z+YL.\(%M
    MN^AT8BL3X99>GO<.+VMX>YZDN&=CO:8POR*?%S=B:VK<BN*!DU:YNS1JQ9<I
    MWM.H;U<\1!T/L6R,,S387E%?SXS?3,=Q^NB@]<D_?3LX_1AW6;R_PZ;$7W*7
    M;5]^9IB">Z%A:EXAK=+W9D@%J86(::`A'4A=63HR]UB%TDWU"0PM-`>J[1A[
    M,)8$S_W('R!E[QG>!10W&#EJSYE=?G'OI/Z%QD`JAO3H]IY3Z:2]-:(\(//A
    M").`#"R;G*XL,NI4Z4R>XR>L&KH)O*S>M'@6,/-D*9GC3,SG!O^N#!M_=PU%
    M?D77LW'O#[^@%`&[]L@808\IW&'C/T3Q4IBM#P.EX+N;J9'F+^RT!-+O)X##
    M@,X'@)8/``UGJLEG:N1%12U3H:5U324A4EN&3IKBB`S,8(C-.#XB:L%G/6#Z
    M\HHBFWH\F3(V#$[N/[_]X/_XYN/9FY\B%'Q'^HK8'_/@S=G[=V_>P8]7P15P
    M0;S]815KP*(/@:4U']"Y"$_F?``<_D8!)2QJ`[0>>G_]0!XKGT[_\0:AV.1B
    MM'.))V[$<-D6(9,?-30(;WB&>A+8^!4&PQYT5;>N;5MT:,(M_PA8(YU`!FL=
    MS]AT638Z8^WNCF[6[^KHQD5<'M]*+FWR174W\'2K+3=#6%7YA*B6];_Q8VF3
    M")4SAV[!#X$UJ_PH)V\85M[U)*J=T];YI%OAGMW)\#[XY^L%(.5P$E1"D5IX
    M<,59:^4)CS,Z;K!1?E^/4"XN5)F>+)S@QCZA7OE&@:4KSU=*Z_=X&5-#6+1P
    M#:`P'Z>0MJ77)BR>F5F].*NMZ;;,:KN=??G@K+:8_#6WUN4XV63!';J(Z3/K
    M4D\AW9QVY]V'SP#??_=^\,;_!?[+1VG$X=>-=<DWJB78YFPH`)06$)2S5B#)
    ML$>9ZNA09KEP_6U)PGBX.YGM5FW_"!.;$`-;;NF3.*>4V)Y(Y%G];1]YM$HF
    MSB@5_Q7?%41R&/N6#\4(<Q-EW-L2XHRT3A6A$JFHC8P:)COV[]]^PJ`,@J]B
    M?3B#/B[5XX$@'79]DE/\D6Y<D\:1/G<B\U5!LM\K,7/AF%FE&VIT81P,X"0>
    M1VCLHXX<DLS)$3?U[JM7^9=QO/%O)OL,\_CW$T0GR=/@Z*<9T.?.SEYO)73:
    M_&.\RH;"X73B\7MTB'@9[IBF^(5>V=__BJJ].WR3)"&/'*[+L%'7S4X22\FV
    MBKRI[[F!^3A./:].J"B08]9WO?/:L6M[Y.%^?9<GXR\'!_3NUY<IEURBS@9"
    M%H+'18_.R(+F;%L4[B-0MY!L.:='`QV1[U#H0H2Q`&U'+B+G$72VLXB^:U8C
    M3Y]('XU[!T.@$+HM"'IG`D2)<7R;Y&^A=L\Q!ZI/2?Z(T1U=])]C5[QZ]&A!
    MN0=$ND(YE;1;>I8*OK_YT7C>"8?IS[%#-CW!;XX$]XICI.[8S5*PG^5UAWVR
    M4WG(YPS%.(?KDO5#RR^;GSV9(L*2L8_B^`ZV-/%CYR%[`&'Q=@IC\&IW0,[D
    M6XZF$@(>2-XZ,MPZ)8N0)D\,F$^39[TD6ZRYS$I8DYB)?%3KDQ1[N#ST%O@>
    M2;<263'*Y9Y,I>CV;&Z'"M6%ZF9E,&#[.29*O*8+(E,FC*8M6^L9!\X396HM
    M#/ZH6%W"PD91,";?7"8;M."_]%;,6,`H[I4L/&&8ZN!G__/9CV?O_W96W)SQ
    MR[D+HSR.-OX7_,&V=W9Y8&[KH;#8GL[1:=U@`5I3D"S)_+^T0USAB9D"6`XQ
    M">O%T.34V/IH(F!#O'J$>5KLU,0/U.8N<N=J!(9SSQR<3/S<LC8=D;DZ\*&1
    MRHICDKH6!?C=#TBN6?_H6TCSG=]X.G+MZ?;'8Y>JUVV4`#EXTK0L)==2"2'^
    M/RXX+M-=L7X\NP<LH-.X@+/.BIQ9I2+'A;WC.E,],BT5V)[M3*9>JR0>.8C:
    M-(7&DK@*%C(?7-Y.D^,8!]9V"NX\//V&Z[K5Z3<>P-*PI`."3H?\&[\6<EF^
    MRN>R#&UHSV*GC90C\)<9RK@L]]AA('B4+2M*[.8O]_J]N/$$78,X()T40\1B
    MVVZKIC+=--3WM);Y%>T(Y9`31BJ=1KE3V7X9E__K;B($X,T%`ARZ9S6X&&F2
    MG\@>'-Y@&7MCE&&OA[Z!B>=MA`MLL6_THNZ>5?9&PJ36G7#BD!**/J/X;X!K
    M'">R$'?#6BB'M%`N,PI[##LF!92#9_O[_8I[/KK>2:0FDINE%5BS6.)SB>-R
    M12R^X8CV]VLG'JN[!BS]>3KE#%'TZTWQ'#7>$"5*(Q9:S5C/&.**7OOX_OW/
    M_NG9>Y0H\?N3,A2B8@?C`@3ER&G4.Z5=\R/+-C<Z+F".E'UEBQ*JX_(+0QU%
    M"U+68;VFB=V"^;&3)*1*J3K*P@!BC0^K%"Q)5O.J=0HYU4ZKE,M;&<8:0(](
    M&`-ALSJ!'IWQ/Q"*K/T8:I329;9%6A<T'3">6$DL(K_?A#DN&S4O9N2JWYZL
    M<W[X?ANT%(;<+_C(-YXGDCUV^;'!7I>2VTLKHSFI"#^I/)3:J5)F%:H4OLSS
    M4OG3Y#21K=H&WR%I5U3Y6J1YS3!W<7M6,UU3KZD\7UUVMPR<.+N;,@%>UJ6C
    M+8.I3>/`?J):%:W<Z@1&C(F-+(5PA(9LGM/A0,Y:F,/HJS]]_OCQS=G/_L^G
    M[]X\-V[FDS`.*V9'60\\/%_`8?#ND_]Q\/[LI[\C-TIIAL;S8'A-;[_8V]TQ
    M]HS3:90GZ/PF3!)$R6^,F]4R*?-E1!GAH`5\>6T,E\OA^,(8K^[(H8\&MU@.
    MKVX/Z9T?H#$,!]LG-<F,;\.%@?G=84HTCN=<8&2VY']2TQ>[.]&DZE3M83A:
    M=+>7Z_'9YDKW.[Z4:AO&_9;HA\U_.6.IO0E:M&/TDOOC3K%]0_-HA#NY49<U
    MC-]M2(#/!E["UQ$PY>D4#BU$EH%"+_*0EV_,U=^8K+]IL`/RW$8.WHJ3ZF2[
    M:.HAWTB&O'JW66M.(4;W-(SVX&1:R&B8JM4"##OQ:/09O4]D;.2O8[0$T]5-
    MGR75%3")EX4.9M713EEC<G,V6[S!*5_5:9BURFB7M9;8:(X*XD?)<&GK-XZW
    MR,\WCUB8;!(RNXXYL@IV,/.Q5X-(W!J^0UZJ5KP`DG(YN9F;XA>O6/U:X.?B
    M`A)QZ,'+5*O5C`)%X>$O^_5MX9U,TW-N>MZBZ7FN*54?:1PLO95I%\6[Y$_:
    M3+,H:#?^8EAU0&>:#>,S.D96JW97A7;C5NW&8;MLK##GXPNI&ML\RP[R<(:R
    MQ>B+Q;XU7Y\7@G?O)L$]+:G0_6(8Z"S*&/C%_$IR1$V,7RG!2MZ5_&A'L,"*
    M(<%*D(>!8`OT6"&R9@DV3XEEC:8+_V)V?B'G-]_@C5Z&<`LPSAMAG*=AG)?!
    MB,BX>O@Q"1<HM.Q>+9!PD4!KF\4D7"30VG97I>W&C>UB$LX):1DJ*X-P2:5`
    M\+OKNP3'2+E]!L>1L)+3Q:8/>FS=BYE-C#'=ZS]+]1?MB@8Y+RTII"SFQ%.3
    MI*`[ABW);55^?XOU]IH"EFY72W^U8`'045YE@>/-Y0)D,"C=9?NXA0*2.6[!
    MI`$2DI]\@E[;,?469"PRPYY:&R7H+2"5"W#32`FI;A:INBELP081=RM(#3/3
    M8A7GFV_&<+X`B6XXGV.)5S\JT\?%26E.:.5T5:61[`'H%AXK(LE%L>&"I4,D
    MN5S1]-U;N4;9(=,/DR&0@PGE62PYJ<J;$N":CC?86TI;UMHD#!(9/-$LK!?#
    M^V`T7P6O5XO#V>BJ6@]D`TZU;2FQ5I8&VL;-*.7NN\TA;$%7PEG-B6\CQ>5E
    M<'<=S'NY<!C,>3#KHA`+&Q058LK%R4SD4(_DU!V;:C(Q:Q1B63A"F2">V!JN
    M.=>51<>'5A;7;46./5@=YBI9N<0A'C8Z.VP60NV8W<UQ?R<)@YSV<D$>.,H$
    M10FFV&%1Q4D$0K-'`4AL#LF",+#P`J?U8!_/T)\R^.9704K]5AA0_>F2H9L4
    M>T0X)KH13_WF5MJNU(X^A!Q4@\=,%+_#`=S3!<=0U<^[V":[\SU`@+*<M38#
    MSW4GSG0ZT:-`[X[.@[O%\O5D-KE>3E;C2UK#*F"6<.%R@+_66MIA<+YG'5J'
    MHB.G:VYK*3\&5S?W`1T!,<-+7.[T[N8JK$9+*^NH@J]H<=:;K*Y6J!D;:)*)
    M2\[5*MS"%C$%,+=ZK95MZ0BWXE#&R:X!HGMDRR/;:T+NEOQ95LN;U"U<MOMK
    M9A>R[HQZ6`+/T1Y>Q0\!LXT5+#_6JD=D"PU<@K?F"27+%B>M<''9X&84SE-8
    MMFS<:\VTI`3>!Z;E*D?A>DG/Q`SVF[5_"@OE"@U7L+/FF20+%86$8@IG<63K
    M(Z6>PD)U.3HTB"<N\.X:D=ZM+=5+]FSD^Z5KHDU0"-LK+570%L836&QA"L_6
    M2JUY-LEBQP'Y+BZV">>I?@J+G??OKYN8*ST!USE<P';WEM)=6X`8LWM+#*-V
    M;$!F1_("PI0"!`^IA6Q__@@%>'1@M-"GZ4"[ZV`V'[T>0[/5]>(;=EH_9FTJ
    MRX)C65B6UINV5S9Z$$B<\P7,>;JZFL&\9_/#V^'=Y76P!-0=_O.V#HJ4"@"A
    MV*5="F/P3(&WWB-`V\HV&\Z&4KS&"CG#T2&,J7HTTA'"]$RL[P$+'(J"*J4Q
    MD$?*/5+_C[Q*]DKOW#Q[T71MGCNZ.C=WL>P*2.A,:D!R`,SNS&CEP&R%U@JB
    M#B?.VD#>B1MFA![;7"N%X53*FNI@/+6\X<1VE1O4>9HW`(X<SJ7RM%NH$-=&
    M_2%=$'ZV(_T\W.%<:[N0.J0"(QN&T@E278M\0-UQ!KJ_H)QEIV2\^16CF+`=
    MAUC!IRX4.RVU/<9&QU*W42J@D'BLHV08-N>:#`/,E(8)TY2@)%/MW>2;W$R:
    M?$":G$PPM1K%3:F"4T/GDM``S&%@<9Z#>M\&;.%Q"W(O:5E!>&"QARH_'ECH
    M&8#QH'7[0;-+##_:#YK=WOGQ&.6;`2*/W&D_<H='[G0;N1OJE4M&WK6P,@#C
    M0;M5@\[5!QY8G(;;RJ;AWJQL,@#CJ7BJ9>\VNQ?8)4X_FQ5%!H@60ZQR6<H-
    MH8VTDKM:4H["=`CG8YG:J-6V9G_Y4&$[OD`'QYO[8$+>DS?L`+FZCF\3SVU@
    M'1YTFUA,9+0F<=7<7%Z]*B-8XUJPFHFGL(G3M@.WO+E5)6=P']S]>WF!3JQW
    MP1R69X+.K!-8JN`.?3FOY_\V)K/%97@YKC`^"/U>Y\%T2<Z_%K*GVUL>N-\I
    M!,*0<,U/C4DP!>1,>K[_Y[//?_+]_NX?P^\,W[\=CB^#B?3]'=\?+I=WL]%J
    M&?A^K\<_/#>&<_+6Z,E^GU)5L+<3?)Z<&*?&-ZSH"9-?C($JK[XSCH_1R<BP
    M+'(`%2F_3+%K&`9Z?LRF,ZH#"CN=LDO#8@!JAHOE(?KD8M(=G7'BD[LO]G:-
    M/2/)!DI-%F2!_G9CW`_O9@!O<81)VQW#05L+<SMD:P$61F(0.T;=4:AE4MS\
    MI].SS[]PB?.WG\(JYQO2+-GQ>5W+8I(;[?@2B'8[MKE/P^O9$EV6:,EGR'#B
    M>1&RJBGSO19>(>3Q$8E2T#4ZH&JMBB-0Y.[.RC6,V'S>$^:^P/_[6#.$?X(3
    MA?S6%"PLRBT_S)8_!@$F]YT$\P"VWHM#^.,@8E]GAQ>_27L$PH=TM1YZS@BZ
    MW4RF05@%J48+Y:[S'726:M*@8[G&=5RKD!(-+A^OB7:V)LH/",-'Y52`<T"'
    M)5-Z>:K98(TVE&(;>D)AYC<MY"CP)E,YT9XSE)M2`\(JDH/C.>M<!]VI(0,:
    ME3JV7-N.;5F%M)>M2JX:!]9V?(*^GTRB0MAXYO\53N(47P+?4!1'7@8^3"[.
    M\>WM`=PG0\R'BD6_J^1EH"O@8)V")UPU^C9QBA.9!'D9&15E42IUG9TBWD_*
    M-@"]'>Z)U/(FK"9/KWRWUR_O_VBW$Y)A640QP^D&FW"3[?Y'XP-N+&-\$8PO
    5%ZNK5V(ZP42SP]W_`@?&QZ/SSP``
    `
    end
    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/
    \
     
     \ /
      Last update: 2005-03-22 13:25    [W:0.189 / U:89.644 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site