Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame^] | 1 | /* |
| 2 | * linux/fs/ufs/cylinder.c |
| 3 | * |
| 4 | * Copyright (C) 1998 |
| 5 | * Daniel Pirkl <daniel.pirkl@email.cz> |
| 6 | * Charles University, Faculty of Mathematics and Physics |
| 7 | * |
| 8 | * ext2 - inode (block) bitmap caching inspired |
| 9 | */ |
| 10 | |
| 11 | #include <linux/fs.h> |
| 12 | #include <linux/ufs_fs.h> |
| 13 | #include <linux/time.h> |
| 14 | #include <linux/stat.h> |
| 15 | #include <linux/string.h> |
| 16 | #include <linux/bitops.h> |
| 17 | |
| 18 | #include <asm/byteorder.h> |
| 19 | |
| 20 | #include "swab.h" |
| 21 | #include "util.h" |
| 22 | |
| 23 | #undef UFS_CYLINDER_DEBUG |
| 24 | |
| 25 | #ifdef UFS_CYLINDER_DEBUG |
| 26 | #define UFSD(x) printk("(%s, %d), %s:", __FILE__, __LINE__, __FUNCTION__); printk x; |
| 27 | #else |
| 28 | #define UFSD(x) |
| 29 | #endif |
| 30 | |
| 31 | |
| 32 | /* |
| 33 | * Read cylinder group into cache. The memory space for ufs_cg_private_info |
| 34 | * structure is already allocated during ufs_read_super. |
| 35 | */ |
| 36 | static void ufs_read_cylinder (struct super_block * sb, |
| 37 | unsigned cgno, unsigned bitmap_nr) |
| 38 | { |
| 39 | struct ufs_sb_info * sbi = UFS_SB(sb); |
| 40 | struct ufs_sb_private_info * uspi; |
| 41 | struct ufs_cg_private_info * ucpi; |
| 42 | struct ufs_cylinder_group * ucg; |
| 43 | unsigned i, j; |
| 44 | |
| 45 | UFSD(("ENTER, cgno %u, bitmap_nr %u\n", cgno, bitmap_nr)) |
| 46 | uspi = sbi->s_uspi; |
| 47 | ucpi = sbi->s_ucpi[bitmap_nr]; |
| 48 | ucg = (struct ufs_cylinder_group *)sbi->s_ucg[cgno]->b_data; |
| 49 | |
| 50 | UCPI_UBH->fragment = ufs_cgcmin(cgno); |
| 51 | UCPI_UBH->count = uspi->s_cgsize >> sb->s_blocksize_bits; |
| 52 | /* |
| 53 | * We have already the first fragment of cylinder group block in buffer |
| 54 | */ |
| 55 | UCPI_UBH->bh[0] = sbi->s_ucg[cgno]; |
| 56 | for (i = 1; i < UCPI_UBH->count; i++) |
| 57 | if (!(UCPI_UBH->bh[i] = sb_bread(sb, UCPI_UBH->fragment + i))) |
| 58 | goto failed; |
| 59 | sbi->s_cgno[bitmap_nr] = cgno; |
| 60 | |
| 61 | ucpi->c_cgx = fs32_to_cpu(sb, ucg->cg_cgx); |
| 62 | ucpi->c_ncyl = fs16_to_cpu(sb, ucg->cg_ncyl); |
| 63 | ucpi->c_niblk = fs16_to_cpu(sb, ucg->cg_niblk); |
| 64 | ucpi->c_ndblk = fs32_to_cpu(sb, ucg->cg_ndblk); |
| 65 | ucpi->c_rotor = fs32_to_cpu(sb, ucg->cg_rotor); |
| 66 | ucpi->c_frotor = fs32_to_cpu(sb, ucg->cg_frotor); |
| 67 | ucpi->c_irotor = fs32_to_cpu(sb, ucg->cg_irotor); |
| 68 | ucpi->c_btotoff = fs32_to_cpu(sb, ucg->cg_btotoff); |
| 69 | ucpi->c_boff = fs32_to_cpu(sb, ucg->cg_boff); |
| 70 | ucpi->c_iusedoff = fs32_to_cpu(sb, ucg->cg_iusedoff); |
| 71 | ucpi->c_freeoff = fs32_to_cpu(sb, ucg->cg_freeoff); |
| 72 | ucpi->c_nextfreeoff = fs32_to_cpu(sb, ucg->cg_nextfreeoff); |
| 73 | ucpi->c_clustersumoff = fs32_to_cpu(sb, ucg->cg_u.cg_44.cg_clustersumoff); |
| 74 | ucpi->c_clusteroff = fs32_to_cpu(sb, ucg->cg_u.cg_44.cg_clusteroff); |
| 75 | ucpi->c_nclusterblks = fs32_to_cpu(sb, ucg->cg_u.cg_44.cg_nclusterblks); |
| 76 | UFSD(("EXIT\n")) |
| 77 | return; |
| 78 | |
| 79 | failed: |
| 80 | for (j = 1; j < i; j++) |
| 81 | brelse (sbi->s_ucg[j]); |
| 82 | sbi->s_cgno[bitmap_nr] = UFS_CGNO_EMPTY; |
| 83 | ufs_error (sb, "ufs_read_cylinder", "can't read cylinder group block %u", cgno); |
| 84 | } |
| 85 | |
| 86 | /* |
| 87 | * Remove cylinder group from cache, doesn't release memory |
| 88 | * allocated for cylinder group (this is done at ufs_put_super only). |
| 89 | */ |
| 90 | void ufs_put_cylinder (struct super_block * sb, unsigned bitmap_nr) |
| 91 | { |
| 92 | struct ufs_sb_info * sbi = UFS_SB(sb); |
| 93 | struct ufs_sb_private_info * uspi; |
| 94 | struct ufs_cg_private_info * ucpi; |
| 95 | struct ufs_cylinder_group * ucg; |
| 96 | unsigned i; |
| 97 | |
| 98 | UFSD(("ENTER, bitmap_nr %u\n", bitmap_nr)) |
| 99 | |
| 100 | uspi = sbi->s_uspi; |
| 101 | if (sbi->s_cgno[bitmap_nr] == UFS_CGNO_EMPTY) { |
| 102 | UFSD(("EXIT\n")) |
| 103 | return; |
| 104 | } |
| 105 | ucpi = sbi->s_ucpi[bitmap_nr]; |
| 106 | ucg = ubh_get_ucg(UCPI_UBH); |
| 107 | |
| 108 | if (uspi->s_ncg > UFS_MAX_GROUP_LOADED && bitmap_nr >= sbi->s_cg_loaded) { |
| 109 | ufs_panic (sb, "ufs_put_cylinder", "internal error"); |
| 110 | return; |
| 111 | } |
| 112 | /* |
| 113 | * rotor is not so important data, so we put it to disk |
| 114 | * at the end of working with cylinder |
| 115 | */ |
| 116 | ucg->cg_rotor = cpu_to_fs32(sb, ucpi->c_rotor); |
| 117 | ucg->cg_frotor = cpu_to_fs32(sb, ucpi->c_frotor); |
| 118 | ucg->cg_irotor = cpu_to_fs32(sb, ucpi->c_irotor); |
| 119 | ubh_mark_buffer_dirty (UCPI_UBH); |
| 120 | for (i = 1; i < UCPI_UBH->count; i++) { |
| 121 | brelse (UCPI_UBH->bh[i]); |
| 122 | } |
| 123 | |
| 124 | sbi->s_cgno[bitmap_nr] = UFS_CGNO_EMPTY; |
| 125 | UFSD(("EXIT\n")) |
| 126 | } |
| 127 | |
| 128 | /* |
| 129 | * Find cylinder group in cache and return it as pointer. |
| 130 | * If cylinder group is not in cache, we will load it from disk. |
| 131 | * |
| 132 | * The cache is managed by LRU algorithm. |
| 133 | */ |
| 134 | struct ufs_cg_private_info * ufs_load_cylinder ( |
| 135 | struct super_block * sb, unsigned cgno) |
| 136 | { |
| 137 | struct ufs_sb_info * sbi = UFS_SB(sb); |
| 138 | struct ufs_sb_private_info * uspi; |
| 139 | struct ufs_cg_private_info * ucpi; |
| 140 | unsigned cg, i, j; |
| 141 | |
| 142 | UFSD(("ENTER, cgno %u\n", cgno)) |
| 143 | |
| 144 | uspi = sbi->s_uspi; |
| 145 | if (cgno >= uspi->s_ncg) { |
| 146 | ufs_panic (sb, "ufs_load_cylinder", "internal error, high number of cg"); |
| 147 | return NULL; |
| 148 | } |
| 149 | /* |
| 150 | * Cylinder group number cg it in cache and it was last used |
| 151 | */ |
| 152 | if (sbi->s_cgno[0] == cgno) { |
| 153 | UFSD(("EXIT\n")) |
| 154 | return sbi->s_ucpi[0]; |
| 155 | } |
| 156 | /* |
| 157 | * Number of cylinder groups is not higher than UFS_MAX_GROUP_LOADED |
| 158 | */ |
| 159 | if (uspi->s_ncg <= UFS_MAX_GROUP_LOADED) { |
| 160 | if (sbi->s_cgno[cgno] != UFS_CGNO_EMPTY) { |
| 161 | if (sbi->s_cgno[cgno] != cgno) { |
| 162 | ufs_panic (sb, "ufs_load_cylinder", "internal error, wrong number of cg in cache"); |
| 163 | UFSD(("EXIT (FAILED)\n")) |
| 164 | return NULL; |
| 165 | } |
| 166 | else { |
| 167 | UFSD(("EXIT\n")) |
| 168 | return sbi->s_ucpi[cgno]; |
| 169 | } |
| 170 | } else { |
| 171 | ufs_read_cylinder (sb, cgno, cgno); |
| 172 | UFSD(("EXIT\n")) |
| 173 | return sbi->s_ucpi[cgno]; |
| 174 | } |
| 175 | } |
| 176 | /* |
| 177 | * Cylinder group number cg is in cache but it was not last used, |
| 178 | * we will move to the first position |
| 179 | */ |
| 180 | for (i = 0; i < sbi->s_cg_loaded && sbi->s_cgno[i] != cgno; i++); |
| 181 | if (i < sbi->s_cg_loaded && sbi->s_cgno[i] == cgno) { |
| 182 | cg = sbi->s_cgno[i]; |
| 183 | ucpi = sbi->s_ucpi[i]; |
| 184 | for (j = i; j > 0; j--) { |
| 185 | sbi->s_cgno[j] = sbi->s_cgno[j-1]; |
| 186 | sbi->s_ucpi[j] = sbi->s_ucpi[j-1]; |
| 187 | } |
| 188 | sbi->s_cgno[0] = cg; |
| 189 | sbi->s_ucpi[0] = ucpi; |
| 190 | /* |
| 191 | * Cylinder group number cg is not in cache, we will read it from disk |
| 192 | * and put it to the first position |
| 193 | */ |
| 194 | } else { |
| 195 | if (sbi->s_cg_loaded < UFS_MAX_GROUP_LOADED) |
| 196 | sbi->s_cg_loaded++; |
| 197 | else |
| 198 | ufs_put_cylinder (sb, UFS_MAX_GROUP_LOADED-1); |
| 199 | ucpi = sbi->s_ucpi[sbi->s_cg_loaded - 1]; |
| 200 | for (j = sbi->s_cg_loaded - 1; j > 0; j--) { |
| 201 | sbi->s_cgno[j] = sbi->s_cgno[j-1]; |
| 202 | sbi->s_ucpi[j] = sbi->s_ucpi[j-1]; |
| 203 | } |
| 204 | sbi->s_ucpi[0] = ucpi; |
| 205 | ufs_read_cylinder (sb, cgno, 0); |
| 206 | } |
| 207 | UFSD(("EXIT\n")) |
| 208 | return sbi->s_ucpi[0]; |
| 209 | } |