13 files changed, 289 insertions, 31 deletions

diff --git a/fs/ufs/balloc.c b/fs/ufs/balloc.c
index 841ac25fd9..f63a09ce86 100644
--- a/fs/ufs/balloc.c
+++ b/fs/ufs/balloc.c
@@ -19,6 +19,7 @@
 #include <linux/bitops.h>
 #include <asm/byteorder.h>
 
+#include "ufs.h"
 #include "swab.h"
 #include "util.h"
 
diff --git a/fs/ufs/cylinder.c b/fs/ufs/cylinder.c
index 09c39e5e63..2a81566564 100644
--- a/fs/ufs/cylinder.c
+++ b/fs/ufs/cylinder.c
@@ -17,6 +17,7 @@
 
 #include <asm/byteorder.h>
 
+#include "ufs.h"
 #include "swab.h"
 #include "util.h"
 
diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
index 2410ec6002..30f8c2bb0c 100644
--- a/fs/ufs/dir.c
+++ b/fs/ufs/dir.c
@@ -21,6 +21,7 @@
 #include <linux/ufs_fs.h>
 #include <linux/swap.h>
 
+#include "ufs.h"
 #include "swab.h"
 #include "util.h"
 
diff --git a/fs/ufs/file.c b/fs/ufs/file.c
index 6705d74c6d..a46c97bf02 100644
--- a/fs/ufs/file.c
+++ b/fs/ufs/file.c
@@ -27,6 +27,9 @@
 #include <linux/ufs_fs.h>
 #include <linux/buffer_head.h>  /* for sync_mapping_buffers() */
 
+#include "ufs.h"
+
+
 static int ufs_sync_file(struct file *file, struct dentry *dentry, int datasync)
 {
         struct inode *inode = dentry->d_inode;
diff --git a/fs/ufs/ialloc.c b/fs/ufs/ialloc.c
index c28a8b6f2f..7e260bc0d9 100644
--- a/fs/ufs/ialloc.c
+++ b/fs/ufs/ialloc.c
@@ -34,6 +34,7 @@
 #include <linux/bitops.h>
 #include <asm/byteorder.h>
 
+#include "ufs.h"
 #include "swab.h"
 #include "util.h"
 
diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index d84d4b0f47..4320782761 100644
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -38,6 +38,7 @@
 #include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
 
+#include "ufs.h"
 #include "swab.h"
 #include "util.h"
 
diff --git a/fs/ufs/namei.c b/fs/ufs/namei.c
index a059ccd064..d8bfbee2fe 100644
--- a/fs/ufs/namei.c
+++ b/fs/ufs/namei.c
@@ -31,7 +31,7 @@
 #include <linux/fs.h>
 #include <linux/ufs_fs.h>
 #include <linux/smp_lock.h>
-#include "swab.h"       /* will go away - see comment in mknod() */
+#include "ufs.h"
 #include "util.h"
 
 static inline int ufs_add_nondir(struct dentry *dentry, struct inode *inode)
@@ -110,7 +110,6 @@ static int ufs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t
         err = PTR_ERR(inode);
         if (!IS_ERR(inode)) {
                 init_special_inode(inode, mode, rdev);
-                /* NOTE: that'll go when we get wide dev_t */
                 ufs_set_inode_dev(inode->i_sb, UFS_I(inode), rdev);
                 mark_inode_dirty(inode);
                 lock_kernel();
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index 38eb0b7a1f..584cf12cc4 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -88,7 +88,10 @@
 #include <linux/buffer_head.h>
 #include <linux/vfs.h>
 #include <linux/log2.h>
+#include <linux/mount.h>
+#include <linux/seq_file.h>
 
+#include "ufs.h"
 #include "swab.h"
 #include "util.h"
 
@@ -286,16 +289,28 @@ void ufs_warning (struct super_block * sb, const char * function,
 }
 
 enum {
-        Opt_type_old, Opt_type_sunx86, Opt_type_sun, Opt_type_44bsd,
-        Opt_type_ufs2, Opt_type_hp, Opt_type_nextstepcd, Opt_type_nextstep,
-        Opt_type_openstep, Opt_onerror_panic, Opt_onerror_lock,
-        Opt_onerror_umount, Opt_onerror_repair, Opt_err
+       Opt_type_old = UFS_MOUNT_UFSTYPE_OLD,
+       Opt_type_sunx86 = UFS_MOUNT_UFSTYPE_SUNx86,
+       Opt_type_sun = UFS_MOUNT_UFSTYPE_SUN,
+       Opt_type_sunos = UFS_MOUNT_UFSTYPE_SUNOS,
+       Opt_type_44bsd = UFS_MOUNT_UFSTYPE_44BSD,
+       Opt_type_ufs2 = UFS_MOUNT_UFSTYPE_UFS2,
+       Opt_type_hp = UFS_MOUNT_UFSTYPE_HP,
+       Opt_type_nextstepcd = UFS_MOUNT_UFSTYPE_NEXTSTEP_CD,
+       Opt_type_nextstep = UFS_MOUNT_UFSTYPE_NEXTSTEP,
+       Opt_type_openstep = UFS_MOUNT_UFSTYPE_OPENSTEP,
+       Opt_onerror_panic = UFS_MOUNT_ONERROR_PANIC,
+       Opt_onerror_lock = UFS_MOUNT_ONERROR_LOCK,
+       Opt_onerror_umount = UFS_MOUNT_ONERROR_UMOUNT,
+       Opt_onerror_repair = UFS_MOUNT_ONERROR_REPAIR,
+       Opt_err
 };
 
 static match_table_t tokens = {
         {Opt_type_old, "ufstype=old"},
         {Opt_type_sunx86, "ufstype=sunx86"},
         {Opt_type_sun, "ufstype=sun"},
+        {Opt_type_sunos, "ufstype=sunos"},
         {Opt_type_44bsd, "ufstype=44bsd"},
         {Opt_type_ufs2, "ufstype=ufs2"},
         {Opt_type_ufs2, "ufstype=5xbsd"},
@@ -303,6 +318,7 @@ static match_table_t tokens = {
         {Opt_type_nextstepcd, "ufstype=nextstep-cd"},
         {Opt_type_nextstep, "ufstype=nextstep"},
         {Opt_type_openstep, "ufstype=openstep"},
+/*end of possible ufs types */
         {Opt_onerror_panic, "onerror=panic"},
         {Opt_onerror_lock, "onerror=lock"},
         {Opt_onerror_umount, "onerror=umount"},
@@ -339,6 +355,10 @@ static int ufs_parse_options (char * options, unsigned * mount_options)
                         ufs_clear_opt (*mount_options, UFSTYPE);
                         ufs_set_opt (*mount_options, UFSTYPE_SUN);
                         break;
+                case Opt_type_sunos:
+                        ufs_clear_opt(*mount_options, UFSTYPE);
+                        ufs_set_opt(*mount_options, UFSTYPE_SUNOS);
+                        break;
                 case Opt_type_44bsd:
                         ufs_clear_opt (*mount_options, UFSTYPE);
                         ufs_set_opt (*mount_options, UFSTYPE_44BSD);
@@ -654,8 +674,8 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
                 ufs_set_opt (sbi->s_mount_opt, UFSTYPE_OLD);
         }
 
-        sbi->s_uspi = uspi =
-                kmalloc (sizeof(struct ufs_sb_private_info), GFP_KERNEL);
+        uspi = kzalloc(sizeof(struct ufs_sb_private_info), GFP_KERNEL);
+        sbi->s_uspi = uspi;
         if (!uspi)
                 goto failed;
         uspi->s_dirblksize = UFS_SECTOR_SIZE;
@@ -692,10 +712,22 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
                 uspi->s_fshift = 10;
                 uspi->s_sbsize = super_block_size = 2048;
                 uspi->s_sbbase = 0;
-                uspi->s_maxsymlinklen = 56;
+                uspi->s_maxsymlinklen = 0; /* Not supported on disk */
                 flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUN | UFS_CG_SUN;
                 break;
 
+        case UFS_MOUNT_UFSTYPE_SUNOS:
+                UFSD(("ufstype=sunos\n"))
+                uspi->s_fsize = block_size = 1024;
+                uspi->s_fmask = ~(1024 - 1);
+                uspi->s_fshift = 10;
+                uspi->s_sbsize = 2048;
+                super_block_size = 2048;
+                uspi->s_sbbase = 0;
+                uspi->s_maxsymlinklen = 0; /* Not supported on disk */
+                flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_SUNOS | UFS_CG_SUN;
+                break;
+
         case UFS_MOUNT_UFSTYPE_SUNx86:
                 UFSD("ufstype=sunx86\n");
                 uspi->s_fsize = block_size = 1024;
@@ -703,7 +735,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
                 uspi->s_fshift = 10;
                 uspi->s_sbsize = super_block_size = 2048;
                 uspi->s_sbbase = 0;
-                uspi->s_maxsymlinklen = 56;
+                uspi->s_maxsymlinklen = 0; /* Not supported on disk */
                 flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUNx86 | UFS_CG_SUN;
                 break;
 
@@ -805,11 +837,18 @@ again:
         if (!ubh) 
             goto failed;
 
-        
         usb1 = ubh_get_usb_first(uspi);
         usb2 = ubh_get_usb_second(uspi);
         usb3 = ubh_get_usb_third(uspi);
 
+        /* Sort out mod used on SunOS 4.1.3 for fs_state */
+        uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);
+        if (((flags & UFS_ST_MASK) == UFS_ST_SUNOS) &&
+            (uspi->s_postblformat != UFS_42POSTBLFMT)) {
+                flags &= ~UFS_ST_MASK;
+                flags |=  UFS_ST_SUN;
+        }
+
         /*
          * Check ufs magic number
          */
@@ -894,18 +933,20 @@ magic_found:
                 goto again;
         }
 
-        sbi->s_flags = flags;/*after that line some functions use s_flags*/
+        /* Set sbi->s_flags here, used by ufs_get_fs_state() below */
+        sbi->s_flags = flags;
         ufs_print_super_stuff(sb, usb1, usb2, usb3);
 
         /*
          * Check, if file system was correctly unmounted.
          * If not, make it read only.
          */
-        if (((flags & UFS_ST_MASK) == UFS_ST_44BSD) ||
-          ((flags & UFS_ST_MASK) == UFS_ST_OLD) ||
-          (((flags & UFS_ST_MASK) == UFS_ST_SUN || 
-          (flags & UFS_ST_MASK) == UFS_ST_SUNx86) && 
-          (ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {
+        if ((((flags & UFS_ST_MASK) == UFS_ST_44BSD)    ||
+             ((flags & UFS_ST_MASK) == UFS_ST_OLD)      ||
+             ((flags & UFS_ST_MASK) == UFS_ST_SUN)      ||
+             ((flags & UFS_ST_MASK) == UFS_ST_SUNOS)    ||
+             ((flags & UFS_ST_MASK) == UFS_ST_SUNx86))  &&
+            (ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time)))) {
                 switch(usb1->fs_clean) {
                 case UFS_FSCLEAN:
                         UFSD("fs is clean\n");
@@ -995,7 +1036,6 @@ magic_found:
         uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_contigsumsize);
         uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);
         uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);
-        uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);
         uspi->s_nrpos = fs32_to_cpu(sb, usb3->fs_nrpos);
         uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);
         uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);
@@ -1077,6 +1117,7 @@ static void ufs_write_super(struct super_block *sb)
         if (!(sb->s_flags & MS_RDONLY)) {
                 usb1->fs_time = cpu_to_fs32(sb, get_seconds());
                 if ((flags & UFS_ST_MASK) == UFS_ST_SUN 
+                  || (flags & UFS_ST_MASK) == UFS_ST_SUNOS
                   || (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
                         ufs_set_fs_state(sb, usb1, usb3,
                                         UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
@@ -1146,6 +1187,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
                 ufs_put_super_internal(sb);
                 usb1->fs_time = cpu_to_fs32(sb, get_seconds());
                 if ((flags & UFS_ST_MASK) == UFS_ST_SUN
+                  || (flags & UFS_ST_MASK) == UFS_ST_SUNOS
                   || (flags & UFS_ST_MASK) == UFS_ST_SUNx86) 
                         ufs_set_fs_state(sb, usb1, usb3,
                                 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
@@ -1162,6 +1204,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
                 return -EINVAL;
 #else
                 if (ufstype != UFS_MOUNT_UFSTYPE_SUN && 
+                    ufstype != UFS_MOUNT_UFSTYPE_SUNOS &&
                     ufstype != UFS_MOUNT_UFSTYPE_44BSD &&
                     ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&
                     ufstype != UFS_MOUNT_UFSTYPE_UFS2) {
@@ -1179,6 +1222,26 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
         return 0;
 }
 
+static int ufs_show_options(struct seq_file *seq, struct vfsmount *vfs)
+{
+        struct ufs_sb_info *sbi = UFS_SB(vfs->mnt_sb);
+        unsigned mval = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;
+        struct match_token *tp = tokens;
+
+        while (tp->token != Opt_onerror_panic && tp->token != mval)
+                ++tp;
+        BUG_ON(tp->token == Opt_onerror_panic);
+        seq_printf(seq, ",%s", tp->pattern);
+
+        mval = sbi->s_mount_opt & UFS_MOUNT_ONERROR;
+        while (tp->token != Opt_err && tp->token != mval)
+                ++tp;
+        BUG_ON(tp->token == Opt_err);
+        seq_printf(seq, ",%s", tp->pattern);
+
+        return 0;
+}
+
 static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
         struct super_block *sb = dentry->d_sb;
@@ -1232,7 +1295,7 @@ static void ufs_destroy_inode(struct inode *inode)
         kmem_cache_free(ufs_inode_cachep, UFS_I(inode));
 }
 
-static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
+static void init_once(struct kmem_cache * cachep, void *foo)
 {
         struct ufs_inode_info *ei = (struct ufs_inode_info *) foo;
 
@@ -1271,6 +1334,7 @@ static const struct super_operations ufs_super_ops = {
         .write_super    = ufs_write_super,
         .statfs         = ufs_statfs,
         .remount_fs     = ufs_remount,
+        .show_options   = ufs_show_options,
 #ifdef CONFIG_QUOTA
         .quota_read     = ufs_quota_read,
         .quota_write    = ufs_quota_write,
diff --git a/fs/ufs/symlink.c b/fs/ufs/symlink.c
index d8549f807e..43ac10e75a 100644
--- a/fs/ufs/symlink.c
+++ b/fs/ufs/symlink.c
@@ -28,6 +28,8 @@
 #include <linux/fs.h>
 #include <linux/namei.h>
 #include <linux/ufs_fs.h>
+#include "ufs.h"
+
 
 static void *ufs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
diff --git a/fs/ufs/truncate.c b/fs/ufs/truncate.c
index 79c54c85fb..311ded34c2 100644
--- a/fs/ufs/truncate.c
+++ b/fs/ufs/truncate.c
@@ -46,6 +46,7 @@
 #include <linux/blkdev.h>
 #include <linux/sched.h>
 
+#include "ufs.h"
 #include "swab.h"
 #include "util.h"
 
diff --git a/fs/ufs/ufs.h b/fs/ufs/ufs.h
new file mode 100644
index 0000000000..7faa4cd71a
--- /dev/null
+++ b/fs/ufs/ufs.h
@@ -0,0 +1,157 @@
+#ifndef _UFS_UFS_H
+#define _UFS_UFS_H 1
+
+#define UFS_MAX_GROUP_LOADED 8
+#define UFS_CGNO_EMPTY ((unsigned)-1)
+
+struct ufs_sb_private_info;
+struct ufs_cg_private_info;
+struct ufs_csum;
+
+struct ufs_sb_info {
+        struct ufs_sb_private_info * s_uspi;
+        struct ufs_csum * s_csp;
+        unsigned s_bytesex;
+        unsigned s_flags;
+        struct buffer_head ** s_ucg;
+        struct ufs_cg_private_info * s_ucpi[UFS_MAX_GROUP_LOADED];
+        unsigned s_cgno[UFS_MAX_GROUP_LOADED];
+        unsigned short s_cg_loaded;
+        unsigned s_mount_opt;
+};
+
+struct ufs_inode_info {
+        union {
+                __fs32  i_data[15];
+                __u8    i_symlink[4*15];
+                __fs64  u2_i_data[15];
+        } i_u1;
+        __u32   i_flags;
+        __u32   i_shadow;
+        __u32   i_unused1;
+        __u32   i_unused2;
+        __u32   i_oeftflag;
+        __u16   i_osync;
+        __u64   i_lastfrag;
+        __u32   i_dir_start_lookup;
+        struct inode vfs_inode;
+};
+
+/* mount options */
+#define UFS_MOUNT_ONERROR               0x0000000F
+#define UFS_MOUNT_ONERROR_PANIC         0x00000001
+#define UFS_MOUNT_ONERROR_LOCK          0x00000002
+#define UFS_MOUNT_ONERROR_UMOUNT        0x00000004
+#define UFS_MOUNT_ONERROR_REPAIR        0x00000008
+
+#define UFS_MOUNT_UFSTYPE               0x0000FFF0
+#define UFS_MOUNT_UFSTYPE_OLD           0x00000010
+#define UFS_MOUNT_UFSTYPE_44BSD         0x00000020
+#define UFS_MOUNT_UFSTYPE_SUN           0x00000040
+#define UFS_MOUNT_UFSTYPE_NEXTSTEP      0x00000080
+#define UFS_MOUNT_UFSTYPE_NEXTSTEP_CD   0x00000100
+#define UFS_MOUNT_UFSTYPE_OPENSTEP      0x00000200
+#define UFS_MOUNT_UFSTYPE_SUNx86        0x00000400
+#define UFS_MOUNT_UFSTYPE_HP            0x00000800
+#define UFS_MOUNT_UFSTYPE_UFS2          0x00001000
+#define UFS_MOUNT_UFSTYPE_SUNOS         0x00002000
+
+#define ufs_clear_opt(o,opt)    o &= ~UFS_MOUNT_##opt
+#define ufs_set_opt(o,opt)      o |= UFS_MOUNT_##opt
+#define ufs_test_opt(o,opt)     ((o) & UFS_MOUNT_##opt)
+
+/*
+ * Debug code
+ */
+#ifdef CONFIG_UFS_DEBUG
+#       define UFSD(f, a...)    {                                       \
+                printk ("UFSD (%s, %d): %s:",                           \
+                        __FILE__, __LINE__, __FUNCTION__);              \
+                printk (f, ## a);                                       \
+        }
+#else
+#       define UFSD(f, a...)    /**/
+#endif
+
+/* balloc.c */
+extern void ufs_free_fragments (struct inode *, u64, unsigned);
+extern void ufs_free_blocks (struct inode *, u64, unsigned);
+extern u64 ufs_new_fragments(struct inode *, void *, u64, u64,
+                             unsigned, int *, struct page *);
+
+/* cylinder.c */
+extern struct ufs_cg_private_info * ufs_load_cylinder (struct super_block *, unsigned);
+extern void ufs_put_cylinder (struct super_block *, unsigned);
+
+/* dir.c */
+extern const struct inode_operations ufs_dir_inode_operations;
+extern int ufs_add_link (struct dentry *, struct inode *);
+extern ino_t ufs_inode_by_name(struct inode *, struct dentry *);
+extern int ufs_make_empty(struct inode *, struct inode *);
+extern struct ufs_dir_entry *ufs_find_entry(struct inode *, struct dentry *, struct page **);
+extern int ufs_delete_entry(struct inode *, struct ufs_dir_entry *, struct page *);
+extern int ufs_empty_dir (struct inode *);
+extern struct ufs_dir_entry *ufs_dotdot(struct inode *, struct page **);
+extern void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
+                         struct page *page, struct inode *inode);
+
+/* file.c */
+extern const struct inode_operations ufs_file_inode_operations;
+extern const struct file_operations ufs_file_operations;
+
+extern const struct address_space_operations ufs_aops;
+
+/* ialloc.c */
+extern void ufs_free_inode (struct inode *inode);
+extern struct inode * ufs_new_inode (struct inode *, int);
+
+/* inode.c */
+extern void ufs_read_inode (struct inode *);
+extern void ufs_put_inode (struct inode *);
+extern int ufs_write_inode (struct inode *, int);
+extern int ufs_sync_inode (struct inode *);
+extern void ufs_delete_inode (struct inode *);
+extern struct buffer_head * ufs_bread (struct inode *, unsigned, int, int *);
+extern int ufs_getfrag_block (struct inode *inode, sector_t fragment, struct buffer_head *bh_result, int create);
+
+/* namei.c */
+extern const struct file_operations ufs_dir_operations;
+
+/* super.c */
+extern void ufs_warning (struct super_block *, const char *, const char *, ...) __attribute__ ((format (printf, 3, 4)));
+extern void ufs_error (struct super_block *, const char *, const char *, ...) __attribute__ ((format (printf, 3, 4)));
+extern void ufs_panic (struct super_block *, const char *, const char *, ...) __attribute__ ((format (printf, 3, 4)));
+
+/* symlink.c */
+extern const struct inode_operations ufs_fast_symlink_inode_operations;
+
+/* truncate.c */
+extern int ufs_truncate (struct inode *, loff_t);
+
+static inline struct ufs_sb_info *UFS_SB(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
+static inline struct ufs_inode_info *UFS_I(struct inode *inode)
+{
+        return container_of(inode, struct ufs_inode_info, vfs_inode);
+}
+
+/*
+ * Give cylinder group number for a file system block.
+ * Give cylinder group block number for a file system block.
+ */
+/* #define      ufs_dtog(d)     ((d) / uspi->s_fpg) */
+static inline u64 ufs_dtog(struct ufs_sb_private_info * uspi, u64 b)
+{
+        do_div(b, uspi->s_fpg);
+        return b;
+}
+/* #define      ufs_dtogd(d)    ((d) % uspi->s_fpg) */
+static inline u32 ufs_dtogd(struct ufs_sb_private_info * uspi, u64 b)
+{
+        return do_div(b, uspi->s_fpg);
+}
+
+#endif /* _UFS_UFS_H */
diff --git a/fs/ufs/util.c b/fs/ufs/util.c
index 84357f1ff0..410084dae3 100644
--- a/fs/ufs/util.c
+++ b/fs/ufs/util.c
@@ -11,6 +11,7 @@
 #include <linux/ufs_fs.h>
 #include <linux/buffer_head.h>
 
+#include "ufs.h"
 #include "swab.h"
 #include "util.h"
 
diff --git a/fs/ufs/util.h b/fs/ufs/util.h
index 79a340a190..b26fc4dec1 100644
--- a/fs/ufs/util.h
+++ b/fs/ufs/util.h
@@ -38,6 +38,10 @@ ufs_get_fs_state(struct super_block *sb, struct ufs_super_block_first *usb1,
                  struct ufs_super_block_third *usb3)
 {
         switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
+        case UFS_ST_SUNOS:
+                if (fs32_to_cpu(sb, usb3->fs_postblformat) == UFS_42POSTBLFMT)
+                        return fs32_to_cpu(sb, usb1->fs_u0.fs_sun.fs_state);
+                /* Fall Through to UFS_ST_SUN */
         case UFS_ST_SUN:
                 return fs32_to_cpu(sb, usb3->fs_un2.fs_sun.fs_state);
         case UFS_ST_SUNx86:
@@ -53,6 +57,12 @@ ufs_set_fs_state(struct super_block *sb, struct ufs_super_block_first *usb1,
                  struct ufs_super_block_third *usb3, s32 value)
 {
         switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
+        case UFS_ST_SUNOS:
+                if (fs32_to_cpu(sb, usb3->fs_postblformat == UFS_42POSTBLFMT)) {
+                        usb1->fs_u0.fs_sun.fs_state = cpu_to_fs32(sb, value);
+                        break;
+                }
+                /* Fall Through to UFS_ST_SUN */
         case UFS_ST_SUN:
                 usb3->fs_un2.fs_sun.fs_state = cpu_to_fs32(sb, value);
                 break;
@@ -81,6 +91,7 @@ ufs_get_fs_qbmask(struct super_block *sb, struct ufs_super_block_third *usb3)
         __fs64 tmp;
 
         switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
+        case UFS_ST_SUNOS:
         case UFS_ST_SUN:
                 ((__fs32 *)&tmp)[0] = usb3->fs_un2.fs_sun.fs_qbmask[0];
                 ((__fs32 *)&tmp)[1] = usb3->fs_un2.fs_sun.fs_qbmask[1];
@@ -104,6 +115,7 @@ ufs_get_fs_qfmask(struct super_block *sb, struct ufs_super_block_third *usb3)
         __fs64 tmp;
 
         switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
+        case UFS_ST_SUNOS:
         case UFS_ST_SUN:
                 ((__fs32 *)&tmp)[0] = usb3->fs_un2.fs_sun.fs_qfmask[0];
                 ((__fs32 *)&tmp)[1] = usb3->fs_un2.fs_sun.fs_qfmask[1];
@@ -179,10 +191,12 @@ static inline u32
 ufs_get_inode_uid(struct super_block *sb, struct ufs_inode *inode)
 {
         switch (UFS_SB(sb)->s_flags & UFS_UID_MASK) {
-        case UFS_UID_EFT:
-                return fs32_to_cpu(sb, inode->ui_u3.ui_sun.ui_uid);
         case UFS_UID_44BSD:
                 return fs32_to_cpu(sb, inode->ui_u3.ui_44.ui_uid);
+        case UFS_UID_EFT:
+                if (inode->ui_u1.oldids.ui_suid == 0xFFFF)
+                        return fs32_to_cpu(sb, inode->ui_u3.ui_sun.ui_uid);
+                /* Fall through */
         default:
                 return fs16_to_cpu(sb, inode->ui_u1.oldids.ui_suid);
         }
@@ -192,24 +206,31 @@ static inline void
 ufs_set_inode_uid(struct super_block *sb, struct ufs_inode *inode, u32 value)
 {
         switch (UFS_SB(sb)->s_flags & UFS_UID_MASK) {
-        case UFS_UID_EFT:
-                inode->ui_u3.ui_sun.ui_uid = cpu_to_fs32(sb, value);
-                break;
         case UFS_UID_44BSD:
                 inode->ui_u3.ui_44.ui_uid = cpu_to_fs32(sb, value);
+                inode->ui_u1.oldids.ui_suid = cpu_to_fs16(sb, value);
+                break;
+        case UFS_UID_EFT:
+                inode->ui_u3.ui_sun.ui_uid = cpu_to_fs32(sb, value);
+                if (value > 0xFFFF)
+                        value = 0xFFFF;
+                /* Fall through */
+        default:
+                inode->ui_u1.oldids.ui_suid = cpu_to_fs16(sb, value);
                 break;
         }
-        inode->ui_u1.oldids.ui_suid = cpu_to_fs16(sb, value); 
 }
 
 static inline u32
 ufs_get_inode_gid(struct super_block *sb, struct ufs_inode *inode)
 {
         switch (UFS_SB(sb)->s_flags & UFS_UID_MASK) {
-        case UFS_UID_EFT:
-                return fs32_to_cpu(sb, inode->ui_u3.ui_sun.ui_gid);
         case UFS_UID_44BSD:
                 return fs32_to_cpu(sb, inode->ui_u3.ui_44.ui_gid);
+        case UFS_UID_EFT:
+                if (inode->ui_u1.oldids.ui_suid == 0xFFFF)
+                        return fs32_to_cpu(sb, inode->ui_u3.ui_sun.ui_gid);
+                /* Fall through */
         default:
                 return fs16_to_cpu(sb, inode->ui_u1.oldids.ui_sgid);
         }
@@ -219,14 +240,19 @@ static inline void
 ufs_set_inode_gid(struct super_block *sb, struct ufs_inode *inode, u32 value)
 {
         switch (UFS_SB(sb)->s_flags & UFS_UID_MASK) {
-        case UFS_UID_EFT:
-                inode->ui_u3.ui_sun.ui_gid = cpu_to_fs32(sb, value);
-                break;
         case UFS_UID_44BSD:
                 inode->ui_u3.ui_44.ui_gid = cpu_to_fs32(sb, value);
+                inode->ui_u1.oldids.ui_sgid =  cpu_to_fs16(sb, value);
+                break;
+        case UFS_UID_EFT:
+                inode->ui_u3.ui_sun.ui_gid = cpu_to_fs32(sb, value);
+                if (value > 0xFFFF)
+                        value = 0xFFFF;
+                /* Fall through */
+        default:
+                inode->ui_u1.oldids.ui_sgid =  cpu_to_fs16(sb, value);
                 break;
         }
-        inode->ui_u1.oldids.ui_sgid =  cpu_to_fs16(sb, value);
 }
 
 extern dev_t ufs_get_inode_dev(struct super_block *, struct ufs_inode_info *);