home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.2 / LINUX-1.2 / LINUX-1 / linux / fs / sysv / inode.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-23  |  27.6 KB  |  1,004 lines
  1. /*
  2.  *  linux/fs/sysv/inode.c
  3.  *
  4.  *  minix/inode.c
  5.  *  Copyright (C) 1991, 1992  Linus Torvalds
  6.  *
  7.  *  xenix/inode.c
  8.  *  Copyright (C) 1992  Doug Evans
  9.  *
  10.  *  coh/inode.c
  11.  *  Copyright (C) 1993  Pascal Haible, Bruno Haible
  12.  *
  13.  *  sysv/inode.c
  14.  *  Copyright (C) 1993  Paul B. Monday
  15.  *
  16.  *  sysv/inode.c
  17.  *  Copyright (C) 1993  Bruno Haible
  18.  *
  19.  *  This file contains code for allocating/freeing inodes and for read/writing
  20.  *  the superblock.
  21.  */
  22.  
  23. #ifdef MODULE
  24. #include <linux/module.h>
  25. #include <linux/version.h>
  26. #else
  27. #define MOD_INC_USE_COUNT
  28. #define MOD_DEC_USE_COUNT
  29. #endif
  30.  
  31. #include <linux/sched.h>
  32. #include <linux/kernel.h>
  33. #include <linux/fs.h>
  34. #include <linux/sysv_fs.h>
  35. #include <linux/stat.h>
  36. #include <linux/string.h>
  37. #include <linux/locks.h>
  38.  
  39. #include <asm/segment.h>
  40.  
  41. void sysv_put_inode(struct inode *inode)
  42. {
  43.     if (inode->i_nlink)
  44.         return;
  45.     inode->i_size = 0;
  46.     sysv_truncate(inode);
  47.     sysv_free_inode(inode);
  48. }
  49.  
  50.  
  51. static struct super_operations sysv_sops = { 
  52.     sysv_read_inode,
  53.     sysv_notify_change,
  54.     sysv_write_inode,
  55.     sysv_put_inode,
  56.     sysv_put_super,
  57.     sysv_write_super,
  58.     sysv_statfs,
  59.     NULL
  60. };
  61.  
  62. /* The following functions try to recognize specific filesystems.
  63.  * We recognize:
  64.  * - Xenix FS by its magic number.
  65.  * - SystemV FS by its magic number.
  66.  * - Coherent FS by its funny fname/fpack field.
  67.  * We discriminate among SystemV4 and SystemV2 FS by the assumption that
  68.  * the time stamp is not < 01-01-1980.
  69.  */
  70.  
  71. static void detected_bs512 (struct super_block *sb)
  72. {
  73.     sb->sv_block_size = 512;
  74.     sb->sv_block_size_1 = 512-1;
  75.     sb->sv_block_size_bits = 9;
  76.     sb->sv_block_size_ratio = 2;
  77.     sb->sv_block_size_ratio_bits = 1;
  78.     sb->sv_inodes_per_block = 512/64;
  79.     sb->sv_inodes_per_block_1 = 512/64-1;
  80.     sb->sv_inodes_per_block_bits = 9-6;
  81.     sb->sv_toobig_block = 10 + 
  82.       (sb->sv_ind_per_block = 512/4) +
  83.       (sb->sv_ind_per_block_2 = (512/4)*(512/4)) +
  84.       (sb->sv_ind_per_block_3 = (512/4)*(512/4)*(512/4));
  85.     sb->sv_ind_per_block_1 = 512/4-1;
  86.     sb->sv_ind_per_block_2_1 = (512/4)*(512/4)-1;
  87.     sb->sv_ind_per_block_2_bits = 2 *
  88.       (sb->sv_ind_per_block_bits = 9-2);
  89.     sb->sv_ind_per_block_block_size_1 = (512/4)*512-1;
  90.     sb->sv_ind_per_block_block_size_bits = (9-2)+9;
  91.     sb->sv_ind_per_block_2_block_size_1 = (512/4)*(512/4)*512-1;
  92.     sb->sv_ind_per_block_2_block_size_bits = (9-2)+(9-2)+9;
  93.     sb->sv_ind0_size = 10 * 512;
  94.     sb->sv_ind1_size = (10 + (512/4))* 512;
  95.     sb->sv_ind2_size = (10 + (512/4) + (512/4)*(512/4)) * 512;
  96. }
  97.  
  98. static void detected_bs1024 (struct super_block *sb)
  99. {
  100.     sb->sv_block_size = 1024;
  101.     sb->sv_block_size_1 = 1024-1;
  102.     sb->sv_block_size_bits = 10;
  103.     sb->sv_block_size_ratio = 1;
  104.     sb->sv_block_size_ratio_bits = 0;
  105.     sb->sv_inodes_per_block = 1024/64;
  106.     sb->sv_inodes_per_block_1 = 1024/64-1;
  107.     sb->sv_inodes_per_block_bits = 10-6;
  108.     sb->sv_toobig_block = 10 + 
  109.       (sb->sv_ind_per_block = 1024/4) +
  110.       (sb->sv_ind_per_block_2 = (1024/4)*(1024/4)) +
  111.       (sb->sv_ind_per_block_3 = (1024/4)*(1024/4)*(1024/4));
  112.     sb->sv_ind_per_block_1 = 1024/4-1;
  113.     sb->sv_ind_per_block_2_1 = (1024/4)*(1024/4)-1;
  114.     sb->sv_ind_per_block_2_bits = 2 *
  115.       (sb->sv_ind_per_block_bits = 10-2);
  116.     sb->sv_ind_per_block_block_size_1 = (1024/4)*1024-1;
  117.     sb->sv_ind_per_block_block_size_bits = (10-2)+10;
  118.     sb->sv_ind_per_block_2_block_size_1 = (1024/4)*(1024/4)*1024-1;
  119.     sb->sv_ind_per_block_2_block_size_bits = (10-2)+(10-2)+10;
  120.     sb->sv_ind0_size = 10 * 1024;
  121.     sb->sv_ind1_size = (10 + (1024/4))* 1024;
  122.     sb->sv_ind2_size = (10 + (1024/4) + (1024/4)*(1024/4)) * 1024;
  123. }
  124.  
  125. static const char* detect_xenix (struct super_block *sb, struct buffer_head *bh)
  126. {
  127.     struct xenix_super_block * sbd;
  128.  
  129.     sbd = (struct xenix_super_block *) bh->b_data;
  130.     if (sbd->s_magic != 0x2b5544)
  131.         return NULL;
  132.     switch (sbd->s_type) {
  133.         case 1: detected_bs512(sb); break;
  134.         case 2: detected_bs1024(sb); break;
  135.         default: return NULL;
  136.     }
  137.     sb->sv_type = FSTYPE_XENIX;
  138.     return "Xenix";
  139. }
  140. static struct super_block * detected_xenix (struct super_block *sb, struct buffer_head *bh1, struct buffer_head *bh2)
  141. {
  142.     struct xenix_super_block * sbd1;
  143.     struct xenix_super_block * sbd2;
  144.  
  145.     if (sb->sv_block_size == BLOCK_SIZE)
  146.         /* block size = 1024, so bh1 = bh2 */
  147.         sbd1 = sbd2 = (struct xenix_super_block *) bh1->b_data;
  148.     else {
  149.         /* block size = 512, so bh1 != bh2 */
  150.         sbd1 = (struct xenix_super_block *) bh1->b_data;
  151.         sbd2 = (struct xenix_super_block *) (bh2->b_data - BLOCK_SIZE/2);
  152.         /* sanity check */
  153.         if (sbd2->s_magic != 0x2b5544)
  154.             return NULL;
  155.     }
  156.  
  157.     sb->sv_convert = 0;
  158.     sb->sv_kludge_symlinks = 1;
  159.     sb->sv_truncate = 1;
  160.     sb->sv_link_max = XENIX_LINK_MAX;
  161.     sb->sv_fic_size = XENIX_NICINOD;
  162.     sb->sv_flc_size = XENIX_NICFREE;
  163.     sb->sv_bh1 = bh1;
  164.     sb->sv_bh2 = bh2;
  165.     sb->sv_sbd1 = (char *) sbd1;
  166.     sb->sv_sbd2 = (char *) sbd2;
  167.     sb->sv_sb_fic_count = &sbd1->s_ninode;
  168.     sb->sv_sb_fic_inodes = &sbd1->s_inode[0];
  169.     sb->sv_sb_total_free_inodes = &sbd2->s_tinode;
  170.     sb->sv_sb_flc_count = &sbd1->s_nfree;
  171.     sb->sv_sb_flc_blocks = &sbd1->s_free[0];
  172.     sb->sv_sb_total_free_blocks = &sbd2->s_tfree;
  173.     sb->sv_sb_time = &sbd2->s_time;
  174.     sb->sv_block_base = 0;
  175.     sb->sv_firstinodezone = 2;
  176.     sb->sv_firstdatazone = sbd1->s_isize;
  177.     sb->sv_nzones = sbd1->s_fsize;
  178.     sb->sv_ndatazones = sb->sv_nzones - sb->sv_firstdatazone;
  179.     return sb;
  180. }
  181.  
  182. static const char* detect_sysv4 (struct super_block *sb, struct buffer_head *bh)
  183. {
  184.     struct sysv4_super_block * sbd;
  185.  
  186.     sbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2);
  187.     if (sbd->s_magic != 0xfd187e20)
  188.         return NULL;
  189.     if (sbd->s_time < 315532800) /* this is likely to happen on SystemV2 FS */
  190.         return NULL;
  191.     switch (sbd->s_type) {
  192.         case 1: detected_bs512(sb); break;
  193.         case 2: detected_bs1024(sb); break;
  194.         default: return NULL;
  195.     }
  196.     sb->sv_type = FSTYPE_SYSV4;
  197.     return "SystemV";
  198. }
  199. static struct super_block * detected_sysv4 (struct super_block *sb, struct buffer_head *bh)
  200. {
  201.     struct sysv4_super_block * sbd;
  202.  
  203.     if (sb->sv_block_size == BLOCK_SIZE)
  204.         sbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2);
  205.     else {
  206.         sbd = (struct sysv4_super_block *) bh->b_data;
  207.         /* sanity check */
  208.         if (sbd->s_magic != 0xfd187e20)
  209.             return NULL;
  210.         if (sbd->s_time < 315532800)
  211.             return NULL;
  212.     }
  213.  
  214.     sb->sv_convert = 0;
  215.     sb->sv_kludge_symlinks = 0; /* ?? */
  216.     sb->sv_truncate = 1;
  217.     sb->sv_link_max = SYSV_LINK_MAX;
  218.     sb->sv_fic_size = SYSV_NICINOD;
  219.     sb->sv_flc_size = SYSV_NICFREE;
  220.     sb->sv_bh1 = bh;
  221.     sb->sv_bh2 = bh;
  222.     sb->sv_sbd1 = (char *) sbd;
  223.     sb->sv_sbd2 = (char *) sbd;
  224.     sb->sv_sb_fic_count = &sbd->s_ninode;
  225.     sb->sv_sb_fic_inodes = &sbd->s_inode[0];
  226.     sb->sv_sb_total_free_inodes = &sbd->s_tinode;
  227.     sb->sv_sb_flc_count = &sbd->s_nfree;
  228.     sb->sv_sb_flc_blocks = &sbd->s_free[0];
  229.     sb->sv_sb_total_free_blocks = &sbd->s_tfree;
  230.     sb->sv_sb_time = &sbd->s_time;
  231.     sb->sv_sb_state = &sbd->s_state;
  232.     sb->sv_block_base = 0;
  233.     sb->sv_firstinodezone = 2;
  234.     sb->sv_firstdatazone = sbd->s_isize;
  235.     sb->sv_nzones = sbd->s_fsize;
  236.     sb->sv_ndatazones = sb->sv_nzones - sb->sv_firstdatazone;
  237.     return sb;
  238. }
  239.  
  240. static const char* detect_sysv2 (struct super_block *sb, struct buffer_head *bh)
  241. {
  242.     struct sysv2_super_block * sbd;
  243.  
  244.     sbd = (struct sysv2_super_block *) (bh->b_data + BLOCK_SIZE/2);
  245.     if (sbd->s_magic != 0xfd187e20)
  246.         return NULL;
  247.     if (sbd->s_time < 315532800) /* this is likely to happen on SystemV4 FS */
  248.         return NULL;
  249.     switch (sbd->s_type) {
  250.         case 1: detected_bs512(sb); break;
  251.         case 2: detected_bs1024(sb); break;
  252.         default: return NULL;
  253.     }
  254.     sb->sv_type = FSTYPE_SYSV2;
  255.     return "SystemV Release 2";
  256. }
  257. static struct super_block * detected_sysv2 (struct super_block *sb, struct buffer_head *bh)
  258. {
  259.     struct sysv2_super_block * sbd;
  260.  
  261.     if (sb->sv_block_size == BLOCK_SIZE)
  262.         sbd = (struct sysv2_super_block *) (bh->b_data + BLOCK_SIZE/2);
  263.     else {
  264.         sbd = (struct sysv2_super_block *) bh->b_data;
  265.         /* sanity check */
  266.         if (sbd->s_magic != 0xfd187e20)
  267.             return NULL;
  268.         if (sbd->s_time < 315532800)
  269.             return NULL;
  270.     }
  271.  
  272.     sb->sv_convert = 0;
  273.     sb->sv_kludge_symlinks = 0; /* ?? */
  274.     sb->sv_truncate = 1;
  275.     sb->sv_link_max = SYSV_LINK_MAX;
  276.     sb->sv_fic_size = SYSV_NICINOD;
  277.     sb->sv_flc_size = SYSV_NICFREE;
  278.     sb->sv_bh1 = bh;
  279.     sb->sv_bh2 = bh;
  280.     sb->sv_sbd1 = (char *) sbd;
  281.     sb->sv_sbd2 = (char *) sbd;
  282.     sb->sv_sb_fic_count = &sbd->s_ninode;
  283.     sb->sv_sb_fic_inodes = &sbd->s_inode[0];
  284.     sb->sv_sb_total_free_inodes = &sbd->s_tinode;
  285.     sb->sv_sb_flc_count = &sbd->s_nfree;
  286.     sb->sv_sb_flc_blocks = &sbd->s_free[0];
  287.     sb->sv_sb_total_free_blocks = &sbd->s_tfree;
  288.     sb->sv_sb_time = &sbd->s_time;
  289.     sb->sv_sb_state = &sbd->s_state;
  290.     sb->sv_block_base = 0;
  291.     sb->sv_firstinodezone = 2;
  292.     sb->sv_firstdatazone = sbd->s_isize;
  293.     sb->sv_nzones = sbd->s_fsize;
  294.     sb->sv_ndatazones = sb->sv_nzones - sb->sv_firstdatazone;
  295.     return sb;
  296. }
  297.  
  298. static const char* detect_coherent (struct super_block *sb, struct buffer_head *bh)
  299. {
  300.     struct coh_super_block * sbd;
  301.  
  302.     sbd = (struct coh_super_block *) (bh->b_data + BLOCK_SIZE/2);
  303.     if ((memcmp(sbd->s_fname,"noname",6) && memcmp(sbd->s_fname,"xxxxx ",6))
  304.         || (memcmp(sbd->s_fpack,"nopack",6) && memcmp(sbd->s_fpack,"xxxxx\n",6)))
  305.         return NULL;
  306.     detected_bs512(sb);
  307.     sb->sv_type = FSTYPE_COH;
  308.     return "Coherent";
  309. }
  310. static struct super_block * detected_coherent (struct super_block *sb, struct buffer_head *bh)
  311. {
  312.     struct coh_super_block * sbd;
  313.  
  314.     sbd = (struct coh_super_block *) bh->b_data;
  315.     /* sanity check */
  316.     if ((memcmp(sbd->s_fname,"noname",6) && memcmp(sbd->s_fname,"xxxxx ",6))
  317.         || (memcmp(sbd->s_fpack,"nopack",6) && memcmp(sbd->s_fpack,"xxxxx\n",6)))
  318.         return NULL;
  319.  
  320.     sb->sv_convert = 1;
  321.     sb->sv_kludge_symlinks = 1;
  322.     sb->sv_truncate = 1;
  323.     sb->sv_link_max = COH_LINK_MAX;
  324.     sb->sv_fic_size = COH_NICINOD;
  325.     sb->sv_flc_size = COH_NICFREE;
  326.     sb->sv_bh1 = bh;
  327.     sb->sv_bh2 = bh;
  328.     sb->sv_sbd1 = (char *) sbd;
  329.     sb->sv_sbd2 = (char *) sbd;
  330.     sb->sv_sb_fic_count = &sbd->s_ninode;
  331.     sb->sv_sb_fic_inodes = &sbd->s_inode[0];
  332.     sb->sv_sb_total_free_inodes = &sbd->s_tinode;
  333.     sb->sv_sb_flc_count = &sbd->s_nfree;
  334.     sb->sv_sb_flc_blocks = &sbd->s_free[0];
  335.     sb->sv_sb_total_free_blocks = &sbd->s_tfree;
  336.     sb->sv_sb_time = &sbd->s_time;
  337.     sb->sv_block_base = 0;
  338.     sb->sv_firstinodezone = 2;
  339.     sb->sv_firstdatazone = sbd->s_isize;
  340.     sb->sv_nzones = from_coh_ulong(sbd->s_fsize);
  341.     sb->sv_ndatazones = sb->sv_nzones - sb->sv_firstdatazone;
  342.     return sb;
  343. }
  344.  
  345. struct super_block *sysv_read_super(struct super_block *sb,void *data, 
  346.                      int silent)
  347. {
  348.     struct buffer_head *bh;
  349.     const char *found;
  350.     int dev = sb->s_dev;
  351.  
  352.     if (1024 != sizeof (struct xenix_super_block))
  353.         panic("Xenix FS: bad super-block size");
  354.     if ((512 != sizeof (struct sysv4_super_block))
  355.             || (512 != sizeof (struct sysv2_super_block)))
  356.         panic("SystemV FS: bad super-block size");
  357.     if (500 != sizeof (struct coh_super_block))
  358.         panic("Coherent FS: bad super-block size");
  359.     if (64 != sizeof (struct sysv_inode))
  360.         panic("sysv fs: bad i-node size");
  361.     MOD_INC_USE_COUNT;
  362.     lock_super(sb);
  363.     set_blocksize(dev,BLOCK_SIZE);
  364.  
  365.     /* Try to read Xenix superblock */
  366.     if ((bh = bread(dev, 1, BLOCK_SIZE)) != NULL) {
  367.         if ((found = detect_xenix(sb,bh)) != NULL)
  368.             goto ok;
  369.         brelse(bh);
  370.     }
  371.     if ((bh = bread(dev, 0, BLOCK_SIZE)) != NULL) {
  372.         /* Try to recognize SystemV superblock */
  373.         if ((found = detect_sysv4(sb,bh)) != NULL)
  374.             goto ok;
  375.         if ((found = detect_sysv2(sb,bh)) != NULL)
  376.             goto ok;
  377.         /* Try to recognize Coherent superblock */
  378.         if ((found = detect_coherent(sb,bh)) != NULL)
  379.             goto ok;
  380.         brelse(bh);
  381.     }
  382.     /* Try to recognize SystemV superblock */
  383.     /* Offset by 1 track, i.e. most probably 9, 15, or 18 kilobytes. */
  384.     {    static int offsets[] = { 9, 15, 18, };
  385.         int i;
  386.         for (i = 0; i < sizeof(offsets)/sizeof(offsets[0]); i++)
  387.             if ((bh = bread(dev, offsets[i], BLOCK_SIZE)) != NULL) {
  388.                 /* Try to recognize SystemV superblock */
  389.                 if ((found = detect_sysv4(sb,bh)) != NULL) {
  390.                     sb->sv_block_base = offsets[i] << sb->sv_block_size_ratio_bits;
  391.                     goto ok;
  392.                 }
  393.                 if ((found = detect_sysv2(sb,bh)) != NULL) {
  394.                     sb->sv_block_base = offsets[i] << sb->sv_block_size_ratio_bits;
  395.                     goto ok;
  396.                 }
  397.                 brelse(bh);
  398.             }
  399.     }
  400.     sb->s_dev=0;
  401.     unlock_super(sb);
  402.     if (!silent)
  403.         printk("VFS: unable to read Xenix/SystemV/Coherent superblock on device %d/%d\n",MAJOR(dev),MINOR(dev));
  404.     failed:
  405.     MOD_DEC_USE_COUNT;
  406.     return NULL;
  407.  
  408.     ok:
  409.     if (sb->sv_block_size == BLOCK_SIZE) {
  410.         switch (sb->sv_type) {
  411.             case FSTYPE_XENIX:
  412.                 if (!detected_xenix(sb,bh,bh))
  413.                     goto bad_superblock;
  414.                 break;
  415.             case FSTYPE_SYSV4:
  416.                 if (!detected_sysv4(sb,bh))
  417.                     goto bad_superblock;
  418.                 break;
  419.             case FSTYPE_SYSV2:
  420.                 if (!detected_sysv2(sb,bh))
  421.                     goto bad_superblock;
  422.                 break;
  423.             default:
  424.             bad_superblock:
  425.                 brelse(bh);
  426.                 sb->s_dev = 0;
  427.                 unlock_super(sb);
  428.                 printk("SysV FS: cannot read superblock in 1024 byte mode\n");
  429.                 goto failed;
  430.         }
  431.     } else {
  432.         /* Switch to another block size. Unfortunately, we have to
  433.            release the 1 KB block bh and read it in two parts again. */
  434.         struct buffer_head *bh1, *bh2;
  435.         unsigned long blocknr = bh->b_blocknr << sb->sv_block_size_ratio_bits;
  436.  
  437.         brelse(bh);
  438.         set_blocksize(dev,sb->sv_block_size);
  439.         bh1 = NULL; bh2 = NULL;
  440.         switch (sb->sv_type) {
  441.             case FSTYPE_XENIX:
  442.                 if ((bh1 = bread(dev, blocknr, sb->sv_block_size)) == NULL)
  443.                     goto bad_superblock2;
  444.                 if ((bh2 = bread(dev, blocknr+1, sb->sv_block_size)) == NULL)
  445.                     goto bad_superblock2;
  446.                 if (!detected_xenix(sb,bh1,bh2))
  447.                     goto bad_superblock2;
  448.                 break;
  449.             case FSTYPE_SYSV4:
  450.                 if ((bh2 = bread(dev, blocknr+1, sb->sv_block_size)) == NULL)
  451.                     goto bad_superblock2;
  452.                 if (!detected_sysv4(sb,bh2))
  453.                     goto bad_superblock2;
  454.                 break;
  455.             case FSTYPE_SYSV2:
  456.                 if ((bh2 = bread(dev, blocknr+1, sb->sv_block_size)) == NULL)
  457.                     goto bad_superblock2;
  458.                 if (!detected_sysv2(sb,bh2))
  459.                     goto bad_superblock2;
  460.                 break;
  461.             case FSTYPE_COH:
  462.                 if ((bh2 = bread(dev, blocknr+1, sb->sv_block_size)) == NULL)
  463.                     goto bad_superblock2;
  464.                 if (!detected_coherent(sb,bh2))
  465.                     goto bad_superblock2;
  466.                 break;
  467.             default:
  468.             bad_superblock2:
  469.                 brelse(bh1);
  470.                 brelse(bh2);
  471.                 set_blocksize(sb->s_dev,BLOCK_SIZE);
  472.                 sb->s_dev = 0;
  473.                 unlock_super(sb);
  474.                 printk("SysV FS: cannot read superblock in 512 byte mode\n");
  475.                 goto failed;
  476.         }
  477.     }
  478.     sb->sv_ninodes = (sb->sv_firstdatazone - sb->sv_firstinodezone) << sb->sv_inodes_per_block_bits;
  479.     if (!silent)
  480.         printk("VFS: Found a %s FS (block size = %d) on device %d/%d\n",found,sb->sv_block_size,MAJOR(dev),MINOR(dev));
  481.     sb->s_magic = SYSV_MAGIC_BASE + sb->sv_type;
  482.     /* The buffer code now supports block size 512 as well as 1024. */
  483.     sb->s_blocksize = sb->sv_block_size;
  484.     sb->s_blocksize_bits = sb->sv_block_size_bits;
  485.     /* set up enough so that it can read an inode */
  486.     sb->s_dev = dev;
  487.     sb->s_op = &sysv_sops;
  488.     sb->s_mounted = iget(sb,SYSV_ROOT_INO);
  489.     unlock_super(sb);
  490.     if (!sb->s_mounted) {
  491.         printk("SysV FS: get root inode failed\n");
  492.         sysv_put_super(sb);
  493.         return NULL;
  494.     }
  495.     sb->s_dirt = 1;
  496.     /* brelse(bh);  resp.  brelse(bh1); brelse(bh2);
  497.        occurs when the disk is unmounted. */
  498.     return sb;
  499. }
  500.  
  501. /* This is only called on sync() and umount(), when s_dirt=1. */
  502. void sysv_write_super (struct super_block *sb)
  503. {
  504.     lock_super(sb);
  505.     if (sb->sv_bh1->b_dirt || sb->sv_bh2->b_dirt) {
  506.         /* If we are going to write out the super block,
  507.            then attach current time stamp.
  508.            But if the filesystem was marked clean, keep it clean. */
  509.         unsigned long time = CURRENT_TIME;
  510.         unsigned long old_time = *sb->sv_sb_time;
  511.         if (sb->sv_convert)
  512.             old_time = from_coh_ulong(old_time);
  513.         if (sb->sv_type == FSTYPE_SYSV4)
  514.             if (*sb->sv_sb_state == 0x7c269d38 - old_time)
  515.                 *sb->sv_sb_state = 0x7c269d38 - time;
  516.         if (sb->sv_convert)
  517.             time = to_coh_ulong(time);
  518.         *sb->sv_sb_time = time;
  519.         mark_buffer_dirty(sb->sv_bh2, 1);
  520.     }
  521.     sb->s_dirt = 0;
  522.     unlock_super(sb);
  523. }
  524.  
  525. void sysv_put_super(struct super_block *sb)
  526. {
  527.     /* we can assume sysv_write_super() has already been called */
  528.     lock_super(sb);
  529.     brelse(sb->sv_bh1);
  530.     if (sb->sv_bh1 != sb->sv_bh2) brelse(sb->sv_bh2);
  531.     /* switch back to default block size */
  532.     if (sb->s_blocksize != BLOCK_SIZE)
  533.         set_blocksize(sb->s_dev,BLOCK_SIZE);
  534.     sb->s_dev = 0;
  535.     unlock_super(sb);
  536.     MOD_DEC_USE_COUNT;
  537. }
  538.  
  539. void sysv_statfs(struct super_block *sb, struct statfs *buf)
  540. {
  541.     long tmp;
  542.  
  543.     put_fs_long(sb->s_magic, &buf->f_type);        /* type of filesystem */
  544.     put_fs_long(sb->sv_block_size, &buf->f_bsize);    /* block size */
  545.     put_fs_long(sb->sv_ndatazones, &buf->f_blocks);    /* total data blocks in file system */
  546.     tmp = sysv_count_free_blocks(sb);
  547.     put_fs_long(tmp, &buf->f_bfree);        /* free blocks in fs */
  548.     put_fs_long(tmp, &buf->f_bavail);        /* free blocks available to non-superuser */
  549.     put_fs_long(sb->sv_ninodes, &buf->f_files);    /* total file nodes in file system */
  550.     put_fs_long(sysv_count_free_inodes(sb), &buf->f_ffree);    /* free file nodes in fs */
  551.     put_fs_long(SYSV_NAMELEN, &buf->f_namelen);
  552.     /* Don't know what value to put in buf->f_fsid */    /* file system id */
  553. }
  554.  
  555.  
  556. /* bmap support for running executables and shared libraries. */
  557.  
  558. static inline int inode_bmap(struct super_block * sb, struct inode * inode, int nr)
  559. {
  560.     int tmp = inode->u.sysv_i.i_data[nr];
  561.     if (!tmp)
  562.         return 0;
  563.     return tmp + sb->sv_block_base;
  564. }
  565.  
  566. static int block_bmap(struct super_block * sb, struct buffer_head * bh, int nr, int convert)
  567. {
  568.     int tmp;
  569.  
  570.     if (!bh)
  571.         return 0;
  572.     tmp = ((sysv_zone_t *) bh->b_data) [nr];
  573.     if (convert)
  574.         tmp = from_coh_ulong(tmp);
  575.     brelse(bh);
  576.     if (!tmp)
  577.         return 0;
  578.     return tmp + sb->sv_block_base;
  579. }
  580.  
  581. int sysv_bmap(struct inode * inode,int block_nr)
  582. {
  583.     unsigned int block = block_nr;
  584.     struct super_block * sb = inode->i_sb;
  585.     int convert;
  586.     int i;
  587.     struct buffer_head * bh;
  588.  
  589.     if (block < 10)
  590.         return inode_bmap(sb,inode,block);
  591.     block -= 10;
  592.     convert = sb->sv_convert;
  593.     if (block < sb->sv_ind_per_block) {
  594.         i = inode_bmap(sb,inode,10);
  595.         if (!i)
  596.             return 0;
  597.         bh = bread(inode->i_dev,i,sb->sv_block_size);
  598.         return block_bmap(sb, bh, block, convert);
  599.     }
  600.     block -= sb->sv_ind_per_block;
  601.     if (block < sb->sv_ind_per_block_2) {
  602.         i = inode_bmap(sb,inode,11);
  603.         if (!i)
  604.             return 0;
  605.         bh = bread(inode->i_dev,i,sb->sv_block_size);
  606.         i = block_bmap(sb, bh, block >> sb->sv_ind_per_block_bits, convert);
  607.         if (!i)
  608.             return 0;
  609.         bh = bread(inode->i_dev,i,sb->sv_block_size);
  610.         return block_bmap(sb, bh, block & sb->sv_ind_per_block_1, convert);
  611.     }
  612.     block -= sb->sv_ind_per_block_2;
  613.     if (block < sb->sv_ind_per_block_3) {
  614.         i = inode_bmap(sb,inode,12);
  615.         if (!i)
  616.             return 0;
  617.         bh = bread(inode->i_dev,i,sb->sv_block_size);
  618.         i = block_bmap(sb, bh, block >> sb->sv_ind_per_block_2_bits, convert);
  619.         if (!i)
  620.             return 0;
  621.         bh = bread(inode->i_dev,i,sb->sv_block_size);
  622.         i = block_bmap(sb, bh, (block >> sb->sv_ind_per_block_bits) & sb->sv_ind_per_block_1,convert);
  623.         if (!i)
  624.             return 0;
  625.         bh = bread(inode->i_dev,i,sb->sv_block_size);
  626.         return block_bmap(sb, bh, block & sb->sv_ind_per_block_1, convert);
  627.     }
  628.     if ((int)block<0) {
  629.         printk("sysv_bmap: block<0");
  630.         return 0;
  631.     }
  632.     printk("sysv_bmap: block>big");
  633.     return 0;
  634. }
  635.  
  636. /* End of bmap support. */
  637.  
  638.  
  639. /* Access selected blocks of regular files (or directories) */
  640.  
  641. static struct buffer_head * inode_getblk(struct inode * inode, int nr, int create)
  642. {
  643.     struct super_block *sb;
  644.     unsigned long tmp;
  645.     unsigned long *p;
  646.     struct buffer_head * result;
  647.  
  648.     sb = inode->i_sb;
  649.     p = inode->u.sysv_i.i_data + nr;
  650. repeat:
  651.     tmp = *p;
  652.     if (tmp) {
  653.         result = sv_getblk(sb, inode->i_dev, tmp);
  654.         if (tmp == *p)
  655.             return result;
  656.         brelse(result);
  657.         goto repeat;
  658.     }
  659.     if (!create)
  660.         return NULL;
  661.     tmp = sysv_new_block(sb);
  662.     if (!tmp)
  663.         return NULL;
  664.     result = sv_getblk(sb, inode->i_dev, tmp);
  665.     if (*p) {
  666.         sysv_free_block(sb,tmp);
  667.         brelse(result);
  668.         goto repeat;
  669.     }
  670.     *p = tmp;
  671.     inode->i_ctime = CURRENT_TIME;
  672.     inode->i_dirt = 1;
  673.     return result;
  674. }
  675.  
  676. static struct buffer_head * block_getblk(struct inode * inode, 
  677.     struct buffer_head * bh, int nr, int create)
  678. {
  679.     struct super_block *sb;
  680.     unsigned long tmp, block;
  681.     sysv_zone_t *p;
  682.     struct buffer_head * result;
  683.  
  684.     if (!bh)
  685.         return NULL;
  686.     if (!bh->b_uptodate) {
  687.         ll_rw_block(READ, 1, &bh);
  688.         wait_on_buffer(bh);
  689.         if (!bh->b_uptodate) {
  690.             brelse(bh);
  691.             return NULL;
  692.         }
  693.     }
  694.     sb = inode->i_sb;
  695.     p = nr + (sysv_zone_t *) bh->b_data;
  696. repeat:
  697.     block = tmp = *p;
  698.     if (sb->sv_convert)
  699.         block = from_coh_ulong(block);
  700.     if (tmp) {
  701.         result = sv_getblk(sb, bh->b_dev, block);
  702.         if (tmp == *p) {
  703.             brelse(bh);
  704.             return result;
  705.         }
  706.         brelse(result);
  707.         goto repeat;
  708.     }
  709.     if (!create) {
  710.         brelse(bh);
  711.         return NULL;
  712.     }
  713.     block = sysv_new_block(sb);
  714.     if (!block) {
  715.         brelse(bh);
  716.         return NULL;
  717.     }
  718.     result = sv_getblk(sb, bh->b_dev, block);
  719.     if (*p) {
  720.         sysv_free_block(sb,block);
  721.         brelse(result);
  722.         goto repeat;
  723.     }
  724.     *p = (sb->sv_convert ? to_coh_ulong(block) : block);
  725.     mark_buffer_dirty(bh, 1);
  726.     brelse(bh);
  727.     return result;
  728. }
  729.  
  730. struct buffer_head * sysv_getblk(struct inode * inode, unsigned int block, int create)
  731. {
  732.     struct super_block * sb = inode->i_sb;
  733.     struct buffer_head * bh;
  734.  
  735.     if (block < 10)
  736.         return inode_getblk(inode,block,create);
  737.     block -= 10;
  738.     if (block < sb->sv_ind_per_block) {
  739.         bh = inode_getblk(inode,10,create);
  740.         return block_getblk(inode, bh, block, create);
  741.     }
  742.     block -= sb->sv_ind_per_block;
  743.     if (block < sb->sv_ind_per_block_2) {
  744.         bh = inode_getblk(inode,11,create);
  745.         bh = block_getblk(inode, bh, block >> sb->sv_ind_per_block_bits, create);
  746.         return block_getblk(inode, bh, block & sb->sv_ind_per_block_1, create);
  747.     }
  748.     block -= sb->sv_ind_per_block_2;
  749.     if (block < sb->sv_ind_per_block_3) {
  750.         bh = inode_getblk(inode,12,create);
  751.         bh = block_getblk(inode, bh, block >> sb->sv_ind_per_block_2_bits, create);
  752.         bh = block_getblk(inode, bh, (block >> sb->sv_ind_per_block_bits) & sb->sv_ind_per_block_1, create);
  753.         return block_getblk(inode, bh, block & sb->sv_ind_per_block_1, create);
  754.     }
  755.     if ((int)block<0) {
  756.         printk("sysv_getblk: block<0");
  757.         return NULL;
  758.     }
  759.     printk("sysv_getblk: block>big");
  760.     return NULL;
  761. }
  762.  
  763. struct buffer_head * sysv_file_bread(struct inode * inode, int block, int create)
  764. {
  765.     struct buffer_head * bh;
  766.  
  767.     bh = sysv_getblk(inode,block,create);
  768.     if (!bh || bh->b_uptodate)
  769.         return bh;
  770.     ll_rw_block(READ, 1, &bh);
  771.     wait_on_buffer(bh);
  772.     if (bh->b_uptodate)
  773.         return bh;
  774.     brelse(bh);
  775.     return NULL;
  776. }
  777.  
  778.  
  779. static inline unsigned long read3byte (char * p)
  780. {
  781.     return (unsigned long)(*(unsigned short *)p)
  782.          | (unsigned long)(*(unsigned char *)(p+2)) << 16;
  783. }
  784.  
  785. static inline void write3byte (char * p, unsigned long val)
  786. {
  787.     *(unsigned short *)p = (unsigned short) val;
  788.     *(unsigned char *)(p+2) = val >> 16;
  789. }
  790.  
  791. static inline unsigned long coh_read3byte (char * p)
  792. {
  793.     return (unsigned long)(*(unsigned char *)p) << 16
  794.          | (unsigned long)(*(unsigned short *)(p+1));
  795. }
  796.  
  797. static inline void coh_write3byte (char * p, unsigned long val)
  798. {
  799.     *(unsigned char *)p = val >> 16;
  800.     *(unsigned short *)(p+1) = (unsigned short) val;
  801. }
  802.  
  803. void sysv_read_inode(struct inode * inode)
  804. {
  805.     struct super_block * sb = inode->i_sb;
  806.     struct buffer_head * bh;
  807.     struct sysv_inode * raw_inode;
  808.     unsigned int block, ino;
  809.     umode_t mode;
  810.  
  811.     ino = inode->i_ino;
  812.     inode->i_op = NULL;
  813.     inode->i_mode = 0;
  814.     if (!ino || ino > sb->sv_ninodes) {
  815.         printk("Bad inode number on dev 0x%04x: %d is out of range\n",
  816.             inode->i_dev, ino);
  817.         return;
  818.     }
  819.     block = sb->sv_firstinodezone + ((ino-1) >> sb->sv_inodes_per_block_bits);
  820.     if (!(bh = sv_bread(sb,inode->i_dev,block))) {
  821.         printk("Major problem: unable to read inode from dev 0x%04x\n",
  822.             inode->i_dev);
  823.         return;
  824.     }
  825.     raw_inode = (struct sysv_inode *) bh->b_data + ((ino-1) & sb->sv_inodes_per_block_1);
  826.     mode = raw_inode->i_mode;
  827.     if (sb->sv_kludge_symlinks)
  828.         mode = from_coh_imode(mode);
  829.     /* SystemV FS: kludge permissions if ino==SYSV_ROOT_INO ?? */
  830.     inode->i_mode = mode;
  831.     inode->i_uid = raw_inode->i_uid;
  832.     inode->i_gid = raw_inode->i_gid;
  833.     inode->i_nlink = raw_inode->i_nlink;
  834.     if (sb->sv_convert) {
  835.         inode->i_size = from_coh_ulong(raw_inode->i_size);
  836.         inode->i_atime = from_coh_ulong(raw_inode->i_atime);
  837.         inode->i_mtime = from_coh_ulong(raw_inode->i_mtime);
  838.         inode->i_ctime = from_coh_ulong(raw_inode->i_ctime);
  839.     } else {
  840.         inode->i_size = raw_inode->i_size;
  841.         inode->i_atime = raw_inode->i_atime;
  842.         inode->i_mtime = raw_inode->i_mtime;
  843.         inode->i_ctime = raw_inode->i_ctime;
  844.     }
  845.     inode->i_blocks = inode->i_blksize = 0;
  846.     if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
  847.         inode->i_rdev = raw_inode->i_a.i_rdev;
  848.     else
  849.     if (sb->sv_convert)
  850.         for (block = 0; block < 10+1+1+1; block++)
  851.             inode->u.sysv_i.i_data[block] =
  852.                 coh_read3byte(&raw_inode->i_a.i_addb[3*block]);
  853.     else
  854.         for (block = 0; block < 10+1+1+1; block++)
  855.             inode->u.sysv_i.i_data[block] =
  856.                 read3byte(&raw_inode->i_a.i_addb[3*block]);
  857.     brelse(bh);
  858.     if (S_ISREG(inode->i_mode))
  859.         inode->i_op = &sysv_file_inode_operations;
  860.     else if (S_ISDIR(inode->i_mode))
  861.         inode->i_op = &sysv_dir_inode_operations;
  862.     else if (S_ISLNK(inode->i_mode))
  863.         inode->i_op = &sysv_symlink_inode_operations;
  864.     else if (S_ISCHR(inode->i_mode))
  865.         inode->i_op = &chrdev_inode_operations;
  866.     else if (S_ISBLK(inode->i_mode))
  867.         inode->i_op = &blkdev_inode_operations;
  868.     else if (S_ISFIFO(inode->i_mode))
  869.         init_fifo(inode);
  870. }
  871.  
  872. /* To avoid inconsistencies between inodes in memory and inodes on disk. */
  873. extern int sysv_notify_change(struct inode *inode, struct iattr *attr)
  874. {
  875.     int error;
  876.  
  877.     if ((error = inode_change_ok(inode, attr)) != 0)
  878.         return error;
  879.  
  880.     if (attr->ia_valid & ATTR_MODE)
  881.         if (inode->i_sb->sv_kludge_symlinks)
  882.             if (attr->ia_mode == COH_KLUDGE_SYMLINK_MODE)
  883.                 attr->ia_mode = COH_KLUDGE_NOT_SYMLINK;
  884.  
  885.     inode_setattr(inode, attr);
  886.  
  887.     return 0;
  888. }
  889.  
  890. static struct buffer_head * sysv_update_inode(struct inode * inode)
  891. {
  892.     struct super_block * sb = inode->i_sb;
  893.     struct buffer_head * bh;
  894.     struct sysv_inode * raw_inode;
  895.     unsigned int ino, block;
  896.     umode_t mode;
  897.  
  898.     ino = inode->i_ino;
  899.     if (!ino || ino > sb->sv_ninodes) {
  900.         printk("Bad inode number on dev 0x%04x: %d is out of range\n",
  901.             inode->i_dev, ino);
  902.         inode->i_dirt = 0;
  903.         return 0;
  904.     }
  905.     block = sb->sv_firstinodezone + ((ino-1) >> sb->sv_inodes_per_block_bits);
  906.     if (!(bh = sv_bread(sb,inode->i_dev,block))) {
  907.         printk("unable to read i-node block\n");
  908.         inode->i_dirt = 0;
  909.         return 0;
  910.     }
  911.     raw_inode = (struct sysv_inode *) bh->b_data + ((ino-1) & sb->sv_inodes_per_block_1);
  912.     mode = inode->i_mode;
  913.     if (sb->sv_kludge_symlinks)
  914.         mode = to_coh_imode(mode);
  915.     raw_inode->i_mode = mode;
  916.     raw_inode->i_uid = inode->i_uid;
  917.     raw_inode->i_gid = inode->i_gid;
  918.     raw_inode->i_nlink = inode->i_nlink;
  919.     if (sb->sv_convert) {
  920.         raw_inode->i_size = to_coh_ulong(inode->i_size);
  921.         raw_inode->i_atime = to_coh_ulong(inode->i_atime);
  922.         raw_inode->i_mtime = to_coh_ulong(inode->i_mtime);
  923.         raw_inode->i_ctime = to_coh_ulong(inode->i_ctime);
  924.     } else {
  925.         raw_inode->i_size = inode->i_size;
  926.         raw_inode->i_atime = inode->i_atime;
  927.         raw_inode->i_mtime = inode->i_mtime;
  928.         raw_inode->i_ctime = inode->i_ctime;
  929.     }
  930.     if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
  931.         raw_inode->i_a.i_rdev = inode->i_rdev; /* write 2 or 3 bytes ?? */
  932.     else
  933.     if (sb->sv_convert)
  934.         for (block = 0; block < 10+1+1+1; block++)
  935.             coh_write3byte(&raw_inode->i_a.i_addb[3*block],inode->u.sysv_i.i_data[block]);
  936.     else
  937.         for (block = 0; block < 10+1+1+1; block++)
  938.             write3byte(&raw_inode->i_a.i_addb[3*block],inode->u.sysv_i.i_data[block]);
  939.     inode->i_dirt=0;
  940.     mark_buffer_dirty(bh, 1);
  941.     return bh;
  942. }
  943.  
  944. void sysv_write_inode(struct inode * inode)
  945. {
  946.     struct buffer_head *bh;
  947.     bh = sysv_update_inode(inode);
  948.     brelse(bh);
  949. }
  950.  
  951. int sysv_sync_inode(struct inode * inode)
  952. {
  953.         int err = 0;
  954.         struct buffer_head *bh;
  955.  
  956.         bh = sysv_update_inode(inode);
  957.         if (bh && bh->b_dirt) {
  958.                 ll_rw_block(WRITE, 1, &bh);
  959.                 wait_on_buffer(bh);
  960.                 if (bh->b_req && !bh->b_uptodate)
  961.                 {
  962.                         printk ("IO error syncing sysv inode [%04x:%08lx]\n",
  963.                                 inode->i_dev, inode->i_ino);
  964.                         err = -1;
  965.                 }
  966.         }
  967.         else if (!bh)
  968.                 err = -1;
  969.         brelse (bh);
  970.         return err;
  971. }
  972.  
  973. #ifdef MODULE
  974.  
  975. /* Every kernel module contains stuff like this. */
  976.  
  977. char kernel_version[] = UTS_RELEASE;
  978.  
  979. static struct file_system_type sysv_fs_type[3] = {
  980.     {sysv_read_super, "xenix", 1, NULL},
  981.     {sysv_read_super, "sysv", 1, NULL},
  982.     {sysv_read_super, "coherent", 1, NULL}
  983. };
  984.  
  985. int init_module(void)
  986. {
  987.     int i;
  988.  
  989.     for (i = 0; i < 3; i++)
  990.         register_filesystem(&sysv_fs_type[i]);
  991.  
  992.     return 0;
  993. }
  994.  
  995. void cleanup_module(void)
  996. {
  997.     int i;
  998.  
  999.     for (i = 0; i < 3; i++)
  1000.         unregister_filesystem(&sysv_fs_type[i]);
  1001. }
  1002.  
  1003. #endif
  1004.