static int
affs_readdir(struct file *file, struct dir_context *ctx)
{
struct inode *inode = file_inode(file);
struct super_block *sb = inode->i_sb;
struct buffer_head *dir_bh = NULL;
struct buffer_head *fh_bh = NULL;
unsigned char *name;
int namelen;
u32 i;
int hash_pos;
int chain_pos;
u32 ino;
int error = 0;
pr_debug("%s(ino=%lu,f_pos=%llx)\n", __func__, inode->i_ino, ctx->pos);
if (ctx->pos < 2) {
file->private_data = (void *)0;
if (!dir_emit_dots(file, ctx))
return 0;
}
affs_lock_dir(inode);
chain_pos = (ctx->pos - 2) & 0xffff;
hash_pos = (ctx->pos - 2) >> 16;
if (chain_pos == 0xffff) {
affs_warning(sb, "readdir", "More than 65535 entries in chain");
chain_pos = 0;
hash_pos++;
ctx->pos = ((hash_pos << 16) | chain_pos) + 2;
}
dir_bh = affs_bread(sb, inode->i_ino);
if (!dir_bh)
goto out_unlock_dir;
/* If the directory hasn't changed since the last call to readdir(),
* we can jump directly to where we left off.
*/
ino = (u32)(long)file->private_data;
if (ino && file->f_version == inode->i_version) {
pr_debug("readdir() left off=%d\n", ino);
goto inside;
}
ino = be32_to_cpu(AFFS_HEAD(dir_bh)->table[hash_pos]);
for (i = 0; ino && i < chain_pos; i++) {
fh_bh = affs_bread(sb, ino);
if (!fh_bh) {
affs_error(sb, "readdir","Cannot read block %d", i);
error = -EIO;
goto out_brelse_dir;
}
ino = be32_to_cpu(AFFS_TAIL(sb, fh_bh)->hash_chain);
affs_brelse(fh_bh);
fh_bh = NULL;
}
if (ino)
goto inside;
hash_pos++;
for (; hash_pos < AFFS_SB(sb)->s_hashsize; hash_pos++) {
ino = be32_to_cpu(AFFS_HEAD(dir_bh)->table[hash_pos]);
if (!ino)
continue;
ctx->pos = (hash_pos << 16) + 2;
inside:
do {
fh_bh = affs_bread(sb, ino);
if (!fh_bh) {
affs_error(sb, "readdir",
"Cannot read block %d", ino);
break;
}
namelen = min(AFFS_TAIL(sb, fh_bh)->name[0],
(u8)AFFSNAMEMAX);
name = AFFS_TAIL(sb, fh_bh)->name + 1;
pr_debug("readdir(): dir_emit(\"%.*s\", ino=%u), hash=%d, f_pos=%llx\n",
namelen, name, ino, hash_pos, ctx->pos);
if (!dir_emit(ctx, name, namelen, ino, DT_UNKNOWN))
goto done;
ctx->pos++;
ino = be32_to_cpu(AFFS_TAIL(sb, fh_bh)->hash_chain);
affs_brelse(fh_bh);
fh_bh = NULL;
} while (ino);
}
done:
file->f_version = inode->i_version;
file->private_data = (void *)(long)ino;
affs_brelse(fh_bh);
out_brelse_dir:
affs_brelse(dir_bh);
out_unlock_dir:
affs_unlock_dir(inode);
return error;
}
struct inode *affs_iget(struct super_block *sb, unsigned long ino)
{
struct affs_sb_info *sbi = AFFS_SB(sb);
struct buffer_head *bh;
// struct affs_head *head;
struct affs_tail *tail;
struct inode *inode;
u32 block;
u32 size;
u32 prot;
u16 id;
inode = iget_locked(sb, ino);
if (!inode)
return ERR_PTR(-ENOMEM);
if (!(inode->i_state & I_NEW))
return inode;
pr_debug("AFFS: affs_iget(%lu)\n", inode->i_ino);
block = inode->i_ino;
bh = affs_bread(sb, block);
if (!bh) {
affs_warning(sb, "read_inode", "Cannot read block %d", block);
goto bad_inode;
}
if (affs_checksum_block(sb, bh) || be32_to_cpu(AFFS_HEAD(bh)->ptype) != T_SHORT) {
affs_warning(sb,"read_inode",
"Checksum or type (ptype=%d) error on inode %d",
AFFS_HEAD(bh)->ptype, block);
goto bad_inode;
}
// head = AFFS_HEAD(bh);
tail = AFFS_TAIL(sb, bh);
prot = be32_to_cpu(tail->protect);
inode->i_size = 0;
inode->i_nlink = 1;
inode->i_mode = 0;
AFFS_I(inode)->i_extcnt = 1;
AFFS_I(inode)->i_ext_last = ~1;
AFFS_I(inode)->i_protect = prot;
atomic_set(&AFFS_I(inode)->i_opencnt, 0);
AFFS_I(inode)->i_blkcnt = 0;
AFFS_I(inode)->i_lc = NULL;
AFFS_I(inode)->i_lc_size = 0;
AFFS_I(inode)->i_lc_shift = 0;
AFFS_I(inode)->i_lc_mask = 0;
AFFS_I(inode)->i_ac = NULL;
AFFS_I(inode)->i_ext_bh = NULL;
AFFS_I(inode)->mmu_private = 0;
AFFS_I(inode)->i_lastalloc = 0;
AFFS_I(inode)->i_pa_cnt = 0;
if (sbi->s_flags & SF_SETMODE)
inode->i_mode = sbi->s_mode;
else
inode->i_mode = prot_to_mode(prot);
id = be16_to_cpu(tail->uid);
if (id == 0 || sbi->s_flags & SF_SETUID)
inode->i_uid = sbi->s_uid;
else if (id == 0xFFFF && sbi->s_flags & SF_MUFS)
inode->i_uid = 0;
else
inode->i_uid = id;
id = be16_to_cpu(tail->gid);
if (id == 0 || sbi->s_flags & SF_SETGID)
inode->i_gid = sbi->s_gid;
else if (id == 0xFFFF && sbi->s_flags & SF_MUFS)
inode->i_gid = 0;
else
inode->i_gid = id;
switch (be32_to_cpu(tail->stype)) {
case ST_ROOT:
inode->i_uid = sbi->s_uid;
inode->i_gid = sbi->s_gid;
/* fall through */
case ST_USERDIR:
if (be32_to_cpu(tail->stype) == ST_USERDIR ||
sbi->s_flags & SF_SETMODE) {
if (inode->i_mode & S_IRUSR)
inode->i_mode |= S_IXUSR;
if (inode->i_mode & S_IRGRP)
inode->i_mode |= S_IXGRP;
if (inode->i_mode & S_IROTH)
inode->i_mode |= S_IXOTH;
inode->i_mode |= S_IFDIR;
} else
inode->i_mode = S_IRUGO | S_IXUGO | S_IWUSR | S_IFDIR;
/* Maybe it should be controlled by mount parameter? */
//inode->i_mode |= S_ISVTX;
inode->i_op = &affs_dir_inode_operations;
inode->i_fop = &affs_dir_operations;
break;
case ST_LINKDIR:
#if 0
affs_warning(sb, "read_inode", "inode is LINKDIR");
goto bad_inode;
#else
inode->i_mode |= S_IFDIR;
/* ... and leave ->i_op and ->i_fop pointing to empty */
break;
#endif
case ST_LINKFILE:
affs_warning(sb, "read_inode", "inode is LINKFILE");
goto bad_inode;
case ST_FILE:
size = be32_to_cpu(tail->size);
inode->i_mode |= S_IFREG;
AFFS_I(inode)->mmu_private = inode->i_size = size;
if (inode->i_size) {
AFFS_I(inode)->i_blkcnt = (size - 1) /
sbi->s_data_blksize + 1;
AFFS_I(inode)->i_extcnt = (AFFS_I(inode)->i_blkcnt - 1) /
sbi->s_hashsize + 1;
}
if (tail->link_chain)
inode->i_nlink = 2;
inode->i_mapping->a_ops = (sbi->s_flags & SF_OFS) ? &affs_aops_ofs : &affs_aops;
inode->i_op = &affs_file_inode_operations;
inode->i_fop = &affs_file_operations;
break;
case ST_SOFTLINK:
inode->i_mode |= S_IFLNK;
inode->i_op = &affs_symlink_inode_operations;
inode->i_data.a_ops = &affs_symlink_aops;
break;
}
inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec
= (be32_to_cpu(tail->change.days) * (24 * 60 * 60) +
be32_to_cpu(tail->change.mins) * 60 +
be32_to_cpu(tail->change.ticks) / 50 +
((8 * 365 + 2) * 24 * 60 * 60)) +
sys_tz.tz_minuteswest * 60;
inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_atime.tv_nsec = 0;
affs_brelse(bh);
unlock_new_inode(inode);
return inode;
bad_inode:
affs_brelse(bh);
iget_failed(inode);
return ERR_PTR(-EIO);
}
int
affs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
{
struct buffer_head *bh;
struct inode *inode;
char *p;
unsigned long tmp;
int i, maxlen, error;
char c, lc;
pr_debug("AFFS: symlink(%lu,\"%.*s\" -> \"%s\")\n",dir->i_ino,
(int)dentry->d_name.len,dentry->d_name.name,symname);
maxlen = 4 * AFFS_I2HSIZE(dir) - 1;
error = -ENOSPC;
inode = affs_new_inode(dir);
if (!inode)
goto out;
inode->i_op = &affs_symlink_inode_operations;
inode->i_mode = S_IFLNK | 0777;
inode->u.affs_i.i_protect = mode_to_prot(inode->i_mode);
error = -EIO;
bh = affs_bread(inode->i_dev,inode->i_ino,AFFS_I2BSIZE(inode));
if (!bh)
goto out_iput;
i = 0;
p = ((struct slink_front *)bh->b_data)->symname;
lc = '/';
if (*symname == '/') {
while (*symname == '/')
symname++;
while (inode->i_sb->u.affs_sb.s_volume[i]) /* Cannot overflow */
*p++ = inode->i_sb->u.affs_sb.s_volume[i++];
}
while (i < maxlen && (c = *symname++)) {
if (c == '.' && lc == '/' && *symname == '.' && symname[1] == '/') {
*p++ = '/';
i++;
symname += 2;
lc = '/';
} else if (c == '.' && lc == '/' && *symname == '/') {
symname++;
lc = '/';
} else {
*p++ = c;
lc = c;
i++;
}
if (lc == '/')
while (*symname == '/')
symname++;
}
*p = 0;
mark_buffer_dirty(bh,1);
affs_brelse(bh);
mark_inode_dirty(inode);
/* N.B. This test shouldn't be necessary ... dentry must be negative */
error = -EEXIST;
bh = affs_find_entry(dir,dentry,&tmp);
if (bh)
goto out_release;
/* N.B. Shouldn't we add the entry before dirtying the buffer? */
error = affs_add_entry(dir,NULL,inode,dentry,ST_SOFTLINK);
if (error)
goto out_release;
d_instantiate(dentry,inode);
dir->i_version = ++event;
mark_inode_dirty(dir);
out:
return error;
out_release:
affs_brelse(bh);
out_iput:
inode->i_nlink = 0;
mark_inode_dirty(inode);
iput(inode);
goto out;
}
static struct super_block *
affs_read_super(struct super_block *sb, void *data, int silent)
{
struct buffer_head *root_bh = NULL;
struct buffer_head *boot_bh;
struct inode *root_inode = NULL;
kdev_t dev = sb->s_dev;
s32 root_block;
int blocks, size, blocksize;
u32 chksum;
int num_bm;
int i, j;
s32 key;
uid_t uid;
gid_t gid;
int reserved;
unsigned long mount_flags;
pr_debug("AFFS: read_super(%s)\n",data ? (const char *)data : "no options");
sb->s_magic = AFFS_SUPER_MAGIC;
sb->s_op = &affs_sops;
memset(AFFS_SB, 0, sizeof(struct affs_sb_info));
init_MUTEX(&AFFS_SB->s_bmlock);
if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block,
&blocksize,&AFFS_SB->s_prefix,
AFFS_SB->s_volume, &mount_flags)) {
printk(KERN_ERR "AFFS: Error parsing options\n");
return NULL;
}
/* N.B. after this point s_prefix must be released */
AFFS_SB->s_flags = mount_flags;
AFFS_SB->s_mode = i;
AFFS_SB->s_uid = uid;
AFFS_SB->s_gid = gid;
AFFS_SB->s_reserved= reserved;
/* Get the size of the device in 512-byte blocks.
* If we later see that the partition uses bigger
* blocks, we will have to change it.
*/
blocks = blk_size[MAJOR(dev)] ? blk_size[MAJOR(dev)][MINOR(dev)] : 0;
if (!blocks) {
printk(KERN_ERR "AFFS: Could not determine device size\n");
goto out_error;
}
size = (BLOCK_SIZE / 512) * blocks;
pr_debug("AFFS: initial blksize=%d, blocks=%d\n", 512, blocks);
affs_set_blocksize(sb, PAGE_SIZE);
/* Try to find root block. Its location depends on the block size. */
i = 512;
j = 4096;
if (blocksize > 0) {
i = j = blocksize;
size = size / (blocksize / 512);
}
for (blocksize = i, key = 0; blocksize <= j; blocksize <<= 1, size >>= 1) {
AFFS_SB->s_root_block = root_block;
if (root_block < 0)
AFFS_SB->s_root_block = (reserved + size - 1) / 2;
pr_debug("AFFS: setting blocksize to %d\n", blocksize);
affs_set_blocksize(sb, blocksize);
AFFS_SB->s_partition_size = size;
/* The root block location that was calculated above is not
* correct if the partition size is an odd number of 512-
* byte blocks, which will be rounded down to a number of
* 1024-byte blocks, and if there were an even number of
* reserved blocks. Ideally, all partition checkers should
* report the real number of blocks of the real blocksize,
* but since this just cannot be done, we have to try to
* find the root block anyways. In the above case, it is one
* block behind the calculated one. So we check this one, too.
*/
for (num_bm = 0; num_bm < 2; num_bm++) {
pr_debug("AFFS: Dev %s, trying root=%u, bs=%d, "
"size=%d, reserved=%d\n",
kdevname(dev),
AFFS_SB->s_root_block + num_bm,
blocksize, size, reserved);
root_bh = affs_bread(sb, AFFS_SB->s_root_block + num_bm);
if (!root_bh)
continue;
if (!affs_checksum_block(sb, root_bh) &&
be32_to_cpu(AFFS_ROOT_HEAD(root_bh)->ptype) == T_SHORT &&
be32_to_cpu(AFFS_ROOT_TAIL(sb, root_bh)->stype) == ST_ROOT) {
AFFS_SB->s_hashsize = blocksize / 4 - 56;
AFFS_SB->s_root_block += num_bm;
key = 1;
goto got_root;
}
affs_brelse(root_bh);
root_bh = NULL;
}
}
if (!silent)
printk(KERN_ERR "AFFS: No valid root block on device %s\n",
kdevname(dev));
goto out_error;
/* N.B. after this point bh must be released */
got_root:
root_block = AFFS_SB->s_root_block;
sb->s_blocksize_bits = blocksize == 512 ? 9 :
blocksize == 1024 ? 10 :
blocksize == 2048 ? 11 : 12;
/* Find out which kind of FS we have */
boot_bh = bread(sb->s_dev, 0, sb->s_blocksize);
if (!boot_bh) {
printk(KERN_ERR "AFFS: Cannot read boot block\n");
goto out_error;
}
chksum = be32_to_cpu(*(u32 *)boot_bh->b_data);
brelse(boot_bh);
/* Dircache filesystems are compatible with non-dircache ones
* when reading. As long as they aren't supported, writing is
* not recommended.
*/
if ((chksum == FS_DCFFS || chksum == MUFS_DCFFS || chksum == FS_DCOFS
|| chksum == MUFS_DCOFS) && !(sb->s_flags & MS_RDONLY)) {
printk(KERN_NOTICE "AFFS: Dircache FS - mounting %s read only\n",
kdevname(dev));
sb->s_flags |= MS_RDONLY;
AFFS_SB->s_flags |= SF_READONLY;
}
switch (chksum) {
case MUFS_FS:
case MUFS_INTLFFS:
case MUFS_DCFFS:
AFFS_SB->s_flags |= SF_MUFS;
/* fall thru */
case FS_INTLFFS:
case FS_DCFFS:
AFFS_SB->s_flags |= SF_INTL;
break;
case MUFS_FFS:
AFFS_SB->s_flags |= SF_MUFS;
break;
case FS_FFS:
break;
case MUFS_OFS:
AFFS_SB->s_flags |= SF_MUFS;
/* fall thru */
case FS_OFS:
AFFS_SB->s_flags |= SF_OFS;
sb->s_flags |= MS_NOEXEC;
break;
case MUFS_DCOFS:
case MUFS_INTLOFS:
AFFS_SB->s_flags |= SF_MUFS;
case FS_DCOFS:
case FS_INTLOFS:
AFFS_SB->s_flags |= SF_INTL | SF_OFS;
sb->s_flags |= MS_NOEXEC;
break;
default:
printk(KERN_ERR "AFFS: Unknown filesystem on device %s: %08X\n",
kdevname(dev), chksum);
goto out_error;
}
if (mount_flags & SF_VERBOSE) {
chksum = cpu_to_be32(chksum);
printk(KERN_NOTICE "AFFS: Mounting volume \"%*s\": Type=%.3s\\%c, Blocksize=%d\n",
AFFS_ROOT_TAIL(sb, root_bh)->disk_name[0],
AFFS_ROOT_TAIL(sb, root_bh)->disk_name + 1,
(char *)&chksum,((char *)&chksum)[3] + '0',blocksize);
}
sb->s_flags |= MS_NODEV | MS_NOSUID;
AFFS_SB->s_data_blksize = sb->s_blocksize;
if (AFFS_SB->s_flags & SF_OFS)
AFFS_SB->s_data_blksize -= 24;
/* Keep super block in cache */
AFFS_SB->s_root_bh = root_bh;
/* N.B. after this point s_root_bh must be released */
if (affs_init_bitmap(sb))
goto out_error;
/* set up enough so that it can read an inode */
root_inode = iget(sb, root_block);
sb->s_root = d_alloc_root(root_inode);
if (!sb->s_root) {
printk(KERN_ERR "AFFS: Get root inode failed\n");
goto out_error;
}
sb->s_root->d_op = &affs_dentry_operations;
pr_debug("AFFS: s_flags=%lX\n",sb->s_flags);
return sb;
/*
* Begin the cascaded cleanup ...
*/
out_error:
if (root_inode)
iput(root_inode);
if (AFFS_SB->s_bitmap)
kfree(AFFS_SB->s_bitmap);
affs_brelse(root_bh);
if (AFFS_SB->s_prefix)
kfree(AFFS_SB->s_prefix);
return NULL;
}
int
affs_add_entry(struct inode *dir, struct inode *link, struct inode *inode,
struct dentry *dentry, int type)
{
struct buffer_head *dir_bh;
struct buffer_head *inode_bh;
struct buffer_head *link_bh;
int retval;
const unsigned char *name = dentry->d_name.name;
int len = dentry->d_name.len;
pr_debug("AFFS: add_entry(dir=%lu,inode=%lu,\"%*s\",type=%d)\n",dir->i_ino,inode->i_ino,
len,name,type);
if ((retval = affs_check_name(name,len)))
return retval;
if (len > 30)
len = 30;
dir_bh = affs_bread(dir->i_dev,dir->i_ino,AFFS_I2BSIZE(dir));
inode_bh = affs_bread(inode->i_dev,inode->i_ino,AFFS_I2BSIZE(inode));
link_bh = NULL;
retval = -EIO;
if (!dir_bh || !inode_bh)
goto addentry_done;
if (link) {
link_bh = affs_bread(link->i_dev,link->i_ino,AFFS_I2BSIZE(link));
if (!link_bh)
goto addentry_done;
}
((struct dir_front *)inode_bh->b_data)->primary_type = cpu_to_be32(T_SHORT);
((struct dir_front *)inode_bh->b_data)->own_key = cpu_to_be32(inode->i_ino);
DIR_END(inode_bh->b_data,inode)->dir_name[0] = len;
strncpy(DIR_END(inode_bh->b_data,inode)->dir_name + 1,name,len);
DIR_END(inode_bh->b_data,inode)->secondary_type = cpu_to_be32(type);
DIR_END(inode_bh->b_data,inode)->parent = cpu_to_be32(dir->i_ino);
lock_super(inode->i_sb);
retval = affs_insert_hash(dir->i_ino,inode_bh,dir);
if (link_bh) {
LINK_END(inode_bh->b_data,inode)->original = cpu_to_be32(link->i_ino);
LINK_END(inode_bh->b_data,inode)->link_chain =
FILE_END(link_bh->b_data,link)->link_chain;
FILE_END(link_bh->b_data,link)->link_chain = cpu_to_be32(inode->i_ino);
affs_fix_checksum(AFFS_I2BSIZE(link),link_bh->b_data,5);
link->i_version = ++global_event;
mark_inode_dirty(link);
mark_buffer_dirty(link_bh,1);
}
affs_fix_checksum(AFFS_I2BSIZE(inode),inode_bh->b_data,5);
affs_fix_checksum(AFFS_I2BSIZE(dir),dir_bh->b_data,5);
dir->i_version = ++global_event;
dir->i_mtime = dir->i_atime = dir->i_ctime = CURRENT_TIME;
unlock_super(inode->i_sb);
mark_inode_dirty(dir);
mark_inode_dirty(inode);
mark_buffer_dirty(dir_bh,1);
mark_buffer_dirty(inode_bh,1);
addentry_done:
affs_brelse(dir_bh);
affs_brelse(inode_bh);
affs_brelse(link_bh);
return retval;
}
int
affs_remove_header(struct dentry *dentry)
{
struct super_block *sb;
struct inode *inode, *dir;
struct buffer_head *bh = NULL;
int retval;
dir = dentry->d_parent->d_inode;
sb = dir->i_sb;
retval = -ENOENT;
inode = dentry->d_inode;
if (!inode)
goto done;
pr_debug("AFFS: remove_header(key=%ld)\n", inode->i_ino);
retval = -EIO;
bh = affs_bread(sb, (u32)(long)dentry->d_fsdata);
if (!bh)
goto done;
affs_lock_link(inode);
affs_lock_dir(dir);
switch (be32_to_cpu(AFFS_TAIL(sb, bh)->stype)) {
case ST_USERDIR:
/* if we ever want to support links to dirs
* i_hash_lock of the inode must only be
* taken after some checks
*/
affs_lock_dir(inode);
retval = affs_empty_dir(inode);
affs_unlock_dir(inode);
if (retval)
goto done_unlock;
break;
default:
break;
}
retval = affs_remove_hash(dir, bh);
if (retval)
goto done_unlock;
mark_buffer_dirty_inode(bh, inode);
affs_unlock_dir(dir);
if (inode->i_nlink > 1)
retval = affs_remove_link(dentry);
else
inode->i_nlink = 0;
affs_unlock_link(inode);
inode->i_ctime = CURRENT_TIME_SEC;
mark_inode_dirty(inode);
done:
affs_brelse(bh);
return retval;
done_unlock:
affs_unlock_dir(dir);
affs_unlock_link(inode);
goto done;
}
void
affs_truncate(struct inode *inode)
{
struct buffer_head *bh = NULL;
int first; /* First block to be thrown away */
int block;
s32 key;
s32 *keyp;
s32 ekey;
s32 ptype, stype;
int freethis;
int net_blocksize;
int blocksize = AFFS_I2BSIZE(inode);
int rem;
int ext;
pr_debug("AFFS: truncate(inode=%ld,size=%lu)\n",inode->i_ino,inode->i_size);
net_blocksize = blocksize - ((inode->i_sb->u.affs_sb.s_flags & SF_OFS) ? 24 : 0);
first = (inode->i_size + net_blocksize - 1) / net_blocksize;
if (inode->u.affs_i.i_lastblock < first - 1) {
/* There has to be at least one new block to be allocated */
if (!inode->u.affs_i.i_ec && alloc_ext_cache(inode)) {
/* XXX Fine! No way to indicate an error. */
return /* -ENOSPC */;
}
bh = affs_getblock(inode,first - 1);
if (!bh) {
affs_warning(inode->i_sb,"truncate","Cannot extend file");
inode->i_size = net_blocksize * (inode->u.affs_i.i_lastblock + 1);
} else if (inode->i_sb->u.affs_sb.s_flags & SF_OFS) {
rem = inode->i_size % net_blocksize;
DATA_FRONT(bh)->data_size = cpu_to_be32(rem ? rem : net_blocksize);
affs_fix_checksum(blocksize,bh->b_data,5);
mark_buffer_dirty(bh,0);
}
goto out_truncate;
}
ekey = inode->i_ino;
ext = 0;
/* Free all blocks starting at 'first' and all then-empty
* extension blocks. Do not free the header block, though.
*/
while (ekey) {
if (!(bh = affs_bread(inode->i_dev,ekey,blocksize))) {
affs_error(inode->i_sb,"truncate","Cannot read block %d",ekey);
goto out_truncate;
}
if (affs_checksum_block(blocksize,bh->b_data,&ptype,&stype)) {
affs_error(inode->i_sb,"truncate","Checksum error in header/ext block %d",
ekey);
goto out_truncate;
}
if (stype != ST_FILE || (ptype != T_SHORT && ptype != T_LIST)) {
affs_error(inode->i_sb,"truncate",
"Bad block (key=%d, ptype=%d, stype=%d)",ekey,ptype,stype);
goto out_truncate;
}
/* Do we have to free this extension block after
* freeing the data blocks pointed to?
*/
freethis = first == 0 && ekey != inode->i_ino;
/* Free the data blocks. 'first' is relative to this
* extension block and may well lie behind this block.
*/
for (block = first; block < AFFS_I2HSIZE(inode); block++) {
keyp = &AFFS_BLOCK(bh->b_data,inode,block);
key = be32_to_cpu(*keyp);
if (key) {
*keyp = 0;
affs_free_block(inode->i_sb,key);
} else
break;
}
keyp = &GET_END_PTR(struct file_end,bh->b_data,blocksize)->extension;
key = be32_to_cpu(*keyp);
/* If 'first' is in this block or is the first
* in the next one, this will be the last in
* the list, thus we have to adjust the count
* and zero the pointer to the next ext block.
*/
if (first <= AFFS_I2HSIZE(inode)) {
((struct file_front *)bh->b_data)->block_count = cpu_to_be32(first);
first = 0;
*keyp = 0;
affs_fix_checksum(blocksize,bh->b_data,5);
mark_buffer_dirty(bh,1);
} else
first -= AFFS_I2HSIZE(inode);
affs_brelse(bh);
bh = NULL;
if (freethis) /* Don't bother fixing checksum */
affs_free_block(inode->i_sb,ekey);
ekey = key;
}
block = ((inode->i_size + net_blocksize - 1) / net_blocksize) - 1;
inode->u.affs_i.i_lastblock = block;
/* If the file is not truncated to a block boundary,
* the partial block after the EOF must be zeroed
* so it cannot become accessible again.
*/
rem = inode->i_size % net_blocksize;
if (rem) {
if ((inode->i_sb->u.affs_sb.s_flags & SF_OFS))
rem += 24;
pr_debug("AFFS: Zeroing from offset %d in block %d\n",rem,block);
bh = affs_getblock(inode,block);
if (bh) {
memset(bh->b_data + rem,0,blocksize - rem);
if ((inode->i_sb->u.affs_sb.s_flags & SF_OFS)) {
((struct data_front *)bh->b_data)->data_size = cpu_to_be32(rem);
((struct data_front *)bh->b_data)->next_data = 0;
affs_fix_checksum(blocksize,bh->b_data,5);
}
mark_buffer_dirty(bh,1);
} else
affs_error(inode->i_sb,"truncate","Cannot read block %d",block);
}
out_truncate:
affs_brelse(bh);
/* Invalidate cache */
if (inode->u.affs_i.i_ec) {
inode->u.affs_i.i_ec->max_ext = 0;
for (key = 0; key < 3; key++) {
inode->u.affs_i.i_ec->kc[key].kc_next_key = 0;
inode->u.affs_i.i_ec->kc[key].kc_last = -1;
}
}
mark_inode_dirty(inode);
}
static int
affs_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
struct inode *inode = filp->f_path.dentry->d_inode;
struct super_block *sb = inode->i_sb;
struct buffer_head *dir_bh;
struct buffer_head *fh_bh;
unsigned char *name;
int namelen;
u32 i;
int hash_pos;
int chain_pos;
u32 f_pos;
u32 ino;
int stored;
int res;
pr_debug("AFFS: readdir(ino=%lu,f_pos=%lx)\n",inode->i_ino,(unsigned long)filp->f_pos);
stored = 0;
res = -EIO;
dir_bh = NULL;
fh_bh = NULL;
f_pos = filp->f_pos;
if (f_pos == 0) {
filp->private_data = (void *)0;
if (filldir(dirent, ".", 1, f_pos, inode->i_ino, DT_DIR) < 0)
return 0;
filp->f_pos = f_pos = 1;
stored++;
}
if (f_pos == 1) {
if (filldir(dirent, "..", 2, f_pos, parent_ino(filp->f_path.dentry), DT_DIR) < 0)
return stored;
filp->f_pos = f_pos = 2;
stored++;
}
affs_lock_dir(inode);
chain_pos = (f_pos - 2) & 0xffff;
hash_pos = (f_pos - 2) >> 16;
if (chain_pos == 0xffff) {
affs_warning(sb, "readdir", "More than 65535 entries in chain");
chain_pos = 0;
hash_pos++;
filp->f_pos = ((hash_pos << 16) | chain_pos) + 2;
}
dir_bh = affs_bread(sb, inode->i_ino);
if (!dir_bh)
goto readdir_out;
ino = (u32)(long)filp->private_data;
if (ino && filp->f_version == inode->i_version) {
pr_debug("AFFS: readdir() left off=%d\n", ino);
goto inside;
}
ino = be32_to_cpu(AFFS_HEAD(dir_bh)->table[hash_pos]);
for (i = 0; ino && i < chain_pos; i++) {
fh_bh = affs_bread(sb, ino);
if (!fh_bh) {
affs_error(sb, "readdir","Cannot read block %d", i);
goto readdir_out;
}
ino = be32_to_cpu(AFFS_TAIL(sb, fh_bh)->hash_chain);
affs_brelse(fh_bh);
fh_bh = NULL;
}
if (ino)
goto inside;
hash_pos++;
for (; hash_pos < AFFS_SB(sb)->s_hashsize; hash_pos++) {
ino = be32_to_cpu(AFFS_HEAD(dir_bh)->table[hash_pos]);
if (!ino)
continue;
f_pos = (hash_pos << 16) + 2;
inside:
do {
fh_bh = affs_bread(sb, ino);
if (!fh_bh) {
affs_error(sb, "readdir","Cannot read block %d", ino);
goto readdir_done;
}
namelen = min(AFFS_TAIL(sb, fh_bh)->name[0], (u8)30);
name = AFFS_TAIL(sb, fh_bh)->name + 1;
pr_debug("AFFS: readdir(): filldir(\"%.*s\", ino=%u), hash=%d, f_pos=%x\n",
namelen, name, ino, hash_pos, f_pos);
if (filldir(dirent, name, namelen, f_pos, ino, DT_UNKNOWN) < 0)
goto readdir_done;
stored++;
f_pos++;
ino = be32_to_cpu(AFFS_TAIL(sb, fh_bh)->hash_chain);
affs_brelse(fh_bh);
fh_bh = NULL;
} while (ino);
}
readdir_done:
filp->f_pos = f_pos;
filp->f_version = inode->i_version;
filp->private_data = (void *)(long)ino;
res = stored;
readdir_out:
affs_brelse(dir_bh);
affs_brelse(fh_bh);
affs_unlock_dir(inode);
pr_debug("AFFS: readdir()=%d\n", stored);
return res;
}
static int
affs_bmap(struct inode *inode, int block)
{
struct buffer_head *bh;
s32 key, nkey;
s32 ptype, stype;
int ext;
int index;
int keycount;
struct key_cache *kc;
struct key_cache *tkc;
struct timeval tv;
s32 *keyp;
int i;
pr_debug("AFFS: bmap(%lu,%d)\n",inode->i_ino,block);
if (block < 0) {
affs_error(inode->i_sb,"bmap","Block < 0");
return 0;
}
if (!inode->u.affs_i.i_ec) {
if (alloc_ext_cache(inode)) {
return 0;
}
}
/* Try to find the requested key in the cache.
* In order to speed this up as much as possible,
* the cache line lookup is done in a separate
* step.
*/
for (i = 0; i < 4; i++) {
tkc = &inode->u.affs_i.i_ec->kc[i];
/* Look in any cache if the key is there */
if (block <= tkc->kc_last && block >= tkc->kc_first) {
return tkc->kc_keys[block - tkc->kc_first];
}
}
kc = NULL;
#ifdef OSKIT
tv.tv_sec = CURRENT_TIME;
tv.tv_usec = 0;
#else
tv = xtime;
#endif
for (i = 0; i < 4; i++) {
tkc = &inode->u.affs_i.i_ec->kc[i];
if (tkc->kc_lru_time.tv_sec > tv.tv_sec)
continue;
if (tkc->kc_lru_time.tv_sec < tv.tv_sec ||
tkc->kc_lru_time.tv_usec < tv.tv_usec) {
kc = tkc;
tv = tkc->kc_lru_time;
}
}
if (!kc) /* Really shouldn't happen */
kc = tkc;
#ifdef OSKIT
kc->kc_lru_time.tv_sec = CURRENT_TIME;
kc->kc_lru_time.tv_usec = 0;
#else
kc->kc_lru_time = xtime;
#endif
keyp = kc->kc_keys;
kc->kc_first = block;
kc->kc_last = -1;
keycount = AFFS_KCSIZE;
/* Calculate sequence number of the extension block where the
* number of the requested block is stored. 0 means it's in
* the file header.
*/
ext = block / AFFS_I2HSIZE(inode);
key = calc_key(inode,&ext);
block -= ext * AFFS_I2HSIZE(inode);
for (;;) {
bh = affs_bread(inode->i_dev,key,AFFS_I2BSIZE(inode));
if (!bh)
return 0;
index = seqnum_to_index(ext);
if (index > inode->u.affs_i.i_ec->max_ext &&
(affs_checksum_block(AFFS_I2BSIZE(inode),bh->b_data,&ptype,&stype) ||
(ptype != T_SHORT && ptype != T_LIST) || stype != ST_FILE)) {
affs_brelse(bh);
return 0;
}
nkey = be32_to_cpu(FILE_END(bh->b_data,inode)->extension);
if (block < AFFS_I2HSIZE(inode)) {
/* Fill cache as much as possible */
if (keycount) {
kc->kc_first = ext * AFFS_I2HSIZE(inode) + block;
keycount = keycount < AFFS_I2HSIZE(inode) - block ? keycount :
AFFS_I2HSIZE(inode) - block;
for (i = 0; i < keycount; i++)
kc->kc_keys[i] = be32_to_cpu(AFFS_BLOCK(bh->b_data,inode,block + i));
kc->kc_last = kc->kc_first + i - 1;
}
break;
}
block -= AFFS_I2HSIZE(inode);
affs_brelse(bh);
ext++;
if (index > inode->u.affs_i.i_ec->max_ext && AFFS_ISINDEX(ext)) {
inode->u.affs_i.i_ec->ec[index] = nkey;
inode->u.affs_i.i_ec->max_ext = index;
}
key = nkey;
}
kc->kc_this_key = key;
kc->kc_this_seq = ext;
kc->kc_next_key = nkey;
key = be32_to_cpu(AFFS_BLOCK(bh->b_data,inode,block));
affs_brelse(bh);
return key;
}
static struct buffer_head *
affs_getblock(struct inode *inode, s32 block)
{
struct super_block *sb = inode->i_sb;
int ofs = sb->u.affs_sb.s_flags & SF_OFS;
int ext = block / AFFS_I2HSIZE(inode);
struct buffer_head *bh, *ebh, *pbh = NULL;
struct key_cache *kc;
s32 key, nkey;
int cf, j, pt;
int index;
int err;
pr_debug("AFFS: getblock(%lu,%d)\n",inode->i_ino,block);
if (block < 0)
goto out_fail;
key = calc_key(inode,&ext);
block -= ext * AFFS_I2HSIZE(inode);
pt = ext ? T_LIST : T_SHORT;
/* Key refers now to the last known extension block,
* ext is its sequence number (if 0, key refers to the
* header block), and block is the block number relative
* to the first block stored in that extension block.
*/
for (;;) { /* Loop over header block and extension blocks */
struct file_front *fdp;
bh = affs_bread(inode->i_dev,key,AFFS_I2BSIZE(inode));
if (!bh)
goto out_fail;
fdp = (struct file_front *) bh->b_data;
err = affs_checksum_block(AFFS_I2BSIZE(inode),bh->b_data,&cf,&j);
if (err || cf != pt || j != ST_FILE) {
affs_error(sb, "getblock",
"Block %d is not a valid %s", key,
pt == T_SHORT ? "file header" : "ext block");
goto out_free_bh;
}
j = be32_to_cpu(((struct file_front *)bh->b_data)->block_count);
for (cf = 0; j < AFFS_I2HSIZE(inode) && j <= block; j++) {
if (ofs && !pbh && inode->u.affs_i.i_lastblock >= 0) {
if (j > 0) {
s32 k = AFFS_BLOCK(bh->b_data, inode,
j - 1);
pbh = affs_bread(inode->i_dev,
be32_to_cpu(k),
AFFS_I2BSIZE(inode));
} else
pbh = affs_getblock(inode,inode->u.affs_i.i_lastblock);
if (!pbh) {
affs_error(sb,"getblock",
"Cannot get last block in file");
break;
}
}
nkey = affs_new_data(inode);
if (!nkey)
break;
inode->u.affs_i.i_lastblock++;
if (AFFS_BLOCK(bh->b_data,inode,j)) {
affs_warning(sb,"getblock","Block already allocated");
affs_free_block(sb,nkey);
continue;
}
AFFS_BLOCK(bh->b_data,inode,j) = cpu_to_be32(nkey);
if (ofs) {
ebh = affs_bread(inode->i_dev,nkey,AFFS_I2BSIZE(inode));
if (!ebh) {
affs_error(sb,"getblock",
"Cannot get block %d",nkey);
affs_free_block(sb,nkey);
AFFS_BLOCK(bh->b_data,inode,j) = 0;
break;
}
DATA_FRONT(ebh)->primary_type = cpu_to_be32(T_DATA);
DATA_FRONT(ebh)->header_key = cpu_to_be32(inode->i_ino);
DATA_FRONT(ebh)->sequence_number = cpu_to_be32(inode->u.affs_i.i_lastblock + 1);
affs_fix_checksum(AFFS_I2BSIZE(inode),
ebh->b_data, 5);
mark_buffer_dirty(ebh, 0);
if (pbh) {
DATA_FRONT(pbh)->data_size = cpu_to_be32(AFFS_I2BSIZE(inode) - 24);
DATA_FRONT(pbh)->next_data = cpu_to_be32(nkey);
affs_fix_checksum(AFFS_I2BSIZE(inode),pbh->b_data,5);
mark_buffer_dirty(pbh,0);
affs_brelse(pbh);
}
pbh = ebh;
}
cf = 1;
}
/* N.B. May need to release pbh after here */
if (cf) {
if (pt == T_SHORT)
fdp->first_data = AFFS_BLOCK(bh->b_data,inode,0);
fdp->block_count = cpu_to_be32(j);
affs_fix_checksum(AFFS_I2BSIZE(inode),bh->b_data,5);
mark_buffer_dirty(bh,1);
}
if (block < j) {
if (pbh)
affs_brelse(pbh);
break;
}
if (j < AFFS_I2HSIZE(inode)) {
/* N.B. What about pbh here? */
goto out_free_bh;
}
block -= AFFS_I2HSIZE(inode);
key = be32_to_cpu(FILE_END(bh->b_data,inode)->extension);
if (!key) {
key = affs_new_header(inode);
if (!key)
goto out_free_bh;
ebh = affs_bread(inode->i_dev,key,AFFS_I2BSIZE(inode));
if (!ebh) {
/* N.B. must free bh here */
goto out_free_block;
}
((struct file_front *)ebh->b_data)->primary_type = cpu_to_be32(T_LIST);
((struct file_front *)ebh->b_data)->own_key = cpu_to_be32(key);
FILE_END(ebh->b_data,inode)->secondary_type = cpu_to_be32(ST_FILE);
FILE_END(ebh->b_data,inode)->parent = cpu_to_be32(inode->i_ino);
affs_fix_checksum(AFFS_I2BSIZE(inode),ebh->b_data,5);
mark_buffer_dirty(ebh, 1);
FILE_END(bh->b_data,inode)->extension = cpu_to_be32(key);
affs_fix_checksum(AFFS_I2BSIZE(inode),bh->b_data,5);
mark_buffer_dirty(bh,1);
affs_brelse(bh);
bh = ebh;
}
pt = T_LIST;
ext++;
index = seqnum_to_index(ext);
if (index > inode->u.affs_i.i_ec->max_ext &&
AFFS_ISINDEX(ext)) {
inode->u.affs_i.i_ec->ec[index] = key;
inode->u.affs_i.i_ec->max_ext = index;
}
affs_brelse(bh);
}
/* Invalidate key cache */
for (j = 0; j < 4; j++) {
kc = &inode->u.affs_i.i_ec->kc[j];
kc->kc_last = -1;
}
key = be32_to_cpu(AFFS_BLOCK(bh->b_data,inode,block));
affs_brelse(bh);
if (!key)
goto out_fail;
bh = affs_bread(inode->i_dev, key, AFFS_I2BSIZE(inode));
return bh;
out_free_block:
affs_free_block(sb, key);
out_free_bh:
affs_brelse(bh);
out_fail:
return NULL;
}
static struct super_block *
affs_read_super(struct super_block *s, void *data, int silent)
{
struct buffer_head *bh = NULL;
struct buffer_head *bb;
struct inode *root_inode;
kdev_t dev = s->s_dev;
s32 root_block;
int blocks, size, blocksize;
u32 chksum;
u32 *bm;
s32 ptype, stype;
int mapidx;
int num_bm;
int i, j;
s32 key;
uid_t uid;
gid_t gid;
int reserved;
int az_no;
int bmalt = 0;
unsigned long mount_flags;
unsigned long offset;
pr_debug("AFFS: read_super(%s)\n",data ? (const char *)data : "no options");
MOD_INC_USE_COUNT;
lock_super(s);
s->s_magic = AFFS_SUPER_MAGIC;
s->s_op = &affs_sops;
s->u.affs_sb.s_bitmap = NULL;
s->u.affs_sb.s_root_bh = NULL;
s->u.affs_sb.s_prefix = NULL;
s->u.affs_sb.s_hashsize= 0;
if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block,
&blocksize,&s->u.affs_sb.s_prefix,
s->u.affs_sb.s_volume, &mount_flags))
goto out_bad_opts;
/* N.B. after this point s_prefix must be released */
s->u.affs_sb.s_flags = mount_flags;
s->u.affs_sb.s_mode = i;
s->u.affs_sb.s_uid = uid;
s->u.affs_sb.s_gid = gid;
s->u.affs_sb.s_reserved= reserved;
/* Get the size of the device in 512-byte blocks.
* If we later see that the partition uses bigger
* blocks, we will have to change it.
*/
blocks = blk_size[MAJOR(dev)][MINOR(dev)];
if (blocks == 0)
goto out_bad_size;
s->u.affs_sb.s_blksize = blksize_size[MAJOR(dev)][MINOR(dev)];
if (!s->u.affs_sb.s_blksize)
s->u.affs_sb.s_blksize = BLOCK_SIZE;
size = (s->u.affs_sb.s_blksize / 512) * blocks;
pr_debug("AFFS: initial blksize=%d, blocks=%d\n",
s->u.affs_sb.s_blksize, blocks);
/* Try to find root block. Its location depends on the block size. */
i = 512;
j = 4096;
if (blocksize > 0) {
i = j = blocksize;
size = size / (blocksize / 512);
}
for (blocksize = i, key = 0; blocksize <= j; blocksize <<= 1, size >>= 1) {
s->u.affs_sb.s_root_block = root_block;
if (root_block < 0)
s->u.affs_sb.s_root_block = (reserved + size - 1) / 2;
pr_debug("AFFS: setting blocksize to %d\n", blocksize);
set_blocksize(dev, blocksize);
/* The root block location that was calculated above is not
* correct if the partition size is an odd number of 512-
* byte blocks, which will be rounded down to a number of
* 1024-byte blocks, and if there were an even number of
* reserved blocks. Ideally, all partition checkers should
* report the real number of blocks of the real blocksize,
* but since this just cannot be done, we have to try to
* find the root block anyways. In the above case, it is one
* block behind the calculated one. So we check this one, too.
*/
for (num_bm = 0; num_bm < 2; num_bm++) {
pr_debug("AFFS: Dev %s, trying root=%u, bs=%d, "
"size=%d, reserved=%d\n",
kdevname(dev),
s->u.affs_sb.s_root_block + num_bm,
blocksize, size, reserved);
bh = affs_bread(dev, s->u.affs_sb.s_root_block + num_bm,
blocksize);
if (!bh)
continue;
if (!affs_checksum_block(blocksize,bh->b_data,&ptype,&stype) &&
ptype == T_SHORT && stype == ST_ROOT) {
s->s_blocksize = blocksize;
s->u.affs_sb.s_hashsize = blocksize / 4 - 56;
s->u.affs_sb.s_root_block += num_bm;
key = 1;
goto got_root;
}
affs_brelse(bh);
bh = NULL;
}
}
goto out_no_valid_block;
/* N.B. after this point bh must be released */
got_root:
root_block = s->u.affs_sb.s_root_block;
s->u.affs_sb.s_partition_size = size;
s->s_blocksize_bits = blocksize == 512 ? 9 :
blocksize == 1024 ? 10 :
blocksize == 2048 ? 11 : 12;
/* Find out which kind of FS we have */
bb = affs_bread(dev,0,s->s_blocksize);
if (!bb)
goto out_no_root_block;
chksum = be32_to_cpu(*(u32 *)bb->b_data);
affs_brelse(bb);
/* Dircache filesystems are compatible with non-dircache ones
* when reading. As long as they aren't supported, writing is
* not recommended.
*/
if ((chksum == FS_DCFFS || chksum == MUFS_DCFFS || chksum == FS_DCOFS
|| chksum == MUFS_DCOFS) && !(s->s_flags & MS_RDONLY)) {
printk(KERN_NOTICE "AFFS: Dircache FS - mounting %s read only\n",
kdevname(dev));
s->s_flags |= MS_RDONLY;
s->u.affs_sb.s_flags |= SF_READONLY;
}
switch (chksum) {
case MUFS_FS:
case MUFS_INTLFFS:
s->u.affs_sb.s_flags |= SF_MUFS;
/* fall thru */
case FS_INTLFFS:
s->u.affs_sb.s_flags |= SF_INTL;
break;
case MUFS_DCFFS:
case MUFS_FFS:
s->u.affs_sb.s_flags |= SF_MUFS;
break;
case FS_DCFFS:
case FS_FFS:
break;
case MUFS_OFS:
s->u.affs_sb.s_flags |= SF_MUFS;
/* fall thru */
case FS_OFS:
s->u.affs_sb.s_flags |= SF_OFS;
s->s_flags |= MS_NOEXEC;
break;
case MUFS_DCOFS:
case MUFS_INTLOFS:
s->u.affs_sb.s_flags |= SF_MUFS;
case FS_DCOFS:
case FS_INTLOFS:
s->u.affs_sb.s_flags |= SF_INTL | SF_OFS;
s->s_flags |= MS_NOEXEC;
break;
default:
goto out_unknown_fs;
}
if (mount_flags & SF_VERBOSE) {
chksum = cpu_to_be32(chksum);
printk(KERN_NOTICE "AFFS: Mounting volume \"%*s\": Type=%.3s\\%c, Blocksize=%d\n",
GET_END_PTR(struct root_end,bh->b_data,blocksize)->disk_name[0],
&GET_END_PTR(struct root_end,bh->b_data,blocksize)->disk_name[1],
(char *)&chksum,((char *)&chksum)[3] + '0',blocksize);
}
default:
goto out_unknown_fs;
}
if (mount_flags & SF_VERBOSE) {
chksum = cpu_to_be32(chksum);
printk(KERN_NOTICE "AFFS: Mounting volume \"%*s\": Type=%.3s\\%c, Blocksize=%d\n",
GET_END_PTR(struct root_end,bh->b_data,blocksize)->disk_name[0],
&GET_END_PTR(struct root_end,bh->b_data,blocksize)->disk_name[1],
(char *)&chksum,((char *)&chksum)[3] + '0',blocksize);
}
s->s_flags |= MS_NODEV | MS_NOSUID;
/* Keep super block in cache */
bb = affs_bread(dev,root_block,s->s_blocksize);
if (!bb)
goto out_no_root_block;
s->u.affs_sb.s_root_bh = bb;
/* N.B. after this point s_root_bh must be released */
/* Allocate space for bitmaps, zones and others */
size = s->u.affs_sb.s_partition_size - reserved;
num_bm = (size + s->s_blocksize * 8 - 32 - 1) / (s->s_blocksize * 8 - 32);
az_no = (size + AFFS_ZONE_SIZE - 1) / (AFFS_ZONE_SIZE - 32);
ptype = num_bm * sizeof(struct affs_bm_info) +
az_no * sizeof(struct affs_alloc_zone) +
MAX_ZONES * sizeof(struct affs_zone);
pr_debug("AFFS: num_bm=%d, az_no=%d, sum=%d\n",num_bm,az_no,ptype);
if (!(s->u.affs_sb.s_bitmap = kmalloc(ptype, GFP_KERNEL)))
void
affs_read_inode(struct inode *inode)
{
struct buffer_head *bh;
struct file_front *file_front;
struct file_end *file_end;
s32 block;
unsigned long prot;
s32 ptype, stype;
unsigned short id;
pr_debug("AFFS: read_inode(%lu)\n",inode->i_ino);
block = inode->i_ino;
if (!(bh = affs_bread(inode->i_dev,block,AFFS_I2BSIZE(inode)))) {
affs_error(inode->i_sb,"read_inode","Cannot read block %d",block);
return;
}
if (affs_checksum_block(AFFS_I2BSIZE(inode),bh->b_data,&ptype,&stype) || ptype != T_SHORT) {
affs_error(inode->i_sb,"read_inode",
"Checksum or type (ptype=%d) error on inode %d",ptype,block);
affs_brelse(bh);
return;
}
file_front = (struct file_front *)bh->b_data;
file_end = GET_END_PTR(struct file_end, bh->b_data,AFFS_I2BSIZE(inode));
prot = (be32_to_cpu(file_end->protect) & ~0x10) ^ FIBF_OWNER;
inode->u.affs_i.i_protect = prot;
inode->u.affs_i.i_parent = be32_to_cpu(file_end->parent);
inode->u.affs_i.i_original = 0;
inode->u.affs_i.i_zone = 0;
inode->u.affs_i.i_hlink = 0;
inode->u.affs_i.i_pa_cnt = 0;
inode->u.affs_i.i_pa_next = 0;
inode->u.affs_i.i_pa_last = 0;
inode->u.affs_i.i_ec = NULL;
inode->u.affs_i.i_lastblock = -1;
inode->i_nlink = 1;
inode->i_mode = 0;
if (inode->i_sb->u.affs_sb.s_flags & SF_SETMODE)
inode->i_mode = inode->i_sb->u.affs_sb.s_mode;
else
inode->i_mode = prot_to_mode(prot);
if (inode->i_sb->u.affs_sb.s_flags & SF_SETUID)
inode->i_uid = inode->i_sb->u.affs_sb.s_uid;
id = be16_to_cpu(file_end->owner_uid);
if (id == 0 || inode->i_sb->u.affs_sb.s_flags & SF_SETUID)
inode->i_uid = inode->i_sb->u.affs_sb.s_uid;
else if (id == 0xFFFF && inode->i_sb->u.affs_sb.s_flags & SF_MUFS)
inode->i_uid = 0;
else
inode->i_uid = id;
id = be16_to_cpu(file_end->owner_gid);
if (id == 0 || inode->i_sb->u.affs_sb.s_flags & SF_SETGID)
inode->i_gid = inode->i_sb->u.affs_sb.s_gid;
else if (id == 0xFFFF && inode->i_sb->u.affs_sb.s_flags & SF_MUFS)
inode->i_gid = 0;
else
inode->i_gid = id;
switch (be32_to_cpu(file_end->secondary_type)) {
case ST_ROOT:
inode->i_uid = inode->i_sb->u.affs_sb.s_uid;
inode->i_gid = inode->i_sb->u.affs_sb.s_gid;
case ST_USERDIR:
if (be32_to_cpu(file_end->secondary_type) == ST_USERDIR ||
inode->i_sb->u.affs_sb.s_flags & SF_SETMODE) {
if (inode->i_mode & S_IRUSR)
inode->i_mode |= S_IXUSR;
if (inode->i_mode & S_IRGRP)
inode->i_mode |= S_IXGRP;
if (inode->i_mode & S_IROTH)
inode->i_mode |= S_IXOTH;
inode->i_mode |= S_IFDIR;
} else
inode->i_mode = S_IRUGO | S_IXUGO | S_IWUSR | S_IFDIR;
inode->i_size = 0;
break;
case ST_LINKDIR:
affs_error(inode->i_sb,"read_inode","inode is LINKDIR");
affs_brelse(bh);
return;
case ST_LINKFILE:
affs_error(inode->i_sb,"read_inode","inode is LINKFILE");
affs_brelse(bh);
return;
case ST_FILE:
inode->i_mode |= S_IFREG;
inode->i_size = be32_to_cpu(file_end->byte_size);
if (inode->i_sb->u.affs_sb.s_flags & SF_OFS)
block = AFFS_I2BSIZE(inode) - 24;
else
block = AFFS_I2BSIZE(inode);
inode->u.affs_i.i_lastblock = ((inode->i_size + block - 1) / block) - 1;
break;
case ST_SOFTLINK:
inode->i_mode |= S_IFLNK;
inode->i_size = 0;
break;
}
inode->i_mtime = inode->i_atime = inode->i_ctime
= (be32_to_cpu(file_end->created.ds_Days) * (24 * 60 * 60) +
be32_to_cpu(file_end->created.ds_Minute) * 60 +
be32_to_cpu(file_end->created.ds_Tick) / 50 +
((8 * 365 + 2) * 24 * 60 * 60)) +
sys_tz.tz_minuteswest * 60;
affs_brelse(bh);
inode->i_op = NULL;
if (S_ISREG(inode->i_mode)) {
if (inode->i_sb->u.affs_sb.s_flags & SF_OFS) {
inode->i_op = &affs_file_inode_operations_ofs;
} else {
inode->i_op = &affs_file_inode_operations;
}
} else if (S_ISDIR(inode->i_mode)) {
/* Maybe it should be controlled by mount parameter? */
inode->i_mode |= S_ISVTX;
inode->i_op = &affs_dir_inode_operations;
}
else if (S_ISLNK(inode->i_mode))
inode->i_op = &affs_symlink_inode_operations;
}
int
affs_add_entry(struct inode *dir, struct inode *inode, struct dentry *dentry, s32 type)
{
struct super_block *sb = dir->i_sb;
struct buffer_head *inode_bh = NULL;
struct buffer_head *bh = NULL;
u32 block = 0;
int retval;
pr_debug("AFFS: add_entry(dir=%u, inode=%u, \"%*s\", type=%d)\n", (u32)dir->i_ino,
(u32)inode->i_ino, (int)dentry->d_name.len, dentry->d_name.name, type);
retval = -EIO;
bh = affs_bread(sb, inode->i_ino);
if (!bh)
goto done;
affs_lock_link(inode);
switch (type) {
case ST_LINKFILE:
case ST_LINKDIR:
retval = -ENOSPC;
block = affs_alloc_block(dir, dir->i_ino);
if (!block)
goto err;
retval = -EIO;
inode_bh = bh;
bh = affs_getzeroblk(sb, block);
if (!bh)
goto err;
break;
default:
break;
}
AFFS_HEAD(bh)->ptype = cpu_to_be32(T_SHORT);
AFFS_HEAD(bh)->key = cpu_to_be32(bh->b_blocknr);
affs_copy_name(AFFS_TAIL(sb, bh)->name, dentry);
AFFS_TAIL(sb, bh)->stype = cpu_to_be32(type);
AFFS_TAIL(sb, bh)->parent = cpu_to_be32(dir->i_ino);
if (inode_bh) {
__be32 chain;
chain = AFFS_TAIL(sb, inode_bh)->link_chain;
AFFS_TAIL(sb, bh)->original = cpu_to_be32(inode->i_ino);
AFFS_TAIL(sb, bh)->link_chain = chain;
AFFS_TAIL(sb, inode_bh)->link_chain = cpu_to_be32(block);
affs_adjust_checksum(inode_bh, block - be32_to_cpu(chain));
mark_buffer_dirty_inode(inode_bh, inode);
inode->i_nlink = 2;
atomic_inc(&inode->i_count);
}
affs_fix_checksum(sb, bh);
mark_buffer_dirty_inode(bh, inode);
dentry->d_fsdata = (void *)(long)bh->b_blocknr;
affs_lock_dir(dir);
retval = affs_insert_hash(dir, bh);
mark_buffer_dirty_inode(bh, inode);
affs_unlock_dir(dir);
affs_unlock_link(inode);
d_instantiate(dentry, inode);
done:
affs_brelse(inode_bh);
affs_brelse(bh);
return retval;
err:
if (block)
affs_free_block(sb, block);
affs_unlock_link(inode);
goto done;
}
struct super_block *
affs_read_super(struct super_block *s,void *data, int silent)
{
struct buffer_head *bh = NULL;
struct buffer_head *bb;
kdev_t dev = s->s_dev;
int root_block;
int size;
__u32 chksum;
__u32 *bm;
int ptype, stype;
int mapidx;
int num_bm;
int i, j;
int key;
int blocksize;
uid_t uid;
gid_t gid;
int reserved;
int az_no;
unsigned long mount_flags;
unsigned long offset;
pr_debug("affs_read_super(%s)\n",data ? (const char *)data : "no options");
MOD_INC_USE_COUNT;
if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block,
&blocksize,&s->u.affs_sb.s_prefix,s->u.affs_sb.s_volume,&mount_flags)) {
s->s_dev = 0;
printk("AFFS: error parsing options.\n");
MOD_DEC_USE_COUNT;
return NULL;
}
lock_super(s);
/* Get the size of the device in 512-byte blocks.
* If we later see that the partition uses bigger
* blocks, we will have to change it.
*/
size = blksize_size[MAJOR(dev)][MINOR(dev)];
size = (size ? size : BLOCK_SIZE) / 512 * blk_size[MAJOR(dev)][MINOR(dev)];
s->u.affs_sb.s_bitmap = NULL;
s->u.affs_sb.s_root_bh = NULL;
s->u.affs_sb.s_flags = mount_flags;
s->u.affs_sb.s_mode = i;
s->u.affs_sb.s_uid = uid;
s->u.affs_sb.s_gid = gid;
if (size == 0) {
s->s_dev = 0;
unlock_super(s);
printk("affs_read_super: could not determine device size\n");
goto out;
}
s->u.affs_sb.s_partition_size = size;
s->u.affs_sb.s_reserved = reserved;
/* Try to find root block. Its location may depend on the block size. */
s->u.affs_sb.s_hashsize = 0;
if (blocksize > 0) {
i = blocksize;
j = blocksize;
} else {
i = 512;
j = 4096;
}
for (blocksize = i, key = 0; blocksize <= j; blocksize <<= 1, size >>= 1) {
if (root_block < 0)
s->u.affs_sb.s_root_block = (reserved + size - 1) / 2;
else
s->u.affs_sb.s_root_block = root_block;
set_blocksize(dev,blocksize);
/* The root block location that was calculated above is not
* correct if the partition size is an odd number of 512-
* byte blocks, which will be rounded down to a number of
* 1024-byte blocks, and if there were an even number of
* reserved blocks. Ideally, all partition checkers should
* report the real number of blocks of the real blocksize,
* but since this just cannot be done, we have to try to
* find the root block anyways. In the above case, it is one
* block behind the calculated one. So we check this one, too.
*/
for (num_bm = 0; num_bm < 2; num_bm++) {
pr_debug("AFFS: Dev %s - trying bs=%d bytes, root at %d, "
"size=%d blocks, %d reserved\n",kdevname(dev),blocksize,
s->u.affs_sb.s_root_block + num_bm,size,reserved);
bh = affs_bread(dev,s->u.affs_sb.s_root_block + num_bm,blocksize);
if (!bh) {
printk("AFFS: unable to read root block\n");
goto out;
}
if (!affs_checksum_block(blocksize,bh->b_data,&ptype,&stype) &&
ptype == T_SHORT && stype == ST_ROOT) {
s->s_blocksize = blocksize;
s->u.affs_sb.s_hashsize = blocksize / 4 - 56;
s->u.affs_sb.s_root_block += num_bm;
key = 1;
break;
}
}
if (key)
break;
affs_brelse(bh);
bh = NULL;
}
if (!key) {
affs_brelse(bh);
if (!silent)
printk("AFFS: Can't find a valid root block on device %s\n",kdevname(dev));
goto out;
}
root_block = s->u.affs_sb.s_root_block;
s->u.affs_sb.s_partition_size = size;
s->s_blocksize_bits = blocksize == 512 ? 9 :
blocksize == 1024 ? 10 :
blocksize == 2048 ? 11 : 12;
/* Find out which kind of FS we have */
bb = affs_bread(dev,0,s->s_blocksize);
if (bb) {
chksum = htonl(*(__u32 *)bb->b_data);
switch (chksum) {
case MUFS_FS:
case MUFS_INTLFFS:
s->u.affs_sb.s_flags |= SF_MUFS;
/* fall thru */
case FS_INTLFFS:
s->u.affs_sb.s_flags |= SF_INTL;
break;
case MUFS_DCFFS:
case MUFS_FFS:
s->u.affs_sb.s_flags |= SF_MUFS;
break;
case FS_DCFFS:
case FS_FFS:
break;
case MUFS_OFS:
s->u.affs_sb.s_flags |= SF_MUFS;
/* fall thru */
case FS_OFS:
s->u.affs_sb.s_flags |= SF_OFS;
break;
case MUFS_DCOFS:
if (!(s->s_flags & MS_RDONLY)) {
printk("AFFS: Dircache FS - mounting %s read only.\n",
kdevname(dev));
}
/* fall thru */
case MUFS_INTLOFS:
s->u.affs_sb.s_flags |= SF_MUFS;
if (0)
/* fall thru */
case FS_DCOFS:
if (!(s->s_flags & MS_RDONLY)) {
printk("AFFS: Dircache FS - mounting %s read only.\n",
kdevname(dev));
}
/* fall thru */
case FS_INTLOFS:
s->u.affs_sb.s_flags |= SF_INTL | SF_OFS;
break;
default:
printk("AFFS: Unknown filesystem on device %s: %08X\n",
kdevname(dev),chksum);
affs_brelse(bb);
goto out;
}
affs_brelse(bb);
} else {
printk("AFFS: Can't get boot block.\n");
goto out;
}
if (mount_flags & SF_VERBOSE) {
chksum = ntohl(chksum);
printk("AFFS: Mounting volume \"%*s\": Type=%.3s\\%c, Blocksize=%d\n",
GET_END_PTR(struct root_end,bh->b_data,blocksize)->disk_name[0],
&GET_END_PTR(struct root_end,bh->b_data,blocksize)->disk_name[1],
(char *)&chksum,((char *)&chksum)[3] + '0',blocksize);
}
static int affs_fill_super(struct super_block *sb, void *data, int silent)
{
struct affs_sb_info *sbi;
struct buffer_head *root_bh = NULL;
struct buffer_head *boot_bh;
struct inode *root_inode = NULL;
s32 root_block;
int size, blocksize;
u32 chksum;
int num_bm;
int i, j;
s32 key;
kuid_t uid;
kgid_t gid;
int reserved;
unsigned long mount_flags;
int tmp_flags; /* fix remount prototype... */
u8 sig[4];
int ret;
save_mount_options(sb, data);
pr_debug("AFFS: read_super(%s)\n",data ? (const char *)data : "no options");
sb->s_magic = AFFS_SUPER_MAGIC;
sb->s_op = &affs_sops;
sb->s_flags |= MS_NODIRATIME;
sbi = kzalloc(sizeof(struct affs_sb_info), GFP_KERNEL);
if (!sbi)
return -ENOMEM;
sb->s_fs_info = sbi;
sbi->sb = sb;
mutex_init(&sbi->s_bmlock);
spin_lock_init(&sbi->symlink_lock);
spin_lock_init(&sbi->work_lock);
INIT_DELAYED_WORK(&sbi->sb_work, flush_superblock);
if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block,
&blocksize,&sbi->s_prefix,
sbi->s_volume, &mount_flags)) {
printk(KERN_ERR "AFFS: Error parsing options\n");
kfree(sbi->s_prefix);
kfree(sbi);
return -EINVAL;
}
/* N.B. after this point s_prefix must be released */
sbi->s_flags = mount_flags;
sbi->s_mode = i;
sbi->s_uid = uid;
sbi->s_gid = gid;
sbi->s_reserved= reserved;
/* Get the size of the device in 512-byte blocks.
* If we later see that the partition uses bigger
* blocks, we will have to change it.
*/
size = sb->s_bdev->bd_inode->i_size >> 9;
pr_debug("AFFS: initial blocksize=%d, #blocks=%d\n", 512, size);
affs_set_blocksize(sb, PAGE_SIZE);
/* Try to find root block. Its location depends on the block size. */
i = 512;
j = 4096;
if (blocksize > 0) {
i = j = blocksize;
size = size / (blocksize / 512);
}
for (blocksize = i, key = 0; blocksize <= j; blocksize <<= 1, size >>= 1) {
sbi->s_root_block = root_block;
if (root_block < 0)
sbi->s_root_block = (reserved + size - 1) / 2;
pr_debug("AFFS: setting blocksize to %d\n", blocksize);
affs_set_blocksize(sb, blocksize);
sbi->s_partition_size = size;
/* The root block location that was calculated above is not
* correct if the partition size is an odd number of 512-
* byte blocks, which will be rounded down to a number of
* 1024-byte blocks, and if there were an even number of
* reserved blocks. Ideally, all partition checkers should
* report the real number of blocks of the real blocksize,
* but since this just cannot be done, we have to try to
* find the root block anyways. In the above case, it is one
* block behind the calculated one. So we check this one, too.
*/
for (num_bm = 0; num_bm < 2; num_bm++) {
pr_debug("AFFS: Dev %s, trying root=%u, bs=%d, "
"size=%d, reserved=%d\n",
sb->s_id,
sbi->s_root_block + num_bm,
blocksize, size, reserved);
root_bh = affs_bread(sb, sbi->s_root_block + num_bm);
if (!root_bh)
continue;
if (!affs_checksum_block(sb, root_bh) &&
be32_to_cpu(AFFS_ROOT_HEAD(root_bh)->ptype) == T_SHORT &&
be32_to_cpu(AFFS_ROOT_TAIL(sb, root_bh)->stype) == ST_ROOT) {
sbi->s_hashsize = blocksize / 4 - 56;
sbi->s_root_block += num_bm;
key = 1;
goto got_root;
}
affs_brelse(root_bh);
root_bh = NULL;
}
}
if (!silent)
printk(KERN_ERR "AFFS: No valid root block on device %s\n",
sb->s_id);
return -EINVAL;
/* N.B. after this point bh must be released */
got_root:
/* Keep super block in cache */
sbi->s_root_bh = root_bh;
root_block = sbi->s_root_block;
/* Find out which kind of FS we have */
boot_bh = sb_bread(sb, 0);
if (!boot_bh) {
printk(KERN_ERR "AFFS: Cannot read boot block\n");
return -EINVAL;
}
memcpy(sig, boot_bh->b_data, 4);
brelse(boot_bh);
chksum = be32_to_cpu(*(__be32 *)sig);
/* Dircache filesystems are compatible with non-dircache ones
* when reading. As long as they aren't supported, writing is
* not recommended.
*/
if ((chksum == FS_DCFFS || chksum == MUFS_DCFFS || chksum == FS_DCOFS
|| chksum == MUFS_DCOFS) && !(sb->s_flags & MS_RDONLY)) {
printk(KERN_NOTICE "AFFS: Dircache FS - mounting %s read only\n",
sb->s_id);
sb->s_flags |= MS_RDONLY;
}
switch (chksum) {
case MUFS_FS:
case MUFS_INTLFFS:
case MUFS_DCFFS:
sbi->s_flags |= SF_MUFS;
/* fall thru */
case FS_INTLFFS:
case FS_DCFFS:
sbi->s_flags |= SF_INTL;
break;
case MUFS_FFS:
sbi->s_flags |= SF_MUFS;
break;
case FS_FFS:
break;
case MUFS_OFS:
sbi->s_flags |= SF_MUFS;
/* fall thru */
case FS_OFS:
sbi->s_flags |= SF_OFS;
sb->s_flags |= MS_NOEXEC;
break;
case MUFS_DCOFS:
case MUFS_INTLOFS:
sbi->s_flags |= SF_MUFS;
case FS_DCOFS:
case FS_INTLOFS:
sbi->s_flags |= SF_INTL | SF_OFS;
sb->s_flags |= MS_NOEXEC;
break;
default:
printk(KERN_ERR "AFFS: Unknown filesystem on device %s: %08X\n",
sb->s_id, chksum);
return -EINVAL;
}
if (mount_flags & SF_VERBOSE) {
u8 len = AFFS_ROOT_TAIL(sb, root_bh)->disk_name[0];
printk(KERN_NOTICE "AFFS: Mounting volume \"%.*s\": Type=%.3s\\%c, Blocksize=%d\n",
len > 31 ? 31 : len,
AFFS_ROOT_TAIL(sb, root_bh)->disk_name + 1,
sig, sig[3] + '0', blocksize);
}
sb->s_flags |= MS_NODEV | MS_NOSUID;
sbi->s_data_blksize = sb->s_blocksize;
if (sbi->s_flags & SF_OFS)
sbi->s_data_blksize -= 24;
tmp_flags = sb->s_flags;
ret = affs_init_bitmap(sb, &tmp_flags);
if (ret)
return ret;
sb->s_flags = tmp_flags;
/* set up enough so that it can read an inode */
root_inode = affs_iget(sb, root_block);
if (IS_ERR(root_inode))
return PTR_ERR(root_inode);
if (AFFS_SB(sb)->s_flags & SF_INTL)
sb->s_d_op = &affs_intl_dentry_operations;
else
sb->s_d_op = &affs_dentry_operations;
sb->s_root = d_make_root(root_inode);
if (!sb->s_root) {
printk(KERN_ERR "AFFS: Get root inode failed\n");
return -ENOMEM;
}
pr_debug("AFFS: s_flags=%lX\n",sb->s_flags);
return 0;
}
static int
affs_remove_link(struct dentry *dentry)
{
struct inode *dir, *inode = dentry->d_inode;
struct super_block *sb = inode->i_sb;
struct buffer_head *bh = NULL, *link_bh = NULL;
u32 link_ino, ino;
int retval;
pr_debug("AFFS: remove_link(key=%ld)\n", inode->i_ino);
retval = -EIO;
bh = affs_bread(sb, inode->i_ino);
if (!bh)
goto done;
link_ino = (u32)(long)dentry->d_fsdata;
if (inode->i_ino == link_ino) {
/* we can't remove the head of the link, as its blocknr is still used as ino,
* so we remove the block of the first link instead.
*/
link_ino = be32_to_cpu(AFFS_TAIL(sb, bh)->link_chain);
link_bh = affs_bread(sb, link_ino);
if (!link_bh)
goto done;
dir = affs_iget(sb, be32_to_cpu(AFFS_TAIL(sb, link_bh)->parent));
if (IS_ERR(dir)) {
retval = PTR_ERR(dir);
goto done;
}
affs_lock_dir(dir);
affs_fix_dcache(dentry, link_ino);
retval = affs_remove_hash(dir, link_bh);
if (retval) {
affs_unlock_dir(dir);
goto done;
}
mark_buffer_dirty_inode(link_bh, inode);
memcpy(AFFS_TAIL(sb, bh)->name, AFFS_TAIL(sb, link_bh)->name, 32);
retval = affs_insert_hash(dir, bh);
if (retval) {
affs_unlock_dir(dir);
goto done;
}
mark_buffer_dirty_inode(bh, inode);
affs_unlock_dir(dir);
iput(dir);
} else {
link_bh = affs_bread(sb, link_ino);
if (!link_bh)
goto done;
}
while ((ino = be32_to_cpu(AFFS_TAIL(sb, bh)->link_chain)) != 0) {
if (ino == link_ino) {
__be32 ino2 = AFFS_TAIL(sb, link_bh)->link_chain;
AFFS_TAIL(sb, bh)->link_chain = ino2;
affs_adjust_checksum(bh, be32_to_cpu(ino2) - link_ino);
mark_buffer_dirty_inode(bh, inode);
retval = 0;
/* Fix the link count, if bh is a normal header block without links */
switch (be32_to_cpu(AFFS_TAIL(sb, bh)->stype)) {
case ST_LINKDIR:
case ST_LINKFILE:
break;
default:
if (!AFFS_TAIL(sb, bh)->link_chain)
inode->i_nlink = 1;
}
affs_free_block(sb, link_ino);
goto done;
}
affs_brelse(bh);
bh = affs_bread(sb, ino);
if (!bh)
goto done;
}
retval = -ENOENT;
done:
affs_brelse(link_bh);
affs_brelse(bh);
return retval;
}
int
affs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
{
struct super_block *sb = dir->i_sb;
struct buffer_head *bh;
struct inode *inode;
char *p;
int i, maxlen, error;
char c, lc;
pr_debug("%s(%lu,\"%pd\" -> \"%s\")\n",
__func__, dir->i_ino, dentry, symname);
maxlen = AFFS_SB(sb)->s_hashsize * sizeof(u32) - 1;
inode = affs_new_inode(dir);
if (!inode)
return -ENOSPC;
inode->i_op = &affs_symlink_inode_operations;
inode->i_data.a_ops = &affs_symlink_aops;
inode->i_mode = S_IFLNK | 0777;
mode_to_prot(inode);
error = -EIO;
bh = affs_bread(sb, inode->i_ino);
if (!bh)
goto err;
i = 0;
p = (char *)AFFS_HEAD(bh)->table;
lc = '/';
if (*symname == '/') {
struct affs_sb_info *sbi = AFFS_SB(sb);
while (*symname == '/')
symname++;
spin_lock(&sbi->symlink_lock);
while (sbi->s_volume[i]) /* Cannot overflow */
*p++ = sbi->s_volume[i++];
spin_unlock(&sbi->symlink_lock);
}
while (i < maxlen && (c = *symname++)) {
if (c == '.' && lc == '/' && *symname == '.' && symname[1] == '/') {
*p++ = '/';
i++;
symname += 2;
lc = '/';
} else if (c == '.' && lc == '/' && *symname == '/') {
symname++;
lc = '/';
} else {
*p++ = c;
lc = c;
i++;
}
if (lc == '/')
while (*symname == '/')
symname++;
}
*p = 0;
mark_buffer_dirty_inode(bh, inode);
affs_brelse(bh);
mark_inode_dirty(inode);
error = affs_add_entry(dir, inode, dentry, ST_SOFTLINK);
if (error)
goto err;
return 0;
err:
clear_nlink(inode);
mark_inode_dirty(inode);
iput(inode);
return error;
}
struct super_block *
affs_read_super(struct super_block *s,void *data, int silent)
{
struct buffer_head *bh = NULL;
struct buffer_head *bb;
kdev_t dev = s->s_dev;
int root_block;
int size;
__u32 chksum;
__u32 *bm;
int ptype, stype;
int mapidx;
int num_bm;
int i, j;
int key;
int blocksize;
uid_t uid;
gid_t gid;
int reserved;
int az_no;
unsigned long mount_flags;
unsigned long offset;
pr_debug("affs_read_super(%s)\n",data ? (const char *)data : "no options");
MOD_INC_USE_COUNT;
if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block,
&blocksize,&s->u.affs_sb.s_prefix,s->u.affs_sb.s_volume,&mount_flags)) {
s->s_dev = 0;
printk("AFFS: error parsing options.\n");
MOD_DEC_USE_COUNT;
return NULL;
}
lock_super(s);
/* Get the size of the device in 512-byte blocks.
* If we later see that the partition uses bigger
* blocks, we will have to change it.
*/
size = blksize_size[MAJOR(dev)][MINOR(dev)];
size = (size ? size : BLOCK_SIZE) / 512 * blk_size[MAJOR(dev)][MINOR(dev)];
s->u.affs_sb.s_bitmap = NULL;
s->u.affs_sb.s_root_bh = NULL;
s->u.affs_sb.s_flags = mount_flags;
s->u.affs_sb.s_mode = i;
s->u.affs_sb.s_uid = uid;
s->u.affs_sb.s_gid = gid;
if (size == 0) {
s->s_dev = 0;
unlock_super(s);
printk("affs_read_super: could not determine device size\n");
goto out;
}
s->u.affs_sb.s_partition_size = size;
s->u.affs_sb.s_reserved = reserved;
/* Try to find root block. Its location may depend on the block size. */
s->u.affs_sb.s_hashsize = 0;
if (blocksize > 0) {
chksum = blocksize;
num_bm = blocksize;
} else {
chksum = 512;
num_bm = 4096;
}
for (blocksize = chksum; blocksize <= num_bm; blocksize <<= 1, size >>= 1) {
if (root_block < 0)
s->u.affs_sb.s_root_block = (reserved + size - 1) / 2;
else
s->u.affs_sb.s_root_block = root_block;
pr_debug("Trying bs=%d bytes, root at %d, size=%d blocks (%d reserved)\n",
blocksize,s->u.affs_sb.s_root_block,size,reserved);
set_blocksize(dev,blocksize);
bh = affs_bread(dev,s->u.affs_sb.s_root_block,blocksize);
if (!bh) {
printk("AFFS: unable to read root block\n");
goto out;
}
if (!affs_checksum_block(blocksize,bh->b_data,&ptype,&stype) &&
ptype == T_SHORT && stype == ST_ROOT) {
s->s_blocksize = blocksize;
s->u.affs_sb.s_hashsize = blocksize / 4 - 56;
break;
}
affs_brelse(bh);
bh = NULL;
}
if (!s->u.affs_sb.s_hashsize) {
affs_brelse(bh);
if (!silent)
printk("AFFS: Can't find a valid root block on device %s\n",kdevname(dev));
goto out;
}
root_block = s->u.affs_sb.s_root_block;
s->u.affs_sb.s_partition_size = size;
s->s_blocksize_bits = blocksize == 512 ? 9 :
blocksize == 1024 ? 10 :
blocksize == 2048 ? 11 : 12;
/* Find out which kind of FS we have */
bb = affs_bread(dev,0,s->s_blocksize);
if (bb) {
chksum = htonl(*(__u32 *)bb->b_data);
switch (chksum) {
case MUFS_FS:
case MUFS_INTLFFS:
s->u.affs_sb.s_flags |= SF_MUFS;
/* fall thru */
case FS_INTLFFS:
s->u.affs_sb.s_flags |= SF_INTL;
break;
case MUFS_FFS:
s->u.affs_sb.s_flags |= SF_MUFS;
break;
case FS_FFS:
break;
case MUFS_OFS:
s->u.affs_sb.s_flags |= SF_MUFS;
/* fall thru */
case FS_OFS:
s->u.affs_sb.s_flags |= SF_OFS;
break;
case MUFS_INTLOFS:
s->u.affs_sb.s_flags |= SF_MUFS;
/* fall thru */
case FS_INTLOFS:
s->u.affs_sb.s_flags |= SF_INTL | SF_OFS;
break;
case FS_DCOFS:
case FS_DCFFS:
case MUFS_DCOFS:
case MUFS_DCFFS:
if (!silent)
printk("AFFS: Unsupported filesystem on device %s: %08X\n",
kdevname(dev),chksum);
if (0)
default:
printk("AFFS: Unknown filesystem on device %s: %08X\n",
kdevname(dev),chksum);
affs_brelse(bb);
goto out;
}
affs_brelse(bb);
} else {
printk("AFFS: Can't get boot block.\n");
goto out;
}
if (mount_flags & SF_VERBOSE) {
chksum = ntohl(chksum);
printk("AFFS: Mounting volume \"%*s\": Type=%.3s\\%c, Blocksize=%d\n",
GET_END_PTR(struct root_end,bh->b_data,blocksize)->disk_name[0],
&GET_END_PTR(struct root_end,bh->b_data,blocksize)->disk_name[1],
(char *)&chksum,((char *)&chksum)[3] + '0',blocksize);
}
