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