5 files changed, 81 insertions, 26 deletions

diff --git a/fs/adfs/adfs.h b/fs/adfs/adfs.h
index 58588ddb178c..a8a58d864f96 100644
--- a/fs/adfs/adfs.h
+++ b/fs/adfs/adfs.h
@@ -50,6 +50,7 @@ struct adfs_sb_info {
         gid_t           s_gid;          /* owner gid                             */
         umode_t         s_owner_mask;   /* ADFS owner perm -> unix perm          */
         umode_t         s_other_mask;   /* ADFS other perm -> unix perm          */
+        int             s_ftsuffix;     /* ,xyz hex filetype suffix option */
 
         __u32           s_ids_per_zone; /* max. no ids in one zone               */
         __u32           s_idlen;        /* length of ID in map                   */
@@ -93,7 +94,7 @@ struct adfs_dir {
 /*
  * This is the overall maximum name length
  */
-#define ADFS_MAX_NAME_LEN       256
+#define ADFS_MAX_NAME_LEN       (256 + 4) /* +4 for ,xyz hex filetype suffix */
 struct object_info {
         __u32           parent_id;              /* parent object id     */
         __u32           file_id;                /* object id            */
@@ -101,10 +102,26 @@ struct object_info {
         __u32           execaddr;               /* execution address    */
         __u32           size;                   /* size                 */
         __u8            attr;                   /* RISC OS attributes   */
-        unsigned char   name_len;               /* name length          */
+        unsigned int    name_len;               /* name length          */
         char            name[ADFS_MAX_NAME_LEN];/* file name            */
+
+        /* RISC OS file type (12-bit: derived from loadaddr) */
+        __u16           filetype;
 };
 
+/* RISC OS 12-bit filetype converts to ,xyz hex filename suffix */
+static inline int append_filetype_suffix(char *buf, __u16 filetype)
+{
+        if (filetype == -1)
+                return 0;
+
+        *buf++ = ',';
+        *buf++ = hex_asc_lo(filetype >> 8);
+        *buf++ = hex_asc_lo(filetype >> 4);
+        *buf++ = hex_asc_lo(filetype >> 0);
+        return 4;
+}
+
 struct adfs_dir_ops {
         int     (*read)(struct super_block *sb, unsigned int id, unsigned int sz, struct adfs_dir *dir);
         int     (*setpos)(struct adfs_dir *dir, unsigned int fpos);
diff --git a/fs/adfs/dir_f.c b/fs/adfs/dir_f.c
index bafc71222e25..4bbe853ee50a 100644
--- a/fs/adfs/dir_f.c
+++ b/fs/adfs/dir_f.c
@@ -52,7 +52,6 @@ static inline int adfs_readname(char *buf, char *ptr, int maxlen)
                         *buf++ = *ptr;
                 ptr++;
         }
-        *buf = '\0';
 
         return buf - old_buf;
 }
@@ -208,7 +207,8 @@ release_buffers:
  * convert a disk-based directory entry to a Linux ADFS directory entry
  */
 static inline void
-adfs_dir2obj(struct object_info *obj, struct adfs_direntry *de)
+adfs_dir2obj(struct adfs_dir *dir, struct object_info *obj,
+        struct adfs_direntry *de)
 {
         obj->name_len = adfs_readname(obj->name, de->dirobname, ADFS_F_NAME_LEN);
         obj->file_id  = adfs_readval(de->dirinddiscadd, 3);
@@ -216,6 +216,23 @@ adfs_dir2obj(struct object_info *obj, struct adfs_direntry *de)
         obj->execaddr = adfs_readval(de->direxec, 4);
         obj->size     = adfs_readval(de->dirlen,  4);
         obj->attr     = de->newdiratts;
+        obj->filetype = -1;
+
+        /*
+         * object is a file and is filetyped and timestamped?
+         * RISC OS 12-bit filetype is stored in load_address[19:8]
+         */
+        if ((0 == (obj->attr & ADFS_NDA_DIRECTORY)) &&
+                (0xfff00000 == (0xfff00000 & obj->loadaddr))) {
+                obj->filetype = (__u16) ((0x000fff00 & obj->loadaddr) >> 8);
+
+                /* optionally append the ,xyz hex filetype suffix */
+                if (ADFS_SB(dir->sb)->s_ftsuffix)
+                        obj->name_len +=
+                                append_filetype_suffix(
+                                        &obj->name[obj->name_len],
+                                        obj->filetype);
+        }
 }
 
 /*
@@ -260,7 +277,7 @@ __adfs_dir_get(struct adfs_dir *dir, int pos, struct object_info *obj)
         if (!de.dirobname[0])
                 return -ENOENT;
 
-        adfs_dir2obj(obj, &de);
+        adfs_dir2obj(dir, obj, &de);
 
         return 0;
 }
diff --git a/fs/adfs/dir_fplus.c b/fs/adfs/dir_fplus.c
index a7f41da8115b..d9e3bee4e653 100644
--- a/fs/adfs/dir_fplus.c
+++ b/fs/adfs/dir_fplus.c
@@ -197,6 +197,24 @@ adfs_fplus_getnext(struct adfs_dir *dir, struct object_info *obj)
                 if (obj->name[i] == '/')
                         obj->name[i] = '.';
 
+        obj->filetype = -1;
+
+        /*
+         * object is a file and is filetyped and timestamped?
+         * RISC OS 12-bit filetype is stored in load_address[19:8]
+         */
+        if ((0 == (obj->attr & ADFS_NDA_DIRECTORY)) &&
+                (0xfff00000 == (0xfff00000 & obj->loadaddr))) {
+                obj->filetype = (__u16) ((0x000fff00 & obj->loadaddr) >> 8);
+
+                /* optionally append the ,xyz hex filetype suffix */
+                if (ADFS_SB(dir->sb)->s_ftsuffix)
+                        obj->name_len +=
+                                append_filetype_suffix(
+                                        &obj->name[obj->name_len],
+                                        obj->filetype);
+        }
+
         dir->pos += 1;
         ret = 0;
 out:
diff --git a/fs/adfs/inode.c b/fs/adfs/inode.c
index 16d7ef2dffe1..92444e94f842 100644
--- a/fs/adfs/inode.c
+++ b/fs/adfs/inode.c
@@ -78,26 +78,13 @@ static const struct address_space_operations adfs_aops = {
         .bmap           = _adfs_bmap
 };
 
-static inline unsigned int
-adfs_filetype(struct inode *inode)
-{
-        unsigned int type;
-
-        if (ADFS_I(inode)->stamped)
-                type = (ADFS_I(inode)->loadaddr >> 8) & 0xfff;
-        else
-                type = (unsigned int) -1;
-
-        return type;
-}
-
 /*
  * Convert ADFS attributes and filetype to Linux permission.
  */
 static umode_t
 adfs_atts2mode(struct super_block *sb, struct inode *inode)
 {
-        unsigned int filetype, attr = ADFS_I(inode)->attr;
+        unsigned int attr = ADFS_I(inode)->attr;
         umode_t mode, rmask;
         struct adfs_sb_info *asb = ADFS_SB(sb);
 
@@ -106,9 +93,7 @@ adfs_atts2mode(struct super_block *sb, struct inode *inode)
                 return S_IFDIR | S_IXUGO | mode;
         }
 
-        filetype = adfs_filetype(inode);
-
-        switch (filetype) {
+        switch (ADFS_I(inode)->filetype) {
         case 0xfc0:     /* LinkFS */
                 return S_IFLNK|S_IRWXUGO;
 
@@ -277,7 +262,8 @@ adfs_iget(struct super_block *sb, struct object_info *obj)
         ADFS_I(inode)->loadaddr  = obj->loadaddr;
         ADFS_I(inode)->execaddr  = obj->execaddr;
         ADFS_I(inode)->attr      = obj->attr;
-        ADFS_I(inode)->stamped    = ((obj->loadaddr & 0xfff00000) == 0xfff00000);
+        ADFS_I(inode)->filetype  = obj->filetype;
+        ADFS_I(inode)->stamped   = ((obj->loadaddr & 0xfff00000) == 0xfff00000);
 
         inode->i_mode    = adfs_atts2mode(sb, inode);
         adfs_adfs2unix_time(&inode->i_mtime, inode);
diff --git a/fs/adfs/super.c b/fs/adfs/super.c
index 06d7388b477b..c8bf36a1996a 100644
--- a/fs/adfs/super.c
+++ b/fs/adfs/super.c
@@ -138,17 +138,20 @@ static int adfs_show_options(struct seq_file *seq, struct vfsmount *mnt)
                 seq_printf(seq, ",ownmask=%o", asb->s_owner_mask);
         if (asb->s_other_mask != ADFS_DEFAULT_OTHER_MASK)
                 seq_printf(seq, ",othmask=%o", asb->s_other_mask);
+        if (asb->s_ftsuffix != 0)
+                seq_printf(seq, ",ftsuffix=%u", asb->s_ftsuffix);
 
         return 0;
 }
 
-enum {Opt_uid, Opt_gid, Opt_ownmask, Opt_othmask, Opt_err};
+enum {Opt_uid, Opt_gid, Opt_ownmask, Opt_othmask, Opt_ftsuffix, Opt_err};
 
 static const match_table_t tokens = {
         {Opt_uid, "uid=%u"},
         {Opt_gid, "gid=%u"},
         {Opt_ownmask, "ownmask=%o"},
         {Opt_othmask, "othmask=%o"},
+        {Opt_ftsuffix, "ftsuffix=%u"},
         {Opt_err, NULL}
 };
 
@@ -189,6 +192,11 @@ static int parse_options(struct super_block *sb, char *options)
                                 return -EINVAL;
                         asb->s_other_mask = option;
                         break;
+                case Opt_ftsuffix:
+                        if (match_int(args, &option))
+                                return -EINVAL;
+                        asb->s_ftsuffix = option;
+                        break;
                 default:
                         printk("ADFS-fs: unrecognised mount option \"%s\" "
                                         "or missing value\n", p);
@@ -366,6 +374,7 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
         asb->s_gid = 0;
         asb->s_owner_mask = ADFS_DEFAULT_OWNER_MASK;
         asb->s_other_mask = ADFS_DEFAULT_OTHER_MASK;
+        asb->s_ftsuffix = 0;
 
         if (parse_options(sb, data))
                 goto error;
@@ -445,11 +454,13 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
 
         root_obj.parent_id = root_obj.file_id = le32_to_cpu(dr->root);
         root_obj.name_len  = 0;
-        root_obj.loadaddr  = 0;
-        root_obj.execaddr  = 0;
+        /* Set root object date as 01 Jan 1987 00:00:00 */
+        root_obj.loadaddr  = 0xfff0003f;
+        root_obj.execaddr  = 0xec22c000;
         root_obj.size      = ADFS_NEWDIR_SIZE;
         root_obj.attr      = ADFS_NDA_DIRECTORY   | ADFS_NDA_OWNER_READ |
                              ADFS_NDA_OWNER_WRITE | ADFS_NDA_PUBLIC_READ;
+        root_obj.filetype  = -1;
 
         /*
          * If this is a F+ disk with variable length directories,
@@ -463,6 +474,12 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
                 asb->s_dir     = &adfs_f_dir_ops;
                 asb->s_namelen = ADFS_F_NAME_LEN;
         }
+        /*
+         * ,xyz hex filetype suffix may be added by driver
+         * to files that have valid RISC OS filetype
+         */
+        if (asb->s_ftsuffix)
+                asb->s_namelen += 4;
 
         sb->s_d_op = &adfs_dentry_operations;
         root = adfs_iget(sb, &root_obj);