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 }