Browse Source

fs: initial qnx6fs addition

Adds support for qnx6fs readonly support to the linux kernel.

* Mount option
  The option mmi_fs can be used to mount Harman Becker/Audi MMI 3G
  HDD qnx6fs filesystems.

* Documentation
  A high level filesystem stucture description can be found in the
  Documentation/filesystems directory. (qnx6.txt)

* Additional features
  - Active (stable) superblock selection
  - Superblock checksum check (enforced)
  - Supports mount of qnx6 filesystems with to host different endianess
  - Automatic endianess detection
  - Longfilename support (with non-enfocing crc check)
  - All blocksizes (512, 1024, 2048 and 4096 supported)

Signed-off-by: Kai Bankett <chaosman@ontika.net>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
master
Kai Bankett 10 years ago
committed by Al Viro
parent
commit
5d026c7242
  1. 174
      Documentation/filesystems/qnx6.txt
  2. 1
      fs/Kconfig
  3. 1
      fs/Makefile
  4. 26
      fs/qnx6/Kconfig
  5. 7
      fs/qnx6/Makefile
  6. 8
      fs/qnx6/README
  7. 291
      fs/qnx6/dir.c
  8. 698
      fs/qnx6/inode.c
  9. 42
      fs/qnx6/namei.c
  10. 135
      fs/qnx6/qnx6.h
  11. 150
      fs/qnx6/super_mmi.c
  12. 1
      include/linux/magic.h
  13. 134
      include/linux/qnx6_fs.h

174
Documentation/filesystems/qnx6.txt

@ -0,0 +1,174 @@
The QNX6 Filesystem
===================
The qnx6fs is used by newer QNX operating system versions. (e.g. Neutrino)
It got introduced in QNX 6.4.0 and is used default since 6.4.1.
Option
======
mmi_fs Mount filesystem as used for example by Audi MMI 3G system
Specification
=============
qnx6fs shares many properties with traditional Unix filesystems. It has the
concepts of blocks, inodes and directories.
On QNX it is possible to create little endian and big endian qnx6 filesystems.
This feature makes it possible to create and use a different endianness fs
for the target (QNX is used on quite a range of embedded systems) plattform
running on a different endianess.
The Linux driver handles endianness transparently. (LE and BE)
Blocks
------
The space in the device or file is split up into blocks. These are a fixed
size of 512, 1024, 2048 or 4096, which is decided when the filesystem is
created.
Blockpointers are 32bit, so the maximum space that can be adressed is
2^32 * 4096 bytes or 16TB
The superblocks
---------------
The superblock contains all global information about the filesystem.
Each qnx6fs got two superblocks, each one having a 64bit serial number.
That serial number is used to identify the "active" superblock.
In write mode with reach new snapshot (after each synchronous write), the
serial of the new master superblock is increased (old superblock serial + 1)
So basically the snapshot functionality is realized by an atomic final
update of the serial number. Before updating that serial, all modifications
are done by copying all modified blocks during that specific write request
(or period) and building up a new (stable) filesystem structure under the
inactive superblock.
Each superblock holds a set of root inodes for the different filesystem
parts. (Inode, Bitmap and Longfilenames)
Each of these root nodes holds information like total size of the stored
data and the adressing levels in that specific tree.
If the level value is 0, up to 16 direct blocks can be adressed by each
node.
Level 1 adds an additional indirect adressing level where each indirect
adressing block holds up to blocksize / 4 bytes pointers to data blocks.
Level 2 adds an additional indirect adressig block level (so, already up
to 16 * 256 * 256 = 1048576 blocks that can be adressed by such a tree)a
Unused block pointers are always set to ~0 - regardless of root node,
indirect adressing blocks or inodes.
Data leaves are always on the lowest level. So no data is stored on upper
tree levels.
The first Superblock is located at 0x2000. (0x2000 is the bootblock size)
The Audi MMI 3G first superblock directly starts at byte 0.
Second superblock position can either be calculated from the superblock
information (total number of filesystem blocks) or by taking the highest
device address, zeroing the last 3 bytes and then substracting 0x1000 from
that address.
0x1000 is the size reserved for each superblock - regardless of the
blocksize of the filesystem.
Inodes
------
Each object in the filesystem is represented by an inode. (index node)
The inode structure contains pointers to the filesystem blocks which contain
the data held in the object and all of the metadata about an object except
its longname. (filenames longer than 27 characters)
The metadata about an object includes the permissions, owner, group, flags,
size, number of blocks used, access time, change time and modification time.
Object mode field is POSIX format. (which makes things easier)
There are also pointers to the first 16 blocks, if the object data can be
adressed with 16 direct blocks.
For more than 16 blocks an indirect adressing in form of another tree is
used. (scheme is the same as the one used for the superblock root nodes)
The filesize is stored 64bit. Inode counting starts with 1. (whilst long
filename inodes start with 0)
Directories
-----------
A directory is a filesystem object and has an inode just like a file.
It is a specially formatted file containing records which associate each
name with an inode number.
'.' inode number points to the directory inode
'..' inode number points to the parent directory inode
Eeach filename record additionally got a filename length field.
One special case are long filenames or subdirectory names.
These got set a filename length field of 0xff in the corresponding directory
record plus the longfile inode number also stored in that record.
With that longfilename inode number, the longfilename tree can be walked
starting with the superblock longfilename root node pointers.
Special files
-------------
Symbolic links are also filesystem objects with inodes. They got a specific
bit in the inode mode field identifying them as symbolic link.
The directory entry file inode pointer points to the target file inode.
Hard links got an inode, a directory entry, but a specific mode bit set,
no block pointers and the directory file record pointing to the target file
inode.
Character and block special devices do not exist in QNX as those files
are handled by the QNX kernel/drivers and created in /dev independant of the
underlaying filesystem.
Long filenames
--------------
Long filenames are stored in a seperate adressing tree. The staring point
is the longfilename root node in the active superblock.
Each data block (tree leaves) holds one long filename. That filename is
limited to 510 bytes. The first two starting bytes are used as length field
for the actual filename.
If that structure shall fit for all allowed blocksizes, it is clear why there
is a limit of 510 bytes for the actual filename stored.
Bitmap
------
The qnx6fs filesystem allocation bitmap is stored in a tree under bitmap
root node in the superblock and each bit in the bitmap represents one
filesystem block.
The first block is block 0, which starts 0x1000 after superblock start.
So for a normal qnx6fs 0x3000 (bootblock + superblock) is the physical
address at which block 0 is located.
Bits at the end of the last bitmap block are set to 1, if the device is
smaller than addressing space in the bitmap.
Bitmap system area
------------------
The bitmap itself is devided into three parts.
First the system area, that is split into two halfs.
Then userspace.
The requirement for a static, fixed preallocated system area comes from how
qnx6fs deals with writes.
Each superblock got it's own half of the system area. So superblock #1
always uses blocks from the lower half whilst superblock #2 just writes to
blocks represented by the upper half bitmap system area bits.
Bitmap blocks, Inode blocks and indirect addressing blocks for those two
tree structures are treated as system blocks.
The rational behind that is that a write request can work on a new snapshot
(system area of the inactive - resp. lower serial numbered superblock) while
at the same time there is still a complete stable filesystem structer in the
other half of the system area.
When finished with writing (a sync write is completed, the maximum sync leap
time or a filesystem sync is requested), serial of the previously inactive
superblock atomically is increased and the fs switches over to that - then
stable declared - superblock.
For all data outside the system area, blocks are just copied while writing.

1
fs/Kconfig

@ -210,6 +210,7 @@ source "fs/minix/Kconfig"
source "fs/omfs/Kconfig"
source "fs/hpfs/Kconfig"
source "fs/qnx4/Kconfig"
source "fs/qnx6/Kconfig"
source "fs/romfs/Kconfig"
source "fs/pstore/Kconfig"
source "fs/sysv/Kconfig"

1
fs/Makefile

@ -102,6 +102,7 @@ obj-$(CONFIG_UBIFS_FS) += ubifs/
obj-$(CONFIG_AFFS_FS) += affs/
obj-$(CONFIG_ROMFS_FS) += romfs/
obj-$(CONFIG_QNX4FS_FS) += qnx4/
obj-$(CONFIG_QNX6FS_FS) += qnx6/
obj-$(CONFIG_AUTOFS4_FS) += autofs4/
obj-$(CONFIG_ADFS_FS) += adfs/
obj-$(CONFIG_FUSE_FS) += fuse/

26
fs/qnx6/Kconfig

@ -0,0 +1,26 @@
config QNX6FS_FS
tristate "QNX6 file system support (read only)"
depends on BLOCK && CRC32
help
This is the file system used by the real-time operating systems
QNX 6 (also called QNX RTP).
Further information is available at <http://www.qnx.com/>.
Say Y if you intend to mount QNX hard disks or floppies formatted
with a mkqnx6fs.
However, keep in mind that this currently is a readonly driver!
To compile this file system support as a module, choose M here: the
module will be called qnx6.
If you don't know whether you need it, then you don't need it:
answer N.
config QNX6FS_DEBUG
bool "QNX6 debugging information"
depends on QNX6FS_FS
help
Turns on extended debugging output.
If you are not a developer working on the QNX6FS, you probably don't
want this:
answer N.

7
fs/qnx6/Makefile

@ -0,0 +1,7 @@
#
# Makefile for the linux qnx4-filesystem routines.
#
obj-$(CONFIG_QNX6FS_FS) += qnx6.o
qnx6-objs := inode.o dir.o namei.o super_mmi.o

8
fs/qnx6/README

@ -0,0 +1,8 @@
This is a snapshot of the QNX6 filesystem for Linux.
Please send diffs and remarks to <chaosman@ontika.net> .
Credits :
Al Viro <viro@ZenIV.linux.org.uk> (endless patience with me & support ;))
Kai Bankett <chaosman@ontika.net> (Maintainer)

291
fs/qnx6/dir.c

@ -0,0 +1,291 @@
/*
* QNX6 file system, Linux implementation.
*
* Version : 1.0.0
*
* History :
*
* 01-02-2012 by Kai Bankett (chaosman@ontika.net) : first release.
* 16-02-2012 pagemap extension by Al Viro
*
*/
#include "qnx6.h"
static unsigned qnx6_lfile_checksum(char *name, unsigned size)
{
unsigned crc = 0;
char *end = name + size;
while (name < end) {
crc = ((crc >> 1) + *(name++)) ^
((crc & 0x00000001) ? 0x80000000 : 0);
}
return crc;
}
static struct page *qnx6_get_page(struct inode *dir, unsigned long n)
{
struct address_space *mapping = dir->i_mapping;
struct page *page = read_mapping_page(mapping, n, NULL);
if (!IS_ERR(page))
kmap(page);
return page;
}
static inline unsigned long dir_pages(struct inode *inode)
{
return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
}
static unsigned last_entry(struct inode *inode, unsigned long page_nr)
{
unsigned long last_byte = inode->i_size;
last_byte -= page_nr << PAGE_CACHE_SHIFT;
if (last_byte > PAGE_CACHE_SIZE)
last_byte = PAGE_CACHE_SIZE;
return last_byte / QNX6_DIR_ENTRY_SIZE;
}
static struct qnx6_long_filename *qnx6_longname(struct super_block *sb,
struct qnx6_long_dir_entry *de,
struct page **p)
{
struct qnx6_sb_info *sbi = QNX6_SB(sb);
u32 s = fs32_to_cpu(sbi, de->de_long_inode); /* in block units */
u32 n = s >> (PAGE_CACHE_SHIFT - sb->s_blocksize_bits); /* in pages */
/* within page */
u32 offs = (s << sb->s_blocksize_bits) & ~PAGE_CACHE_MASK;
struct address_space *mapping = sbi->longfile->i_mapping;
struct page *page = read_mapping_page(mapping, n, NULL);
if (IS_ERR(page))
return ERR_CAST(page);
kmap(*p = page);
return (struct qnx6_long_filename *)(page_address(page) + offs);
}
static int qnx6_dir_longfilename(struct inode *inode,
struct qnx6_long_dir_entry *de,
void *dirent, loff_t pos,
unsigned de_inode, filldir_t filldir)
{
struct qnx6_long_filename *lf;
struct super_block *s = inode->i_sb;
struct qnx6_sb_info *sbi = QNX6_SB(s);
struct page *page;
int lf_size;
if (de->de_size != 0xff) {
/* error - long filename entries always have size 0xff
in direntry */
printk(KERN_ERR "qnx6: invalid direntry size (%i).\n",
de->de_size);
return 0;
}
lf = qnx6_longname(s, de, &page);
if (IS_ERR(lf)) {
printk(KERN_ERR "qnx6:Error reading longname\n");
return 0;
}
lf_size = fs16_to_cpu(sbi, lf->lf_size);
if (lf_size > QNX6_LONG_NAME_MAX) {
QNX6DEBUG((KERN_INFO "file %s\n", lf->lf_fname));
printk(KERN_ERR "qnx6:Filename too long (%i)\n", lf_size);
qnx6_put_page(page);
return 0;
}
/* calc & validate longfilename checksum
mmi 3g filesystem does not have that checksum */
if (!test_opt(s, MMI_FS) && fs32_to_cpu(sbi, de->de_checksum) !=
qnx6_lfile_checksum(lf->lf_fname, lf_size))
printk(KERN_INFO "qnx6: long filename checksum error.\n");
QNX6DEBUG((KERN_INFO "qnx6_readdir:%.*s inode:%u\n",
lf_size, lf->lf_fname, de_inode));
if (filldir(dirent, lf->lf_fname, lf_size, pos, de_inode,
DT_UNKNOWN) < 0) {
qnx6_put_page(page);
return 0;
}
qnx6_put_page(page);
/* success */
return 1;
}
static int qnx6_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
struct inode *inode = filp->f_path.dentry->d_inode;
struct super_block *s = inode->i_sb;
struct qnx6_sb_info *sbi = QNX6_SB(s);
loff_t pos = filp->f_pos & (QNX6_DIR_ENTRY_SIZE - 1);
unsigned long npages = dir_pages(inode);
unsigned long n = pos >> PAGE_CACHE_SHIFT;
unsigned start = (pos & ~PAGE_CACHE_MASK) / QNX6_DIR_ENTRY_SIZE;
bool done = false;
if (filp->f_pos >= inode->i_size)
return 0;
for ( ; !done && n < npages; n++, start = 0) {
struct page *page = qnx6_get_page(inode, n);
int limit = last_entry(inode, n);
struct qnx6_dir_entry *de;
int i = start;
if (IS_ERR(page)) {
printk(KERN_ERR "qnx6_readdir: read failed\n");
filp->f_pos = (n + 1) << PAGE_CACHE_SHIFT;
return PTR_ERR(page);
}
de = ((struct qnx6_dir_entry *)page_address(page)) + start;
for (; i < limit; i++, de++, pos += QNX6_DIR_ENTRY_SIZE) {
int size = de->de_size;
u32 no_inode = fs32_to_cpu(sbi, de->de_inode);
if (!no_inode || !size)
continue;
if (size > QNX6_SHORT_NAME_MAX) {
/* long filename detected
get the filename from long filename
structure / block */
if (!qnx6_dir_longfilename(inode,
(struct qnx6_long_dir_entry *)de,
dirent, pos, no_inode,
filldir)) {
done = true;
break;
}
} else {
QNX6DEBUG((KERN_INFO "qnx6_readdir:%.*s"
" inode:%u\n", size, de->de_fname,
no_inode));
if (filldir(dirent, de->de_fname, size,
pos, no_inode, DT_UNKNOWN)
< 0) {
done = true;
break;
}
}
}
qnx6_put_page(page);
}
filp->f_pos = pos;
return 0;
}
/*
* check if the long filename is correct.
*/
static unsigned qnx6_long_match(int len, const char *name,
struct qnx6_long_dir_entry *de, struct inode *dir)
{
struct super_block *s = dir->i_sb;
struct qnx6_sb_info *sbi = QNX6_SB(s);
struct page *page;
int thislen;
struct qnx6_long_filename *lf = qnx6_longname(s, de, &page);
if (IS_ERR(lf))
return 0;
thislen = fs16_to_cpu(sbi, lf->lf_size);
if (len != thislen) {
qnx6_put_page(page);
return 0;
}
if (memcmp(name, lf->lf_fname, len) == 0) {
qnx6_put_page(page);
return fs32_to_cpu(sbi, de->de_inode);
}
qnx6_put_page(page);
return 0;
}
/*
* check if the filename is correct.
*/
static unsigned qnx6_match(struct super_block *s, int len, const char *name,
struct qnx6_dir_entry *de)
{
struct qnx6_sb_info *sbi = QNX6_SB(s);
if (memcmp(name, de->de_fname, len) == 0)
return fs32_to_cpu(sbi, de->de_inode);
return 0;
}
unsigned qnx6_find_entry(int len, struct inode *dir, const char *name,
struct page **res_page)
{
struct super_block *s = dir->i_sb;
struct qnx6_inode_info *ei = QNX6_I(dir);
struct page *page = NULL;
unsigned long start, n;
unsigned long npages = dir_pages(dir);
unsigned ino;
struct qnx6_dir_entry *de;
struct qnx6_long_dir_entry *lde;
*res_page = NULL;
if (npages == 0)
return 0;
start = ei->i_dir_start_lookup;
if (start >= npages)
start = 0;
n = start;
do {
page = qnx6_get_page(dir, n);
if (!IS_ERR(page)) {
int limit = last_entry(dir, n);
int i;
de = (struct qnx6_dir_entry *)page_address(page);
for (i = 0; i < limit; i++, de++) {
if (len <= QNX6_SHORT_NAME_MAX) {
/* short filename */
if (len != de->de_size)
continue;
ino = qnx6_match(s, len, name, de);
if (ino)
goto found;
} else if (de->de_size == 0xff) {
/* deal with long filename */
lde = (struct qnx6_long_dir_entry *)de;
ino = qnx6_long_match(len,
name, lde, dir);
if (ino)
goto found;
} else
printk(KERN_ERR "qnx6: undefined "
"filename size in inode.\n");
}
qnx6_put_page(page);
}
if (++n >= npages)
n = 0;
} while (n != start);
return 0;
found:
*res_page = page;
ei->i_dir_start_lookup = n;
return ino;
}
const struct file_operations qnx6_dir_operations = {
.llseek = generic_file_llseek,
.read = generic_read_dir,
.readdir = qnx6_readdir,
.fsync = generic_file_fsync,
};
const struct inode_operations qnx6_dir_inode_operations = {
.lookup = qnx6_lookup,
};

698
fs/qnx6/inode.c

@ -0,0 +1,698 @@
/*
* QNX6 file system, Linux implementation.
*
* Version : 1.0.0
*
* History :
*
* 01-02-2012 by Kai Bankett (chaosman@ontika.net) : first release.
* 16-02-2012 pagemap extension by Al Viro
*
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/highuid.h>
#include <linux/pagemap.h>
#include <linux/buffer_head.h>
#include <linux/writeback.h>
#include <linux/statfs.h>
#include <linux/parser.h>
#include <linux/seq_file.h>
#include <linux/mount.h>
#include <linux/crc32.h>
#include <linux/mpage.h>
#include "qnx6.h"
static const struct super_operations qnx6_sops;
static void qnx6_put_super(struct super_block *sb);
static struct inode *qnx6_alloc_inode(struct super_block *sb);
static void qnx6_destroy_inode(struct inode *inode);
static int qnx6_remount(struct super_block *sb, int *flags, char *data);
static int qnx6_statfs(struct dentry *dentry, struct kstatfs *buf);
static int qnx6_show_options(struct seq_file *seq, struct dentry *root);
static const struct super_operations qnx6_sops = {
.alloc_inode = qnx6_alloc_inode,
.destroy_inode = qnx6_destroy_inode,
.put_super = qnx6_put_super,
.statfs = qnx6_statfs,
.remount_fs = qnx6_remount,
.show_options = qnx6_show_options,
};
static int qnx6_show_options(struct seq_file *seq, struct dentry *root)
{
struct super_block *sb = root->d_sb;
struct qnx6_sb_info *sbi = QNX6_SB(sb);
if (sbi->s_mount_opt & QNX6_MOUNT_MMI_FS)
seq_puts(seq, ",mmi_fs");
return 0;
}
static int qnx6_remount(struct super_block *sb, int *flags, char *data)
{
*flags |= MS_RDONLY;
return 0;
}
static unsigned qnx6_get_devblock(struct super_block *sb, __fs32 block)
{
struct qnx6_sb_info *sbi = QNX6_SB(sb);
return fs32_to_cpu(sbi, block) + sbi->s_blks_off;
}
static unsigned qnx6_block_map(struct inode *inode, unsigned iblock);
static int qnx6_get_block(struct inode *inode, sector_t iblock,
struct buffer_head *bh, int create)
{
unsigned phys;
QNX6DEBUG((KERN_INFO "qnx6: qnx6_get_block inode=[%ld] iblock=[%ld]\n",
inode->i_ino, (unsigned long)iblock));
phys = qnx6_block_map(inode, iblock);
if (phys) {
/* logical block is before EOF */
map_bh(bh, inode->i_sb, phys);
}
return 0;
}
static int qnx6_check_blockptr(__fs32 ptr)
{
if (ptr == ~(__fs32)0) {
printk(KERN_ERR "qnx6: hit unused blockpointer.\n");
return 0;
}
return 1;
}
static int qnx6_readpage(struct file *file, struct page *page)
{
return mpage_readpage(page, qnx6_get_block);
}
static int qnx6_readpages(struct file *file, struct address_space *mapping,
struct list_head *pages, unsigned nr_pages)
{
return mpage_readpages(mapping, pages, nr_pages, qnx6_get_block);
}
/*
* returns the block number for the no-th element in the tree
* inodebits requred as there are multiple inodes in one inode block
*/
static unsigned qnx6_block_map(struct inode *inode, unsigned no)
{
struct super_block *s = inode->i_sb;
struct qnx6_sb_info *sbi = QNX6_SB(s);
struct qnx6_inode_info *ei = QNX6_I(inode);
unsigned block = 0;
struct buffer_head *bh;
__fs32 ptr;
int levelptr;
int ptrbits = sbi->s_ptrbits;
int bitdelta;
u32 mask = (1 << ptrbits) - 1;
int depth = ei->di_filelevels;
int i;
bitdelta = ptrbits * depth;
levelptr = no >> bitdelta;
if (levelptr > QNX6_NO_DIRECT_POINTERS - 1) {
printk(KERN_ERR "qnx6:Requested file block number (%u) too big.",
no);
return 0;
}
block = qnx6_get_devblock(s, ei->di_block_ptr[levelptr]);
for (i = 0; i < depth; i++) {
bh = sb_bread(s, block);
if (!bh) {
printk(KERN_ERR "qnx6:Error reading block (%u)\n",
block);
return 0;
}
bitdelta -= ptrbits;
levelptr = (no >> bitdelta) & mask;
ptr = ((__fs32 *)bh->b_data)[levelptr];
if (!qnx6_check_blockptr(ptr))
return 0;
block = qnx6_get_devblock(s, ptr);
brelse(bh);
}
return block;
}
static int qnx6_statfs(struct dentry *dentry, struct kstatfs *buf)
{
struct super_block *sb = dentry->d_sb;
struct qnx6_sb_info *sbi = QNX6_SB(sb);
u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
buf->f_type = sb->s_magic;
buf->f_bsize = sb->s_blocksize;
buf->f_blocks = fs32_to_cpu(sbi, sbi->sb->sb_num_blocks);
buf->f_bfree = fs32_to_cpu(sbi, sbi->sb->sb_free_blocks);
buf->f_files = fs32_to_cpu(sbi, sbi->sb->sb_num_inodes);
buf->f_ffree = fs32_to_cpu(sbi, sbi->sb->sb_free_inodes);
buf->f_bavail = buf->f_bfree;
buf->f_namelen = QNX6_LONG_NAME_MAX;
buf->f_fsid.val[0] = (u32)id;
buf->f_fsid.val[1] = (u32)(id >> 32);
return 0;
}
/*
* Check the root directory of the filesystem to make sure
* it really _is_ a qnx6 filesystem, and to check the size
* of the directory entry.
*/
static const char *qnx6_checkroot(struct super_block *s)
{
static char match_root[2][3] = {".\0\0", "..\0"};
int i, error = 0;
struct qnx6_dir_entry *dir_entry;
struct inode *root = s->s_root->d_inode;
struct address_space *mapping = root->i_mapping;
struct page *page = read_mapping_page(mapping, 0, NULL);
if (IS_ERR(page))
return "error reading root directory";
kmap(page);
dir_entry = page_address(page);
for (i = 0; i < 2; i++) {
/* maximum 3 bytes - due to match_root limitation */
if (strncmp(dir_entry[i].de_fname, match_root[i], 3))
error = 1;
}
qnx6_put_page(page);
if (error)
return "error reading root directory.";
return NULL;
}
#ifdef CONFIG_QNX6FS_DEBUG
void qnx6_superblock_debug(struct qnx6_super_block *sb, struct super_block *s)
{
struct qnx6_sb_info *sbi = QNX6_SB(s);
QNX6DEBUG((KERN_INFO "magic: %08x\n",
fs32_to_cpu(sbi, sb->sb_magic)));
QNX6DEBUG((KERN_INFO "checksum: %08x\n",
fs32_to_cpu(sbi, sb->sb_checksum)));
QNX6DEBUG((KERN_INFO "serial: %llx\n",
fs64_to_cpu(sbi, sb->sb_serial)));
QNX6DEBUG((KERN_INFO "flags: %08x\n",
fs32_to_cpu(sbi, sb->sb_flags)));
QNX6DEBUG((KERN_INFO "blocksize: %08x\n",
fs32_to_cpu(sbi, sb->sb_blocksize)));
QNX6DEBUG((KERN_INFO "num_inodes: %08x\n",
fs32_to_cpu(sbi, sb->sb_num_inodes)));
QNX6DEBUG((KERN_INFO "free_inodes: %08x\n",
fs32_to_cpu(sbi, sb->sb_free_inodes)));
QNX6DEBUG((KERN_INFO "num_blocks: %08x\n",
fs32_to_cpu(sbi, sb->sb_num_blocks)));
QNX6DEBUG((KERN_INFO "free_blocks: %08x\n",
fs32_to_cpu(sbi, sb->sb_free_blocks)));
QNX6DEBUG((KERN_INFO "inode_levels: %02x\n",
sb->Inode.levels));
}
#endif
enum {
Opt_mmifs,
Opt_err
};
static const match_table_t tokens = {
{Opt_mmifs, "mmi_fs"},
{Opt_err, NULL}
};
static int qnx6_parse_options(char *options, struct super_block *sb)
{
char *p;
struct qnx6_sb_info *sbi = QNX6_SB(sb);
substring_t args[MAX_OPT_ARGS];
if (!options)
return 1;
while ((p = strsep(&options, ",")) != NULL) {
int token;
if (!*p)
continue;
token = match_token(p, tokens, args);
switch (token) {
case Opt_mmifs:
set_opt(sbi->s_mount_opt, MMI_FS);
break;
default:
return 0;
}
}
return 1;
}
static struct buffer_head *qnx6_check_first_superblock(struct super_block *s,
int offset, int silent)
{
struct qnx6_sb_info *sbi = QNX6_SB(s);
struct buffer_head *bh;
struct qnx6_super_block *sb;
/* Check the superblock signatures
start with the first superblock */
bh = sb_bread(s, offset);
if (!bh) {
printk(KERN_ERR "qnx6: unable to read the first superblock\n");
return NULL;
}
sb = (struct qnx6_super_block *)bh->b_data;
if (fs32_to_cpu(sbi, sb->sb_magic) != QNX6_SUPER_MAGIC) {
sbi->s_bytesex = BYTESEX_BE;
if (fs32_to_cpu(sbi, sb->sb_magic) == QNX6_SUPER_MAGIC) {
/* we got a big endian fs */
QNX6DEBUG((KERN_INFO "qnx6: fs got different"
" endianess.\n"));
return bh;
} else
sbi->s_bytesex = BYTESEX_LE;
if (!silent) {
if (offset == 0) {
printk(KERN_ERR "qnx6: wrong signature (magic)"
" in superblock #1.\n");
} else {
printk(KERN_INFO "qnx6: wrong signature (magic)"
" at position (0x%lx) - will try"
" alternative position (0x0000).\n",
offset * s->s_blocksize);
}
}
brelse(bh);
return NULL;
}
return bh;
}
static struct inode *qnx6_private_inode(struct super_block *s,
struct qnx6_root_node *p);
static int qnx6_fill_super(struct super_block *s, void *data, int silent)
{
struct buffer_head *bh1 = NULL, *bh2 = NULL;
struct qnx6_super_block *sb1 = NULL, *sb2 = NULL;
struct qnx6_sb_info *sbi;
struct inode *root;
const char *errmsg;
struct qnx6_sb_info *qs;
int ret = -EINVAL;
u64 offset;
int bootblock_offset = QNX6_BOOTBLOCK_SIZE;
qs = kzalloc(sizeof(struct qnx6_sb_info), GFP_KERNEL);
if (!qs)
return -ENOMEM;
s->s_fs_info = qs;
/* Superblock always is 512 Byte long */
if (!sb_set_blocksize(s, QNX6_SUPERBLOCK_SIZE)) {
printk(KERN_ERR "qnx6: unable to set blocksize\n");
goto outnobh;
}
/* parse the mount-options */
if (!qnx6_parse_options((char *) data, s)) {
printk(KERN_ERR "qnx6: invalid mount options.\n");
goto outnobh;
}
if (test_opt(s, MMI_FS)) {
sb1 = qnx6_mmi_fill_super(s, silent);
if (sb1)
goto mmi_success;
else
goto outnobh;
}
sbi = QNX6_SB(s);
sbi->s_bytesex = BYTESEX_LE;
/* Check the superblock signatures
start with the first superblock */
bh1 = qnx6_check_first_superblock(s,
bootblock_offset / QNX6_SUPERBLOCK_SIZE, silent);
if (!bh1) {
/* try again without bootblock offset */
bh1 = qnx6_check_first_superblock(s, 0, silent);
if (!bh1) {
printk(KERN_ERR "qnx6: unable to read the first superblock\n");
goto outnobh;
}
/* seems that no bootblock at partition start */
bootblock_offset = 0;
}
sb1 = (struct qnx6_super_block *)bh1->b_data;
#ifdef CONFIG_QNX6FS_DEBUG
qnx6_superblock_debug(sb1, s);
#endif
/* checksum check - start at byte 8 and end at byte 512 */
if (fs32_to_cpu(sbi, sb1->sb_checksum) !=
crc32_be(0, (char *)(bh1->b_data + 8), 504)) {
printk(KERN_ERR "qnx6: superblock #1 checksum error\n");
goto out;
}
/* set new blocksize */
if (!sb_set_blocksize(s, fs32_to_cpu(sbi, sb1->sb_blocksize))) {
printk(KERN_ERR "qnx6: unable to set blocksize\n");
goto out;
}
/* blocksize invalidates bh - pull it back in */
brelse(bh1);
bh1 = sb_bread(s, bootblock_offset >> s->s_blocksize_bits);
if (!bh1)
goto outnobh;
sb1 = (struct qnx6_super_block *)bh1->b_data;
/* calculate second superblock blocknumber */
offset = fs32_to_cpu(sbi, sb1->sb_num_blocks) +
(bootblock_offset >> s->s_blocksize_bits) +
(QNX6_SUPERBLOCK_AREA >> s->s_blocksize_bits);
/* set bootblock offset */
sbi->s_blks_off = (bootblock_offset >> s->s_blocksize_bits) +
(QNX6_SUPERBLOCK_AREA >> s->s_blocksize_bits);
/* next the second superblock */
bh2 = sb_bread(s, offset);
if (!bh2) {
printk(KERN_ERR "qnx6: unable to read the second superblock\n");
goto out;
}
sb2 = (struct qnx6_super_block *)bh2->b_data;
if (fs32_to_cpu(sbi, sb2->sb_magic) != QNX6_SUPER_MAGIC) {
if (!silent)
printk(KERN_ERR "qnx6: wrong signature (magic)"
" in superblock #2.\n");
goto out;
}
/* checksum check - start at byte 8 and end at byte 512 */
if (fs32_to_cpu(sbi, sb2->sb_checksum) !=
crc32_be(0, (char *)(bh2->b_data + 8), 504)) {
printk(KERN_ERR "qnx6: superblock #2 checksum error\n");
goto out;
}
if (fs64_to_cpu(sbi, sb1->sb_serial) >=
fs64_to_cpu(sbi, sb2->sb_serial)) {
/* superblock #1 active */
sbi->sb_buf = bh1;
sbi->sb = (struct qnx6_super_block *)bh1->b_data;
brelse(bh2);
printk(KERN_INFO "qnx6: superblock #1 active\n");
} else {
/* superblock #2 active */
sbi->sb_buf = bh2;
sbi->sb = (struct qnx6_super_block *)bh2->b_data;
brelse(bh1);
printk(KERN_INFO "qnx6: superblock #2 active\n");
}
mmi_success:
/* sanity check - limit maximum indirect pointer levels */
if (sb1->Inode.levels > QNX6_PTR_MAX_LEVELS) {
printk(KERN_ERR "qnx6: too many inode levels (max %i, sb %i)\n",
QNX6_PTR_MAX_LEVELS, sb1->Inode.levels);
goto out;
}
if (sb1->Longfile.levels > QNX6_PTR_MAX_LEVELS) {
printk(KERN_ERR "qnx6: too many longfilename levels"
" (max %i, sb %i)\n",
QNX6_PTR_MAX_LEVELS, sb1->Longfile.levels);
goto out;
}
s->s_op = &qnx6_sops;
s->s_magic = QNX6_SUPER_MAGIC;
s->s_flags |= MS_RDONLY; /* Yup, read-only yet */
/* ease the later tree level calculations */
sbi = QNX6_SB(s);
sbi->s_ptrbits = ilog2(s->s_blocksize / 4);
sbi->inodes = qnx6_private_inode(s, &sb1->Inode);
if (!sbi->inodes)
goto out;
sbi->longfile = qnx6_private_inode(s, &sb1->Longfile);
if (!sbi->longfile)
goto out1;
/* prefetch root inode */
root = qnx6_iget(s, QNX6_ROOT_INO);
if (IS_ERR(root)) {
printk(KERN_ERR "qnx6: get inode failed\n");
ret = PTR_ERR(root);
goto out2;
}
ret = -ENOMEM;
s->s_root = d_make_root(root);
if (!s->s_root)
goto out2;
ret = -EINVAL;
errmsg = qnx6_checkroot(s);
if (errmsg != NULL) {
if (!silent)
printk(KERN_ERR "qnx6: %s\n", errmsg);
goto out3;
}
return 0;
out3:
dput(s->s_root);
s->s_root = NULL;
out2:
iput(sbi->longfile);
out1:
iput(sbi->inodes);
out:
if (bh1)
brelse(bh1);
if (bh2)
brelse(bh2);
outnobh:
kfree(qs);
s->s_fs_info = NULL;
return ret;
}
static void qnx6_put_super(struct super_block *sb)
{
struct qnx6_sb_info *qs = QNX6_SB(sb);
brelse(qs->sb_buf);
iput(qs->longfile);
iput(qs->inodes);
kfree(qs);
sb->s_fs_info = NULL;
return;
}
static sector_t qnx6_bmap(struct address_space *mapping, sector_t block)
{
return generic_block_bmap(mapping, block, qnx6_get_block);
}
static const struct address_space_operations qnx6_aops = {
.readpage = qnx6_readpage,
.readpages = qnx6_readpages,
.bmap = qnx6_bmap
};
static struct inode *qnx6_private_inode(struct super_block *s,
struct qnx6_root_node *p)
{
struct inode *inode = new_inode(s);
if (inode) {
struct qnx6_inode_info *ei = QNX6_I(inode);
struct qnx6_sb_info *sbi = QNX6_SB(s);
inode->i_size = fs64_to_cpu(sbi, p->size);
memcpy(ei->di_block_ptr, p->ptr, sizeof(p->ptr));
ei->di_filelevels = p->levels;
inode->i_mode = S_IFREG | S_IRUSR; /* probably wrong */
inode->i_mapping->a_ops = &qnx6_aops;
}
return inode;
}
struct inode *qnx6_iget(struct super_block *sb, unsigned ino)
{
struct qnx6_sb_info *sbi = QNX6_SB(sb);
struct qnx6_inode_entry *raw_inode;
struct inode *inode;
struct qnx6_inode_info *ei;
struct address_space *mapping;
struct page *page;
u32 n, offs;
inode = iget_locked(sb, ino);
if (!inode)
return ERR_PTR(-ENOMEM);
if (!(inode->i_state & I_NEW))
return inode;
ei = QNX6_I(inode);
inode->i_mode = 0;
if (ino == 0) {
printk(KERN_ERR "qnx6: bad inode number on dev %s: %u is "
"out of range\n",
sb->s_id, ino);
iget_failed(inode);
return ERR_PTR(-EIO);
}
n = (ino - 1) >> (PAGE_CACHE_SHIFT - QNX6_INODE_SIZE_BITS);
offs = (ino - 1) & (~PAGE_CACHE_MASK >> QNX6_INODE_SIZE_BITS);
mapping = sbi->inodes->i_mapping;
page = read_mapping_page(mapping, n, NULL);
if (IS_ERR(page)) {
printk(KERN_ERR "qnx6: major problem: unable to read inode from "
"dev %s\n", sb->s_id);
iget_failed(inode);
return ERR_CAST(page);
}
kmap(page);
raw_inode = ((struct qnx6_inode_entry *)page_address(page)) + offs;
inode->i_mode = fs16_to_cpu(sbi, raw_inode->di_mode);
inode->i_uid = (uid_t)fs32_to_cpu(sbi, raw_inode->di_uid);
inode->i_gid = (gid_t)fs32_to_cpu(sbi, raw_inode->di_gid);
inode->i_size = fs64_to_cpu(sbi, raw_inode->di_size);
inode->i_mtime.tv_sec = fs32_to_cpu(sbi, raw_inode->di_mtime);
inode->i_mtime.tv_nsec = 0;
inode->i_atime.tv_sec = fs32_to_cpu(sbi, raw_inode->di_atime);
inode->i_atime.tv_nsec = 0;
inode->i_ctime.tv_sec = fs32_to_cpu(sbi, raw_inode->di_ctime);
inode->i_ctime.tv_nsec = 0;
/* calc blocks based on 512 byte blocksize */
inode->i_blocks = (inode->i_size + 511) >> 9;
memcpy(&ei->di_block_ptr, &raw_inode->di_block_ptr,
sizeof(raw_inode->di_block_ptr));
ei->di_filelevels = raw_inode->di_filelevels;
if (S_ISREG(inode->i_mode)) {
inode->i_fop = &generic_ro_fops;
inode->i_mapping->a_ops = &qnx6_aops;
} else if (S_ISDIR(inode->i_mode)) {
inode->i_op = &qnx6_dir_inode_operations;
inode->i_fop = &qnx6_dir_operations;
inode->i_mapping->a_ops = &qnx6_aops;
} else if (S_ISLNK(inode->i_mode)) {
inode->i_op = &page_symlink_inode_operations;
inode->i_mapping->a_ops = &qnx6_aops;
} else
init_special_inode(inode, inode->i_mode, 0);
qnx6_put_page(page);
unlock_new_inode(inode);
return inode;
}
static struct kmem_cache *qnx6_inode_cachep;
static struct inode *qnx6_alloc_inode(struct super_block *sb)
{
struct qnx6_inode_info *ei;
ei = kmem_cache_alloc(qnx6_inode_cachep, GFP_KERNEL);
if (!ei)
return NULL;
return &ei->vfs_inode;
}
static void qnx6_i_callback(struct rcu_head *head)
{
struct inode *inode = container_of(head, struct inode, i_rcu);
INIT_LIST_HEAD(&inode->i_dentry);
kmem_cache_free(qnx6_inode_cachep, QNX6_I(inode));
}
static void qnx6_destroy_inode(struct inode *inode)
{
call_rcu(&inode->i_rcu, qnx6_i_callback);
}
static void init_once(void *foo)
{
struct qnx6_inode_info *ei = (struct qnx6_inode_info *) foo;
inode_init_once(&ei->vfs_inode);
}
static int init_inodecache(void)
{
qnx6_inode_cachep = kmem_cache_create("qnx6_inode_cache",
sizeof(struct qnx6_inode_info),
0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD),
init_once);
if (!qnx6_inode_cachep)
return -ENOMEM;
return 0;
}
static void destroy_inodecache(void)
{
kmem_cache_destroy(qnx6_inode_cachep);
}
static struct dentry *qnx6_mount(struct file_system_type *fs_type,
int flags, const char *dev_name, void *data)
{
return mount_bdev(fs_type, flags, dev_name, data, qnx6_fill_super);
}
static struct file_system_type qnx6_fs_type = {
.owner = THIS_MODULE,
.name = "qnx6",
.mount = qnx6_mount,
.kill_sb = kill_block_super,
.fs_flags = FS_REQUIRES_DEV,
};
static int __init init_qnx6_fs(void)
{
int err;
err = init_inodecache();
if (err)
return err;
err = register_filesystem(&qnx6_fs_type);
if (err) {
destroy_inodecache();
return err;
}
printk(KERN_INFO "QNX6 filesystem 1.0.0 registered.\n");
return 0;
}
static void __exit exit_qnx6_fs(void)
{
unregister_filesystem(&qnx6_fs_type);
destroy_inodecache();
}
module_init(init_qnx6_fs)
module_exit(exit_qnx6_fs)
MODULE_LICENSE("GPL");

42
fs/qnx6/namei.c

@ -0,0 +1,42 @@
/*
* QNX6 file system, Linux implementation.
*
* Version : 1.0.0
*
* History :
*
* 01-02-2012 by Kai Bankett (chaosman@ontika.net) : first release.
* 16-02-2012 pagemap extension by Al Viro
*
*/
#include "qnx6.h"
struct dentry *qnx6_lookup(struct inode *dir, struct dentry *dentry,
struct nameidata *nd)
{
unsigned ino;
struct page *page;
struct inode *foundinode = NULL;
const char *name = dentry->d_name.name;
int len = dentry->d_name.len;
if (len > QNX6_LONG_NAME_MAX)
return ERR_PTR(-ENAMETOOLONG);
ino = qnx6_find_entry(len, dir, name, &page);
if (ino) {
foundinode = qnx6_iget(dir->i_sb, ino);
qnx6_put_page(page);
if (IS_ERR(foundinode)) {
QNX6DEBUG((KERN_ERR "qnx6: lookup->iget -> "
" error %ld\n", PTR_ERR(foundinode)));
return ERR_CAST(foundinode);
}
} else {
QNX6DEBUG((KERN_INFO "qnx6_lookup: not found %s\n", name));
return NULL;
}
d_add(dentry, foundinode);
return NULL;
}

135
fs/qnx6/qnx6.h

@ -0,0 +1,135 @@
/*
* QNX6 file system, Linux implementation.
*
* Version : 1.0.0
*
* History :
*
* 01-02-2012 by Kai Bankett (chaosman@ontika.net) : first release.
* 16-02-2012 page map extension by Al Viro
*
*/
#include <linux/fs.h>
#include <linux/pagemap.h>
typedef __u16 __bitwise __fs16;
typedef __u32 __bitwise __fs32;
typedef __u64 __bitwise __fs64;
#include <linux/qnx6_fs.h>
#ifdef CONFIG_QNX6FS_DEBUG
#define QNX6DEBUG(X) printk X
#else
#define QNX6DEBUG(X) (void) 0
#endif
struct qnx6_sb_info {
struct buffer_head *sb_buf; /* superblock buffer */
struct qnx6_super_block *sb; /* our superblock */
int s_blks_off; /* blkoffset fs-startpoint */
int s_ptrbits; /* indirect pointer bitfield */
unsigned long s_mount_opt; /* all mount options */
int s_bytesex; /* holds endianess info */
struct inode * inodes;
struct inode * longfile;
};
struct qnx6_inode_info {
__fs32 di_block_ptr[QNX6_NO_DIRECT_POINTERS];
__u8 di_filelevels;
__u32 i_dir_start_lookup;
struct inode vfs_inode;
};
extern struct inode *qnx6_iget(struct super_block *sb, unsigned ino);
extern struct dentry *qnx6_lookup(struct inode *dir, struct dentry *dentry,
struct nameidata *nd);
#ifdef CONFIG_QNX6FS_DEBUG
extern void qnx6_superblock_debug(struct qnx6_super_block *,
struct super_block *);
#endif
extern const struct inode_operations qnx6_dir_inode_operations;
extern const struct file_operations qnx6_dir_operations;
static inline struct qnx6_sb_info *QNX6_SB(struct super_block *sb)
{
return sb->s_fs_info;
}
static inline struct qnx6_inode_info *QNX6_I(struct inode *inode)
{
return container_of(inode, struct qnx6_inode_info, vfs_inode);
}
#define clear_opt(o, opt) (o &= ~(QNX6_MOUNT_##opt))
#define set_opt(o, opt) (o |= (QNX6_MOUNT_##opt))
#define test_opt(sb, opt) (QNX6_SB(sb)->s_mount_opt & \
QNX6_MOUNT_##opt)
enum {
BYTESEX_LE,
BYTESEX_BE,
};
static inline __u64 fs64_to_cpu(struct qnx6_sb_info *sbi, __fs64 n)
{
if (sbi->s_bytesex == BYTESEX_LE)
return le64_to_cpu((__force __le64)n);
else
return be64_to_cpu((__force __be64)n);
}
static inline __fs64 cpu_to_fs64(struct qnx6_sb_info *sbi, __u64 n)
{
if (sbi->s_bytesex == BYTESEX_LE)
return (__force __fs64)cpu_to_le64(n);
else
return (__force __fs64)cpu_to_be64(n);
}
static inline __u32 fs32_to_cpu(struct qnx6_sb_info *sbi, __fs32 n)
{
if (sbi->s_bytesex == BYTESEX_LE)
return le32_to_cpu((__force __le32)n);
else
return be32_to_cpu((__force __be32)n);
}
static inline __fs32 cpu_to_fs32(struct qnx6_sb_info *sbi, __u32 n)
{
if (sbi->s_bytesex == BYTESEX_LE)
return (__force __fs32)cpu_to_le32(n);
else
return (__force __fs32)cpu_to_be32(n);
}
static inline __u16 fs16_to_cpu(struct qnx6_sb_info *sbi, __fs16 n)
{
if (sbi->s_bytesex == BYTESEX_LE)
return le16_to_cpu((__force __le16)n);
else
return be16_to_cpu((__force __be16)n);
}
static inline __fs16 cpu_to_fs16(struct qnx6_sb_info *sbi, __u16 n)
{
if (sbi->s_bytesex == BYTESEX_LE)
return (__force __fs16)cpu_to_le16(n);
else
return (__force __fs16)cpu_to_be16(n);
}
extern struct qnx6_super_block *qnx6_mmi_fill_super(struct super_block *s,
int silent);
static inline void qnx6_put_page(struct page *page)
{
kunmap(page);
page_cache_release(page);
}
extern unsigned qnx6_find_entry(int len, struct inode *dir, const char *name,
struct page **res_page);

150
fs/qnx6/super_mmi.c

@ -0,0 +1,150 @@
/*
* QNX6 file system, Linux implementation.
*
* Version : 1.0.0
*
* History :
*
* 01-02-2012 by Kai Bankett (chaosman@ontika.net) : first release.
*
*/
#include <linux/buffer_head.h>
#include <linux/slab.h>
#include <linux/crc32.h>
#include "qnx6.h"
static void qnx6_mmi_copy_sb(struct qnx6_super_block *qsb,
struct qnx6_mmi_super_block *sb)
{
qsb->sb_magic = sb->sb_magic;
qsb->sb_checksum = sb->sb_checksum;
qsb->sb_serial = sb->sb_serial;
qsb->sb_blocksize = sb->sb_blocksize;
qsb->sb_num_inodes = sb->sb_num_inodes;
qsb->sb_free_inodes = sb->sb_free_inodes;
qsb->sb_num_blocks = sb->sb_num_blocks;
qsb->sb_free_blocks = sb->sb_free_blocks;
/* the rest of the superblock is the same */
memcpy(&qsb->Inode, &sb->Inode, sizeof(sb->Inode));
memcpy(&qsb->Bitmap, &sb->Bitmap, sizeof(sb->Bitmap));
memcpy(&qsb->Longfile, &sb->Longfile, sizeof(sb->Longfile));
}
struct qnx6_super_block *qnx6_mmi_fill_super(struct super_block *s, int silent)
{
struct buffer_head *bh1, *bh2 = NULL;
struct qnx6_mmi_super_block *sb1, *sb2;
struct qnx6_super_block *qsb = NULL;
struct qnx6_sb_info *sbi;
__u64 offset;
/* Check the superblock signatures
start with the first superblock */
bh1 = sb_bread(s, 0);
if (!bh1) {
printk(KERN_ERR "qnx6: Unable to read first mmi superblock\n");
return NULL;
}
sb1 = (struct qnx6_mmi_super_block *)bh1->b_data;
sbi = QNX6_SB(s);
if (fs32_to_cpu(sbi, sb1->sb_magic) != QNX6_SUPER_MAGIC) {
if (!silent) {
printk(KERN_ERR "qnx6: wrong signature (magic) in"
" superblock #1.\n");
goto out;
}
}
/* checksum check - start at byte 8 and end at byte 512 */
if (fs32_to_cpu(sbi, sb1->sb_checksum) !=
crc32_be(0, (char *)(bh1->b_data + 8), 504)) {
printk(KERN_ERR "qnx6: superblock #1 checksum error\n");
goto out;
}
/* calculate second superblock blocknumber */
offset = fs32_to_cpu(sbi, sb1->sb_num_blocks) + QNX6_SUPERBLOCK_AREA /
fs32_to_cpu(sbi, sb1->sb_blocksize);
/* set new blocksize */
if (!sb_set_blocksize(s, fs32_to_cpu(sbi, sb1->sb_blocksize))) {
printk(KERN_ERR "qnx6: unable to set blocksize\n");
goto out;
}
/* blocksize invalidates bh - pull it back in */
brelse(bh1);
bh1 = sb_bread(s, 0);
if (!bh1)
goto out;
sb1 = (struct qnx6_mmi_super_block *)bh1->b_data;
/* read second superblock */
bh2 = sb_bread(s, offset);
if (!bh2) {
printk(KERN_ERR "qnx6: unable to read the second superblock\n");
goto out;
}
sb2 = (struct qnx6_mmi_super_block *)bh2->b_data;
if (fs32_to_cpu(sbi, sb2->sb_magic) != QNX6_SUPER_MAGIC) {
if (!silent)
printk(KERN_ERR "qnx6: wrong signature (magic) in"
" superblock #2.\n");
goto out;
}
/* checksum check - start at byte 8 and end at byte 512 */
if (fs32_to_cpu(sbi, sb2->sb_checksum)
!= crc32_be(0, (char *)(bh2->b_data + 8), 504)) {
printk(KERN_ERR "qnx6: superblock #1 checksum error\n");
goto out;
}
qsb = kmalloc(sizeof(*qsb), GFP_KERNEL);
if (!qsb) {
printk(KERN_ERR "qnx6: unable to allocate memory.\n");
goto out;
}
if (fs64_to_cpu(sbi, sb1->sb_serial) >
fs64_to_cpu(sbi, sb2->sb_serial)) {
/* superblock #1 active */
qnx6_mmi_copy_sb(qsb, sb1);
#ifdef CONFIG_QNX6FS_DEBUG
qnx6_superblock_debug(qsb, s);
#endif
memcpy(bh1->b_data, qsb, sizeof(struct qnx6_super_block));
sbi->sb_buf = bh1;
sbi->sb = (struct qnx6_super_block *)bh1->b_data;
brelse(bh2);
printk(KERN_INFO "qnx6: superblock #1 active\n");
} else {
/* superblock #2 active */
qnx6_mmi_copy_sb(qsb, sb2);
#ifdef CONFIG_QNX6FS_DEBUG
qnx6_superblock_debug(qsb, s);
#endif
memcpy(bh2->b_data, qsb, sizeof(struct qnx6_super_block));
sbi->sb_buf = bh2;
sbi->sb = (struct qnx6_super_block *)bh2->b_data;
brelse(bh1);
printk(KERN_INFO "qnx6: superblock #2 active\n");
}
kfree(qsb);
/* offset for mmi_fs is just SUPERBLOCK_AREA bytes */
sbi->s_blks_off = QNX6_SUPERBLOCK_AREA / s->s_blocksize;
/* success */
return sbi->sb;
out:
if (bh1 != NULL)
brelse(bh1);
if (bh2 != NULL)
brelse(bh2);
return NULL;
}

1
include/linux/magic.h

@ -42,6 +42,7 @@
#define OPENPROM_SUPER_MAGIC 0x9fa1
#define PROC_SUPER_MAGIC 0x9fa0
#define QNX4_SUPER_MAGIC 0x002f /* qnx4 fs detection */
#define QNX6_SUPER_MAGIC 0x68191122 /* qnx6 fs detection */
#define REISERFS_SUPER_MAGIC 0x52654973 /* used by gcc */
/* used by file system utilities that

134
include/linux/qnx6_fs.h

@ -0,0 +1,134 @@
/*
* Name : qnx6_fs.h
* Author : Kai Bankett
* Function : qnx6 global filesystem definitions
* History : 17-01-2012 created
*/
#ifndef _LINUX_QNX6_FS_H
#define _LINUX_QNX6_FS_H
#include <linux/types.h>
#include <linux/magic.h>
#define QNX6_ROOT_INO 1
/* for di_status */
#define QNX6_FILE_DIRECTORY 0x01
#define QNX6_FILE_DELETED 0x02
#define QNX6_FILE_NORMAL 0x03
#define QNX6_SUPERBLOCK_SIZE 0x200 /* superblock always is 512 bytes */
#define QNX6_SUPERBLOCK_AREA 0x1000 /* area reserved for superblock */
#define QNX6_BOOTBLOCK_SIZE 0x2000 /* heading bootblock area */
#define QNX6_DIR_ENTRY_SIZE 0x20 /* dir entry size of 32 bytes */
#define QNX6_INODE_SIZE 0x80 /* each inode is 128 bytes */
#define QNX6_INODE_SIZE_BITS 7 /* inode entry size shift */
#define QNX6_NO_DIRECT_POINTERS 16 /* 16 blockptrs in sbl/inode */
#define QNX6_PTR_MAX_LEVELS 5 /* maximum indirect levels */
/* for filenames */
#define QNX6_SHORT_NAME_MAX 27
#define QNX6_LONG_NAME_MAX 510
/* list of mount options */
#define QNX6_MOUNT_MMI_FS 0x010000 /* mount as Audi MMI 3G fs */
/*
* This is the original qnx6 inode layout on disk.
* Each inode is 128 byte long