root/fs/ufs/ufs_super.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

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

/* [previous][next][first][last][top][bottom][index][help] */