Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dat.c
Go to the documentation of this file.
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 <[email protected]>.
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 
46 };
47 
48 static inline struct nilfs_dat_info *NILFS_DAT_I(struct inode *dat)
49 {
50  return (struct nilfs_dat_info *)NILFS_MDT(dat);
51 }
52 
53 static int nilfs_dat_prepare_entry(struct inode *dat,
54  struct nilfs_palloc_req *req, int create)
55 {
57  create, &req->pr_entry_bh);
58 }
59 
60 static void nilfs_dat_commit_entry(struct inode *dat,
61  struct nilfs_palloc_req *req)
62 {
64  nilfs_mdt_mark_dirty(dat);
65  brelse(req->pr_entry_bh);
66 }
67 
68 static void nilfs_dat_abort_entry(struct inode *dat,
69  struct nilfs_palloc_req *req)
70 {
71  brelse(req->pr_entry_bh);
72 }
73 
75 {
76  int ret;
77 
78  ret = nilfs_palloc_prepare_alloc_entry(dat, req);
79  if (ret < 0)
80  return ret;
81 
82  ret = nilfs_dat_prepare_entry(dat, req, 1);
83  if (ret < 0)
85 
86  return ret;
87 }
88 
90 {
91  struct nilfs_dat_entry *entry;
92  void *kaddr;
93 
94  kaddr = kmap_atomic(req->pr_entry_bh->b_page);
95  entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
96  req->pr_entry_bh, kaddr);
99  entry->de_blocknr = cpu_to_le64(0);
100  kunmap_atomic(kaddr);
101 
103  nilfs_dat_commit_entry(dat, req);
104 }
105 
107 {
108  nilfs_dat_abort_entry(dat, req);
110 }
111 
112 static void nilfs_dat_commit_free(struct inode *dat,
113  struct nilfs_palloc_req *req)
114 {
115  struct nilfs_dat_entry *entry;
116  void *kaddr;
117 
118  kaddr = kmap_atomic(req->pr_entry_bh->b_page);
119  entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
120  req->pr_entry_bh, kaddr);
122  entry->de_end = cpu_to_le64(NILFS_CNO_MIN);
123  entry->de_blocknr = cpu_to_le64(0);
124  kunmap_atomic(kaddr);
125 
126  nilfs_dat_commit_entry(dat, req);
128 }
129 
131 {
132  int ret;
133 
134  ret = nilfs_dat_prepare_entry(dat, req, 0);
135  WARN_ON(ret == -ENOENT);
136  return ret;
137 }
138 
141 {
142  struct nilfs_dat_entry *entry;
143  void *kaddr;
144 
145  kaddr = kmap_atomic(req->pr_entry_bh->b_page);
146  entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
147  req->pr_entry_bh, kaddr);
148  entry->de_start = cpu_to_le64(nilfs_mdt_cno(dat));
149  entry->de_blocknr = cpu_to_le64(blocknr);
150  kunmap_atomic(kaddr);
151 
152  nilfs_dat_commit_entry(dat, req);
153 }
154 
156 {
157  struct nilfs_dat_entry *entry;
158  __u64 start;
160  void *kaddr;
161  int ret;
162 
163  ret = nilfs_dat_prepare_entry(dat, req, 0);
164  if (ret < 0) {
165  WARN_ON(ret == -ENOENT);
166  return ret;
167  }
168 
169  kaddr = kmap_atomic(req->pr_entry_bh->b_page);
170  entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
171  req->pr_entry_bh, kaddr);
172  start = le64_to_cpu(entry->de_start);
173  blocknr = le64_to_cpu(entry->de_blocknr);
174  kunmap_atomic(kaddr);
175 
176  if (blocknr == 0) {
177  ret = nilfs_palloc_prepare_free_entry(dat, req);
178  if (ret < 0) {
179  nilfs_dat_abort_entry(dat, req);
180  return ret;
181  }
182  }
183 
184  return 0;
185 }
186 
187 void nilfs_dat_commit_end(struct inode *dat, struct nilfs_palloc_req *req,
188  int dead)
189 {
190  struct nilfs_dat_entry *entry;
191  __u64 start, end;
193  void *kaddr;
194 
195  kaddr = kmap_atomic(req->pr_entry_bh->b_page);
196  entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
197  req->pr_entry_bh, kaddr);
198  end = start = le64_to_cpu(entry->de_start);
199  if (!dead) {
200  end = nilfs_mdt_cno(dat);
201  WARN_ON(start > end);
202  }
203  entry->de_end = cpu_to_le64(end);
204  blocknr = le64_to_cpu(entry->de_blocknr);
205  kunmap_atomic(kaddr);
206 
207  if (blocknr == 0)
208  nilfs_dat_commit_free(dat, req);
209  else
210  nilfs_dat_commit_entry(dat, req);
211 }
212 
213 void nilfs_dat_abort_end(struct inode *dat, struct nilfs_palloc_req *req)
214 {
215  struct nilfs_dat_entry *entry;
216  __u64 start;
218  void *kaddr;
219 
220  kaddr = kmap_atomic(req->pr_entry_bh->b_page);
221  entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
222  req->pr_entry_bh, kaddr);
223  start = le64_to_cpu(entry->de_start);
224  blocknr = le64_to_cpu(entry->de_blocknr);
225  kunmap_atomic(kaddr);
226 
227  if (start == nilfs_mdt_cno(dat) && blocknr == 0)
229  nilfs_dat_abort_entry(dat, req);
230 }
231 
233  struct nilfs_palloc_req *oldreq,
234  struct nilfs_palloc_req *newreq)
235 {
236  int ret;
237 
238  ret = nilfs_dat_prepare_end(dat, oldreq);
239  if (!ret) {
240  ret = nilfs_dat_prepare_alloc(dat, newreq);
241  if (ret < 0)
242  nilfs_dat_abort_end(dat, oldreq);
243  }
244  return ret;
245 }
246 
248  struct nilfs_palloc_req *oldreq,
249  struct nilfs_palloc_req *newreq, int dead)
250 {
251  nilfs_dat_commit_end(dat, oldreq, dead);
252  nilfs_dat_commit_alloc(dat, newreq);
253 }
254 
255 void nilfs_dat_abort_update(struct inode *dat,
256  struct nilfs_palloc_req *oldreq,
257  struct nilfs_palloc_req *newreq)
258 {
259  nilfs_dat_abort_end(dat, oldreq);
260  nilfs_dat_abort_alloc(dat, newreq);
261 }
262 
277 int nilfs_dat_mark_dirty(struct inode *dat, __u64 vblocknr)
278 {
279  struct nilfs_palloc_req req;
280  int ret;
281 
282  req.pr_entry_nr = vblocknr;
283  ret = nilfs_dat_prepare_entry(dat, &req, 0);
284  if (ret == 0)
285  nilfs_dat_commit_entry(dat, &req);
286  return ret;
287 }
288 
307 int nilfs_dat_freev(struct inode *dat, __u64 *vblocknrs, size_t nitems)
308 {
309  return nilfs_palloc_freev(dat, vblocknrs, nitems);
310 }
311 
328 int nilfs_dat_move(struct inode *dat, __u64 vblocknr, sector_t blocknr)
329 {
330  struct buffer_head *entry_bh;
331  struct nilfs_dat_entry *entry;
332  void *kaddr;
333  int ret;
334 
335  ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
336  if (ret < 0)
337  return ret;
338 
339  /*
340  * The given disk block number (blocknr) is not yet written to
341  * the device at this point.
342  *
343  * To prevent nilfs_dat_translate() from returning the
344  * uncommitted block number, this makes a copy of the entry
345  * buffer and redirects nilfs_dat_translate() to the copy.
346  */
347  if (!buffer_nilfs_redirected(entry_bh)) {
348  ret = nilfs_mdt_freeze_buffer(dat, entry_bh);
349  if (ret) {
350  brelse(entry_bh);
351  return ret;
352  }
353  }
354 
355  kaddr = kmap_atomic(entry_bh->b_page);
356  entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
357  if (unlikely(entry->de_blocknr == cpu_to_le64(0))) {
358  printk(KERN_CRIT "%s: vbn = %llu, [%llu, %llu)\n", __func__,
359  (unsigned long long)vblocknr,
360  (unsigned long long)le64_to_cpu(entry->de_start),
361  (unsigned long long)le64_to_cpu(entry->de_end));
362  kunmap_atomic(kaddr);
363  brelse(entry_bh);
364  return -EINVAL;
365  }
366  WARN_ON(blocknr == 0);
367  entry->de_blocknr = cpu_to_le64(blocknr);
368  kunmap_atomic(kaddr);
369 
370  mark_buffer_dirty(entry_bh);
371  nilfs_mdt_mark_dirty(dat);
372 
373  brelse(entry_bh);
374 
375  return 0;
376 }
377 
397 int nilfs_dat_translate(struct inode *dat, __u64 vblocknr, sector_t *blocknrp)
398 {
399  struct buffer_head *entry_bh, *bh;
400  struct nilfs_dat_entry *entry;
402  void *kaddr;
403  int ret;
404 
405  ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
406  if (ret < 0)
407  return ret;
408 
409  if (!nilfs_doing_gc() && buffer_nilfs_redirected(entry_bh)) {
410  bh = nilfs_mdt_get_frozen_buffer(dat, entry_bh);
411  if (bh) {
412  WARN_ON(!buffer_uptodate(bh));
413  brelse(entry_bh);
414  entry_bh = bh;
415  }
416  }
417 
418  kaddr = kmap_atomic(entry_bh->b_page);
419  entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
420  blocknr = le64_to_cpu(entry->de_blocknr);
421  if (blocknr == 0) {
422  ret = -ENOENT;
423  goto out;
424  }
425  *blocknrp = blocknr;
426 
427  out:
428  kunmap_atomic(kaddr);
429  brelse(entry_bh);
430  return ret;
431 }
432 
433 ssize_t nilfs_dat_get_vinfo(struct inode *dat, void *buf, unsigned visz,
434  size_t nvi)
435 {
436  struct buffer_head *entry_bh;
437  struct nilfs_dat_entry *entry;
438  struct nilfs_vinfo *vinfo = buf;
439  __u64 first, last;
440  void *kaddr;
441  unsigned long entries_per_block = NILFS_MDT(dat)->mi_entries_per_block;
442  int i, j, n, ret;
443 
444  for (i = 0; i < nvi; i += n) {
445  ret = nilfs_palloc_get_entry_block(dat, vinfo->vi_vblocknr,
446  0, &entry_bh);
447  if (ret < 0)
448  return ret;
449  kaddr = kmap_atomic(entry_bh->b_page);
450  /* last virtual block number in this block */
451  first = vinfo->vi_vblocknr;
452  do_div(first, entries_per_block);
453  first *= entries_per_block;
454  last = first + entries_per_block - 1;
455  for (j = i, n = 0;
456  j < nvi && vinfo->vi_vblocknr >= first &&
457  vinfo->vi_vblocknr <= last;
458  j++, n++, vinfo = (void *)vinfo + visz) {
460  dat, vinfo->vi_vblocknr, entry_bh, kaddr);
461  vinfo->vi_start = le64_to_cpu(entry->de_start);
462  vinfo->vi_end = le64_to_cpu(entry->de_end);
463  vinfo->vi_blocknr = le64_to_cpu(entry->de_blocknr);
464  }
465  kunmap_atomic(kaddr);
466  brelse(entry_bh);
467  }
468 
469  return nvi;
470 }
471 
479 int nilfs_dat_read(struct super_block *sb, size_t entry_size,
480  struct nilfs_inode *raw_inode, struct inode **inodep)
481 {
482  static struct lock_class_key dat_lock_key;
483  struct inode *dat;
484  struct nilfs_dat_info *di;
485  int err;
486 
488  if (unlikely(!dat))
489  return -ENOMEM;
490  if (!(dat->i_state & I_NEW))
491  goto out;
492 
493  err = nilfs_mdt_init(dat, NILFS_MDT_GFP, sizeof(*di));
494  if (err)
495  goto failed;
496 
497  err = nilfs_palloc_init_blockgroup(dat, entry_size);
498  if (err)
499  goto failed;
500 
501  di = NILFS_DAT_I(dat);
502  lockdep_set_class(&di->mi.mi_sem, &dat_lock_key);
505 
506  err = nilfs_read_inode_common(dat, raw_inode);
507  if (err)
508  goto failed;
509 
510  unlock_new_inode(dat);
511  out:
512  *inodep = dat;
513  return 0;
514  failed:
515  iget_failed(dat);
516  return err;
517 }