xref: /openbmc/linux/fs/nilfs2/dat.c (revision fd589a8f)
1 /*
2  * dat.c - NILFS disk address translation.
3  *
4  * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  * Written by Koji Sato <koji@osrg.net>.
21  */
22 
23 #include <linux/types.h>
24 #include <linux/buffer_head.h>
25 #include <linux/string.h>
26 #include <linux/errno.h>
27 #include "nilfs.h"
28 #include "mdt.h"
29 #include "alloc.h"
30 #include "dat.h"
31 
32 
33 #define NILFS_CNO_MIN	((__u64)1)
34 #define NILFS_CNO_MAX	(~(__u64)0)
35 
36 static int nilfs_dat_prepare_entry(struct inode *dat,
37 				   struct nilfs_palloc_req *req, int create)
38 {
39 	return nilfs_palloc_get_entry_block(dat, req->pr_entry_nr,
40 					    create, &req->pr_entry_bh);
41 }
42 
43 static void nilfs_dat_commit_entry(struct inode *dat,
44 				   struct nilfs_palloc_req *req)
45 {
46 	nilfs_mdt_mark_buffer_dirty(req->pr_entry_bh);
47 	nilfs_mdt_mark_dirty(dat);
48 	brelse(req->pr_entry_bh);
49 }
50 
51 static void nilfs_dat_abort_entry(struct inode *dat,
52 				  struct nilfs_palloc_req *req)
53 {
54 	brelse(req->pr_entry_bh);
55 }
56 
57 int nilfs_dat_prepare_alloc(struct inode *dat, struct nilfs_palloc_req *req)
58 {
59 	int ret;
60 
61 	ret = nilfs_palloc_prepare_alloc_entry(dat, req);
62 	if (ret < 0)
63 		return ret;
64 
65 	ret = nilfs_dat_prepare_entry(dat, req, 1);
66 	if (ret < 0)
67 		nilfs_palloc_abort_alloc_entry(dat, req);
68 
69 	return ret;
70 }
71 
72 void nilfs_dat_commit_alloc(struct inode *dat, struct nilfs_palloc_req *req)
73 {
74 	struct nilfs_dat_entry *entry;
75 	void *kaddr;
76 
77 	kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
78 	entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
79 					     req->pr_entry_bh, kaddr);
80 	entry->de_start = cpu_to_le64(NILFS_CNO_MIN);
81 	entry->de_end = cpu_to_le64(NILFS_CNO_MAX);
82 	entry->de_blocknr = cpu_to_le64(0);
83 	kunmap_atomic(kaddr, KM_USER0);
84 
85 	nilfs_palloc_commit_alloc_entry(dat, req);
86 	nilfs_dat_commit_entry(dat, req);
87 }
88 
89 void nilfs_dat_abort_alloc(struct inode *dat, struct nilfs_palloc_req *req)
90 {
91 	nilfs_dat_abort_entry(dat, req);
92 	nilfs_palloc_abort_alloc_entry(dat, req);
93 }
94 
95 void nilfs_dat_commit_free(struct inode *dat, struct nilfs_palloc_req *req)
96 {
97 	struct nilfs_dat_entry *entry;
98 	void *kaddr;
99 
100 	kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
101 	entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
102 					     req->pr_entry_bh, kaddr);
103 	entry->de_start = cpu_to_le64(NILFS_CNO_MIN);
104 	entry->de_end = cpu_to_le64(NILFS_CNO_MIN);
105 	entry->de_blocknr = cpu_to_le64(0);
106 	kunmap_atomic(kaddr, KM_USER0);
107 
108 	nilfs_dat_commit_entry(dat, req);
109 	nilfs_palloc_commit_free_entry(dat, req);
110 }
111 
112 int nilfs_dat_prepare_start(struct inode *dat, struct nilfs_palloc_req *req)
113 {
114 	int ret;
115 
116 	ret = nilfs_dat_prepare_entry(dat, req, 0);
117 	WARN_ON(ret == -ENOENT);
118 	return ret;
119 }
120 
121 void nilfs_dat_commit_start(struct inode *dat, struct nilfs_palloc_req *req,
122 			    sector_t blocknr)
123 {
124 	struct nilfs_dat_entry *entry;
125 	void *kaddr;
126 
127 	kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
128 	entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
129 					     req->pr_entry_bh, kaddr);
130 	entry->de_start = cpu_to_le64(nilfs_mdt_cno(dat));
131 	entry->de_blocknr = cpu_to_le64(blocknr);
132 	kunmap_atomic(kaddr, KM_USER0);
133 
134 	nilfs_dat_commit_entry(dat, req);
135 }
136 
137 int nilfs_dat_prepare_end(struct inode *dat, struct nilfs_palloc_req *req)
138 {
139 	struct nilfs_dat_entry *entry;
140 	__u64 start;
141 	sector_t blocknr;
142 	void *kaddr;
143 	int ret;
144 
145 	ret = nilfs_dat_prepare_entry(dat, req, 0);
146 	if (ret < 0) {
147 		WARN_ON(ret == -ENOENT);
148 		return ret;
149 	}
150 
151 	kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
152 	entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
153 					     req->pr_entry_bh, kaddr);
154 	start = le64_to_cpu(entry->de_start);
155 	blocknr = le64_to_cpu(entry->de_blocknr);
156 	kunmap_atomic(kaddr, KM_USER0);
157 
158 	if (blocknr == 0) {
159 		ret = nilfs_palloc_prepare_free_entry(dat, req);
160 		if (ret < 0) {
161 			nilfs_dat_abort_entry(dat, req);
162 			return ret;
163 		}
164 	}
165 
166 	return 0;
167 }
168 
169 void nilfs_dat_commit_end(struct inode *dat, struct nilfs_palloc_req *req,
170 			  int dead)
171 {
172 	struct nilfs_dat_entry *entry;
173 	__u64 start, end;
174 	sector_t blocknr;
175 	void *kaddr;
176 
177 	kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
178 	entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
179 					     req->pr_entry_bh, kaddr);
180 	end = start = le64_to_cpu(entry->de_start);
181 	if (!dead) {
182 		end = nilfs_mdt_cno(dat);
183 		WARN_ON(start > end);
184 	}
185 	entry->de_end = cpu_to_le64(end);
186 	blocknr = le64_to_cpu(entry->de_blocknr);
187 	kunmap_atomic(kaddr, KM_USER0);
188 
189 	if (blocknr == 0)
190 		nilfs_dat_commit_free(dat, req);
191 	else
192 		nilfs_dat_commit_entry(dat, req);
193 }
194 
195 void nilfs_dat_abort_end(struct inode *dat, struct nilfs_palloc_req *req)
196 {
197 	struct nilfs_dat_entry *entry;
198 	__u64 start;
199 	sector_t blocknr;
200 	void *kaddr;
201 
202 	kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
203 	entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
204 					     req->pr_entry_bh, kaddr);
205 	start = le64_to_cpu(entry->de_start);
206 	blocknr = le64_to_cpu(entry->de_blocknr);
207 	kunmap_atomic(kaddr, KM_USER0);
208 
209 	if (start == nilfs_mdt_cno(dat) && blocknr == 0)
210 		nilfs_palloc_abort_free_entry(dat, req);
211 	nilfs_dat_abort_entry(dat, req);
212 }
213 
214 int nilfs_dat_prepare_update(struct inode *dat,
215 			     struct nilfs_palloc_req *oldreq,
216 			     struct nilfs_palloc_req *newreq)
217 {
218 	int ret;
219 
220 	ret = nilfs_dat_prepare_end(dat, oldreq);
221 	if (!ret) {
222 		ret = nilfs_dat_prepare_alloc(dat, newreq);
223 		if (ret < 0)
224 			nilfs_dat_abort_end(dat, oldreq);
225 	}
226 	return ret;
227 }
228 
229 void nilfs_dat_commit_update(struct inode *dat,
230 			     struct nilfs_palloc_req *oldreq,
231 			     struct nilfs_palloc_req *newreq, int dead)
232 {
233 	nilfs_dat_commit_end(dat, oldreq, dead);
234 	nilfs_dat_commit_alloc(dat, newreq);
235 }
236 
237 void nilfs_dat_abort_update(struct inode *dat,
238 			    struct nilfs_palloc_req *oldreq,
239 			    struct nilfs_palloc_req *newreq)
240 {
241 	nilfs_dat_abort_end(dat, oldreq);
242 	nilfs_dat_abort_alloc(dat, newreq);
243 }
244 
245 /**
246  * nilfs_dat_mark_dirty -
247  * @dat: DAT file inode
248  * @vblocknr: virtual block number
249  *
250  * Description:
251  *
252  * Return Value: On success, 0 is returned. On error, one of the following
253  * negative error codes is returned.
254  *
255  * %-EIO - I/O error.
256  *
257  * %-ENOMEM - Insufficient amount of memory available.
258  */
259 int nilfs_dat_mark_dirty(struct inode *dat, __u64 vblocknr)
260 {
261 	struct nilfs_palloc_req req;
262 	int ret;
263 
264 	req.pr_entry_nr = vblocknr;
265 	ret = nilfs_dat_prepare_entry(dat, &req, 0);
266 	if (ret == 0)
267 		nilfs_dat_commit_entry(dat, &req);
268 	return ret;
269 }
270 
271 /**
272  * nilfs_dat_freev - free virtual block numbers
273  * @dat: DAT file inode
274  * @vblocknrs: array of virtual block numbers
275  * @nitems: number of virtual block numbers
276  *
277  * Description: nilfs_dat_freev() frees the virtual block numbers specified by
278  * @vblocknrs and @nitems.
279  *
280  * Return Value: On success, 0 is returned. On error, one of the following
281  * nagative error codes is returned.
282  *
283  * %-EIO - I/O error.
284  *
285  * %-ENOMEM - Insufficient amount of memory available.
286  *
287  * %-ENOENT - The virtual block number have not been allocated.
288  */
289 int nilfs_dat_freev(struct inode *dat, __u64 *vblocknrs, size_t nitems)
290 {
291 	return nilfs_palloc_freev(dat, vblocknrs, nitems);
292 }
293 
294 /**
295  * nilfs_dat_move - change a block number
296  * @dat: DAT file inode
297  * @vblocknr: virtual block number
298  * @blocknr: block number
299  *
300  * Description: nilfs_dat_move() changes the block number associated with
301  * @vblocknr to @blocknr.
302  *
303  * Return Value: On success, 0 is returned. On error, one of the following
304  * negative error codes is returned.
305  *
306  * %-EIO - I/O error.
307  *
308  * %-ENOMEM - Insufficient amount of memory available.
309  */
310 int nilfs_dat_move(struct inode *dat, __u64 vblocknr, sector_t blocknr)
311 {
312 	struct buffer_head *entry_bh;
313 	struct nilfs_dat_entry *entry;
314 	void *kaddr;
315 	int ret;
316 
317 	ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
318 	if (ret < 0)
319 		return ret;
320 	kaddr = kmap_atomic(entry_bh->b_page, KM_USER0);
321 	entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
322 	if (unlikely(entry->de_blocknr == cpu_to_le64(0))) {
323 		printk(KERN_CRIT "%s: vbn = %llu, [%llu, %llu)\n", __func__,
324 		       (unsigned long long)vblocknr,
325 		       (unsigned long long)le64_to_cpu(entry->de_start),
326 		       (unsigned long long)le64_to_cpu(entry->de_end));
327 		kunmap_atomic(kaddr, KM_USER0);
328 		brelse(entry_bh);
329 		return -EINVAL;
330 	}
331 	WARN_ON(blocknr == 0);
332 	entry->de_blocknr = cpu_to_le64(blocknr);
333 	kunmap_atomic(kaddr, KM_USER0);
334 
335 	nilfs_mdt_mark_buffer_dirty(entry_bh);
336 	nilfs_mdt_mark_dirty(dat);
337 
338 	brelse(entry_bh);
339 
340 	return 0;
341 }
342 
343 /**
344  * nilfs_dat_translate - translate a virtual block number to a block number
345  * @dat: DAT file inode
346  * @vblocknr: virtual block number
347  * @blocknrp: pointer to a block number
348  *
349  * Description: nilfs_dat_translate() maps the virtual block number @vblocknr
350  * to the corresponding block number.
351  *
352  * Return Value: On success, 0 is returned and the block number associated
353  * with @vblocknr is stored in the place pointed by @blocknrp. On error, one
354  * of the following negative error codes is returned.
355  *
356  * %-EIO - I/O error.
357  *
358  * %-ENOMEM - Insufficient amount of memory available.
359  *
360  * %-ENOENT - A block number associated with @vblocknr does not exist.
361  */
362 int nilfs_dat_translate(struct inode *dat, __u64 vblocknr, sector_t *blocknrp)
363 {
364 	struct buffer_head *entry_bh;
365 	struct nilfs_dat_entry *entry;
366 	sector_t blocknr;
367 	void *kaddr;
368 	int ret;
369 
370 	ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
371 	if (ret < 0)
372 		return ret;
373 
374 	kaddr = kmap_atomic(entry_bh->b_page, KM_USER0);
375 	entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
376 	blocknr = le64_to_cpu(entry->de_blocknr);
377 	if (blocknr == 0) {
378 		ret = -ENOENT;
379 		goto out;
380 	}
381 	if (blocknrp != NULL)
382 		*blocknrp = blocknr;
383 
384  out:
385 	kunmap_atomic(kaddr, KM_USER0);
386 	brelse(entry_bh);
387 	return ret;
388 }
389 
390 ssize_t nilfs_dat_get_vinfo(struct inode *dat, void *buf, unsigned visz,
391 			    size_t nvi)
392 {
393 	struct buffer_head *entry_bh;
394 	struct nilfs_dat_entry *entry;
395 	struct nilfs_vinfo *vinfo = buf;
396 	__u64 first, last;
397 	void *kaddr;
398 	unsigned long entries_per_block = NILFS_MDT(dat)->mi_entries_per_block;
399 	int i, j, n, ret;
400 
401 	for (i = 0; i < nvi; i += n) {
402 		ret = nilfs_palloc_get_entry_block(dat, vinfo->vi_vblocknr,
403 						   0, &entry_bh);
404 		if (ret < 0)
405 			return ret;
406 		kaddr = kmap_atomic(entry_bh->b_page, KM_USER0);
407 		/* last virtual block number in this block */
408 		first = vinfo->vi_vblocknr;
409 		do_div(first, entries_per_block);
410 		first *= entries_per_block;
411 		last = first + entries_per_block - 1;
412 		for (j = i, n = 0;
413 		     j < nvi && vinfo->vi_vblocknr >= first &&
414 			     vinfo->vi_vblocknr <= last;
415 		     j++, n++, vinfo = (void *)vinfo + visz) {
416 			entry = nilfs_palloc_block_get_entry(
417 				dat, vinfo->vi_vblocknr, entry_bh, kaddr);
418 			vinfo->vi_start = le64_to_cpu(entry->de_start);
419 			vinfo->vi_end = le64_to_cpu(entry->de_end);
420 			vinfo->vi_blocknr = le64_to_cpu(entry->de_blocknr);
421 		}
422 		kunmap_atomic(kaddr, KM_USER0);
423 		brelse(entry_bh);
424 	}
425 
426 	return nvi;
427 }
428