From 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Sat, 16 Apr 2005 15:20:36 -0700 Subject: Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip! --- fs/qnx4/Makefile | 7 + fs/qnx4/README | 9 + fs/qnx4/bitmap.c | 165 +++++++++++++++ fs/qnx4/dir.c | 99 +++++++++ fs/qnx4/file.c | 42 ++++ fs/qnx4/fsync.c | 170 +++++++++++++++ fs/qnx4/inode.c | 603 +++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/qnx4/namei.c | 249 ++++++++++++++++++++++ fs/qnx4/truncate.c | 39 ++++ 9 files changed, 1383 insertions(+) create mode 100644 fs/qnx4/Makefile create mode 100644 fs/qnx4/README create mode 100644 fs/qnx4/bitmap.c create mode 100644 fs/qnx4/dir.c create mode 100644 fs/qnx4/file.c create mode 100644 fs/qnx4/fsync.c create mode 100644 fs/qnx4/inode.c create mode 100644 fs/qnx4/namei.c create mode 100644 fs/qnx4/truncate.c (limited to 'fs/qnx4') diff --git a/fs/qnx4/Makefile b/fs/qnx4/Makefile new file mode 100644 index 000000000000..502d7fe98bab --- /dev/null +++ b/fs/qnx4/Makefile @@ -0,0 +1,7 @@ +# +# Makefile for the linux qnx4-filesystem routines. +# + +obj-$(CONFIG_QNX4FS_FS) += qnx4.o + +qnx4-objs := inode.o dir.o namei.o file.o bitmap.o truncate.o fsync.o diff --git a/fs/qnx4/README b/fs/qnx4/README new file mode 100644 index 000000000000..1f1e320d91da --- /dev/null +++ b/fs/qnx4/README @@ -0,0 +1,9 @@ + + This is a snapshot of the QNX4 filesystem for Linux. + Please send diffs and remarks to . + +Credits : + +Richard "Scuba" A. Frowijn +Frank "Jedi/Sector One" Denis +Anders Larsen (Maintainer) diff --git a/fs/qnx4/bitmap.c b/fs/qnx4/bitmap.c new file mode 100644 index 000000000000..991253927658 --- /dev/null +++ b/fs/qnx4/bitmap.c @@ -0,0 +1,165 @@ +/* + * QNX4 file system, Linux implementation. + * + * Version : 0.2.1 + * + * Using parts of the xiafs filesystem. + * + * History : + * + * 28-05-1998 by Richard Frowijn : first release. + * 20-06-1998 by Frank Denis : basic optimisations. + * 25-06-1998 by Frank Denis : qnx4_is_free, qnx4_set_bitmap, qnx4_bmap . + * 28-06-1998 by Frank Denis : qnx4_free_inode (to be fixed) . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +int qnx4_new_block(struct super_block *sb) +{ + return 0; +} + +static void count_bits(register const char *bmPart, register int size, + int *const tf) +{ + char b; + int tot = *tf; + + if (size > QNX4_BLOCK_SIZE) { + size = QNX4_BLOCK_SIZE; + } + do { + b = *bmPart++; + if ((b & 1) == 0) + tot++; + if ((b & 2) == 0) + tot++; + if ((b & 4) == 0) + tot++; + if ((b & 8) == 0) + tot++; + if ((b & 16) == 0) + tot++; + if ((b & 32) == 0) + tot++; + if ((b & 64) == 0) + tot++; + if ((b & 128) == 0) + tot++; + size--; + } while (size != 0); + *tf = tot; +} + +unsigned long qnx4_count_free_blocks(struct super_block *sb) +{ + int start = le32_to_cpu(qnx4_sb(sb)->BitMap->di_first_xtnt.xtnt_blk) - 1; + int total = 0; + int total_free = 0; + int offset = 0; + int size = le32_to_cpu(qnx4_sb(sb)->BitMap->di_size); + struct buffer_head *bh; + + while (total < size) { + if ((bh = sb_bread(sb, start + offset)) == NULL) { + printk("qnx4: I/O error in counting free blocks\n"); + break; + } + count_bits(bh->b_data, size - total, &total_free); + brelse(bh); + total += QNX4_BLOCK_SIZE; + offset++; + } + + return total_free; +} + +#ifdef CONFIG_QNX4FS_RW + +int qnx4_is_free(struct super_block *sb, long block) +{ + int start = le32_to_cpu(qnx4_sb(sb)->BitMap->di_first_xtnt.xtnt_blk) - 1; + int size = le32_to_cpu(qnx4_sb(sb)->BitMap->di_size); + struct buffer_head *bh; + const char *g; + int ret = -EIO; + + start += block / (QNX4_BLOCK_SIZE * 8); + QNX4DEBUG(("qnx4: is_free requesting block [%lu], bitmap in block [%lu]\n", + (unsigned long) block, (unsigned long) start)); + (void) size; /* CHECKME */ + bh = sb_bread(sb, start); + if (bh == NULL) { + return -EIO; + } + g = bh->b_data + (block % QNX4_BLOCK_SIZE); + if (((*g) & (1 << (block % 8))) == 0) { + QNX4DEBUG(("qnx4: is_free -> block is free\n")); + ret = 1; + } else { + QNX4DEBUG(("qnx4: is_free -> block is busy\n")); + ret = 0; + } + brelse(bh); + + return ret; +} + +int qnx4_set_bitmap(struct super_block *sb, long block, int busy) +{ + int start = le32_to_cpu(qnx4_sb(sb)->BitMap->di_first_xtnt.xtnt_blk) - 1; + int size = le32_to_cpu(qnx4_sb(sb)->BitMap->di_size); + struct buffer_head *bh; + char *g; + + start += block / (QNX4_BLOCK_SIZE * 8); + QNX4DEBUG(("qnx4: set_bitmap requesting block [%lu], bitmap in block [%lu]\n", + (unsigned long) block, (unsigned long) start)); + (void) size; /* CHECKME */ + bh = sb_bread(sb, start); + if (bh == NULL) { + return -EIO; + } + g = bh->b_data + (block % QNX4_BLOCK_SIZE); + if (busy == 0) { + (*g) &= ~(1 << (block % 8)); + } else { + (*g) |= (1 << (block % 8)); + } + mark_buffer_dirty(bh); + brelse(bh); + + return 0; +} + +static void qnx4_clear_inode(struct inode *inode) +{ + struct qnx4_inode_entry *qnx4_ino = qnx4_raw_inode(inode); + /* What for? */ + memset(qnx4_ino->di_fname, 0, sizeof qnx4_ino->di_fname); + qnx4_ino->di_size = 0; + qnx4_ino->di_num_xtnts = 0; + qnx4_ino->di_mode = 0; + qnx4_ino->di_status = 0; +} + +void qnx4_free_inode(struct inode *inode) +{ + if (inode->i_ino < 1) { + printk("free_inode: inode 0 or nonexistent inode\n"); + return; + } + qnx4_clear_inode(inode); + clear_inode(inode); +} + +#endif diff --git a/fs/qnx4/dir.c b/fs/qnx4/dir.c new file mode 100644 index 000000000000..cd66147cca04 --- /dev/null +++ b/fs/qnx4/dir.c @@ -0,0 +1,99 @@ +/* + * QNX4 file system, Linux implementation. + * + * Version : 0.2.1 + * + * Using parts of the xiafs filesystem. + * + * History : + * + * 28-05-1998 by Richard Frowijn : first release. + * 20-06-1998 by Frank Denis : Linux 2.1.99+ & dcache support. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + + +static int qnx4_readdir(struct file *filp, void *dirent, filldir_t filldir) +{ + struct inode *inode = filp->f_dentry->d_inode; + unsigned int offset; + struct buffer_head *bh; + struct qnx4_inode_entry *de; + struct qnx4_link_info *le; + unsigned long blknum; + int ix, ino; + int size; + + QNX4DEBUG(("qnx4_readdir:i_size = %ld\n", (long) inode->i_size)); + QNX4DEBUG(("filp->f_pos = %ld\n", (long) filp->f_pos)); + + lock_kernel(); + + while (filp->f_pos < inode->i_size) { + blknum = qnx4_block_map( inode, filp->f_pos >> QNX4_BLOCK_SIZE_BITS ); + bh = sb_bread(inode->i_sb, blknum); + if(bh==NULL) { + printk(KERN_ERR "qnx4_readdir: bread failed (%ld)\n", blknum); + break; + } + ix = (int)(filp->f_pos >> QNX4_DIR_ENTRY_SIZE_BITS) % QNX4_INODES_PER_BLOCK; + while (ix < QNX4_INODES_PER_BLOCK) { + offset = ix * QNX4_DIR_ENTRY_SIZE; + de = (struct qnx4_inode_entry *) (bh->b_data + offset); + size = strlen(de->di_fname); + if (size) { + if ( !( de->di_status & QNX4_FILE_LINK ) && size > QNX4_SHORT_NAME_MAX ) + size = QNX4_SHORT_NAME_MAX; + else if ( size > QNX4_NAME_MAX ) + size = QNX4_NAME_MAX; + + if ( ( de->di_status & (QNX4_FILE_USED|QNX4_FILE_LINK) ) != 0 ) { + QNX4DEBUG(("qnx4_readdir:%.*s\n", size, de->di_fname)); + if ( ( de->di_status & QNX4_FILE_LINK ) == 0 ) + ino = blknum * QNX4_INODES_PER_BLOCK + ix - 1; + else { + le = (struct qnx4_link_info*)de; + ino = ( le->dl_inode_blk - 1 ) * + QNX4_INODES_PER_BLOCK + + le->dl_inode_ndx; + } + if (filldir(dirent, de->di_fname, size, filp->f_pos, ino, DT_UNKNOWN) < 0) { + brelse(bh); + goto out; + } + } + } + ix++; + filp->f_pos += QNX4_DIR_ENTRY_SIZE; + } + brelse(bh); + } +out: + unlock_kernel(); + return 0; +} + +struct file_operations qnx4_dir_operations = +{ + .read = generic_read_dir, + .readdir = qnx4_readdir, + .fsync = file_fsync, +}; + +struct inode_operations qnx4_dir_inode_operations = +{ + .lookup = qnx4_lookup, +#ifdef CONFIG_QNX4FS_RW + .create = qnx4_create, + .unlink = qnx4_unlink, + .rmdir = qnx4_rmdir, +#endif +}; diff --git a/fs/qnx4/file.c b/fs/qnx4/file.c new file mode 100644 index 000000000000..b471315e24ef --- /dev/null +++ b/fs/qnx4/file.c @@ -0,0 +1,42 @@ +/* + * QNX4 file system, Linux implementation. + * + * Version : 0.2.1 + * + * Using parts of the xiafs filesystem. + * + * History : + * + * 25-05-1998 by Richard Frowijn : first release. + * 21-06-1998 by Frank Denis : wrote qnx4_readpage to use generic_file_read. + * 27-06-1998 by Frank Denis : file overwriting. + */ + +#include +#include +#include +#include +#include + +/* + * We have mostly NULL's here: the current defaults are ok for + * the qnx4 filesystem. + */ +struct file_operations qnx4_file_operations = +{ + .llseek = generic_file_llseek, + .read = generic_file_read, + .mmap = generic_file_mmap, + .sendfile = generic_file_sendfile, +#ifdef CONFIG_QNX4FS_RW + .write = generic_file_write, + .fsync = qnx4_sync_file, +#endif +}; + +struct inode_operations qnx4_file_inode_operations = +{ +#ifdef CONFIG_QNX4FS_RW + .truncate = qnx4_truncate, +#endif +}; diff --git a/fs/qnx4/fsync.c b/fs/qnx4/fsync.c new file mode 100644 index 000000000000..df5bc75d5414 --- /dev/null +++ b/fs/qnx4/fsync.c @@ -0,0 +1,170 @@ +/* + * QNX4 file system, Linux implementation. + * + * Version : 0.1 + * + * Using parts of the xiafs filesystem. + * + * History : + * + * 24-03-1998 by Richard Frowijn : first release. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + +/* + * The functions for qnx4 fs file synchronization. + */ + +#ifdef CONFIG_QNX4FS_RW + +static int sync_block(struct inode *inode, unsigned short *block, int wait) +{ + struct buffer_head *bh; + unsigned short tmp; + + if (!*block) + return 0; + tmp = *block; + bh = sb_find_get_block(inode->i_sb, *block); + if (!bh) + return 0; + if (*block != tmp) { + brelse(bh); + return 1; + } + if (wait && buffer_req(bh) && !buffer_uptodate(bh)) { + brelse(bh); + return -1; + } + if (wait || !buffer_uptodate(bh) || !buffer_dirty(bh)) { + brelse(bh); + return 0; + } + ll_rw_block(WRITE, 1, &bh); + atomic_dec(&bh->b_count); + return 0; +} + +#ifdef WTF +static int sync_iblock(struct inode *inode, unsigned short *iblock, + struct buffer_head **bh, int wait) +{ + int rc; + unsigned short tmp; + + *bh = NULL; + tmp = *iblock; + if (!tmp) + return 0; + rc = sync_block(inode, iblock, wait); + if (rc) + return rc; + *bh = sb_bread(inode->i_sb, tmp); + if (tmp != *iblock) { + brelse(*bh); + *bh = NULL; + return 1; + } + if (!*bh) + return -1; + return 0; +} +#endif + +static int sync_direct(struct inode *inode, int wait) +{ + int i; + int rc, err = 0; + + for (i = 0; i < 7; i++) { + rc = sync_block(inode, + (unsigned short *) qnx4_raw_inode(inode)->di_first_xtnt.xtnt_blk + i, wait); + if (rc > 0) + break; + if (rc) + err = rc; + } + return err; +} + +#ifdef WTF +static int sync_indirect(struct inode *inode, unsigned short *iblock, int wait) +{ + int i; + struct buffer_head *ind_bh; + int rc, err = 0; + + rc = sync_iblock(inode, iblock, &ind_bh, wait); + if (rc || !ind_bh) + return rc; + + for (i = 0; i < 512; i++) { + rc = sync_block(inode, + ((unsigned short *) ind_bh->b_data) + i, + wait); + if (rc > 0) + break; + if (rc) + err = rc; + } + brelse(ind_bh); + return err; +} + +static int sync_dindirect(struct inode *inode, unsigned short *diblock, + int wait) +{ + int i; + struct buffer_head *dind_bh; + int rc, err = 0; + + rc = sync_iblock(inode, diblock, &dind_bh, wait); + if (rc || !dind_bh) + return rc; + + for (i = 0; i < 512; i++) { + rc = sync_indirect(inode, + ((unsigned short *) dind_bh->b_data) + i, + wait); + if (rc > 0) + break; + if (rc) + err = rc; + } + brelse(dind_bh); + return err; +} +#endif + +int qnx4_sync_file(struct file *file, struct dentry *dentry, int unused) +{ + struct inode *inode = dentry->d_inode; + int wait, err = 0; + + (void) file; + if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || + S_ISLNK(inode->i_mode))) + return -EINVAL; + + lock_kernel(); + for (wait = 0; wait <= 1; wait++) { + err |= sync_direct(inode, wait); + } + err |= qnx4_sync_inode(inode); + unlock_kernel(); + return (err < 0) ? -EIO : 0; +} + +#endif diff --git a/fs/qnx4/inode.c b/fs/qnx4/inode.c new file mode 100644 index 000000000000..aa92d6b76a9a --- /dev/null +++ b/fs/qnx4/inode.c @@ -0,0 +1,603 @@ +/* + * QNX4 file system, Linux implementation. + * + * Version : 0.2.1 + * + * Using parts of the xiafs filesystem. + * + * History : + * + * 01-06-1998 by Richard Frowijn : first release. + * 20-06-1998 by Frank Denis : Linux 2.1.99+ support, boot signature, misc. + * 30-06-1998 by Frank Denis : first step to write inodes. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define QNX4_VERSION 4 +#define QNX4_BMNAME ".bitmap" + +static struct super_operations qnx4_sops; + +#ifdef CONFIG_QNX4FS_RW + +int qnx4_sync_inode(struct inode *inode) +{ + int err = 0; +# if 0 + struct buffer_head *bh; + + bh = qnx4_update_inode(inode); + if (bh && buffer_dirty(bh)) + { + sync_dirty_buffer(bh); + if (buffer_req(bh) && !buffer_uptodate(bh)) + { + printk ("IO error syncing qnx4 inode [%s:%08lx]\n", + inode->i_sb->s_id, inode->i_ino); + err = -1; + } + brelse (bh); + } else if (!bh) { + err = -1; + } +# endif + + return err; +} + +static void qnx4_delete_inode(struct inode *inode) +{ + QNX4DEBUG(("qnx4: deleting inode [%lu]\n", (unsigned long) inode->i_ino)); + inode->i_size = 0; + qnx4_truncate(inode); + lock_kernel(); + qnx4_free_inode(inode); + unlock_kernel(); +} + +static void qnx4_write_super(struct super_block *sb) +{ + lock_kernel(); + QNX4DEBUG(("qnx4: write_super\n")); + sb->s_dirt = 0; + unlock_kernel(); +} + +static int qnx4_write_inode(struct inode *inode, int unused) +{ + struct qnx4_inode_entry *raw_inode; + int block, ino; + struct buffer_head *bh; + ino = inode->i_ino; + + QNX4DEBUG(("qnx4: write inode 1.\n")); + if (inode->i_nlink == 0) { + return 0; + } + if (!ino) { + printk("qnx4: bad inode number on dev %s: %d is out of range\n", + inode->i_sb->s_id, ino); + return -EIO; + } + QNX4DEBUG(("qnx4: write inode 2.\n")); + block = ino / QNX4_INODES_PER_BLOCK; + lock_kernel(); + if (!(bh = sb_bread(inode->i_sb, block))) { + printk("qnx4: major problem: unable to read inode from dev " + "%s\n", inode->i_sb->s_id); + unlock_kernel(); + return -EIO; + } + raw_inode = ((struct qnx4_inode_entry *) bh->b_data) + + (ino % QNX4_INODES_PER_BLOCK); + raw_inode->di_mode = cpu_to_le16(inode->i_mode); + raw_inode->di_uid = cpu_to_le16(fs_high2lowuid(inode->i_uid)); + raw_inode->di_gid = cpu_to_le16(fs_high2lowgid(inode->i_gid)); + raw_inode->di_nlink = cpu_to_le16(inode->i_nlink); + raw_inode->di_size = cpu_to_le32(inode->i_size); + raw_inode->di_mtime = cpu_to_le32(inode->i_mtime.tv_sec); + raw_inode->di_atime = cpu_to_le32(inode->i_atime.tv_sec); + raw_inode->di_ctime = cpu_to_le32(inode->i_ctime.tv_sec); + raw_inode->di_first_xtnt.xtnt_size = cpu_to_le32(inode->i_blocks); + mark_buffer_dirty(bh); + brelse(bh); + unlock_kernel(); + return 0; +} + +#endif + +static void qnx4_put_super(struct super_block *sb); +static struct inode *qnx4_alloc_inode(struct super_block *sb); +static void qnx4_destroy_inode(struct inode *inode); +static void qnx4_read_inode(struct inode *); +static int qnx4_remount(struct super_block *sb, int *flags, char *data); +static int qnx4_statfs(struct super_block *, struct kstatfs *); + +static struct super_operations qnx4_sops = +{ + .alloc_inode = qnx4_alloc_inode, + .destroy_inode = qnx4_destroy_inode, + .read_inode = qnx4_read_inode, + .put_super = qnx4_put_super, + .statfs = qnx4_statfs, + .remount_fs = qnx4_remount, +#ifdef CONFIG_QNX4FS_RW + .write_inode = qnx4_write_inode, + .delete_inode = qnx4_delete_inode, + .write_super = qnx4_write_super, +#endif +}; + +static int qnx4_remount(struct super_block *sb, int *flags, char *data) +{ + struct qnx4_sb_info *qs; + + qs = qnx4_sb(sb); + qs->Version = QNX4_VERSION; +#ifndef CONFIG_QNX4FS_RW + *flags |= MS_RDONLY; +#endif + if (*flags & MS_RDONLY) { + return 0; + } + + mark_buffer_dirty(qs->sb_buf); + + return 0; +} + +static struct buffer_head *qnx4_getblk(struct inode *inode, int nr, + int create) +{ + struct buffer_head *result = NULL; + + if ( nr >= 0 ) + nr = qnx4_block_map( inode, nr ); + if (nr) { + result = sb_getblk(inode->i_sb, nr); + return result; + } + if (!create) { + return NULL; + } +#if 0 + tmp = qnx4_new_block(inode->i_sb); + if (!tmp) { + return NULL; + } + result = sb_getblk(inode->i_sb, tmp); + if (tst) { + qnx4_free_block(inode->i_sb, tmp); + brelse(result); + goto repeat; + } + tst = tmp; +#endif + inode->i_ctime = CURRENT_TIME_SEC; + mark_inode_dirty(inode); + return result; +} + +struct buffer_head *qnx4_bread(struct inode *inode, int block, int create) +{ + struct buffer_head *bh; + + bh = qnx4_getblk(inode, block, create); + if (!bh || buffer_uptodate(bh)) { + return bh; + } + ll_rw_block(READ, 1, &bh); + wait_on_buffer(bh); + if (buffer_uptodate(bh)) { + return bh; + } + brelse(bh); + + return NULL; +} + +static int qnx4_get_block( struct inode *inode, sector_t iblock, struct buffer_head *bh, int create ) +{ + unsigned long phys; + + QNX4DEBUG(("qnx4: qnx4_get_block inode=[%ld] iblock=[%ld]\n",inode->i_ino,iblock)); + + phys = qnx4_block_map( inode, iblock ); + if ( phys ) { + // logical block is before EOF + map_bh(bh, inode->i_sb, phys); + } else if ( create ) { + // to be done. + } + return 0; +} + +unsigned long qnx4_block_map( struct inode *inode, long iblock ) +{ + int ix; + long offset, i_xblk; + unsigned long block = 0; + struct buffer_head *bh = NULL; + struct qnx4_xblk *xblk = NULL; + struct qnx4_inode_entry *qnx4_inode = qnx4_raw_inode(inode); + qnx4_nxtnt_t nxtnt = le16_to_cpu(qnx4_inode->di_num_xtnts); + + if ( iblock < le32_to_cpu(qnx4_inode->di_first_xtnt.xtnt_size) ) { + // iblock is in the first extent. This is easy. + block = le32_to_cpu(qnx4_inode->di_first_xtnt.xtnt_blk) + iblock - 1; + } else { + // iblock is beyond first extent. We have to follow the extent chain. + i_xblk = le32_to_cpu(qnx4_inode->di_xblk); + offset = iblock - le32_to_cpu(qnx4_inode->di_first_xtnt.xtnt_size); + ix = 0; + while ( --nxtnt > 0 ) { + if ( ix == 0 ) { + // read next xtnt block. + bh = sb_bread(inode->i_sb, i_xblk - 1); + if ( !bh ) { + QNX4DEBUG(("qnx4: I/O error reading xtnt block [%ld])\n", i_xblk - 1)); + return -EIO; + } + xblk = (struct qnx4_xblk*)bh->b_data; + if ( memcmp( xblk->xblk_signature, "IamXblk", 7 ) ) { + QNX4DEBUG(("qnx4: block at %ld is not a valid xtnt\n", qnx4_inode->i_xblk)); + return -EIO; + } + } + if ( offset < le32_to_cpu(xblk->xblk_xtnts[ix].xtnt_size) ) { + // got it! + block = le32_to_cpu(xblk->xblk_xtnts[ix].xtnt_blk) + offset - 1; + break; + } + offset -= le32_to_cpu(xblk->xblk_xtnts[ix].xtnt_size); + if ( ++ix >= xblk->xblk_num_xtnts ) { + i_xblk = le32_to_cpu(xblk->xblk_next_xblk); + ix = 0; + brelse( bh ); + bh = NULL; + } + } + if ( bh ) + brelse( bh ); + } + + QNX4DEBUG(("qnx4: mapping block %ld of inode %ld = %ld\n",iblock,inode->i_ino,block)); + return block; +} + +static int qnx4_statfs(struct super_block *sb, struct kstatfs *buf) +{ + lock_kernel(); + + buf->f_type = sb->s_magic; + buf->f_bsize = sb->s_blocksize; + buf->f_blocks = le32_to_cpu(qnx4_sb(sb)->BitMap->di_size) * 8; + buf->f_bfree = qnx4_count_free_blocks(sb); + buf->f_bavail = buf->f_bfree; + buf->f_namelen = QNX4_NAME_MAX; + + unlock_kernel(); + + return 0; +} + +/* + * Check the root directory of the filesystem to make sure + * it really _is_ a qnx4 filesystem, and to check the size + * of the directory entry. + */ +static const char *qnx4_checkroot(struct super_block *sb) +{ + struct buffer_head *bh; + struct qnx4_inode_entry *rootdir; + int rd, rl; + int i, j; + int found = 0; + + if (*(qnx4_sb(sb)->sb->RootDir.di_fname) != '/') { + return "no qnx4 filesystem (no root dir)."; + } else { + QNX4DEBUG(("QNX4 filesystem found on dev %s.\n", sb->s_id)); + rd = le32_to_cpu(qnx4_sb(sb)->sb->RootDir.di_first_xtnt.xtnt_blk) - 1; + rl = le32_to_cpu(qnx4_sb(sb)->sb->RootDir.di_first_xtnt.xtnt_size); + for (j = 0; j < rl; j++) { + bh = sb_bread(sb, rd + j); /* root dir, first block */ + if (bh == NULL) { + return "unable to read root entry."; + } + for (i = 0; i < QNX4_INODES_PER_BLOCK; i++) { + rootdir = (struct qnx4_inode_entry *) (bh->b_data + i * QNX4_DIR_ENTRY_SIZE); + if (rootdir->di_fname != NULL) { + QNX4DEBUG(("Rootdir entry found : [%s]\n", rootdir->di_fname)); + if (!strncmp(rootdir->di_fname, QNX4_BMNAME, sizeof QNX4_BMNAME)) { + found = 1; + qnx4_sb(sb)->BitMap = kmalloc( sizeof( struct qnx4_inode_entry ), GFP_KERNEL ); + if (!qnx4_sb(sb)->BitMap) { + brelse (bh); + return "not enough memory for bitmap inode"; + } + memcpy( qnx4_sb(sb)->BitMap, rootdir, sizeof( struct qnx4_inode_entry ) ); /* keep bitmap inode known */ + break; + } + } + } + brelse(bh); + if (found != 0) { + break; + } + } + if (found == 0) { + return "bitmap file not found."; + } + } + return NULL; +} + +static int qnx4_fill_super(struct super_block *s, void *data, int silent) +{ + struct buffer_head *bh; + struct inode *root; + const char *errmsg; + struct qnx4_sb_info *qs; + + qs = kmalloc(sizeof(struct qnx4_sb_info), GFP_KERNEL); + if (!qs) + return -ENOMEM; + s->s_fs_info = qs; + memset(qs, 0, sizeof(struct qnx4_sb_info)); + + sb_set_blocksize(s, QNX4_BLOCK_SIZE); + + /* Check the superblock signature. Since the qnx4 code is + dangerous, we should leave as quickly as possible + if we don't belong here... */ + bh = sb_bread(s, 1); + if (!bh) { + printk("qnx4: unable to read the superblock\n"); + goto outnobh; + } + if ( le32_to_cpu( *(__u32*)bh->b_data ) != QNX4_SUPER_MAGIC ) { + if (!silent) + printk("qnx4: wrong fsid in superblock.\n"); + goto out; + } + s->s_op = &qnx4_sops; + s->s_magic = QNX4_SUPER_MAGIC; +#ifndef CONFIG_QNX4FS_RW + s->s_flags |= MS_RDONLY; /* Yup, read-only yet */ +#endif + qnx4_sb(s)->sb_buf = bh; + qnx4_sb(s)->sb = (struct qnx4_super_block *) bh->b_data; + + + /* check before allocating dentries, inodes, .. */ + errmsg = qnx4_checkroot(s); + if (errmsg != NULL) { + if (!silent) + printk("qnx4: %s\n", errmsg); + goto out; + } + + /* does root not have inode number QNX4_ROOT_INO ?? */ + root = iget(s, QNX4_ROOT_INO * QNX4_INODES_PER_BLOCK); + if (!root) { + printk("qnx4: get inode failed\n"); + goto out; + } + + s->s_root = d_alloc_root(root); + if (s->s_root == NULL) + goto outi; + + brelse(bh); + + return 0; + + outi: + iput(root); + out: + brelse(bh); + outnobh: + kfree(qs); + s->s_fs_info = NULL; + return -EINVAL; +} + +static void qnx4_put_super(struct super_block *sb) +{ + struct qnx4_sb_info *qs = qnx4_sb(sb); + kfree( qs->BitMap ); + kfree( qs ); + sb->s_fs_info = NULL; + return; +} + +static int qnx4_writepage(struct page *page, struct writeback_control *wbc) +{ + return block_write_full_page(page,qnx4_get_block, wbc); +} +static int qnx4_readpage(struct file *file, struct page *page) +{ + return block_read_full_page(page,qnx4_get_block); +} +static int qnx4_prepare_write(struct file *file, struct page *page, + unsigned from, unsigned to) +{ + struct qnx4_inode_info *qnx4_inode = qnx4_i(page->mapping->host); + return cont_prepare_write(page, from, to, qnx4_get_block, + &qnx4_inode->mmu_private); +} +static sector_t qnx4_bmap(struct address_space *mapping, sector_t block) +{ + return generic_block_bmap(mapping,block,qnx4_get_block); +} +static struct address_space_operations qnx4_aops = { + .readpage = qnx4_readpage, + .writepage = qnx4_writepage, + .sync_page = block_sync_page, + .prepare_write = qnx4_prepare_write, + .commit_write = generic_commit_write, + .bmap = qnx4_bmap +}; + +static void qnx4_read_inode(struct inode *inode) +{ + struct buffer_head *bh; + struct qnx4_inode_entry *raw_inode; + int block, ino; + struct super_block *sb = inode->i_sb; + struct qnx4_inode_entry *qnx4_inode = qnx4_raw_inode(inode); + + ino = inode->i_ino; + inode->i_mode = 0; + + QNX4DEBUG(("Reading inode : [%d]\n", ino)); + if (!ino) { + printk("qnx4: bad inode number on dev %s: %d is out of range\n", + sb->s_id, ino); + return; + } + block = ino / QNX4_INODES_PER_BLOCK; + + if (!(bh = sb_bread(sb, block))) { + printk("qnx4: major problem: unable to read inode from dev " + "%s\n", sb->s_id); + return; + } + raw_inode = ((struct qnx4_inode_entry *) bh->b_data) + + (ino % QNX4_INODES_PER_BLOCK); + + inode->i_mode = le16_to_cpu(raw_inode->di_mode); + inode->i_uid = (uid_t)le16_to_cpu(raw_inode->di_uid); + inode->i_gid = (gid_t)le16_to_cpu(raw_inode->di_gid); + inode->i_nlink = le16_to_cpu(raw_inode->di_nlink); + inode->i_size = le32_to_cpu(raw_inode->di_size); + inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->di_mtime); + inode->i_mtime.tv_nsec = 0; + inode->i_atime.tv_sec = le32_to_cpu(raw_inode->di_atime); + inode->i_atime.tv_nsec = 0; + inode->i_ctime.tv_sec = le32_to_cpu(raw_inode->di_ctime); + inode->i_ctime.tv_nsec = 0; + inode->i_blocks = le32_to_cpu(raw_inode->di_first_xtnt.xtnt_size); + inode->i_blksize = QNX4_DIR_ENTRY_SIZE; + + memcpy(qnx4_inode, raw_inode, QNX4_DIR_ENTRY_SIZE); + if (S_ISREG(inode->i_mode)) { + inode->i_op = &qnx4_file_inode_operations; + inode->i_fop = &qnx4_file_operations; + inode->i_mapping->a_ops = &qnx4_aops; + qnx4_i(inode)->mmu_private = inode->i_size; + } else if (S_ISDIR(inode->i_mode)) { + inode->i_op = &qnx4_dir_inode_operations; + inode->i_fop = &qnx4_dir_operations; + } else if (S_ISLNK(inode->i_mode)) { + inode->i_op = &page_symlink_inode_operations; + inode->i_mapping->a_ops = &qnx4_aops; + qnx4_i(inode)->mmu_private = inode->i_size; + } else + printk("qnx4: bad inode %d on dev %s\n",ino,sb->s_id); + brelse(bh); +} + +static kmem_cache_t *qnx4_inode_cachep; + +static struct inode *qnx4_alloc_inode(struct super_block *sb) +{ + struct qnx4_inode_info *ei; + ei = kmem_cache_alloc(qnx4_inode_cachep, SLAB_KERNEL); + if (!ei) + return NULL; + return &ei->vfs_inode; +} + +static void qnx4_destroy_inode(struct inode *inode) +{ + kmem_cache_free(qnx4_inode_cachep, qnx4_i(inode)); +} + +static void init_once(void *foo, kmem_cache_t * cachep, + unsigned long flags) +{ + struct qnx4_inode_info *ei = (struct qnx4_inode_info *) foo; + + if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) == + SLAB_CTOR_CONSTRUCTOR) + inode_init_once(&ei->vfs_inode); +} + +static int init_inodecache(void) +{ + qnx4_inode_cachep = kmem_cache_create("qnx4_inode_cache", + sizeof(struct qnx4_inode_info), + 0, SLAB_RECLAIM_ACCOUNT, + init_once, NULL); + if (qnx4_inode_cachep == NULL) + return -ENOMEM; + return 0; +} + +static void destroy_inodecache(void) +{ + if (kmem_cache_destroy(qnx4_inode_cachep)) + printk(KERN_INFO + "qnx4_inode_cache: not all structures were freed\n"); +} + +static struct super_block *qnx4_get_sb(struct file_system_type *fs_type, + int flags, const char *dev_name, void *data) +{ + return get_sb_bdev(fs_type, flags, dev_name, data, qnx4_fill_super); +} + +static struct file_system_type qnx4_fs_type = { + .owner = THIS_MODULE, + .name = "qnx4", + .get_sb = qnx4_get_sb, + .kill_sb = kill_block_super, + .fs_flags = FS_REQUIRES_DEV, +}; + +static int __init init_qnx4_fs(void) +{ + int err; + + err = init_inodecache(); + if (err) + return err; + + err = register_filesystem(&qnx4_fs_type); + if (err) { + destroy_inodecache(); + return err; + } + + printk("QNX4 filesystem 0.2.3 registered.\n"); + return 0; +} + +static void __exit exit_qnx4_fs(void) +{ + unregister_filesystem(&qnx4_fs_type); + destroy_inodecache(); +} + +module_init(init_qnx4_fs) +module_exit(exit_qnx4_fs) +MODULE_LICENSE("GPL"); + diff --git a/fs/qnx4/namei.c b/fs/qnx4/namei.c new file mode 100644 index 000000000000..4af4951d7f54 --- /dev/null +++ b/fs/qnx4/namei.c @@ -0,0 +1,249 @@ +/* + * QNX4 file system, Linux implementation. + * + * Version : 0.2.1 + * + * Using parts of the xiafs filesystem. + * + * History : + * + * 01-06-1998 by Richard Frowijn : first release. + * 21-06-1998 by Frank Denis : dcache support, fixed error codes. + * 04-07-1998 by Frank Denis : first step for rmdir/unlink. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +/* + * check if the filename is correct. For some obscure reason, qnx writes a + * new file twice in the directory entry, first with all possible options at 0 + * and for a second time the way it is, they want us not to access the qnx + * filesystem when whe are using linux. + */ +static int qnx4_match(int len, const char *name, + struct buffer_head *bh, unsigned long *offset) +{ + struct qnx4_inode_entry *de; + int namelen, thislen; + + if (bh == NULL) { + printk("qnx4: matching unassigned buffer !\n"); + return 0; + } + de = (struct qnx4_inode_entry *) (bh->b_data + *offset); + *offset += QNX4_DIR_ENTRY_SIZE; + if ((de->di_status & QNX4_FILE_LINK) != 0) { + namelen = QNX4_NAME_MAX; + } else { + namelen = QNX4_SHORT_NAME_MAX; + } + /* "" means "." ---> so paths like "/usr/lib//libc.a" work */ + if (!len && (de->di_fname[0] == '.') && (de->di_fname[1] == '\0')) { + return 1; + } + thislen = strlen( de->di_fname ); + if ( thislen > namelen ) + thislen = namelen; + if (len != thislen) { + return 0; + } + if (strncmp(name, de->di_fname, len) == 0) { + if ((de->di_status & (QNX4_FILE_USED|QNX4_FILE_LINK)) != 0) { + return 1; + } + } + return 0; +} + +static struct buffer_head *qnx4_find_entry(int len, struct inode *dir, + const char *name, struct qnx4_inode_entry **res_dir, int *ino) +{ + unsigned long block, offset, blkofs; + struct buffer_head *bh; + + *res_dir = NULL; + if (!dir->i_sb) { + printk("qnx4: no superblock on dir.\n"); + return NULL; + } + bh = NULL; + block = offset = blkofs = 0; + while (blkofs * QNX4_BLOCK_SIZE + offset < dir->i_size) { + if (!bh) { + bh = qnx4_bread(dir, blkofs, 0); + if (!bh) { + blkofs++; + continue; + } + } + *res_dir = (struct qnx4_inode_entry *) (bh->b_data + offset); + if (qnx4_match(len, name, bh, &offset)) { + block = qnx4_block_map( dir, blkofs ); + *ino = block * QNX4_INODES_PER_BLOCK + + (offset / QNX4_DIR_ENTRY_SIZE) - 1; + return bh; + } + if (offset < bh->b_size) { + continue; + } + brelse(bh); + bh = NULL; + offset = 0; + blkofs++; + } + brelse(bh); + *res_dir = NULL; + return NULL; +} + +struct dentry * qnx4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) +{ + int ino; + struct qnx4_inode_entry *de; + struct qnx4_link_info *lnk; + struct buffer_head *bh; + const char *name = dentry->d_name.name; + int len = dentry->d_name.len; + struct inode *foundinode = NULL; + + lock_kernel(); + if (!(bh = qnx4_find_entry(len, dir, name, &de, &ino))) + goto out; + /* The entry is linked, let's get the real info */ + if ((de->di_status & QNX4_FILE_LINK) == QNX4_FILE_LINK) { + lnk = (struct qnx4_link_info *) de; + ino = (le32_to_cpu(lnk->dl_inode_blk) - 1) * + QNX4_INODES_PER_BLOCK + + lnk->dl_inode_ndx; + } + brelse(bh); + + if ((foundinode = iget(dir->i_sb, ino)) == NULL) { + unlock_kernel(); + QNX4DEBUG(("qnx4: lookup->iget -> NULL\n")); + return ERR_PTR(-EACCES); + } +out: + unlock_kernel(); + d_add(dentry, foundinode); + + return NULL; +} + +#ifdef CONFIG_QNX4FS_RW +int qnx4_create(struct inode *dir, struct dentry *dentry, int mode, + struct nameidata *nd) +{ + QNX4DEBUG(("qnx4: qnx4_create\n")); + if (dir == NULL) { + return -ENOENT; + } + return -ENOSPC; +} + +int qnx4_rmdir(struct inode *dir, struct dentry *dentry) +{ + struct buffer_head *bh; + struct qnx4_inode_entry *de; + struct inode *inode; + int retval; + int ino; + + QNX4DEBUG(("qnx4: qnx4_rmdir [%s]\n", dentry->d_name.name)); + lock_kernel(); + bh = qnx4_find_entry(dentry->d_name.len, dir, dentry->d_name.name, + &de, &ino); + if (bh == NULL) { + unlock_kernel(); + return -ENOENT; + } + inode = dentry->d_inode; + if (inode->i_ino != ino) { + retval = -EIO; + goto end_rmdir; + } +#if 0 + if (!empty_dir(inode)) { + retval = -ENOTEMPTY; + goto end_rmdir; + } +#endif + if (inode->i_nlink != 2) { + QNX4DEBUG(("empty directory has nlink!=2 (%d)\n", inode->i_nlink)); + } + QNX4DEBUG(("qnx4: deleting directory\n")); + de->di_status = 0; + memset(de->di_fname, 0, sizeof de->di_fname); + de->di_mode = 0; + mark_buffer_dirty(bh); + inode->i_nlink = 0; + mark_inode_dirty(inode); + inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC; + dir->i_nlink--; + mark_inode_dirty(dir); + retval = 0; + + end_rmdir: + brelse(bh); + + unlock_kernel(); + return retval; +} + +int qnx4_unlink(struct inode *dir, struct dentry *dentry) +{ + struct buffer_head *bh; + struct qnx4_inode_entry *de; + struct inode *inode; + int retval; + int ino; + + QNX4DEBUG(("qnx4: qnx4_unlink [%s]\n", dentry->d_name.name)); + lock_kernel(); + bh = qnx4_find_entry(dentry->d_name.len, dir, dentry->d_name.name, + &de, &ino); + if (bh == NULL) { + unlock_kernel(); + return -ENOENT; + } + inode = dentry->d_inode; + if (inode->i_ino != ino) { + retval = -EIO; + goto end_unlink; + } + retval = -EPERM; + if (!inode->i_nlink) { + QNX4DEBUG(("Deleting nonexistent file (%s:%lu), %d\n", + inode->i_sb->s_id, + inode->i_ino, inode->i_nlink)); + inode->i_nlink = 1; + } + de->di_status = 0; + memset(de->di_fname, 0, sizeof de->di_fname); + de->di_mode = 0; + mark_buffer_dirty(bh); + dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC; + mark_inode_dirty(dir); + inode->i_nlink--; + inode->i_ctime = dir->i_ctime; + mark_inode_dirty(inode); + retval = 0; + +end_unlink: + unlock_kernel(); + brelse(bh); + + return retval; +} +#endif diff --git a/fs/qnx4/truncate.c b/fs/qnx4/truncate.c new file mode 100644 index 000000000000..86563ec01b39 --- /dev/null +++ b/fs/qnx4/truncate.c @@ -0,0 +1,39 @@ +/* + * QNX4 file system, Linux implementation. + * + * Version : 0.1 + * + * Using parts of the xiafs filesystem. + * + * History : + * + * 30-06-1998 by Frank DENIS : ugly filler. + */ + +#include +#include +#include +#include +#include +#include +#include + +#ifdef CONFIG_QNX4FS_RW + +void qnx4_truncate(struct inode *inode) +{ + if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || + S_ISLNK(inode->i_mode))) { + return; + } + lock_kernel(); + if (!(S_ISDIR(inode->i_mode))) { + /* TODO */ + } + QNX4DEBUG(("qnx4: qnx4_truncate called\n")); + inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC; + mark_inode_dirty(inode); + unlock_kernel(); +} + +#endif -- cgit v1.2.3