xref: /openbmc/linux/fs/ufs/util.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
1 /*
2  *  linux/fs/ufs/util.c
3  *
4  * Copyright (C) 1998
5  * Daniel Pirkl <daniel.pirkl@email.cz>
6  * Charles University, Faculty of Mathematics and Physics
7  */
8 
9 #include <linux/string.h>
10 #include <linux/slab.h>
11 #include <linux/ufs_fs.h>
12 #include <linux/buffer_head.h>
13 
14 #include "swab.h"
15 #include "util.h"
16 
17 struct ufs_buffer_head * _ubh_bread_ (struct ufs_sb_private_info * uspi,
18 	struct super_block *sb, u64 fragment, u64 size)
19 {
20 	struct ufs_buffer_head * ubh;
21 	unsigned i, j ;
22 	u64  count = 0;
23 	if (size & ~uspi->s_fmask)
24 		return NULL;
25 	count = size >> uspi->s_fshift;
26 	if (count > UFS_MAXFRAG)
27 		return NULL;
28 	ubh = (struct ufs_buffer_head *)
29 		kmalloc (sizeof (struct ufs_buffer_head), GFP_KERNEL);
30 	if (!ubh)
31 		return NULL;
32 	ubh->fragment = fragment;
33 	ubh->count = count;
34 	for (i = 0; i < count; i++)
35 		if (!(ubh->bh[i] = sb_bread(sb, fragment + i)))
36 			goto failed;
37 	for (; i < UFS_MAXFRAG; i++)
38 		ubh->bh[i] = NULL;
39 	return ubh;
40 failed:
41 	for (j = 0; j < i; j++)
42 		brelse (ubh->bh[j]);
43 	kfree(ubh);
44 	return NULL;
45 }
46 
47 struct ufs_buffer_head * ubh_bread_uspi (struct ufs_sb_private_info * uspi,
48 	struct super_block *sb, u64 fragment, u64 size)
49 {
50 	unsigned i, j;
51 	u64 count = 0;
52 	if (size & ~uspi->s_fmask)
53 		return NULL;
54 	count = size >> uspi->s_fshift;
55 	if (count <= 0 || count > UFS_MAXFRAG)
56 		return NULL;
57 	USPI_UBH(uspi)->fragment = fragment;
58 	USPI_UBH(uspi)->count = count;
59 	for (i = 0; i < count; i++)
60 		if (!(USPI_UBH(uspi)->bh[i] = sb_bread(sb, fragment + i)))
61 			goto failed;
62 	for (; i < UFS_MAXFRAG; i++)
63 		USPI_UBH(uspi)->bh[i] = NULL;
64 	return USPI_UBH(uspi);
65 failed:
66 	for (j = 0; j < i; j++)
67 		brelse (USPI_UBH(uspi)->bh[j]);
68 	return NULL;
69 }
70 
71 void ubh_brelse (struct ufs_buffer_head * ubh)
72 {
73 	unsigned i;
74 	if (!ubh)
75 		return;
76 	for (i = 0; i < ubh->count; i++)
77 		brelse (ubh->bh[i]);
78 	kfree (ubh);
79 }
80 
81 void ubh_brelse_uspi (struct ufs_sb_private_info * uspi)
82 {
83 	unsigned i;
84 	if (!USPI_UBH(uspi))
85 		return;
86 	for ( i = 0; i < USPI_UBH(uspi)->count; i++ ) {
87 		brelse (USPI_UBH(uspi)->bh[i]);
88 		USPI_UBH(uspi)->bh[i] = NULL;
89 	}
90 }
91 
92 void ubh_mark_buffer_dirty (struct ufs_buffer_head * ubh)
93 {
94 	unsigned i;
95 	if (!ubh)
96 		return;
97 	for ( i = 0; i < ubh->count; i++ )
98 		mark_buffer_dirty (ubh->bh[i]);
99 }
100 
101 void ubh_mark_buffer_uptodate (struct ufs_buffer_head * ubh, int flag)
102 {
103 	unsigned i;
104 	if (!ubh)
105 		return;
106 	if (flag) {
107 		for ( i = 0; i < ubh->count; i++ )
108 			set_buffer_uptodate (ubh->bh[i]);
109 	} else {
110 		for ( i = 0; i < ubh->count; i++ )
111 			clear_buffer_uptodate (ubh->bh[i]);
112 	}
113 }
114 
115 void ubh_ll_rw_block(int rw, struct ufs_buffer_head *ubh)
116 {
117 	if (!ubh)
118 		return;
119 
120 	ll_rw_block(rw, ubh->count, ubh->bh);
121 }
122 
123 void ubh_wait_on_buffer (struct ufs_buffer_head * ubh)
124 {
125 	unsigned i;
126 	if (!ubh)
127 		return;
128 	for ( i = 0; i < ubh->count; i++ )
129 		wait_on_buffer (ubh->bh[i]);
130 }
131 
132 void ubh_bforget (struct ufs_buffer_head * ubh)
133 {
134 	unsigned i;
135 	if (!ubh)
136 		return;
137 	for ( i = 0; i < ubh->count; i++ ) if ( ubh->bh[i] )
138 		bforget (ubh->bh[i]);
139 }
140 
141 int ubh_buffer_dirty (struct ufs_buffer_head * ubh)
142 {
143 	unsigned i;
144 	unsigned result = 0;
145 	if (!ubh)
146 		return 0;
147 	for ( i = 0; i < ubh->count; i++ )
148 		result |= buffer_dirty(ubh->bh[i]);
149 	return result;
150 }
151 
152 void _ubh_ubhcpymem_(struct ufs_sb_private_info * uspi,
153 	unsigned char * mem, struct ufs_buffer_head * ubh, unsigned size)
154 {
155 	unsigned len, bhno;
156 	if (size > (ubh->count << uspi->s_fshift))
157 		size = ubh->count << uspi->s_fshift;
158 	bhno = 0;
159 	while (size) {
160 		len = min_t(unsigned int, size, uspi->s_fsize);
161 		memcpy (mem, ubh->bh[bhno]->b_data, len);
162 		mem += uspi->s_fsize;
163 		size -= len;
164 		bhno++;
165 	}
166 }
167 
168 void _ubh_memcpyubh_(struct ufs_sb_private_info * uspi,
169 	struct ufs_buffer_head * ubh, unsigned char * mem, unsigned size)
170 {
171 	unsigned len, bhno;
172 	if (size > (ubh->count << uspi->s_fshift))
173 		size = ubh->count << uspi->s_fshift;
174 	bhno = 0;
175 	while (size) {
176 		len = min_t(unsigned int, size, uspi->s_fsize);
177 		memcpy (ubh->bh[bhno]->b_data, mem, len);
178 		mem += uspi->s_fsize;
179 		size -= len;
180 		bhno++;
181 	}
182 }
183 
184 dev_t
185 ufs_get_inode_dev(struct super_block *sb, struct ufs_inode_info *ufsi)
186 {
187 	__u32 fs32;
188 	dev_t dev;
189 
190 	if ((UFS_SB(sb)->s_flags & UFS_ST_MASK) == UFS_ST_SUNx86)
191 		fs32 = fs32_to_cpu(sb, ufsi->i_u1.i_data[1]);
192 	else
193 		fs32 = fs32_to_cpu(sb, ufsi->i_u1.i_data[0]);
194 	switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
195 	case UFS_ST_SUNx86:
196 	case UFS_ST_SUN:
197 		if ((fs32 & 0xffff0000) == 0 ||
198 		    (fs32 & 0xffff0000) == 0xffff0000)
199 			dev = old_decode_dev(fs32 & 0x7fff);
200 		else
201 			dev = MKDEV(sysv_major(fs32), sysv_minor(fs32));
202 		break;
203 
204 	default:
205 		dev = old_decode_dev(fs32);
206 		break;
207 	}
208 	return dev;
209 }
210 
211 void
212 ufs_set_inode_dev(struct super_block *sb, struct ufs_inode_info *ufsi, dev_t dev)
213 {
214 	__u32 fs32;
215 
216 	switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
217 	case UFS_ST_SUNx86:
218 	case UFS_ST_SUN:
219 		fs32 = sysv_encode_dev(dev);
220 		if ((fs32 & 0xffff8000) == 0) {
221 			fs32 = old_encode_dev(dev);
222 		}
223 		break;
224 
225 	default:
226 		fs32 = old_encode_dev(dev);
227 		break;
228 	}
229 	if ((UFS_SB(sb)->s_flags & UFS_ST_MASK) == UFS_ST_SUNx86)
230 		ufsi->i_u1.i_data[1] = cpu_to_fs32(sb, fs32);
231 	else
232 		ufsi->i_u1.i_data[0] = cpu_to_fs32(sb, fs32);
233 }
234 
235 /**
236  * ufs_get_locked_page() - locate, pin and lock a pagecache page, if not exist
237  * read it from disk.
238  * @mapping: the address_space to search
239  * @index: the page index
240  *
241  * Locates the desired pagecache page, if not exist we'll read it,
242  * locks it, increments its reference
243  * count and returns its address.
244  *
245  */
246 
247 struct page *ufs_get_locked_page(struct address_space *mapping,
248 				 pgoff_t index)
249 {
250 	struct page *page;
251 
252 	page = find_lock_page(mapping, index);
253 	if (!page) {
254 		page = read_mapping_page(mapping, index, NULL);
255 
256 		if (IS_ERR(page)) {
257 			printk(KERN_ERR "ufs_change_blocknr: "
258 			       "read_mapping_page error: ino %lu, index: %lu\n",
259 			       mapping->host->i_ino, index);
260 			goto out;
261 		}
262 
263 		lock_page(page);
264 
265 		if (unlikely(page->mapping == NULL)) {
266 			/* Truncate got there first */
267 			unlock_page(page);
268 			page_cache_release(page);
269 			page = NULL;
270 			goto out;
271 		}
272 
273 		if (!PageUptodate(page) || PageError(page)) {
274 			unlock_page(page);
275 			page_cache_release(page);
276 
277 			printk(KERN_ERR "ufs_change_blocknr: "
278 			       "can not read page: ino %lu, index: %lu\n",
279 			       mapping->host->i_ino, index);
280 
281 			page = ERR_PTR(-EIO);
282 		}
283 	}
284 out:
285 	return page;
286 }
287