UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'work.adfs' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs 

Pull adfs updates from Al Viro:
 "More ADFS patches from Russell King"

* 'work.adfs' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  fs/adfs: add time stamp and file type helpers
  fs/adfs: super: limit idlen according to directory type
  fs/adfs: super: fix use-after-free bug
  fs/adfs: super: safely update options on remount
  fs/adfs: super: correct superblock flags
  fs/adfs: clean up indirect disc addresses and fragment IDs
  fs/adfs: clean up error message printing
  fs/adfs: use %pV for error messages
  fs/adfs: use format_version from disc_record
  fs/adfs: add helper to get filesystem size
  fs/adfs: add helper to get discrecord from map
  fs/adfs: correct disc record structure
This commit is contained in:
Linus Torvalds 2019-07-19 11:33:22 -07:00
parent 933a90bf4f b4ed8f75c8
commit d2fbf4b6d5
8 changed files with 164 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
fs/adfs/adfs.h
View File

@ -1,4 +1,5 @@
/* SPDX-License-Identifier: GPL-2.0 */ /* SPDX-License-Identifier: GPL-2.0 */
#include <linux/buffer_head.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/adfs_fs.h> #include <linux/adfs_fs.h>
@ -8,6 +9,15 @@
#define ADFS_BAD_FRAG 1 #define ADFS_BAD_FRAG 1
#define ADFS_ROOT_FRAG 2 #define ADFS_ROOT_FRAG 2
#define ADFS_FILETYPE_NONE ((u16)~0)
/* RISC OS 12-bit filetype is stored in load_address[19:8] */
static inline u16 adfs_filetype(u32 loadaddr)
{
return (loadaddr & 0xfff00000) == 0xfff00000 ?
(loadaddr >> 8) & 0xfff : ADFS_FILETYPE_NONE;
}
#define ADFS_NDA_OWNER_READ (1 << 0) #define ADFS_NDA_OWNER_READ (1 << 0)
#define ADFS_NDA_OWNER_WRITE (1 << 1) #define ADFS_NDA_OWNER_WRITE (1 << 1)
#define ADFS_NDA_LOCKED (1 << 2) #define ADFS_NDA_LOCKED (1 << 2)
@ -18,22 +28,28 @@
#include "dir_f.h" #include "dir_f.h"
struct buffer_head;
/* /*
* adfs file system inode data in memory * adfs file system inode data in memory
*/ */
struct adfs_inode_info { struct adfs_inode_info {
loff_t mmu_private; loff_t mmu_private;
unsigned long parent_id; /* object id of parent */ __u32 parent_id; /* parent indirect disc address */
__u32 loadaddr; /* RISC OS load address */ __u32 loadaddr; /* RISC OS load address */
__u32 execaddr; /* RISC OS exec address */ __u32 execaddr; /* RISC OS exec address */
unsigned int filetype; /* RISC OS file type */
unsigned int attr; /* RISC OS permissions */ unsigned int attr; /* RISC OS permissions */
unsigned int stamped:1; /* RISC OS file has date/time */
struct inode vfs_inode; struct inode vfs_inode;
}; };
static inline struct adfs_inode_info *ADFS_I(struct inode *inode)
{
return container_of(inode, struct adfs_inode_info, vfs_inode);
}
static inline bool adfs_inode_is_stamped(struct inode *inode)
{
return (ADFS_I(inode)->loadaddr & 0xfff00000) == 0xfff00000;
}
/* /*
* Forward-declare this * Forward-declare this
*/ */
@ -59,10 +75,8 @@ struct adfs_sb_info {
__u32 s_ids_per_zone; /* max. no ids in one zone */ __u32 s_ids_per_zone; /* max. no ids in one zone */
__u32 s_idlen; /* length of ID in map */ __u32 s_idlen; /* length of ID in map */
__u32 s_map_size; /* sector size of a map */ __u32 s_map_size; /* sector size of a map */
unsigned long s_size; /* total size (in blocks) of this fs */
signed int s_map2blk; /* shift left by this for map->sector*/ signed int s_map2blk; /* shift left by this for map->sector*/
unsigned int s_log2sharesize;/* log2 share size */ unsigned int s_log2sharesize;/* log2 share size */
__le32 s_version; /* disc format version */
unsigned int s_namelen; /* maximum number of characters in name */ unsigned int s_namelen; /* maximum number of characters in name */
}; };
@ -71,11 +85,6 @@ static inline struct adfs_sb_info *ADFS_SB(struct super_block *sb)
return sb->s_fs_info; return sb->s_fs_info;
} }
static inline struct adfs_inode_info *ADFS_I(struct inode *inode)
{
return container_of(inode, struct adfs_inode_info, vfs_inode);
}
/* /*
* Directory handling * Directory handling
*/ */
@ -89,7 +98,7 @@ struct adfs_dir {
struct buffer_head **bh_fplus; struct buffer_head **bh_fplus;
unsigned int pos; unsigned int pos;
unsigned int parent_id; __u32 parent_id;
struct adfs_dirheader dirhead; struct adfs_dirheader dirhead;
union adfs_dirtail dirtail; union adfs_dirtail dirtail;
@ -101,20 +110,18 @@ struct adfs_dir {
#define ADFS_MAX_NAME_LEN (256 + 4) /* +4 for ,xyz hex filetype suffix */ #define ADFS_MAX_NAME_LEN (256 + 4) /* +4 for ,xyz hex filetype suffix */
struct object_info { struct object_info {
__u32 parent_id; /* parent object id */ __u32 parent_id; /* parent object id */
__u32 file_id; /* object id */ __u32 indaddr; /* indirect disc addr */
__u32 loadaddr; /* load address */ __u32 loadaddr; /* load address */
__u32 execaddr; /* execution address */ __u32 execaddr; /* execution address */
__u32 size; /* size */ __u32 size; /* size */
__u8 attr; /* RISC OS attributes */ __u8 attr; /* RISC OS attributes */
unsigned int name_len; /* name length */ unsigned int name_len; /* name length */
char name[ADFS_MAX_NAME_LEN];/* file name */ char name[ADFS_MAX_NAME_LEN];/* file name */
/* RISC OS file type (12-bit: derived from loadaddr) */
__u16 filetype;
}; };
struct adfs_dir_ops { struct adfs_dir_ops {
int (*read)(struct super_block *sb, unsigned int id, unsigned int sz, struct adfs_dir *dir); int (*read)(struct super_block *sb, unsigned int indaddr,
unsigned int size, struct adfs_dir *dir);
int (*setpos)(struct adfs_dir *dir, unsigned int fpos); int (*setpos)(struct adfs_dir *dir, unsigned int fpos);
int (*getnext)(struct adfs_dir *dir, struct object_info *obj); int (*getnext)(struct adfs_dir *dir, struct object_info *obj);
int (*update)(struct adfs_dir *dir, struct object_info *obj); int (*update)(struct adfs_dir *dir, struct object_info *obj);
@ -137,7 +144,7 @@ int adfs_write_inode(struct inode *inode, struct writeback_control *wbc);
int adfs_notify_change(struct dentry *dentry, struct iattr *attr); int adfs_notify_change(struct dentry *dentry, struct iattr *attr);
/* map.c */ /* map.c */
extern int adfs_map_lookup(struct super_block *sb, unsigned int frag_id, unsigned int offset); int adfs_map_lookup(struct super_block *sb, u32 frag_id, unsigned int offset);
extern unsigned int adfs_map_free(struct super_block *sb); extern unsigned int adfs_map_free(struct super_block *sb);
/* Misc */ /* Misc */
@ -145,6 +152,7 @@ __printf(3, 4)
void __adfs_error(struct super_block *sb, const char *function, void __adfs_error(struct super_block *sb, const char *function,
const char *fmt, ...); const char *fmt, ...);
#define adfs_error(sb, fmt...) __adfs_error(sb, __func__, fmt) #define adfs_error(sb, fmt...) __adfs_error(sb, __func__, fmt)
void adfs_msg(struct super_block *sb, const char *pfx, const char *fmt, ...);
/* super.c */ /* super.c */
@ -182,16 +190,28 @@ static inline __u32 signed_asl(__u32 val, signed int shift)
* *
* The root directory ID should always be looked up in the map [3.4] * The root directory ID should always be looked up in the map [3.4]
*/ */
static inline int static inline int __adfs_block_map(struct super_block *sb, u32 indaddr,
__adfs_block_map(struct super_block *sb, unsigned int object_id,
unsigned int block) unsigned int block)
{ {
if (object_id & 255) { if (indaddr & 255) {
unsigned int off; unsigned int off;
off = (object_id & 255) - 1; off = (indaddr & 255) - 1;
block += off << ADFS_SB(sb)->s_log2sharesize; block += off << ADFS_SB(sb)->s_log2sharesize;
} }
return adfs_map_lookup(sb, object_id >> 8, block); return adfs_map_lookup(sb, indaddr >> 8, block);
}
/* Return the disc record from the map */
static inline
struct adfs_discrecord *adfs_map_discrecord(struct adfs_discmap *dm)
{
return (void *)(dm[0].dm_bh->b_data + 4);
}
static inline u64 adfs_disc_size(const struct adfs_discrecord *dr)
{
return (u64)le32_to_cpu(dr->disc_size_high) << 32 |
le32_to_cpu(dr->disc_size);
} }

25
fs/adfs/dir.c
View File

@ -35,20 +35,14 @@ void adfs_object_fixup(struct adfs_dir *dir, struct object_info *obj)
if (obj->name_len <= 2 && dots == obj->name_len) if (obj->name_len <= 2 && dots == obj->name_len)
obj->name[0] = '^'; obj->name[0] = '^';
obj->filetype = -1;
/* /*
* object is a file and is filetyped and timestamped? * If the object is a file, and the user requested the ,xyz hex
* RISC OS 12-bit filetype is stored in load_address[19:8] * filetype suffix to the name, check the filetype and append.
*/ */
if ((0 == (obj->attr & ADFS_NDA_DIRECTORY)) && if (!(obj->attr & ADFS_NDA_DIRECTORY) && ADFS_SB(dir->sb)->s_ftsuffix) {
(0xfff00000 == (0xfff00000 & obj->loadaddr))) { u16 filetype = adfs_filetype(obj->loadaddr);
obj->filetype = (__u16) ((0x000fff00 & obj->loadaddr) >> 8);
/* optionally append the ,xyz hex filetype suffix */
if (ADFS_SB(dir->sb)->s_ftsuffix) {
__u16 filetype = obj->filetype;
if (filetype != ADFS_FILETYPE_NONE) {
obj->name[obj->name_len++] = ','; obj->name[obj->name_len++] = ',';
obj->name[obj->name_len++] = hex_asc_lo(filetype >> 8); obj->name[obj->name_len++] = hex_asc_lo(filetype >> 8);
obj->name[obj->name_len++] = hex_asc_lo(filetype >> 4); obj->name[obj->name_len++] = hex_asc_lo(filetype >> 4);
@ -92,7 +86,7 @@ adfs_readdir(struct file *file, struct dir_context *ctx)
goto unlock_out; goto unlock_out;
while (ops->getnext(&dir, &obj) == 0) { while (ops->getnext(&dir, &obj) == 0) {
if (!dir_emit(ctx, obj.name, obj.name_len, if (!dir_emit(ctx, obj.name, obj.name_len,
obj.file_id, DT_UNKNOWN)) obj.indaddr, DT_UNKNOWN))
break; break;
ctx->pos++; ctx->pos++;
} }
@ -113,8 +107,8 @@ adfs_dir_update(struct super_block *sb, struct object_info *obj, int wait)
const struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir; const struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
struct adfs_dir dir; struct adfs_dir dir;
printk(KERN_INFO "adfs_dir_update: object %06X in dir %06X\n", printk(KERN_INFO "adfs_dir_update: object %06x in dir %06x\n",
obj->file_id, obj->parent_id); obj->indaddr, obj->parent_id);
if (!ops->update) { if (!ops->update) {
ret = -EINVAL; ret = -EINVAL;
@ -178,7 +172,8 @@ static int adfs_dir_lookup_byname(struct inode *inode, const struct qstr *qstr,
goto out; goto out;
if (ADFS_I(inode)->parent_id != dir.parent_id) { if (ADFS_I(inode)->parent_id != dir.parent_id) {
adfs_error(sb, "parent directory changed under me! (%lx but got %x)\n", adfs_error(sb,
"parent directory changed under me! (%06x but got %06x)\n",
ADFS_I(inode)->parent_id, dir.parent_id); ADFS_I(inode)->parent_id, dir.parent_id);
ret = -EIO; ret = -EIO;
goto free_out; goto free_out;

36
fs/adfs/dir_f.c
View File

@ -6,7 +6,6 @@
* *
* E and F format directory handling * E and F format directory handling
*/ */
#include <linux/buffer_head.h>
#include "adfs.h" #include "adfs.h"
#include "dir_f.h" #include "dir_f.h"
@ -124,11 +123,8 @@ adfs_dir_checkbyte(const struct adfs_dir *dir)
return (dircheck ^ (dircheck >> 8) ^ (dircheck >> 16) ^ (dircheck >> 24)) & 0xff; return (dircheck ^ (dircheck >> 8) ^ (dircheck >> 16) ^ (dircheck >> 24)) & 0xff;
} }
/* /* Read and check that a directory is valid */
* Read and check that a directory is valid static int adfs_dir_read(struct super_block *sb, u32 indaddr,
*/
static int
adfs_dir_read(struct super_block *sb, unsigned long object_id,
unsigned int size, struct adfs_dir *dir) unsigned int size, struct adfs_dir *dir)
{ {
const unsigned int blocksize_bits = sb->s_blocksize_bits; const unsigned int blocksize_bits = sb->s_blocksize_bits;
@ -149,10 +145,10 @@ adfs_dir_read(struct super_block *sb, unsigned long object_id,
for (blk = 0; blk < size; blk++) { for (blk = 0; blk < size; blk++) {
int phys; int phys;
phys = __adfs_block_map(sb, object_id, blk); phys = __adfs_block_map(sb, indaddr, blk);
if (!phys) { if (!phys) {
adfs_error(sb, "dir object %lX has a hole at offset %d", adfs_error(sb, "dir %06x has a hole at offset %d",
object_id, blk); indaddr, blk);
goto release_buffers; goto release_buffers;
} }
@ -180,8 +176,7 @@ adfs_dir_read(struct super_block *sb, unsigned long object_id,
return 0; return 0;
bad_dir: bad_dir:
adfs_error(sb, "corrupted directory fragment %lX", adfs_error(sb, "dir %06x is corrupted", indaddr);
object_id);
release_buffers: release_buffers:
for (blk -= 1; blk >= 0; blk -= 1) for (blk -= 1; blk >= 0; blk -= 1)
brelse(dir->bh[blk]); brelse(dir->bh[blk]);
@ -208,7 +203,7 @@ adfs_dir2obj(struct adfs_dir *dir, struct object_info *obj,
} }
obj->name_len = name_len; obj->name_len = name_len;
obj->file_id = adfs_readval(de->dirinddiscadd, 3); obj->indaddr = adfs_readval(de->dirinddiscadd, 3);
obj->loadaddr = adfs_readval(de->dirload, 4); obj->loadaddr = adfs_readval(de->dirload, 4);
obj->execaddr = adfs_readval(de->direxec, 4); obj->execaddr = adfs_readval(de->direxec, 4);
obj->size = adfs_readval(de->dirlen, 4); obj->size = adfs_readval(de->dirlen, 4);
@ -223,7 +218,7 @@ adfs_dir2obj(struct adfs_dir *dir, struct object_info *obj,
static inline void static inline void
adfs_obj2dir(struct adfs_direntry *de, struct object_info *obj) adfs_obj2dir(struct adfs_direntry *de, struct object_info *obj)
{ {
adfs_writeval(de->dirinddiscadd, 3, obj->file_id); adfs_writeval(de->dirinddiscadd, 3, obj->indaddr);
adfs_writeval(de->dirload, 4, obj->loadaddr); adfs_writeval(de->dirload, 4, obj->loadaddr);
adfs_writeval(de->direxec, 4, obj->execaddr); adfs_writeval(de->direxec, 4, obj->execaddr);
adfs_writeval(de->dirlen, 4, obj->size); adfs_writeval(de->dirlen, 4, obj->size);
@ -309,8 +304,7 @@ __adfs_dir_put(struct adfs_dir *dir, int pos, struct object_info *obj)
* the caller is responsible for holding the necessary * the caller is responsible for holding the necessary
* locks. * locks.
*/ */
static int static int adfs_dir_find_entry(struct adfs_dir *dir, u32 indaddr)
adfs_dir_find_entry(struct adfs_dir *dir, unsigned long object_id)
{ {
int pos, ret; int pos, ret;
@ -322,7 +316,7 @@ adfs_dir_find_entry(struct adfs_dir *dir, unsigned long object_id)
if (!__adfs_dir_get(dir, pos, &obj)) if (!__adfs_dir_get(dir, pos, &obj))
break; break;
if (obj.file_id == object_id) { if (obj.indaddr == indaddr) {
ret = pos; ret = pos;
break; break;
} }
@ -331,15 +325,15 @@ adfs_dir_find_entry(struct adfs_dir *dir, unsigned long object_id)
return ret; return ret;
} }
static int static int adfs_f_read(struct super_block *sb, u32 indaddr, unsigned int size,
adfs_f_read(struct super_block *sb, unsigned int id, unsigned int sz, struct adfs_dir *dir) struct adfs_dir *dir)
{ {
int ret; int ret;
if (sz != ADFS_NEWDIR_SIZE) if (size != ADFS_NEWDIR_SIZE)
return -EIO; return -EIO;
ret = adfs_dir_read(sb, id, sz, dir); ret = adfs_dir_read(sb, indaddr, size, dir);
if (ret) if (ret)
adfs_error(sb, "unable to read directory"); adfs_error(sb, "unable to read directory");
else else
@ -376,7 +370,7 @@ adfs_f_update(struct adfs_dir *dir, struct object_info *obj)
struct super_block *sb = dir->sb; struct super_block *sb = dir->sb;
int ret, i; int ret, i;
ret = adfs_dir_find_entry(dir, obj->file_id); ret = adfs_dir_find_entry(dir, obj->indaddr);
if (ret < 0) { if (ret < 0) {
adfs_error(dir->sb, "unable to locate entry to update"); adfs_error(dir->sb, "unable to locate entry to update");
goto out; goto out;

19
fs/adfs/dir_fplus.c
View File

@ -4,7 +4,6 @@
* *
* Copyright (C) 1997-1999 Russell King * Copyright (C) 1997-1999 Russell King
*/ */
#include <linux/buffer_head.h>
#include <linux/slab.h> #include <linux/slab.h>
#include "adfs.h" #include "adfs.h"
#include "dir_fplus.h" #include "dir_fplus.h"
@ -37,17 +36,15 @@ adfs_fplus_read(struct super_block *sb, unsigned int id, unsigned int sz, struct
h = (struct adfs_bigdirheader *)dir->bh_fplus[0]->b_data; h = (struct adfs_bigdirheader *)dir->bh_fplus[0]->b_data;
size = le32_to_cpu(h->bigdirsize); size = le32_to_cpu(h->bigdirsize);
if (size != sz) { if (size != sz) {
printk(KERN_WARNING "adfs: adfs_fplus_read:" adfs_msg(sb, KERN_WARNING,
" directory header size %X\n" "directory header size %X does not match directory size %X",
" does not match directory size %X\n",
size, sz); size, sz);
} }
if (h->bigdirversion[0] != 0 || h->bigdirversion[1] != 0 || if (h->bigdirversion[0] != 0 || h->bigdirversion[1] != 0 ||
h->bigdirversion[2] != 0 || size & 2047 || h->bigdirversion[2] != 0 || size & 2047 ||
h->bigdirstartname != cpu_to_le32(BIGDIRSTARTNAME)) { h->bigdirstartname != cpu_to_le32(BIGDIRSTARTNAME)) {
printk(KERN_WARNING "adfs: dir object %X has" adfs_error(sb, "dir %06x has malformed header", id);
" malformed dir header\n", id);
goto out; goto out;
} }
@ -58,9 +55,10 @@ adfs_fplus_read(struct super_block *sb, unsigned int id, unsigned int sz, struct
kcalloc(size, sizeof(struct buffer_head *), kcalloc(size, sizeof(struct buffer_head *),
GFP_KERNEL); GFP_KERNEL);
if (!bh_fplus) { if (!bh_fplus) {
adfs_msg(sb, KERN_ERR,
"not enough memory for dir object %X (%d blocks)",
id, size);
ret = -ENOMEM; ret = -ENOMEM;
adfs_error(sb, "not enough memory for"
" dir object %X (%d blocks)", id, size);
goto out; goto out;
} }
dir->bh_fplus = bh_fplus; dir->bh_fplus = bh_fplus;
@ -91,8 +89,7 @@ adfs_fplus_read(struct super_block *sb, unsigned int id, unsigned int sz, struct
if (t->bigdirendname != cpu_to_le32(BIGDIRENDNAME) || if (t->bigdirendname != cpu_to_le32(BIGDIRENDNAME) ||
t->bigdirendmasseq != h->startmasseq || t->bigdirendmasseq != h->startmasseq ||
t->reserved[0] != 0 || t->reserved[1] != 0) { t->reserved[0] != 0 || t->reserved[1] != 0) {
printk(KERN_WARNING "adfs: dir object %X has " adfs_error(sb, "dir %06x has malformed tail", id);
"malformed dir end\n", id);
goto out; goto out;
} }
@ -180,7 +177,7 @@ adfs_fplus_getnext(struct adfs_dir *dir, struct object_info *obj)
obj->loadaddr = le32_to_cpu(bde.bigdirload); obj->loadaddr = le32_to_cpu(bde.bigdirload);
obj->execaddr = le32_to_cpu(bde.bigdirexec); obj->execaddr = le32_to_cpu(bde.bigdirexec);
obj->size = le32_to_cpu(bde.bigdirlen); obj->size = le32_to_cpu(bde.bigdirlen);
obj->file_id = le32_to_cpu(bde.bigdirindaddr); obj->indaddr = le32_to_cpu(bde.bigdirindaddr);
obj->attr = le32_to_cpu(bde.bigdirattr); obj->attr = le32_to_cpu(bde.bigdirattr);
obj->name_len = le32_to_cpu(bde.bigdirobnamelen); obj->name_len = le32_to_cpu(bde.bigdirobnamelen);

12
fs/adfs/inode.c
View File

@ -94,7 +94,7 @@ adfs_atts2mode(struct super_block *sb, struct inode *inode)
return S_IFDIR | S_IXUGO | mode; return S_IFDIR | S_IXUGO | mode;
} }
switch (ADFS_I(inode)->filetype) { switch (adfs_filetype(ADFS_I(inode)->loadaddr)) {
case 0xfc0: /* LinkFS */ case 0xfc0: /* LinkFS */
return S_IFLNK|S_IRWXUGO; return S_IFLNK|S_IRWXUGO;
@ -174,7 +174,7 @@ adfs_adfs2unix_time(struct timespec64 *tv, struct inode *inode)
2208988800000000000LL; 2208988800000000000LL;
s64 nsec; s64 nsec;
if (ADFS_I(inode)->stamped == 0) if (!adfs_inode_is_stamped(inode))
goto cur_time; goto cur_time;
high = ADFS_I(inode)->loadaddr & 0xFF; /* top 8 bits of timestamp */ high = ADFS_I(inode)->loadaddr & 0xFF; /* top 8 bits of timestamp */
@ -213,7 +213,7 @@ adfs_unix2adfs_time(struct inode *inode, unsigned int secs)
{ {
unsigned int high, low; unsigned int high, low;
if (ADFS_I(inode)->stamped) { if (adfs_inode_is_stamped(inode)) {
/* convert 32-bit seconds to 40-bit centi-seconds */ /* convert 32-bit seconds to 40-bit centi-seconds */
low = (secs & 255) * 100; low = (secs & 255) * 100;
high = (secs / 256) * 100 + (low >> 8) + 0x336e996a; high = (secs / 256) * 100 + (low >> 8) + 0x336e996a;
@ -247,7 +247,7 @@ adfs_iget(struct super_block *sb, struct object_info *obj)
inode->i_uid = ADFS_SB(sb)->s_uid; inode->i_uid = ADFS_SB(sb)->s_uid;
inode->i_gid = ADFS_SB(sb)->s_gid; inode->i_gid = ADFS_SB(sb)->s_gid;
inode->i_ino = obj->file_id; inode->i_ino = obj->indaddr;
inode->i_size = obj->size; inode->i_size = obj->size;
set_nlink(inode, 2); set_nlink(inode, 2);
inode->i_blocks = (inode->i_size + sb->s_blocksize - 1) >> inode->i_blocks = (inode->i_size + sb->s_blocksize - 1) >>
@ -263,8 +263,6 @@ adfs_iget(struct super_block *sb, struct object_info *obj)
ADFS_I(inode)->loadaddr = obj->loadaddr; ADFS_I(inode)->loadaddr = obj->loadaddr;
ADFS_I(inode)->execaddr = obj->execaddr; ADFS_I(inode)->execaddr = obj->execaddr;
ADFS_I(inode)->attr = obj->attr; ADFS_I(inode)->attr = obj->attr;
ADFS_I(inode)->filetype = obj->filetype;
ADFS_I(inode)->stamped = ((obj->loadaddr & 0xfff00000) == 0xfff00000);
inode->i_mode = adfs_atts2mode(sb, inode); inode->i_mode = adfs_atts2mode(sb, inode);
adfs_adfs2unix_time(&inode->i_mtime, inode); adfs_adfs2unix_time(&inode->i_mtime, inode);
@ -355,7 +353,7 @@ int adfs_write_inode(struct inode *inode, struct writeback_control *wbc)
struct object_info obj; struct object_info obj;
int ret; int ret;
obj.file_id = inode->i_ino; obj.indaddr = inode->i_ino;
obj.name_len = 0; obj.name_len = 0;
obj.parent_id = ADFS_I(inode)->parent_id; obj.parent_id = ADFS_I(inode)->parent_id;
obj.loadaddr = ADFS_I(inode)->loadaddr; obj.loadaddr = ADFS_I(inode)->loadaddr;

15
fs/adfs/map.c
View File

@ -4,7 +4,6 @@
* *
* Copyright (C) 1997-2002 Russell King * Copyright (C) 1997-2002 Russell King
*/ */
#include <linux/buffer_head.h>
#include <asm/unaligned.h> #include <asm/unaligned.h>
#include "adfs.h" #include "adfs.h"
@ -64,9 +63,8 @@ static DEFINE_RWLOCK(adfs_map_lock);
* output of: * output of:
* gcc -D__KERNEL__ -O2 -I../../include -o - -S map.c * gcc -D__KERNEL__ -O2 -I../../include -o - -S map.c
*/ */
static int static int lookup_zone(const struct adfs_discmap *dm, const unsigned int idlen,
lookup_zone(const struct adfs_discmap *dm, const unsigned int idlen, const u32 frag_id, unsigned int *offset)
const unsigned int frag_id, unsigned int *offset)
{ {
const unsigned int mapsize = dm->dm_endbit; const unsigned int mapsize = dm->dm_endbit;
const u32 idmask = (1 << idlen) - 1; const u32 idmask = (1 << idlen) - 1;
@ -185,9 +183,8 @@ error:
return 0; return 0;
} }
static int static int scan_map(struct adfs_sb_info *asb, unsigned int zone,
scan_map(struct adfs_sb_info *asb, unsigned int zone, const u32 frag_id, unsigned int mapoff)
const unsigned int frag_id, unsigned int mapoff)
{ {
const unsigned int idlen = asb->s_idlen; const unsigned int idlen = asb->s_idlen;
struct adfs_discmap *dm, *dm_end; struct adfs_discmap *dm, *dm_end;
@ -241,9 +238,7 @@ adfs_map_free(struct super_block *sb)
return signed_asl(total, asb->s_map2blk); return signed_asl(total, asb->s_map2blk);
} }
int int adfs_map_lookup(struct super_block *sb, u32 frag_id, unsigned int offset)
adfs_map_lookup(struct super_block *sb, unsigned int frag_id,
unsigned int offset)
{ {
struct adfs_sb_info *asb = ADFS_SB(sb); struct adfs_sb_info *asb = ADFS_SB(sb);
unsigned int zone, mapoff; unsigned int zone, mapoff;

121
fs/adfs/super.c
View File

@ -6,7 +6,6 @@
*/ */
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/buffer_head.h>
#include <linux/parser.h> #include <linux/parser.h>
#include <linux/mount.h> #include <linux/mount.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
@ -17,25 +16,42 @@
#include "dir_f.h" #include "dir_f.h"
#include "dir_fplus.h" #include "dir_fplus.h"
#define ADFS_SB_FLAGS SB_NOATIME
#define ADFS_DEFAULT_OWNER_MASK S_IRWXU #define ADFS_DEFAULT_OWNER_MASK S_IRWXU
#define ADFS_DEFAULT_OTHER_MASK (S_IRWXG | S_IRWXO) #define ADFS_DEFAULT_OTHER_MASK (S_IRWXG | S_IRWXO)
void __adfs_error(struct super_block *sb, const char *function, const char *fmt, ...) void __adfs_error(struct super_block *sb, const char *function, const char *fmt, ...)
{ {
char error_buf[128]; struct va_format vaf;
va_list args; va_list args;
va_start(args, fmt); va_start(args, fmt);
vsnprintf(error_buf, sizeof(error_buf), fmt, args); vaf.fmt = fmt;
va_end(args); vaf.va = &args;
printk(KERN_CRIT "ADFS-fs error (device %s)%s%s: %s\n", printk(KERN_CRIT "ADFS-fs error (device %s)%s%s: %pV\n",
sb->s_id, function ? ": " : "", sb->s_id, function ? ": " : "",
function ? function : "", error_buf); function ? function : "", &vaf);
va_end(args);
}
void adfs_msg(struct super_block *sb, const char *pfx, const char *fmt, ...)
{
struct va_format vaf;
va_list args;
va_start(args, fmt);
vaf.fmt = fmt;
vaf.va = &args;
printk("%sADFS-fs (%s): %pV\n", pfx, sb->s_id, &vaf);
va_end(args);
} }
static int adfs_checkdiscrecord(struct adfs_discrecord *dr) static int adfs_checkdiscrecord(struct adfs_discrecord *dr)
{ {
unsigned int max_idlen;
int i; int i;
/* sector size must be 256, 512 or 1024 bytes */ /* sector size must be 256, 512 or 1024 bytes */
@ -55,8 +71,13 @@ static int adfs_checkdiscrecord(struct adfs_discrecord *dr)
if (le32_to_cpu(dr->disc_size_high) >> dr->log2secsize) if (le32_to_cpu(dr->disc_size_high) >> dr->log2secsize)
return 1; return 1;
/* idlen must be no greater than 19 v2 [1.0] */ /*
if (dr->idlen > 19) * Maximum idlen is limited to 16 bits for new directories by
* the three-byte storage of an indirect disc address. For
* big directories, idlen must be no greater than 19 v2 [1.0]
*/
max_idlen = dr->format_version ? 19 : 16;
if (dr->idlen > max_idlen)
return 1; return 1;
/* reserved bytes should be zero */ /* reserved bytes should be zero */
@ -152,10 +173,10 @@ static const match_table_t tokens = {
{Opt_err, NULL} {Opt_err, NULL}
}; };
static int parse_options(struct super_block *sb, char *options) static int parse_options(struct super_block *sb, struct adfs_sb_info *asb,
char *options)
{ {
char *p; char *p;
struct adfs_sb_info *asb = ADFS_SB(sb);
int option; int option;
if (!options) if (!options)
@ -199,8 +220,9 @@ static int parse_options(struct super_block *sb, char *options)
asb->s_ftsuffix = option; asb->s_ftsuffix = option;
break; break;
default: default:
printk("ADFS-fs: unrecognised mount option \"%s\" " adfs_msg(sb, KERN_ERR,
"or missing value\n", p); "unrecognised mount option \"%s\" or missing value",
p);
return -EINVAL; return -EINVAL;
} }
} }
@ -209,21 +231,31 @@ static int parse_options(struct super_block *sb, char *options)
static int adfs_remount(struct super_block *sb, int *flags, char *data) static int adfs_remount(struct super_block *sb, int *flags, char *data)
{ {
struct adfs_sb_info temp_asb;
int ret;
sync_filesystem(sb); sync_filesystem(sb);
*flags |= SB_NODIRATIME; *flags |= ADFS_SB_FLAGS;
return parse_options(sb, data);
temp_asb = *ADFS_SB(sb);
ret = parse_options(sb, &temp_asb, data);
if (ret == 0)
*ADFS_SB(sb) = temp_asb;
return ret;
} }
static int adfs_statfs(struct dentry *dentry, struct kstatfs *buf) static int adfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{ {
struct super_block *sb = dentry->d_sb; struct super_block *sb = dentry->d_sb;
struct adfs_sb_info *sbi = ADFS_SB(sb); struct adfs_sb_info *sbi = ADFS_SB(sb);
struct adfs_discrecord *dr = adfs_map_discrecord(sbi->s_map);
u64 id = huge_encode_dev(sb->s_bdev->bd_dev); u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
buf->f_type = ADFS_SUPER_MAGIC; buf->f_type = ADFS_SUPER_MAGIC;
buf->f_namelen = sbi->s_namelen; buf->f_namelen = sbi->s_namelen;
buf->f_bsize = sb->s_blocksize; buf->f_bsize = sb->s_blocksize;
buf->f_blocks = sbi->s_size; buf->f_blocks = adfs_disc_size(dr) >> sb->s_blocksize_bits;
buf->f_files = sbi->s_ids_per_zone * sbi->s_map_size; buf->f_files = sbi->s_ids_per_zone * sbi->s_map_size;
buf->f_bavail = buf->f_bavail =
buf->f_bfree = adfs_map_free(sb); buf->f_bfree = adfs_map_free(sb);
@ -327,8 +359,7 @@ static struct adfs_discmap *adfs_read_map(struct super_block *sb, struct adfs_di
i = zone - 1; i = zone - 1;
dm[0].dm_startblk = 0; dm[0].dm_startblk = 0;
dm[0].dm_startbit = ADFS_DR_SIZE_BITS; dm[0].dm_startbit = ADFS_DR_SIZE_BITS;
dm[i].dm_endbit = (le32_to_cpu(dr->disc_size_high) << (32 - dr->log2bpmb)) + dm[i].dm_endbit = (adfs_disc_size(dr) >> dr->log2bpmb) +
(le32_to_cpu(dr->disc_size) >> dr->log2bpmb) +
(ADFS_DR_SIZE_BITS - i * zone_size); (ADFS_DR_SIZE_BITS - i * zone_size);
if (adfs_checkmap(sb, dm)) if (adfs_checkmap(sb, dm))
@ -344,27 +375,18 @@ error_free:
return ERR_PTR(-EIO); return ERR_PTR(-EIO);
} }
static inline unsigned long adfs_discsize(struct adfs_discrecord *dr, int block_bits)
{
unsigned long discsize;
discsize = le32_to_cpu(dr->disc_size_high) << (32 - block_bits);
discsize |= le32_to_cpu(dr->disc_size) >> block_bits;
return discsize;
}
static int adfs_fill_super(struct super_block *sb, void *data, int silent) static int adfs_fill_super(struct super_block *sb, void *data, int silent)
{ {
struct adfs_discrecord *dr; struct adfs_discrecord *dr;
struct buffer_head *bh; struct buffer_head *bh;
struct object_info root_obj; struct object_info root_obj;
unsigned char *b_data; unsigned char *b_data;
unsigned int blocksize;
struct adfs_sb_info *asb; struct adfs_sb_info *asb;
struct inode *root; struct inode *root;
int ret = -EINVAL; int ret = -EINVAL;
sb->s_flags |= SB_NODIRATIME; sb->s_flags |= ADFS_SB_FLAGS;
asb = kzalloc(sizeof(*asb), GFP_KERNEL); asb = kzalloc(sizeof(*asb), GFP_KERNEL);
if (!asb) if (!asb)
@ -378,12 +400,12 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
asb->s_other_mask = ADFS_DEFAULT_OTHER_MASK; asb->s_other_mask = ADFS_DEFAULT_OTHER_MASK;
asb->s_ftsuffix = 0; asb->s_ftsuffix = 0;
if (parse_options(sb, data)) if (parse_options(sb, asb, data))
goto error; goto error;
sb_set_blocksize(sb, BLOCK_SIZE); sb_set_blocksize(sb, BLOCK_SIZE);
if (!(bh = sb_bread(sb, ADFS_DISCRECORD / BLOCK_SIZE))) { if (!(bh = sb_bread(sb, ADFS_DISCRECORD / BLOCK_SIZE))) {
adfs_error(sb, "unable to read superblock"); adfs_msg(sb, KERN_ERR, "error: unable to read superblock");
ret = -EIO; ret = -EIO;
goto error; goto error;
} }
@ -391,11 +413,8 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
b_data = bh->b_data + (ADFS_DISCRECORD % BLOCK_SIZE); b_data = bh->b_data + (ADFS_DISCRECORD % BLOCK_SIZE);
if (adfs_checkbblk(b_data)) { if (adfs_checkbblk(b_data)) {
if (!silent)
printk("VFS: Can't find an adfs filesystem on dev "
"%s.\n", sb->s_id);
ret = -EINVAL; ret = -EINVAL;
goto error_free_bh; goto error_badfs;
} }
dr = (struct adfs_discrecord *)(b_data + ADFS_DR_OFFSET); dr = (struct adfs_discrecord *)(b_data + ADFS_DR_OFFSET);
@ -404,33 +423,33 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
* Do some sanity checks on the ADFS disc record * Do some sanity checks on the ADFS disc record
*/ */
if (adfs_checkdiscrecord(dr)) { if (adfs_checkdiscrecord(dr)) {
if (!silent)
printk("VPS: Can't find an adfs filesystem on dev "
"%s.\n", sb->s_id);
ret = -EINVAL; ret = -EINVAL;
goto error_free_bh; goto error_badfs;
} }
blocksize = 1 << dr->log2secsize;
brelse(bh); brelse(bh);
if (sb_set_blocksize(sb, 1 << dr->log2secsize)) {
if (sb_set_blocksize(sb, blocksize)) {
bh = sb_bread(sb, ADFS_DISCRECORD / sb->s_blocksize); bh = sb_bread(sb, ADFS_DISCRECORD / sb->s_blocksize);
if (!bh) { if (!bh) {
adfs_error(sb, "couldn't read superblock on " adfs_msg(sb, KERN_ERR,
"2nd try."); "error: couldn't read superblock on 2nd try.");
ret = -EIO; ret = -EIO;
goto error; goto error;
} }
b_data = bh->b_data + (ADFS_DISCRECORD % sb->s_blocksize); b_data = bh->b_data + (ADFS_DISCRECORD % sb->s_blocksize);
if (adfs_checkbblk(b_data)) { if (adfs_checkbblk(b_data)) {
adfs_error(sb, "disc record mismatch, very weird!"); adfs_msg(sb, KERN_ERR,
"error: disc record mismatch, very weird!");
ret = -EINVAL; ret = -EINVAL;
goto error_free_bh; goto error_free_bh;
} }
dr = (struct adfs_discrecord *)(b_data + ADFS_DR_OFFSET); dr = (struct adfs_discrecord *)(b_data + ADFS_DR_OFFSET);
} else { } else {
if (!silent) if (!silent)
printk(KERN_ERR "VFS: Unsupported blocksize on dev " adfs_msg(sb, KERN_ERR,
"%s.\n", sb->s_id); "error: unsupported blocksize");
ret = -EINVAL; ret = -EINVAL;
goto error; goto error;
} }
@ -443,8 +462,6 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
asb->s_idlen = dr->idlen; asb->s_idlen = dr->idlen;
asb->s_map_size = dr->nzones | (dr->nzones_high << 8); asb->s_map_size = dr->nzones | (dr->nzones_high << 8);
asb->s_map2blk = dr->log2bpmb - dr->log2secsize; asb->s_map2blk = dr->log2bpmb - dr->log2secsize;
asb->s_size = adfs_discsize(dr, sb->s_blocksize_bits);
asb->s_version = dr->format_version;
asb->s_log2sharesize = dr->log2sharesize; asb->s_log2sharesize = dr->log2sharesize;
asb->s_map = adfs_read_map(sb, dr); asb->s_map = adfs_read_map(sb, dr);
@ -460,9 +477,9 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
*/ */
sb->s_op = &adfs_sops; sb->s_op = &adfs_sops;
dr = (struct adfs_discrecord *)(asb->s_map[0].dm_bh->b_data + 4); dr = adfs_map_discrecord(asb->s_map);
root_obj.parent_id = root_obj.file_id = le32_to_cpu(dr->root); root_obj.parent_id = root_obj.indaddr = le32_to_cpu(dr->root);
root_obj.name_len = 0; root_obj.name_len = 0;
/* Set root object date as 01 Jan 1987 00:00:00 */ /* Set root object date as 01 Jan 1987 00:00:00 */
root_obj.loadaddr = 0xfff0003f; root_obj.loadaddr = 0xfff0003f;
@ -470,13 +487,12 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
root_obj.size = ADFS_NEWDIR_SIZE; root_obj.size = ADFS_NEWDIR_SIZE;
root_obj.attr = ADFS_NDA_DIRECTORY | ADFS_NDA_OWNER_READ | root_obj.attr = ADFS_NDA_DIRECTORY | ADFS_NDA_OWNER_READ |
ADFS_NDA_OWNER_WRITE | ADFS_NDA_PUBLIC_READ; ADFS_NDA_OWNER_WRITE | ADFS_NDA_PUBLIC_READ;
root_obj.filetype = -1;
/* /*
* If this is a F+ disk with variable length directories, * If this is a F+ disk with variable length directories,
* get the root_size from the disc record. * get the root_size from the disc record.
*/ */
if (asb->s_version) { if (dr->format_version) {
root_obj.size = le32_to_cpu(dr->root_size); root_obj.size = le32_to_cpu(dr->root_size);
asb->s_dir = &adfs_fplus_dir_ops; asb->s_dir = &adfs_fplus_dir_ops;
asb->s_namelen = ADFS_FPLUS_NAME_LEN; asb->s_namelen = ADFS_FPLUS_NAME_LEN;
@ -505,6 +521,11 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
} }
return 0; return 0;
error_badfs:
if (!silent)
adfs_msg(sb, KERN_ERR,
"error: can't find an ADFS filesystem on dev %s.",
sb->s_id);
error_free_bh: error_free_bh:
brelse(bh); brelse(bh);
error: error:

6
include/uapi/linux/adfs_fs.h
View File

@ -29,17 +29,17 @@ struct adfs_discrecord {
__u8 log2sharesize:4; __u8 log2sharesize:4;
__u8 unused40:4; __u8 unused40:4;
__u8 big_flag:1; __u8 big_flag:1;
__u8 unused41:1; __u8 unused41:7;
__u8 nzones_high; __u8 nzones_high;
__u8 reserved43;
__le32 format_version; __le32 format_version;
__le32 root_size; __le32 root_size;
__u8 unused52[60 - 52]; __u8 unused52[60 - 52];
}; } __attribute__((packed, aligned(4)));
#define ADFS_DISCRECORD (0xc00) #define ADFS_DISCRECORD (0xc00)
#define ADFS_DR_OFFSET (0x1c0) #define ADFS_DR_OFFSET (0x1c0)
#define ADFS_DR_SIZE 60 #define ADFS_DR_SIZE 60
#define ADFS_DR_SIZE_BITS (ADFS_DR_SIZE << 3) #define ADFS_DR_SIZE_BITS (ADFS_DR_SIZE << 3)
#endif /* _UAPI_ADFS_FS_H */ #endif /* _UAPI_ADFS_FS_H */