diff -urN linux-2.4/Documentation/Configure.help linux-2.5/Documentation/Configure.help --- linux-2.4/Documentation/Configure.help Sat Nov 24 11:03:27 2001 +++ linux-2.5/Documentation/Configure.help Sat Nov 24 12:20:11 2001 @@ -13864,7 +13864,7 @@ The initial permissions of the root directory can be set with the mount option "mode". -Simple RAM-based file system support +Simple RAM-based file system support CONFIG_RAMFS Ramfs is a file system which keeps all files in RAM. It allows read and write access. @@ -13877,6 +13877,18 @@ inserted in and removed from the running kernel whenever you want), say M here and read . The module will be called ramfs.o. + +DumbFS Support (Experimental) +CONFIG_DUMBFS + DumbFs is a file system which doesn't do a whole lot atm, + and hence is rather dumb. + It uses Ramfs primitives, but is an attempt to do something + clever with the journalling layer. This is probably a Dumb idea. + + If you want to compile this as a module ( = code which can be + inserted in and removed from the running kernel whenever you want), + say M here and read . The module + will be called dumbfs.o. ISO 9660 CD-ROM file system support CONFIG_ISO9660_FS diff -urN linux-2.4/fs/Config.in linux-2.5/fs/Config.in --- linux-2.4/fs/Config.in Sat Nov 24 11:04:00 2001 +++ linux-2.5/fs/Config.in Sat Nov 24 11:52:38 2001 @@ -46,6 +46,7 @@ tristate 'Compressed ROM file system support' CONFIG_CRAMFS bool 'Virtual memory file system support (former shm fs)' CONFIG_TMPFS tristate 'Simple RAM-based file system support' CONFIG_RAMFS +tristate 'DumbFS support (Experimental)' CONFIG_DUMBFS tristate 'ISO 9660 CDROM file system support' CONFIG_ISO9660_FS dep_mbool ' Microsoft Joliet CDROM extensions' CONFIG_JOLIET $CONFIG_ISO9660_FS diff -urN linux-2.4/fs/Makefile linux-2.5/fs/Makefile --- linux-2.4/fs/Makefile Sat Nov 24 11:04:00 2001 +++ linux-2.5/fs/Makefile Sat Nov 24 12:42:32 2001 @@ -32,6 +32,7 @@ subdir-$(CONFIG_ZLIB_FS_INFLATE) += inflate_fs subdir-$(CONFIG_CRAMFS) += cramfs subdir-$(CONFIG_RAMFS) += ramfs +subdir-$(CONFIG_DUMBFS) += dumbfs subdir-$(CONFIG_CODA_FS) += coda subdir-$(CONFIG_INTERMEZZO_FS) += intermezzo subdir-$(CONFIG_MINIX_FS) += minix Binary files linux-2.4/fs/dumbfs/.inode.c.swo and linux-2.5/fs/dumbfs/.inode.c.swo differ diff -urN linux-2.4/fs/dumbfs/Makefile linux-2.5/fs/dumbfs/Makefile --- linux-2.4/fs/dumbfs/Makefile Thu Jan 1 01:00:00 1970 +++ linux-2.5/fs/dumbfs/Makefile Sat Nov 24 11:50:36 2001 @@ -0,0 +1,10 @@ +# +# Makefile for the linux dumbfs routines. +# + +O_TARGET := dumbfs.o + +obj-y := inode.o +obj-m := $(O_TARGET) + +include $(TOPDIR)/Rules.make diff -urN linux-2.4/fs/dumbfs/inode.c linux-2.5/fs/dumbfs/inode.c --- linux-2.4/fs/dumbfs/inode.c Thu Jan 1 01:00:00 1970 +++ linux-2.5/fs/dumbfs/inode.c Sun Nov 25 16:18:08 2001 @@ -0,0 +1,390 @@ +/* + * DumbFs a filesystem for Linux. + * + * Copyright (C) 2001 Roger Gammans + * + * based on ramfs:- + * Copyright (C) 2000 Linus Torvalds. + * 2000 Transmeta Corp. + * + * Usage limits added by David Gibson, Linuxcare Australia. + * This file is released under the GPL. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include + +/* some random number, copied from /dev/urandom.. */ +#define DUMBFS_MAGIC 0xADD528E7 + +/* + * Statically allocated filestructure means inodes are assigned as: + * 0 -> journal (phys log). + * 1 -> Root Dir + * 2 -> datafile + * 3 -> indexfile + * + * We also use the inode number in a hidoues hack later in + * or block alloc scheme! + */ +#define DUMBFS_JOURNAL_INO 0 +#define DUMBFS_ROOTDIR_INO 1 +#define DUMBFS_DATFILE_INO 2 +#define DUMBFS_NDXFILE_INO 3 + +/* our on disk super block matches out in core super block + * layout + */ +typedef struct dumbfs_sb_info dumbfs_dsk_super; + +static struct super_operations dumbfs_ops; +static struct file_operations dumbfs_dir_operations; +static struct file_operations dumbfs_file_operations; +static struct inode_operations dumbfs_dir_inode_operations; + +static int dumbfs_statfs(struct super_block *sb, struct statfs *buf) +{ + buf->f_type = DUMBFS_MAGIC; + buf->f_bsize = sb->s_blocksize; + buf->f_namelen = 255; + return 0; +} + +/* + * Lookup the data. This is trivial - if the doesn't match + * either of our two root files then it don't exist. + */ +static struct dentry * dumbfs_lookup(struct inode *dir, struct dentry *dentry) +{ + struct inode* inode = NULL; + //Is this our rootdir + if (dir->i_ino == DUMBFS_ROOTDIR_INO) { + + int ino =0; + if (!memcmp(dentry->d_name.name,"data",4)) + ino = DUMBFS_DATFILE_INO; + if (!memcmp(dentry->d_name.name,"index",5)) + ino = DUMBFS_NDXFILE_INO; + if (ino) + inode =iget(dir->i_sb , ino); + if (!inode) + return ERR_PTR(-EACCES); + + d_add(dentry,inode); + return dentry; + } + d_add(dentry, NULL); + return NULL; +} + +void dumbfs_read_inode(struct inode * inode) { + + + inode->i_uid = inode->i_sb->u.dumbfs_sb.uid; + inode->i_gid = inode->i_sb->u.dumbfs_sb.gid; + inode->i_atime = inode->i_sb->u.dumbfs_sb.atime; + inode->i_mtime = inode->i_sb->u.dumbfs_sb.mtime; + inode->i_ctime = inode->i_sb->u.dumbfs_sb.ctime; + + switch (inode->i_ino) { + case DUMBFS_JOURNAL_INO: + printk(KERN_ERR "Dumbfs: Request for journalling inode"); + break; + case DUMBFS_ROOTDIR_INO: + inode->i_mode = 0555; + inode->i_op = &dumbfs_dir_inode_operations; + inode->i_fop = &dumbfs_dir_operations; + break; + case DUMBFS_DATFILE_INO: + inode->i_mode = 0644; + inode->i_fop = &dumbfs_file_operations; + inode->i_blocks = inode->i_sb->u.dumbfs_sb.datblks; + break; + case DUMBFS_NDXFILE_INO: + inode->i_mode = 0644; + inode->i_fop = &dumbfs_file_operations; + inode->i_blocks = inode->i_sb->u.dumbfs_sb.ndxblks; + break; + default: + printk(KERN_ERR "Dumbfs: Request for invalid inode %li", inode->i_ino); + } + +} + +struct inode *dumbfs_get_inode(struct super_block *sb, int mode, int dev) +{ + struct inode * inode = new_inode(sb); + + if (inode) { + inode->i_mode = mode; + + + inode->i_uid = current->fsuid; + inode->i_gid = current->fsgid; + inode->i_blksize = PAGE_CACHE_SIZE; + inode->i_blocks = 0; + inode->i_rdev = NODEV; + inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; + switch (mode & S_IFMT) { + default: + init_special_inode(inode, mode, dev); + break; + case S_IFREG: + inode->i_fop = &dumbfs_file_operations; + break; + case S_IFDIR: + inode->i_op = &dumbfs_dir_inode_operations; + inode->i_fop = &dumbfs_dir_operations; + break; + case S_IFLNK: + inode->i_op = &page_symlink_inode_operations; + break; + } + } + return inode; +} + +#if 0 +/* + * File creation. Allocate an inode, and we're done.. + */ +static int dumbfs_mknod(struct inode *dir, struct dentry *dentry, int mode, int dev) +{ + struct inode * inode = dumbfs_get_inode(dir->i_sb, mode, dev); + int error = -ENOSPC; + + if (inode) { + d_instantiate(dentry, inode); + dget(dentry); /* Extra count - pin the dentry in core */ + error = 0; + } + return error; +} + +static int dumbfs_mkdir(struct inode * dir, struct dentry * dentry, int mode) +{ + return dumbfs_mknod(dir, dentry, mode | S_IFDIR, 0); +} + +static int dumbfs_create(struct inode *dir, struct dentry *dentry, int mode) +{ + return dumbfs_mknod(dir, dentry, mode | S_IFREG, 0); +} + +/* + * Link a file.. + */ +static int dumbfs_link(struct dentry *old_dentry, struct inode * dir, struct dentry * dentry) +{ + struct inode *inode = old_dentry->d_inode; + + if (S_ISDIR(inode->i_mode)) + return -EPERM; + + inode->i_nlink++; + atomic_inc(&inode->i_count); /* New dentry reference */ + dget(dentry); /* Extra pinning count for the created dentry */ + d_instantiate(dentry, inode); + return 0; +} + +static inline int dumbfs_positive(struct dentry *dentry) +{ + return dentry->d_inode && !d_unhashed(dentry); +} + +/* + * Check that a directory is empty (this works + * for regular files too, they'll just always be + * considered empty..). + * + * Note that an empty directory can still have + * children, they just all have to be negative.. + */ +static int dumbfs_empty(struct dentry *dentry) +{ + struct list_head *list; + + spin_lock(&dcache_lock); + list = dentry->d_subdirs.next; + + while (list != &dentry->d_subdirs) { + struct dentry *de = list_entry(list, struct dentry, d_child); + + if (dumbfs_positive(de)) { + spin_unlock(&dcache_lock); + return 0; + } + list = list->next; + } + spin_unlock(&dcache_lock); + return 1; +} + +/* + * This works for both directories and regular files. + * (non-directories will always have empty subdirs) + */ +static int dumbfs_unlink(struct inode * dir, struct dentry *dentry) +{ + int retval = -ENOTEMPTY; + + if (dumbfs_empty(dentry)) { + struct inode *inode = dentry->d_inode; + + inode->i_nlink--; + dput(dentry); /* Undo the count from "create" - this does all the work */ + retval = 0; + } + return retval; +} + +#define dumbfs_rmdir dumbfs_unlink + +/* + * The VFS layer already does all the dentry stuff for rename, + * we just have to decrement the usage count for the target if + * it exists so that the VFS layer correctly free's it when it + * gets overwritten. + */ +static int dumbfs_rename(struct inode * old_dir, struct dentry *old_dentry, struct inode * new_dir,struct dentry *new_dentry) +{ + int error = -ENOTEMPTY; + + if (dumbfs_empty(new_dentry)) { + struct inode *inode = new_dentry->d_inode; + if (inode) { + inode->i_nlink--; + dput(new_dentry); + } + error = 0; + } + return error; +} + +static int dumbfs_symlink(struct inode * dir, struct dentry *dentry, const char * symname) +{ + int error; + + error = dumbfs_mknod(dir, dentry, S_IFLNK | S_IRWXUGO, 0); + if (!error) { + int l = strlen(symname)+1; + struct inode *inode = dentry->d_inode; + error = block_symlink(inode, symname, l); + } + return error; +} +#endif +static int dumbfs_sync_file(struct file * file, struct dentry *dentry, int datasync) +{ + return 0; +} + +static struct file_operations dumbfs_file_operations = { + /*llseek: dumbfs_file_seek, + read: dumbfs_file_read, + write: dumbfs_file_write, + open: dumbfs_file_open,*/ + fsync: dumbfs_sync_file, + /*release: dumbfs_file_release,*/ +}; + +static struct file_operations dumbfs_dir_operations = { + read: generic_read_dir, + readdir: dcache_readdir, + fsync: dumbfs_sync_file, +}; + +static struct inode_operations dumbfs_dir_inode_operations = { + lookup: dumbfs_lookup, +/* create: dumbfs_create, + link: dumbfs_link, + unlink: dumbfs_unlink, + symlink: dumbfs_symlink, + mkdir: dumbfs_mkdir, + rmdir: dumbfs_rmdir, + mknod: dumbfs_mknod, + rename: dumbfs_rename, +*/ +}; + +static struct super_operations dumbfs_ops = { + /*TODO + * write_super: + * put_super: ? + * write_inode: + * put_inode:? + */ + read_inode: dumbfs_read_inode, + statfs: dumbfs_statfs, +}; + + +static struct super_block *dumbfs_read_super(struct super_block * sb, void * data, int silent) +{ + struct inode * inode; + struct dentry * root; + + struct buffer_head *devsb =bread(sb->s_dev , 0 , block_size(sb->s_dev)); + if (devsb && ((u32*)(devsb->b_data))[0] == DUMBFS_MAGIC) + return NULL; + + /* + * Set up.. + * the filesystem should be of the same native size + * of the device. + */ + sb->s_blocksize = block_size(sb->s_dev); + if (sb->s_blocksize != ((u32*)(devsb->b_data))[1]) + return NULL; + + sb->s_blocksize_bits = blksize_bits(sb->s_dev); + sb->s_magic = DUMBFS_MAGIC; + + /*Tell vfs about the rest of us..*/ + sb->s_op = &dumbfs_ops; + + /* memcpy the super block into on incore stuct. */ + memcpy(&(sb->u.dumbfs_sb),devsb->b_data,sizeof(struct dumbfs_sb_info)); + + /* TODO: mounted flag? */ + brelse(devsb); + + /*Get root directory.*/ + inode = iget(sb, DUMBFS_ROOTDIR_INO); + if (!inode) + return NULL; + + root = d_alloc_root(inode); + if (!root) { + iput(inode); + return NULL; + } + sb->s_root = root; + return sb; +} + +static DECLARE_FSTYPE(dumbfs_fs_type, "dumbfs", dumbfs_read_super, + FS_REQUIRES_DEV); + +static int __init init_dumbfs_fs(void) +{ + return register_filesystem(&dumbfs_fs_type); +} + +static void __exit exit_dumbfs_fs(void) +{ + unregister_filesystem(&dumbfs_fs_type); +} + +module_init(init_dumbfs_fs) +module_exit(exit_dumbfs_fs) +MODULE_LICENSE("GPL"); + diff -urN linux-2.4/fs/dumbfs/inode.c.ramfs linux-2.5/fs/dumbfs/inode.c.ramfs --- linux-2.4/fs/dumbfs/inode.c.ramfs Thu Jan 1 01:00:00 1970 +++ linux-2.5/fs/dumbfs/inode.c.ramfs Sat Nov 24 11:48:00 2001 @@ -0,0 +1,342 @@ +/* + * Resizable simple ram filesystem for Linux. + * + * Copyright (C) 2000 Linus Torvalds. + * 2000 Transmeta Corp. + * + * Usage limits added by David Gibson, Linuxcare Australia. + * This file is released under the GPL. + */ + +/* + * NOTE! This filesystem is probably most useful + * not as a real filesystem, but as an example of + * how virtual filesystems can be written. + * + * It doesn't get much simpler than this. Consider + * that this file implements the full semantics of + * a POSIX-compliant read-write filesystem. + * + * Note in particular how the filesystem does not + * need to implement any data structures of its own + * to keep track of the virtual data: using the VFS + * caches is sufficient. + */ + +#include +#include +#include +#include +#include +#include + +#include + +/* some random number */ +#define RAMFS_MAGIC 0x858458f6 + +static struct super_operations ramfs_ops; +static struct address_space_operations ramfs_aops; +static struct file_operations ramfs_dir_operations; +static struct file_operations ramfs_file_operations; +static struct inode_operations ramfs_dir_inode_operations; + +static int ramfs_statfs(struct super_block *sb, struct statfs *buf) +{ + buf->f_type = RAMFS_MAGIC; + buf->f_bsize = PAGE_CACHE_SIZE; + buf->f_namelen = 255; + return 0; +} + +/* + * Lookup the data. This is trivial - if the dentry didn't already + * exist, we know it is negative. + */ +static struct dentry * ramfs_lookup(struct inode *dir, struct dentry *dentry) +{ + d_add(dentry, NULL); + return NULL; +} + +/* + * Read a page. Again trivial. If it didn't already exist + * in the page cache, it is zero-filled. + */ +static int ramfs_readpage(struct file *file, struct page * page) +{ + if (!Page_Uptodate(page)) { + memset(kmap(page), 0, PAGE_CACHE_SIZE); + kunmap(page); + flush_dcache_page(page); + SetPageUptodate(page); + } + UnlockPage(page); + return 0; +} + +static int ramfs_prepare_write(struct file *file, struct page *page, unsigned offset, unsigned to) +{ + void *addr = kmap(page); + if (!Page_Uptodate(page)) { + memset(addr, 0, PAGE_CACHE_SIZE); + flush_dcache_page(page); + SetPageUptodate(page); + } + SetPageDirty(page); + return 0; +} + +static int ramfs_commit_write(struct file *file, struct page *page, unsigned offset, unsigned to) +{ + struct inode *inode = page->mapping->host; + loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to; + + kunmap(page); + if (pos > inode->i_size) + inode->i_size = pos; + return 0; +} + +struct inode *ramfs_get_inode(struct super_block *sb, int mode, int dev) +{ + struct inode * inode = new_inode(sb); + + if (inode) { + inode->i_mode = mode; + inode->i_uid = current->fsuid; + inode->i_gid = current->fsgid; + inode->i_blksize = PAGE_CACHE_SIZE; + inode->i_blocks = 0; + inode->i_rdev = NODEV; + inode->i_mapping->a_ops = &ramfs_aops; + inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; + switch (mode & S_IFMT) { + default: + init_special_inode(inode, mode, dev); + break; + case S_IFREG: + inode->i_fop = &ramfs_file_operations; + break; + case S_IFDIR: + inode->i_op = &ramfs_dir_inode_operations; + inode->i_fop = &ramfs_dir_operations; + break; + case S_IFLNK: + inode->i_op = &page_symlink_inode_operations; + break; + } + } + return inode; +} + +/* + * File creation. Allocate an inode, and we're done.. + */ +static int ramfs_mknod(struct inode *dir, struct dentry *dentry, int mode, int dev) +{ + struct inode * inode = ramfs_get_inode(dir->i_sb, mode, dev); + int error = -ENOSPC; + + if (inode) { + d_instantiate(dentry, inode); + dget(dentry); /* Extra count - pin the dentry in core */ + error = 0; + } + return error; +} + +static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, int mode) +{ + return ramfs_mknod(dir, dentry, mode | S_IFDIR, 0); +} + +static int ramfs_create(struct inode *dir, struct dentry *dentry, int mode) +{ + return ramfs_mknod(dir, dentry, mode | S_IFREG, 0); +} + +/* + * Link a file.. + */ +static int ramfs_link(struct dentry *old_dentry, struct inode * dir, struct dentry * dentry) +{ + struct inode *inode = old_dentry->d_inode; + + if (S_ISDIR(inode->i_mode)) + return -EPERM; + + inode->i_nlink++; + atomic_inc(&inode->i_count); /* New dentry reference */ + dget(dentry); /* Extra pinning count for the created dentry */ + d_instantiate(dentry, inode); + return 0; +} + +static inline int ramfs_positive(struct dentry *dentry) +{ + return dentry->d_inode && !d_unhashed(dentry); +} + +/* + * Check that a directory is empty (this works + * for regular files too, they'll just always be + * considered empty..). + * + * Note that an empty directory can still have + * children, they just all have to be negative.. + */ +static int ramfs_empty(struct dentry *dentry) +{ + struct list_head *list; + + spin_lock(&dcache_lock); + list = dentry->d_subdirs.next; + + while (list != &dentry->d_subdirs) { + struct dentry *de = list_entry(list, struct dentry, d_child); + + if (ramfs_positive(de)) { + spin_unlock(&dcache_lock); + return 0; + } + list = list->next; + } + spin_unlock(&dcache_lock); + return 1; +} + +/* + * This works for both directories and regular files. + * (non-directories will always have empty subdirs) + */ +static int ramfs_unlink(struct inode * dir, struct dentry *dentry) +{ + int retval = -ENOTEMPTY; + + if (ramfs_empty(dentry)) { + struct inode *inode = dentry->d_inode; + + inode->i_nlink--; + dput(dentry); /* Undo the count from "create" - this does all the work */ + retval = 0; + } + return retval; +} + +#define ramfs_rmdir ramfs_unlink + +/* + * The VFS layer already does all the dentry stuff for rename, + * we just have to decrement the usage count for the target if + * it exists so that the VFS layer correctly free's it when it + * gets overwritten. + */ +static int ramfs_rename(struct inode * old_dir, struct dentry *old_dentry, struct inode * new_dir,struct dentry *new_dentry) +{ + int error = -ENOTEMPTY; + + if (ramfs_empty(new_dentry)) { + struct inode *inode = new_dentry->d_inode; + if (inode) { + inode->i_nlink--; + dput(new_dentry); + } + error = 0; + } + return error; +} + +static int ramfs_symlink(struct inode * dir, struct dentry *dentry, const char * symname) +{ + int error; + + error = ramfs_mknod(dir, dentry, S_IFLNK | S_IRWXUGO, 0); + if (!error) { + int l = strlen(symname)+1; + struct inode *inode = dentry->d_inode; + error = block_symlink(inode, symname, l); + } + return error; +} + +static int ramfs_sync_file(struct file * file, struct dentry *dentry, int datasync) +{ + return 0; +} + +static struct address_space_operations ramfs_aops = { + readpage: ramfs_readpage, + writepage: fail_writepage, + prepare_write: ramfs_prepare_write, + commit_write: ramfs_commit_write +}; + +static struct file_operations ramfs_file_operations = { + read: generic_file_read, + write: generic_file_write, + mmap: generic_file_mmap, + fsync: ramfs_sync_file, +}; + +static struct file_operations ramfs_dir_operations = { + read: generic_read_dir, + readdir: dcache_readdir, + fsync: ramfs_sync_file, +}; + +static struct inode_operations ramfs_dir_inode_operations = { + create: ramfs_create, + lookup: ramfs_lookup, + link: ramfs_link, + unlink: ramfs_unlink, + symlink: ramfs_symlink, + mkdir: ramfs_mkdir, + rmdir: ramfs_rmdir, + mknod: ramfs_mknod, + rename: ramfs_rename, +}; + +static struct super_operations ramfs_ops = { + statfs: ramfs_statfs, + put_inode: force_delete, +}; + +static struct super_block *ramfs_read_super(struct super_block * sb, void * data, int silent) +{ + struct inode * inode; + struct dentry * root; + + sb->s_blocksize = PAGE_CACHE_SIZE; + sb->s_blocksize_bits = PAGE_CACHE_SHIFT; + sb->s_magic = RAMFS_MAGIC; + sb->s_op = &ramfs_ops; + inode = ramfs_get_inode(sb, S_IFDIR | 0755, 0); + if (!inode) + return NULL; + + root = d_alloc_root(inode); + if (!root) { + iput(inode); + return NULL; + } + sb->s_root = root; + return sb; +} + +static DECLARE_FSTYPE(ramfs_fs_type, "ramfs", ramfs_read_super, FS_LITTER); + +static int __init init_ramfs_fs(void) +{ + return register_filesystem(&ramfs_fs_type); +} + +static void __exit exit_ramfs_fs(void) +{ + unregister_filesystem(&ramfs_fs_type); +} + +module_init(init_ramfs_fs) +module_exit(exit_ramfs_fs) +MODULE_LICENSE("GPL"); + diff -urN linux-2.4/include/linux/dumbfs_fs_sb.h linux-2.5/include/linux/dumbfs_fs_sb.h --- linux-2.4/include/linux/dumbfs_fs_sb.h Thu Jan 1 01:00:00 1970 +++ linux-2.5/include/linux/dumbfs_fs_sb.h Sun Nov 25 13:14:47 2001 @@ -0,0 +1,21 @@ +#ifndef __DUMBFS_FS_SB +#define __DUMBFS_FS_SB + +/* dumbfs superblock in-core data */ + +struct dumbfs_sb_info { + + u32 magic; + u32 blksize; + uid_t uid; + gid_t gid; + /*Length in blks of files*/ + u32 jornalblks; + u32 datblks; + u32 ndxblks; + /*all time stamps are the same.*/ + time_t atime,ctime,mtime; + + +}; +#endif diff -urN linux-2.4/include/linux/fs.h linux-2.5/include/linux/fs.h --- linux-2.4/include/linux/fs.h Sat Nov 24 11:04:08 2001 +++ linux-2.5/include/linux/fs.h Sun Nov 25 15:54:29 2001 @@ -689,6 +690,7 @@ #include #include #include +#include extern struct list_head super_blocks; extern spinlock_t sb_lock; @@ -747,6 +749,7 @@ struct usbdev_sb_info usbdevfs_sb; struct jffs2_sb_info jffs2_sb; struct cramfs_sb_info cramfs_sb; + struct dumbfs_sb_info dumbfs_sb; void *generic_sbp; } u; /*