xref: /openbmc/linux/fs/ufs/cylinder.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
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 }
210