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 struct nilfs_dat_info {
  37         struct nilfs_mdt_info mi;
  38         struct nilfs_palloc_cache palloc_cache;
  39 };
  40
  41 static inline struct nilfs_dat_info *NILFS_DAT_I(struct inode *dat)
  42 {
  43         return (struct nilfs_dat_info *)NILFS_MDT(dat);
  44 }
  45
  46 static int nilfs_dat_prepare_entry(struct inode *dat,
  47                                    struct nilfs_palloc_req *req, int create)
  48 {
  49         return nilfs_palloc_get_entry_block(dat, req->pr_entry_nr,
  50                                             create, &req->pr_entry_bh);
  51 }
  52
  53 static void nilfs_dat_commit_entry(struct inode *dat,
  54                                    struct nilfs_palloc_req *req)
  55 {
  56         nilfs_mdt_mark_buffer_dirty(req->pr_entry_bh);
  57         nilfs_mdt_mark_dirty(dat);
  58         brelse(req->pr_entry_bh);
  59 }
  60
  61 static void nilfs_dat_abort_entry(struct inode *dat,
  62                                   struct nilfs_palloc_req *req)
  63 {
  64         brelse(req->pr_entry_bh);
  65 }
  66
  67 int nilfs_dat_prepare_alloc(struct inode *dat, struct nilfs_palloc_req *req)
  68 {
  69         int ret;
  70
  71         ret = nilfs_palloc_prepare_alloc_entry(dat, req);
  72         if (ret < 0)
  73                 return ret;
  74
  75         ret = nilfs_dat_prepare_entry(dat, req, 1);
  76         if (ret < 0)
  77                 nilfs_palloc_abort_alloc_entry(dat, req);
  78
  79         return ret;
  80 }
  81
  82 void nilfs_dat_commit_alloc(struct inode *dat, struct nilfs_palloc_req *req)
  83 {
  84         struct nilfs_dat_entry *entry;
  85         void *kaddr;
  86
  87         kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
  88         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
  89                                              req->pr_entry_bh, kaddr);
  90         entry->de_start = cpu_to_le64(NILFS_CNO_MIN);
  91         entry->de_end = cpu_to_le64(NILFS_CNO_MAX);
  92         entry->de_blocknr = cpu_to_le64(0);
  93         kunmap_atomic(kaddr, KM_USER0);
  94
  95         nilfs_palloc_commit_alloc_entry(dat, req);
  96         nilfs_dat_commit_entry(dat, req);
  97 }
  98
  99 void nilfs_dat_abort_alloc(struct inode *dat, struct nilfs_palloc_req *req)
 100 {
 101         nilfs_dat_abort_entry(dat, req);
 102         nilfs_palloc_abort_alloc_entry(dat, req);
 103 }
 104
 105 void nilfs_dat_commit_free(struct inode *dat, struct nilfs_palloc_req *req)
 106 {
 107         struct nilfs_dat_entry *entry;
 108         void *kaddr;
 109
 110         kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
 111         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
 112                                              req->pr_entry_bh, kaddr);
 113         entry->de_start = cpu_to_le64(NILFS_CNO_MIN);
 114         entry->de_end = cpu_to_le64(NILFS_CNO_MIN);
 115         entry->de_blocknr = cpu_to_le64(0);
 116         kunmap_atomic(kaddr, KM_USER0);
 117
 118         nilfs_dat_commit_entry(dat, req);
 119         nilfs_palloc_commit_free_entry(dat, req);
 120 }
 121
 122 int nilfs_dat_prepare_start(struct inode *dat, struct nilfs_palloc_req *req)
 123 {
 124         int ret;
 125
 126         ret = nilfs_dat_prepare_entry(dat, req, 0);
 127         WARN_ON(ret == -ENOENT);
 128         return ret;
 129 }
 130
 131 void nilfs_dat_commit_start(struct inode *dat, struct nilfs_palloc_req *req,
 132                             sector_t blocknr)
 133 {
 134         struct nilfs_dat_entry *entry;
 135         void *kaddr;
 136
 137         kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
 138         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
 139                                              req->pr_entry_bh, kaddr);
 140         entry->de_start = cpu_to_le64(nilfs_mdt_cno(dat));
 141         entry->de_blocknr = cpu_to_le64(blocknr);
 142         kunmap_atomic(kaddr, KM_USER0);
 143
 144         nilfs_dat_commit_entry(dat, req);
 145 }
 146
 147 int nilfs_dat_prepare_end(struct inode *dat, struct nilfs_palloc_req *req)
 148 {
 149         struct nilfs_dat_entry *entry;
 150         __u64 start;
 151         sector_t blocknr;
 152         void *kaddr;
 153         int ret;
 154
 155         ret = nilfs_dat_prepare_entry(dat, req, 0);
 156         if (ret < 0) {
 157                 WARN_ON(ret == -ENOENT);
 158                 return ret;
 159         }
 160
 161         kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
 162         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
 163                                              req->pr_entry_bh, kaddr);
 164         start = le64_to_cpu(entry->de_start);
 165         blocknr = le64_to_cpu(entry->de_blocknr);
 166         kunmap_atomic(kaddr, KM_USER0);
 167
 168         if (blocknr == 0) {
 169                 ret = nilfs_palloc_prepare_free_entry(dat, req);
 170                 if (ret < 0) {
 171                         nilfs_dat_abort_entry(dat, req);
 172                         return ret;
 173                 }
 174         }
 175
 176         return 0;
 177 }
 178
 179 void nilfs_dat_commit_end(struct inode *dat, struct nilfs_palloc_req *req,
 180                           int dead)
 181 {
 182         struct nilfs_dat_entry *entry;
 183         __u64 start, end;
 184         sector_t blocknr;
 185         void *kaddr;
 186
 187         kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
 188         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
 189                                              req->pr_entry_bh, kaddr);
 190         end = start = le64_to_cpu(entry->de_start);
 191         if (!dead) {
 192                 end = nilfs_mdt_cno(dat);
 193                 WARN_ON(start > end);
 194         }
 195         entry->de_end = cpu_to_le64(end);
 196         blocknr = le64_to_cpu(entry->de_blocknr);
 197         kunmap_atomic(kaddr, KM_USER0);
 198
 199         if (blocknr == 0)
 200                 nilfs_dat_commit_free(dat, req);
 201         else
 202                 nilfs_dat_commit_entry(dat, req);
 203 }
 204
 205 void nilfs_dat_abort_end(struct inode *dat, struct nilfs_palloc_req *req)
 206 {
 207         struct nilfs_dat_entry *entry;
 208         __u64 start;
 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         start = le64_to_cpu(entry->de_start);
 216         blocknr = le64_to_cpu(entry->de_blocknr);
 217         kunmap_atomic(kaddr, KM_USER0);
 218
 219         if (start == nilfs_mdt_cno(dat) && blocknr == 0)
 220                 nilfs_palloc_abort_free_entry(dat, req);
 221         nilfs_dat_abort_entry(dat, req);
 222 }
 223
 224 int nilfs_dat_prepare_update(struct inode *dat,
 225                              struct nilfs_palloc_req *oldreq,
 226                              struct nilfs_palloc_req *newreq)
 227 {
 228         int ret;
 229
 230         ret = nilfs_dat_prepare_end(dat, oldreq);
 231         if (!ret) {
 232                 ret = nilfs_dat_prepare_alloc(dat, newreq);
 233                 if (ret < 0)
 234                         nilfs_dat_abort_end(dat, oldreq);
 235         }
 236         return ret;
 237 }
 238
 239 void nilfs_dat_commit_update(struct inode *dat,
 240                              struct nilfs_palloc_req *oldreq,
 241                              struct nilfs_palloc_req *newreq, int dead)
 242 {
 243         nilfs_dat_commit_end(dat, oldreq, dead);
 244         nilfs_dat_commit_alloc(dat, newreq);
 245 }
 246
 247 void nilfs_dat_abort_update(struct inode *dat,
 248                             struct nilfs_palloc_req *oldreq,
 249                             struct nilfs_palloc_req *newreq)
 250 {
 251         nilfs_dat_abort_end(dat, oldreq);
 252         nilfs_dat_abort_alloc(dat, newreq);
 253 }
 254
 255 /**
 256  * nilfs_dat_mark_dirty -
 257  * @dat: DAT file inode
 258  * @vblocknr: virtual block number
 259  *
 260  * Description:
 261  *
 262  * Return Value: On success, 0 is returned. On error, one of the following
 263  * negative error codes is returned.
 264  *
 265  * %-EIO - I/O error.
 266  *
 267  * %-ENOMEM - Insufficient amount of memory available.
 268  */
 269 int nilfs_dat_mark_dirty(struct inode *dat, __u64 vblocknr)
 270 {
 271         struct nilfs_palloc_req req;
 272         int ret;
 273
 274         req.pr_entry_nr = vblocknr;
 275         ret = nilfs_dat_prepare_entry(dat, &req, 0);
 276         if (ret == 0)
 277                 nilfs_dat_commit_entry(dat, &req);
 278         return ret;
 279 }
 280
 281 /**
 282  * nilfs_dat_freev - free virtual block numbers
 283  * @dat: DAT file inode
 284  * @vblocknrs: array of virtual block numbers
 285  * @nitems: number of virtual block numbers
 286  *
 287  * Description: nilfs_dat_freev() frees the virtual block numbers specified by
 288  * @vblocknrs and @nitems.
 289  *
 290  * Return Value: On success, 0 is returned. On error, one of the following
 291  * nagative error codes is returned.
 292  *
 293  * %-EIO - I/O error.
 294  *
 295  * %-ENOMEM - Insufficient amount of memory available.
 296  *
 297  * %-ENOENT - The virtual block number have not been allocated.
 298  */
 299 int nilfs_dat_freev(struct inode *dat, __u64 *vblocknrs, size_t nitems)
 300 {
 301         return nilfs_palloc_freev(dat, vblocknrs, nitems);
 302 }
 303
 304 /**
 305  * nilfs_dat_move - change a block number
 306  * @dat: DAT file inode
 307  * @vblocknr: virtual block number
 308  * @blocknr: block number
 309  *
 310  * Description: nilfs_dat_move() changes the block number associated with
 311  * @vblocknr to @blocknr.
 312  *
 313  * Return Value: On success, 0 is returned. On error, one of the following
 314  * negative error codes is returned.
 315  *
 316  * %-EIO - I/O error.
 317  *
 318  * %-ENOMEM - Insufficient amount of memory available.
 319  */
 320 int nilfs_dat_move(struct inode *dat, __u64 vblocknr, sector_t blocknr)
 321 {
 322         struct buffer_head *entry_bh;
 323         struct nilfs_dat_entry *entry;
 324         void *kaddr;
 325         int ret;
 326
 327         ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
 328         if (ret < 0)
 329                 return ret;
 330         kaddr = kmap_atomic(entry_bh->b_page, KM_USER0);
 331         entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
 332         if (unlikely(entry->de_blocknr == cpu_to_le64(0))) {
 333                 printk(KERN_CRIT "%s: vbn = %llu, [%llu, %llu)\n", __func__,
 334                        (unsigned long long)vblocknr,
 335                        (unsigned long long)le64_to_cpu(entry->de_start),
 336                        (unsigned long long)le64_to_cpu(entry->de_end));
 337                 kunmap_atomic(kaddr, KM_USER0);
 338                 brelse(entry_bh);
 339                 return -EINVAL;
 340         }
 341         WARN_ON(blocknr == 0);
 342         entry->de_blocknr = cpu_to_le64(blocknr);
 343         kunmap_atomic(kaddr, KM_USER0);
 344
 345         nilfs_mdt_mark_buffer_dirty(entry_bh);
 346         nilfs_mdt_mark_dirty(dat);
 347
 348         brelse(entry_bh);
 349
 350         return 0;
 351 }
 352
 353 /**
 354  * nilfs_dat_translate - translate a virtual block number to a block number
 355  * @dat: DAT file inode
 356  * @vblocknr: virtual block number
 357  * @blocknrp: pointer to a block number
 358  *
 359  * Description: nilfs_dat_translate() maps the virtual block number @vblocknr
 360  * to the corresponding block number.
 361  *
 362  * Return Value: On success, 0 is returned and the block number associated
 363  * with @vblocknr is stored in the place pointed by @blocknrp. On error, one
 364  * of the following negative error codes is returned.
 365  *
 366  * %-EIO - I/O error.
 367  *
 368  * %-ENOMEM - Insufficient amount of memory available.
 369  *
 370  * %-ENOENT - A block number associated with @vblocknr does not exist.
 371  */
 372 int nilfs_dat_translate(struct inode *dat, __u64 vblocknr, sector_t *blocknrp)
 373 {
 374         struct buffer_head *entry_bh;
 375         struct nilfs_dat_entry *entry;
 376         sector_t blocknr;
 377         void *kaddr;
 378         int ret;
 379
 380         ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
 381         if (ret < 0)
 382                 return ret;
 383
 384         kaddr = kmap_atomic(entry_bh->b_page, KM_USER0);
 385         entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
 386         blocknr = le64_to_cpu(entry->de_blocknr);
 387         if (blocknr == 0) {
 388                 ret = -ENOENT;
 389                 goto out;
 390         }
 391         if (blocknrp != NULL)
 392                 *blocknrp = blocknr;
 393
 394  out:
 395         kunmap_atomic(kaddr, KM_USER0);
 396         brelse(entry_bh);
 397         return ret;
 398 }
 399
 400 ssize_t nilfs_dat_get_vinfo(struct inode *dat, void *buf, unsigned visz,
 401                             size_t nvi)
 402 {
 403         struct buffer_head *entry_bh;
 404         struct nilfs_dat_entry *entry;
 405         struct nilfs_vinfo *vinfo = buf;
 406         __u64 first, last;
 407         void *kaddr;
 408         unsigned long entries_per_block = NILFS_MDT(dat)->mi_entries_per_block;
 409         int i, j, n, ret;
 410
 411         for (i = 0; i < nvi; i += n) {
 412                 ret = nilfs_palloc_get_entry_block(dat, vinfo->vi_vblocknr,
 413                                                    0, &entry_bh);
 414                 if (ret < 0)
 415                         return ret;
 416                 kaddr = kmap_atomic(entry_bh->b_page, KM_USER0);
 417                 /* last virtual block number in this block */
 418                 first = vinfo->vi_vblocknr;
 419                 do_div(first, entries_per_block);
 420                 first *= entries_per_block;
 421                 last = first + entries_per_block - 1;
 422                 for (j = i, n = 0;
 423                      j < nvi && vinfo->vi_vblocknr >= first &&
 424                              vinfo->vi_vblocknr <= last;
 425                      j++, n++, vinfo = (void *)vinfo + visz) {
 426                         entry = nilfs_palloc_block_get_entry(
 427                                 dat, vinfo->vi_vblocknr, entry_bh, kaddr);
 428                         vinfo->vi_start = le64_to_cpu(entry->de_start);
 429                         vinfo->vi_end = le64_to_cpu(entry->de_end);
 430                         vinfo->vi_blocknr = le64_to_cpu(entry->de_blocknr);
 431                 }
 432                 kunmap_atomic(kaddr, KM_USER0);
 433                 brelse(entry_bh);
 434         }
 435
 436         return nvi;
 437 }
 438
 439 /**
 440  * nilfs_dat_read - read dat inode
 441  * @dat: dat inode
 442  * @raw_inode: on-disk dat inode
 443  */
 444 int nilfs_dat_read(struct inode *dat, struct nilfs_inode *raw_inode)
 445 {
 446         return nilfs_read_inode_common(dat, raw_inode);
 447 }
 448
 449 /**
 450  * nilfs_dat_new - create dat file
 451  * @nilfs: nilfs object
 452  * @entry_size: size of a dat entry
 453  */
 454 struct inode *nilfs_dat_new(struct the_nilfs *nilfs, size_t entry_size)
 455 {
 456         static struct lock_class_key dat_lock_key;
 457         struct inode *dat;
 458         struct nilfs_dat_info *di;
 459         int err;
 460
 461         dat = nilfs_mdt_new(nilfs, NULL, NILFS_DAT_INO, sizeof(*di));
 462         if (dat) {
 463                 err = nilfs_palloc_init_blockgroup(dat, entry_size);
 464                 if (unlikely(err)) {
 465                         nilfs_mdt_destroy(dat);
 466                         return NULL;
 467                 }
 468
 469                 di = NILFS_DAT_I(dat);
 470                 lockdep_set_class(&di->mi.mi_sem, &dat_lock_key);
 471                 nilfs_palloc_setup_cache(dat, &di->palloc_cache);
 472         }
 473         return dat;
 474 }