/* * Lookup/Create a block at offset 'block' into 'inode'. We currently do * not support creation of new blocks, so we return -EIO for this case. */ int adfs_get_block(struct inode *inode, long block, struct buffer_head *bh, int create) { if (block < 0) goto abort_negative; if (!create) { if (block >= inode->i_blocks) goto abort_toobig; block = __adfs_block_map(inode->i_sb, inode->i_ino, block); if (block) { bh->b_dev = inode->i_dev; bh->b_blocknr = block; bh->b_state |= (1UL << BH_Mapped); } return 0; } /* don't support allocation of blocks yet */ return -EIO; abort_negative: adfs_error(inode->i_sb, "block %d < 0", block); return -EIO; abort_toobig: return 0; }
static int adfs_dir_lookup_byname(struct inode *inode, struct qstr *name, struct object_info *obj) { struct super_block *sb = inode->i_sb; struct adfs_dir_ops *ops = sb->u.adfs_sb.s_dir; struct adfs_dir dir; int ret; ret = ops->read(sb, inode->i_ino, inode->i_size, &dir); if (ret) goto out; if (inode->u.adfs_i.parent_id != dir.parent_id) { adfs_error(sb, "parent directory changed under me! (%lx but got %lx)\n", inode->u.adfs_i.parent_id, dir.parent_id); ret = -EIO; goto free_out; } obj->parent_id = inode->i_ino; /* * '.' is handled by reserved_lookup() in fs/namei.c */ if (name->len == 2 && name->name[0] == '.' && name->name[1] == '.') { /* * Currently unable to fill in the rest of 'obj', * but this is better than nothing. We need to * ascend one level to find it's parent. */ obj->name_len = 0; obj->file_id = obj->parent_id; goto free_out; } read_lock(&adfs_dir_lock); ret = ops->setpos(&dir, 0); if (ret) goto unlock_out; ret = -ENOENT; while (ops->getnext(&dir, obj) == 0) { if (adfs_match(name, obj)) { ret = 0; break; } } unlock_out: read_unlock(&adfs_dir_lock); free_out: ops->free(&dir); out: return ret; }
static int adfs_fplus_read(struct super_block *sb, unsigned int id, unsigned int sz, struct adfs_dir *dir) { struct adfs_bigdirheader *h; struct adfs_bigdirtail *t; unsigned long block; unsigned int blk, size; int i, ret = -EIO; dir->nr_buffers = 0; block = __adfs_block_map(sb, id, 0); if (!block) { adfs_error(sb, "dir object %X has a hole at offset 0", id); goto out; } dir->bh[0] = bread(sb->s_dev, block, sb->s_blocksize); if (!dir->bh[0]) goto out; dir->nr_buffers += 1; h = (struct adfs_bigdirheader *)dir->bh[0]->b_data; size = le32_to_cpu(h->bigdirsize); if (size != sz) { printk(KERN_WARNING "adfs: adfs_fplus_read: directory header size\n" " does not match directory size\n"); } if (h->bigdirversion[0] != 0 || h->bigdirversion[1] != 0 || h->bigdirversion[2] != 0 || size & 2047 || h->bigdirstartname != cpu_to_le32(BIGDIRSTARTNAME)) goto out; size >>= sb->s_blocksize_bits; for (blk = 1; blk < size; blk++) { block = __adfs_block_map(sb, id, blk); if (!block) { adfs_error(sb, "dir object %X has a hole at offset %d", id, blk); goto out; } dir->bh[blk] = bread(sb->s_dev, block, sb->s_blocksize); if (!dir->bh[blk]) goto out; dir->nr_buffers = blk; } t = (struct adfs_bigdirtail *)(dir->bh[size - 1]->b_data + (sb->s_blocksize - 8)); if (t->bigdirendname != cpu_to_le32(BIGDIRENDNAME) || t->bigdirendmasseq != h->startmasseq || t->reserved[0] != 0 || t->reserved[1] != 0) goto out; dir->parent_id = le32_to_cpu(h->bigdirparent); dir->sb = sb; return 0; out: for (i = 0; i < dir->nr_buffers; i++) brelse(dir->bh[i]); dir->sb = NULL; return ret; }