Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4
[linux-2.6] / fs / nilfs2 / dat.c
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 int nilfs_dat_prepare_free(struct inode *dat, struct nilfs_palloc_req *req)
96 {
97         int ret;
98
99         ret = nilfs_palloc_prepare_free_entry(dat, req);
100         if (ret < 0)
101                 return ret;
102         ret = nilfs_dat_prepare_entry(dat, req, 0);
103         if (ret < 0) {
104                 nilfs_palloc_abort_free_entry(dat, req);
105                 return ret;
106         }
107         return 0;
108 }
109
110 void nilfs_dat_commit_free(struct inode *dat, struct nilfs_palloc_req *req)
111 {
112         struct nilfs_dat_entry *entry;
113         void *kaddr;
114
115         kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
116         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
117                                              req->pr_entry_bh, kaddr);
118         entry->de_start = cpu_to_le64(NILFS_CNO_MIN);
119         entry->de_end = cpu_to_le64(NILFS_CNO_MIN);
120         entry->de_blocknr = cpu_to_le64(0);
121         kunmap_atomic(kaddr, KM_USER0);
122
123         nilfs_dat_commit_entry(dat, req);
124         nilfs_palloc_commit_free_entry(dat, req);
125 }
126
127 void nilfs_dat_abort_free(struct inode *dat, struct nilfs_palloc_req *req)
128 {
129         nilfs_dat_abort_entry(dat, req);
130         nilfs_palloc_abort_free_entry(dat, req);
131 }
132
133 int nilfs_dat_prepare_start(struct inode *dat, struct nilfs_palloc_req *req)
134 {
135         int ret;
136
137         ret = nilfs_dat_prepare_entry(dat, req, 0);
138         WARN_ON(ret == -ENOENT);
139         return ret;
140 }
141
142 void nilfs_dat_commit_start(struct inode *dat, struct nilfs_palloc_req *req,
143                             sector_t blocknr)
144 {
145         struct nilfs_dat_entry *entry;
146         void *kaddr;
147
148         kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
149         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
150                                              req->pr_entry_bh, kaddr);
151         entry->de_start = cpu_to_le64(nilfs_mdt_cno(dat));
152         if (entry->de_blocknr != cpu_to_le64(0) ||
153             entry->de_end != cpu_to_le64(NILFS_CNO_MAX)) {
154                 printk(KERN_CRIT
155                        "%s: vbn = %llu, start = %llu, end = %llu, pbn = %llu\n",
156                        __func__, (unsigned long long)req->pr_entry_nr,
157                        (unsigned long long)le64_to_cpu(entry->de_start),
158                        (unsigned long long)le64_to_cpu(entry->de_end),
159                        (unsigned long long)le64_to_cpu(entry->de_blocknr));
160         }
161         entry->de_blocknr = cpu_to_le64(blocknr);
162         kunmap_atomic(kaddr, KM_USER0);
163
164         nilfs_dat_commit_entry(dat, req);
165 }
166
167 void nilfs_dat_abort_start(struct inode *dat, struct nilfs_palloc_req *req)
168 {
169         nilfs_dat_abort_entry(dat, req);
170 }
171
172 int nilfs_dat_prepare_end(struct inode *dat, struct nilfs_palloc_req *req)
173 {
174         struct nilfs_dat_entry *entry;
175         __u64 start;
176         sector_t blocknr;
177         void *kaddr;
178         int ret;
179
180         ret = nilfs_dat_prepare_entry(dat, req, 0);
181         if (ret < 0) {
182                 WARN_ON(ret == -ENOENT);
183                 return ret;
184         }
185
186         kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
187         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
188                                              req->pr_entry_bh, kaddr);
189         start = le64_to_cpu(entry->de_start);
190         blocknr = le64_to_cpu(entry->de_blocknr);
191         kunmap_atomic(kaddr, KM_USER0);
192
193         if (blocknr == 0) {
194                 ret = nilfs_palloc_prepare_free_entry(dat, req);
195                 if (ret < 0) {
196                         nilfs_dat_abort_entry(dat, req);
197                         return ret;
198                 }
199         }
200
201         return 0;
202 }
203
204 void nilfs_dat_commit_end(struct inode *dat, struct nilfs_palloc_req *req,
205                           int dead)
206 {
207         struct nilfs_dat_entry *entry;
208         __u64 start, end;
209         sector_t blocknr;
210         void *kaddr;
211
212         kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
213         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
214                                              req->pr_entry_bh, kaddr);
215         end = start = le64_to_cpu(entry->de_start);
216         if (!dead) {
217                 end = nilfs_mdt_cno(dat);
218                 WARN_ON(start > end);
219         }
220         entry->de_end = cpu_to_le64(end);
221         blocknr = le64_to_cpu(entry->de_blocknr);
222         kunmap_atomic(kaddr, KM_USER0);
223
224         if (blocknr == 0)
225                 nilfs_dat_commit_free(dat, req);
226         else
227                 nilfs_dat_commit_entry(dat, req);
228 }
229
230 void nilfs_dat_abort_end(struct inode *dat, struct nilfs_palloc_req *req)
231 {
232         struct nilfs_dat_entry *entry;
233         __u64 start;
234         sector_t blocknr;
235         void *kaddr;
236
237         kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
238         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
239                                              req->pr_entry_bh, kaddr);
240         start = le64_to_cpu(entry->de_start);
241         blocknr = le64_to_cpu(entry->de_blocknr);
242         kunmap_atomic(kaddr, KM_USER0);
243
244         if (start == nilfs_mdt_cno(dat) && blocknr == 0)
245                 nilfs_palloc_abort_free_entry(dat, req);
246         nilfs_dat_abort_entry(dat, req);
247 }
248
249 /**
250  * nilfs_dat_mark_dirty -
251  * @dat: DAT file inode
252  * @vblocknr: virtual block number
253  *
254  * Description:
255  *
256  * Return Value: On success, 0 is returned. On error, one of the following
257  * negative error codes is returned.
258  *
259  * %-EIO - I/O error.
260  *
261  * %-ENOMEM - Insufficient amount of memory available.
262  */
263 int nilfs_dat_mark_dirty(struct inode *dat, __u64 vblocknr)
264 {
265         struct nilfs_palloc_req req;
266         int ret;
267
268         req.pr_entry_nr = vblocknr;
269         ret = nilfs_dat_prepare_entry(dat, &req, 0);
270         if (ret == 0)
271                 nilfs_dat_commit_entry(dat, &req);
272         return ret;
273 }
274
275 /**
276  * nilfs_dat_freev - free virtual block numbers
277  * @dat: DAT file inode
278  * @vblocknrs: array of virtual block numbers
279  * @nitems: number of virtual block numbers
280  *
281  * Description: nilfs_dat_freev() frees the virtual block numbers specified by
282  * @vblocknrs and @nitems.
283  *
284  * Return Value: On success, 0 is returned. On error, one of the following
285  * nagative error codes is returned.
286  *
287  * %-EIO - I/O error.
288  *
289  * %-ENOMEM - Insufficient amount of memory available.
290  *
291  * %-ENOENT - The virtual block number have not been allocated.
292  */
293 int nilfs_dat_freev(struct inode *dat, __u64 *vblocknrs, size_t nitems)
294 {
295         return nilfs_palloc_freev(dat, vblocknrs, nitems);
296 }
297
298 /**
299  * nilfs_dat_move - change a block number
300  * @dat: DAT file inode
301  * @vblocknr: virtual block number
302  * @blocknr: block number
303  *
304  * Description: nilfs_dat_move() changes the block number associated with
305  * @vblocknr to @blocknr.
306  *
307  * Return Value: On success, 0 is returned. On error, one of the following
308  * negative error codes is returned.
309  *
310  * %-EIO - I/O error.
311  *
312  * %-ENOMEM - Insufficient amount of memory available.
313  */
314 int nilfs_dat_move(struct inode *dat, __u64 vblocknr, sector_t blocknr)
315 {
316         struct buffer_head *entry_bh;
317         struct nilfs_dat_entry *entry;
318         void *kaddr;
319         int ret;
320
321         ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
322         if (ret < 0)
323                 return ret;
324         kaddr = kmap_atomic(entry_bh->b_page, KM_USER0);
325         entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
326         if (unlikely(entry->de_blocknr == cpu_to_le64(0))) {
327                 printk(KERN_CRIT "%s: vbn = %llu, [%llu, %llu)\n", __func__,
328                        (unsigned long long)vblocknr,
329                        (unsigned long long)le64_to_cpu(entry->de_start),
330                        (unsigned long long)le64_to_cpu(entry->de_end));
331                 kunmap_atomic(kaddr, KM_USER0);
332                 brelse(entry_bh);
333                 return -EINVAL;
334         }
335         WARN_ON(blocknr == 0);
336         entry->de_blocknr = cpu_to_le64(blocknr);
337         kunmap_atomic(kaddr, KM_USER0);
338
339         nilfs_mdt_mark_buffer_dirty(entry_bh);
340         nilfs_mdt_mark_dirty(dat);
341
342         brelse(entry_bh);
343
344         return 0;
345 }
346
347 /**
348  * nilfs_dat_translate - translate a virtual block number to a block number
349  * @dat: DAT file inode
350  * @vblocknr: virtual block number
351  * @blocknrp: pointer to a block number
352  *
353  * Description: nilfs_dat_translate() maps the virtual block number @vblocknr
354  * to the corresponding block number.
355  *
356  * Return Value: On success, 0 is returned and the block number associated
357  * with @vblocknr is stored in the place pointed by @blocknrp. On error, one
358  * of the following negative error codes is returned.
359  *
360  * %-EIO - I/O error.
361  *
362  * %-ENOMEM - Insufficient amount of memory available.
363  *
364  * %-ENOENT - A block number associated with @vblocknr does not exist.
365  */
366 int nilfs_dat_translate(struct inode *dat, __u64 vblocknr, sector_t *blocknrp)
367 {
368         struct buffer_head *entry_bh;
369         struct nilfs_dat_entry *entry;
370         sector_t blocknr;
371         void *kaddr;
372         int ret;
373
374         ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
375         if (ret < 0)
376                 return ret;
377
378         kaddr = kmap_atomic(entry_bh->b_page, KM_USER0);
379         entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
380         blocknr = le64_to_cpu(entry->de_blocknr);
381         if (blocknr == 0) {
382                 ret = -ENOENT;
383                 goto out;
384         }
385         if (blocknrp != NULL)
386                 *blocknrp = blocknr;
387
388  out:
389         kunmap_atomic(kaddr, KM_USER0);
390         brelse(entry_bh);
391         return ret;
392 }
393
394 ssize_t nilfs_dat_get_vinfo(struct inode *dat, struct nilfs_vinfo *vinfo,
395                             size_t nvi)
396 {
397         struct buffer_head *entry_bh;
398         struct nilfs_dat_entry *entry;
399         __u64 first, last;
400         void *kaddr;
401         unsigned long entries_per_block = NILFS_MDT(dat)->mi_entries_per_block;
402         int i, j, n, ret;
403
404         for (i = 0; i < nvi; i += n) {
405                 ret = nilfs_palloc_get_entry_block(dat, vinfo[i].vi_vblocknr,
406                                                    0, &entry_bh);
407                 if (ret < 0)
408                         return ret;
409                 kaddr = kmap_atomic(entry_bh->b_page, KM_USER0);
410                 /* last virtual block number in this block */
411                 first = vinfo[i].vi_vblocknr;
412                 do_div(first, entries_per_block);
413                 first *= entries_per_block;
414                 last = first + entries_per_block - 1;
415                 for (j = i, n = 0;
416                      j < nvi && vinfo[j].vi_vblocknr >= first &&
417                              vinfo[j].vi_vblocknr <= last;
418                      j++, n++) {
419                         entry = nilfs_palloc_block_get_entry(
420                                 dat, vinfo[j].vi_vblocknr, entry_bh, kaddr);
421                         vinfo[j].vi_start = le64_to_cpu(entry->de_start);
422                         vinfo[j].vi_end = le64_to_cpu(entry->de_end);
423                         vinfo[j].vi_blocknr = le64_to_cpu(entry->de_blocknr);
424                 }
425                 kunmap_atomic(kaddr, KM_USER0);
426                 brelse(entry_bh);
427         }
428
429         return nvi;
430 }