fs/nilfs2/dat.c

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