fs/ufs/ufs_super.c

/* */
This source file includes following definitions.
init_ufs_fs
ufs_print_super_stuff
ufs_read_super
ufs_put_super
ufs_statfs
   1 /*
   2  *  linux/fs/ufs/ufs_super.c
   3  *
   4  * Copyright (C) 1996
   5  * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
   6  * Laboratory for Computer Science Research Computing Facility
   7  * Rutgers, The State University of New Jersey
   8  *
   9  * $Id: ufs_super.c,v 1.1 1996/04/21 14:41:19 davem Exp $
  10  *
  11  */
  12 
  13 #include <linux/kernel.h>
  14 #include <linux/fs.h>
  15 #include <linux/ufs_fs.h>
  16 #include <linux/module.h>
  17 #include <linux/locks.h>
  18 
  19 #include <asm/segment.h>
  20 
  21 struct super_block * ufs_read_super(struct super_block * sb, void * data, int silent);
  22 void ufs_put_super (struct super_block * sb);
  23 void ufs_statfs(struct super_block * sb, struct statfs * buf, int bufsize);
  24 
  25 extern void ufs_read_inode(struct inode * inode);
  26 extern void ufs_put_inode(struct inode * inode);
  27 
  28 static struct super_operations ufs_super_ops = {
  29         &ufs_read_inode,
  30         NULL,                   /* notify_change() */
  31         NULL,                   /* XXX - ufs_write_inode() */
  32         &ufs_put_inode,
  33         &ufs_put_super,
  34         NULL,                   /* XXX - ufs_write_super() */
  35         &ufs_statfs,
  36         NULL,                   /* XXX - ufs_remount() */
  37 };
  38 
  39 static struct file_system_type ufs_fs_type = {
  40         &ufs_read_super, "ufs", 1, NULL
  41 };
  42 
  43 int
  44 init_ufs_fs(void)
     /*  */
  45 {
  46         return(register_filesystem(&ufs_fs_type));
  47 }
  48 
  49 static void
  50 ufs_print_super_stuff(struct super_block * sb, struct ufs_superblock * usb)
     /*  */
  51 {
  52 
  53         printk("fs_sblkno: 0x%8.8x\n", usb->fs_sblkno);
  54         printk("fs_size: 0x%8.8x\n", usb->fs_size);
  55         printk("fs_ncg: 0x%8.8x\n", usb->fs_ncg);
  56         printk("fs_bsize: 0x%8.8x\n", usb->fs_bsize);
  57         printk("fs_frag: 0x%8.8x\n", usb->fs_frag);
  58         printk("fs_nindir: 0x%8.8x\n", usb->fs_nindir);
  59         printk("fs_inopb: 0x%8.8x\n", usb->fs_inopb);
  60         printk("fs_optim: 0x%8.8x\n", usb->fs_optim);
  61         printk("fs_ncyl: 0x%8.8x\n", usb->fs_ncyl);
  62         printk("fs_state: 0x%8.8x\n", usb->fs_state);
  63         printk("fs_magic: 0x%8.8x\n", usb->fs_magic);
  64         printk("fs_fsmnt: `%s'\n", usb->fs_fsmnt);
  65 
  66         return;
  67 }
  68 
  69 struct super_block *
  70 ufs_read_super(struct super_block * sb, void * data, int silent)
     /*  */
  71 {
  72         struct ufs_superblock * usb;
  73         struct buffer_head * bh1, *bh2;
  74 
  75         /* sb->s_dev and sb->s_flags are set by our caller
  76          * data is the mystery argument to sys_mount()
  77          *
  78          * Our caller also sets s_dev, s_covered, s_rd_only, s_dirt,
  79          *   and s_type when we return.
  80          */
  81 
  82         lock_super (sb);
  83 
  84         /* XXX - make everything read only for testing */
  85         sb->s_flags |= MS_RDONLY;
  86 
  87         if (!(bh1 = bread(sb->s_dev, UFS_SBLOCK/BLOCK_SIZE, BLOCK_SIZE)) ||
  88             !(bh2 = bread(sb->s_dev, (UFS_SBLOCK + BLOCK_SIZE)/BLOCK_SIZE,
  89                           BLOCK_SIZE))) {
  90                 sb->s_dev = 0;
  91                 unlock_super (sb);
  92                 if (bh1) {
  93                         brelse(bh1);
  94                 }
  95                 printk ("ufs_read_super: unable to read superblock\n");
  96 
  97                 return 0;
  98         }
  99         /* XXX - redo this so we can free it later... */
 100         usb = (struct ufs_superblock *)__get_free_page(GFP_KERNEL); 
 101         if (usb == NULL) {
 102                 printk ("ufs_read_super: get_free_page() failed\n");
 103         }
 104 
 105         memcpy((char *)usb, bh1->b_data, BLOCK_SIZE);
 106         memcpy((char *)usb + BLOCK_SIZE, bh2->b_data,
 107                sizeof(struct ufs_superblock) - BLOCK_SIZE);
 108 
 109         brelse(bh1);
 110         brelse(bh2);
 111 
 112         if (usb->fs_magic != UFS_MAGIC) {
 113                 /* XXX - replace hard-coded constant with a byte-swap macro */
 114                 if (usb->fs_magic == 0x54190100) {
 115                         printk ("ufs_read_super: can't grok byteswapped fs on dev %d/%d\n",
 116                                 MAJOR(sb->s_dev), MINOR(sb->s_dev));
 117                         silent = 1;
 118                 }
 119                 sb->s_dev = 0;
 120                 unlock_super (sb);
 121                 if (!silent)
 122                         printk ("ufs_read_super: bad magic number 0x%8.8x on dev %d/%d\n",
 123                                 usb->fs_magic, MAJOR(sb->s_dev),
 124                                 MINOR(sb->s_dev));
 125                 return(NULL);
 126         }
 127 
 128         /* We found a UFS filesystem on this device. */
 129 
 130         /* XXX - parse args */
 131 
 132         if (usb->fs_bsize != UFS_BSIZE) {
 133                 printk("ufs_read_super: fs_bsize %d != %d\n", usb->fs_bsize,
 134                        UFS_BSIZE);
 135                 goto ufs_read_super_lose;
 136         }
 137 
 138         if (usb->fs_fsize != UFS_FSIZE) {
 139                 printk("ufs_read_super: fs_fsize %d != %d\n", usb->fs_fsize,
 140                        UFS_FSIZE);
 141                 goto ufs_read_super_lose;
 142         }
 143 
 144         if (usb->fs_nindir != UFS_NINDIR) {
 145                 printk("ufs_read_super: fs_nindir %d != %d\n", usb->fs_nindir,
 146                        UFS_NINDIR);
 147                 printk("ufs_read_super: fucking Sun blows me\n");
 148         }
 149 
 150         printk("ufs_read_super: fs last mounted on \"%s\"\n", usb->fs_fsmnt);
 151 
 152         if (usb->fs_state == UFS_FSOK - usb->fs_time) {
 153                 switch(usb->fs_clean) {
 154                         case UFS_FSCLEAN:
 155                           printk("ufs_read_super: fs is clean\n");
 156                           break;
 157                         case UFS_FSSTABLE:
 158                           printk("ufs_read_super: fs is stable\n");
 159                           break;
 160                         case UFS_FSACTIVE:
 161                           printk("ufs_read_super: fs is active\n");
 162                           sb->s_flags |= MS_RDONLY;
 163                           break;
 164                         case UFS_FSBAD:
 165                           printk("ufs_read_super: fs is bad\n");
 166                           sb->s_flags |= MS_RDONLY;
 167                           break;
 168                         default:
 169                           printk("ufs_read_super: can't grok fs_clean 0x%x\n",
 170                                  usb->fs_clean);
 171                           sb->s_flags |= MS_RDONLY;
 172                           break;
 173                 }
 174         } else {
 175                 printk("ufs_read_super: fs needs fsck\n");
 176                 sb->s_flags |= MS_RDONLY;
 177                 /* XXX - make it read only or barf if it's not (/, /usr) */
 178         }
 179 
 180         /* XXX - sanity check sb fields */
 181 
 182         sb->s_blocksize = usb->fs_fsize;
 183         sb->s_blocksize_bits = 10;  /* XXX */
 184         /* XXX - sb->s_lock */
 185         sb->s_op = &ufs_super_ops;
 186         sb->dq_op = 0; /* XXX */
 187         sb->s_magic = usb->fs_magic;
 188         /* sb->s_time */
 189         /* sb->s_wait */
 190         /* XXX - sb->u.ufs_sb */
 191         sb->u.ufs_sb.s_raw_sb = usb; /* XXX - maybe move this to the top */
 192         sb->u.ufs_sb.s_flags = 0;
 193         sb->u.ufs_sb.s_ncg = usb->fs_ncg;
 194         sb->u.ufs_sb.s_ipg = usb->fs_ipg;
 195         sb->u.ufs_sb.s_fpg = usb->fs_fpg;
 196         sb->u.ufs_sb.s_fsize = usb->fs_fsize;
 197         sb->u.ufs_sb.s_bsize = usb->fs_bsize;
 198         sb->u.ufs_sb.s_iblkno = usb->fs_iblkno;
 199         sb->u.ufs_sb.s_dblkno = usb->fs_dblkno;
 200         sb->u.ufs_sb.s_cgoffset = usb->fs_cgoffset;
 201         sb->u.ufs_sb.s_cgmask = usb->fs_cgmask;
 202         sb->u.ufs_sb.s_inopb = usb->fs_inopb;
 203         sb->u.ufs_sb.s_fsfrag = usb->fs_frag; /* XXX - rename this later */
 204         sb->s_mounted = iget(sb, UFS_ROOTINO);
 205 
 206         printk("ufs_read_super: inopb %lu\n", sb->u.ufs_sb.s_inopb);
 207         /*
 208          * XXX - read cg structs?
 209          */
 210 
 211         unlock_super(sb);
 212         return(sb);
 213 
 214        ufs_read_super_lose:
 215         /* XXX - clean up */
 216         return(0);
 217 }
 218 
 219 void ufs_put_super (struct super_block * sb)
     /*  */
 220 {
 221 
 222         printk("ufs_put_super\n"); /* XXX */
 223 
 224         lock_super (sb);
 225         /* XXX - sync fs data, set state to ok, and flush buffers */
 226         sb->s_dev = 0;
 227 
 228         /* XXX - free allocated kernel memory */
 229 
 230         unlock_super (sb);
 231         MOD_DEC_USE_COUNT;
 232 
 233         return;
 234 }
 235 
 236 void ufs_statfs(struct super_block * sb, struct statfs * buf, int bufsiz)
     /*  */
 237 {
 238         struct statfs tmp;
 239 
 240         printk("ufs_statfs\n"); /* XXX */
 241         tmp.f_type = sb->s_magic;
 242         tmp.f_bsize = PAGE_SIZE;
 243         tmp.f_blocks = sb->u.ufs_sb.s_raw_sb->fs_dsize;
 244         tmp.f_bfree = sb->u.ufs_sb.s_raw_sb->fs_cstotal.cs_nbfree;
 245         tmp.f_bavail =  sb->u.ufs_sb.s_raw_sb->fs_cstotal.cs_nbfree; /* XXX */
 246         tmp.f_files = sb->u.ufs_sb.s_ncg * sb->u.ufs_sb.s_ipg;
 247         tmp.f_ffree = sb->u.ufs_sb.s_raw_sb->fs_cstotal.cs_nifree;
 248         tmp.f_fsid.val[0] = sb->u.ufs_sb.s_raw_sb->fs_id[0];
 249         tmp.f_fsid.val[1] = sb->u.ufs_sb.s_raw_sb->fs_id[1];
 250         tmp.f_namelen = MAXNAMLEN;
 251 /*        tmp.f_spare[6] */
 252 
 253         memcpy_tofs(buf, &tmp, bufsiz);
 254 
 255         return;
 256 }
 257 
 258 
 259 /*
 260  * Local Variables: ***
 261  * c-indent-level: 8 ***
 262  * c-continued-statement-offset: 8 ***
 263  * c-brace-offset: -8 ***
 264  * c-argdecl-indent: 0 ***
 265  * c-label-offset: -8 ***
 266  * End: ***
 267  */
/* */
root/fs/ufs/ufs_super.c

DEFINITIONS
