fs/nilfs2/direct.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * NILFS direct block pointer.
   4  *
   5  * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
   6  *
   7  * Written by Koji Sato.
   8  */
   9
  10 #include <linux/errno.h>
  11 #include "nilfs.h"
  12 #include "page.h"
  13 #include "direct.h"
  14 #include "alloc.h"
  15 #include "dat.h"
  16
  17 static inline __le64 *nilfs_direct_dptrs(const struct nilfs_bmap *direct)
  18 {
  19         return (__le64 *)
  20                 ((struct nilfs_direct_node *)direct->b_u.u_data + 1);
  21 }
  22
  23 static inline __u64
  24 nilfs_direct_get_ptr(const struct nilfs_bmap *direct, __u64 key)
  25 {
  26         return le64_to_cpu(*(nilfs_direct_dptrs(direct) + key));
  27 }
  28
  29 static inline void nilfs_direct_set_ptr(struct nilfs_bmap *direct,
  30                                         __u64 key, __u64 ptr)
  31 {
  32         *(nilfs_direct_dptrs(direct) + key) = cpu_to_le64(ptr);
  33 }
  34
  35 static int nilfs_direct_lookup(const struct nilfs_bmap *direct,
  36                                __u64 key, int level, __u64 *ptrp)
  37 {
  38         __u64 ptr;
  39
  40         if (key > NILFS_DIRECT_KEY_MAX || level != 1)
  41                 return -ENOENT;
  42         ptr = nilfs_direct_get_ptr(direct, key);
  43         if (ptr == NILFS_BMAP_INVALID_PTR)
  44                 return -ENOENT;
  45
  46         *ptrp = ptr;
  47         return 0;
  48 }
  49
  50 static int nilfs_direct_lookup_contig(const struct nilfs_bmap *direct,
  51                                       __u64 key, __u64 *ptrp,
  52                                       unsigned int maxblocks)
  53 {
  54         struct inode *dat = NULL;
  55         __u64 ptr, ptr2;
  56         sector_t blocknr;
  57         int ret, cnt;
  58
  59         if (key > NILFS_DIRECT_KEY_MAX)
  60                 return -ENOENT;
  61         ptr = nilfs_direct_get_ptr(direct, key);
  62         if (ptr == NILFS_BMAP_INVALID_PTR)
  63                 return -ENOENT;
  64
  65         if (NILFS_BMAP_USE_VBN(direct)) {
  66                 dat = nilfs_bmap_get_dat(direct);
  67                 ret = nilfs_dat_translate(dat, ptr, &blocknr);
  68                 if (ret < 0)
  69                         goto dat_error;
  70                 ptr = blocknr;
  71         }
  72
  73         maxblocks = min_t(unsigned int, maxblocks,
  74                           NILFS_DIRECT_KEY_MAX - key + 1);
  75         for (cnt = 1; cnt < maxblocks &&
  76                      (ptr2 = nilfs_direct_get_ptr(direct, key + cnt)) !=
  77                      NILFS_BMAP_INVALID_PTR;
  78              cnt++) {
  79                 if (dat) {
  80                         ret = nilfs_dat_translate(dat, ptr2, &blocknr);
  81                         if (ret < 0)
  82                                 goto dat_error;
  83                         ptr2 = blocknr;
  84                 }
  85                 if (ptr2 != ptr + cnt)
  86                         break;
  87         }
  88         *ptrp = ptr;
  89         return cnt;
  90
  91  dat_error:
  92         if (ret == -ENOENT)
  93                 ret = -EINVAL;  /* Notify bmap layer of metadata corruption */
  94         return ret;
  95 }
  96
  97 static __u64
  98 nilfs_direct_find_target_v(const struct nilfs_bmap *direct, __u64 key)
  99 {
 100         __u64 ptr;
 101
 102         ptr = nilfs_bmap_find_target_seq(direct, key);
 103         if (ptr != NILFS_BMAP_INVALID_PTR)
 104                 /* sequential access */
 105                 return ptr;
 106
 107         /* block group */
 108         return nilfs_bmap_find_target_in_group(direct);
 109 }
 110
 111 static int nilfs_direct_insert(struct nilfs_bmap *bmap, __u64 key, __u64 ptr)
 112 {
 113         union nilfs_bmap_ptr_req req;
 114         struct inode *dat = NULL;
 115         struct buffer_head *bh;
 116         int ret;
 117
 118         if (key > NILFS_DIRECT_KEY_MAX)
 119                 return -ENOENT;
 120         if (nilfs_direct_get_ptr(bmap, key) != NILFS_BMAP_INVALID_PTR)
 121                 return -EEXIST;
 122
 123         if (NILFS_BMAP_USE_VBN(bmap)) {
 124                 req.bpr_ptr = nilfs_direct_find_target_v(bmap, key);
 125                 dat = nilfs_bmap_get_dat(bmap);
 126         }
 127         ret = nilfs_bmap_prepare_alloc_ptr(bmap, &req, dat);
 128         if (!ret) {
 129                 /* ptr must be a pointer to a buffer head. */
 130                 bh = (struct buffer_head *)((unsigned long)ptr);
 131                 set_buffer_nilfs_volatile(bh);
 132
 133                 nilfs_bmap_commit_alloc_ptr(bmap, &req, dat);
 134                 nilfs_direct_set_ptr(bmap, key, req.bpr_ptr);
 135
 136                 if (!nilfs_bmap_dirty(bmap))
 137                         nilfs_bmap_set_dirty(bmap);
 138
 139                 if (NILFS_BMAP_USE_VBN(bmap))
 140                         nilfs_bmap_set_target_v(bmap, key, req.bpr_ptr);
 141
 142                 nilfs_inode_add_blocks(bmap->b_inode, 1);
 143         }
 144         return ret;
 145 }
 146
 147 static int nilfs_direct_delete(struct nilfs_bmap *bmap, __u64 key)
 148 {
 149         union nilfs_bmap_ptr_req req;
 150         struct inode *dat;
 151         int ret;
 152
 153         if (key > NILFS_DIRECT_KEY_MAX ||
 154             nilfs_direct_get_ptr(bmap, key) == NILFS_BMAP_INVALID_PTR)
 155                 return -ENOENT;
 156
 157         dat = NILFS_BMAP_USE_VBN(bmap) ? nilfs_bmap_get_dat(bmap) : NULL;
 158         req.bpr_ptr = nilfs_direct_get_ptr(bmap, key);
 159
 160         ret = nilfs_bmap_prepare_end_ptr(bmap, &req, dat);
 161         if (!ret) {
 162                 nilfs_bmap_commit_end_ptr(bmap, &req, dat);
 163                 nilfs_direct_set_ptr(bmap, key, NILFS_BMAP_INVALID_PTR);
 164                 nilfs_inode_sub_blocks(bmap->b_inode, 1);
 165         }
 166         return ret;
 167 }
 168
 169 static int nilfs_direct_seek_key(const struct nilfs_bmap *direct, __u64 start,
 170                                  __u64 *keyp)
 171 {
 172         __u64 key;
 173
 174         for (key = start; key <= NILFS_DIRECT_KEY_MAX; key++) {
 175                 if (nilfs_direct_get_ptr(direct, key) !=
 176                     NILFS_BMAP_INVALID_PTR) {
 177                         *keyp = key;
 178                         return 0;
 179                 }
 180         }
 181         return -ENOENT;
 182 }
 183
 184 static int nilfs_direct_last_key(const struct nilfs_bmap *direct, __u64 *keyp)
 185 {
 186         __u64 key, lastkey;
 187
 188         lastkey = NILFS_DIRECT_KEY_MAX + 1;
 189         for (key = NILFS_DIRECT_KEY_MIN; key <= NILFS_DIRECT_KEY_MAX; key++)
 190                 if (nilfs_direct_get_ptr(direct, key) !=
 191                     NILFS_BMAP_INVALID_PTR)
 192                         lastkey = key;
 193
 194         if (lastkey == NILFS_DIRECT_KEY_MAX + 1)
 195                 return -ENOENT;
 196
 197         *keyp = lastkey;
 198
 199         return 0;
 200 }
 201
 202 static int nilfs_direct_check_insert(const struct nilfs_bmap *bmap, __u64 key)
 203 {
 204         return key > NILFS_DIRECT_KEY_MAX;
 205 }
 206
 207 static int nilfs_direct_gather_data(struct nilfs_bmap *direct,
 208                                     __u64 *keys, __u64 *ptrs, int nitems)
 209 {
 210         __u64 key;
 211         __u64 ptr;
 212         int n;
 213
 214         if (nitems > NILFS_DIRECT_NBLOCKS)
 215                 nitems = NILFS_DIRECT_NBLOCKS;
 216         n = 0;
 217         for (key = 0; key < nitems; key++) {
 218                 ptr = nilfs_direct_get_ptr(direct, key);
 219                 if (ptr != NILFS_BMAP_INVALID_PTR) {
 220                         keys[n] = key;
 221                         ptrs[n] = ptr;
 222                         n++;
 223                 }
 224         }
 225         return n;
 226 }
 227
 228 int nilfs_direct_delete_and_convert(struct nilfs_bmap *bmap,
 229                                     __u64 key, __u64 *keys, __u64 *ptrs, int n)
 230 {
 231         __le64 *dptrs;
 232         int ret, i, j;
 233
 234         /* no need to allocate any resource for conversion */
 235
 236         /* delete */
 237         ret = bmap->b_ops->bop_delete(bmap, key);
 238         if (ret < 0)
 239                 return ret;
 240
 241         /* free resources */
 242         if (bmap->b_ops->bop_clear != NULL)
 243                 bmap->b_ops->bop_clear(bmap);
 244
 245         /* convert */
 246         dptrs = nilfs_direct_dptrs(bmap);
 247         for (i = 0, j = 0; i < NILFS_DIRECT_NBLOCKS; i++) {
 248                 if ((j < n) && (i == keys[j])) {
 249                         dptrs[i] = (i != key) ?
 250                                 cpu_to_le64(ptrs[j]) :
 251                                 NILFS_BMAP_INVALID_PTR;
 252                         j++;
 253                 } else
 254                         dptrs[i] = NILFS_BMAP_INVALID_PTR;
 255         }
 256
 257         nilfs_direct_init(bmap);
 258         return 0;
 259 }
 260
 261 static int nilfs_direct_propagate(struct nilfs_bmap *bmap,
 262                                   struct buffer_head *bh)
 263 {
 264         struct nilfs_palloc_req oldreq, newreq;
 265         struct inode *dat;
 266         __u64 key;
 267         __u64 ptr;
 268         int ret;
 269
 270         if (!NILFS_BMAP_USE_VBN(bmap))
 271                 return 0;
 272
 273         dat = nilfs_bmap_get_dat(bmap);
 274         key = nilfs_bmap_data_get_key(bmap, bh);
 275         ptr = nilfs_direct_get_ptr(bmap, key);
 276         if (!buffer_nilfs_volatile(bh)) {
 277                 oldreq.pr_entry_nr = ptr;
 278                 newreq.pr_entry_nr = ptr;
 279                 ret = nilfs_dat_prepare_update(dat, &oldreq, &newreq);
 280                 if (ret < 0)
 281                         return ret;
 282                 nilfs_dat_commit_update(dat, &oldreq, &newreq,
 283                                         bmap->b_ptr_type == NILFS_BMAP_PTR_VS);
 284                 set_buffer_nilfs_volatile(bh);
 285                 nilfs_direct_set_ptr(bmap, key, newreq.pr_entry_nr);
 286         } else
 287                 ret = nilfs_dat_mark_dirty(dat, ptr);
 288
 289         return ret;
 290 }
 291
 292 static int nilfs_direct_assign_v(struct nilfs_bmap *direct,
 293                                  __u64 key, __u64 ptr,
 294                                  struct buffer_head **bh,
 295                                  sector_t blocknr,
 296                                  union nilfs_binfo *binfo)
 297 {
 298         struct inode *dat = nilfs_bmap_get_dat(direct);
 299         union nilfs_bmap_ptr_req req;
 300         int ret;
 301
 302         req.bpr_ptr = ptr;
 303         ret = nilfs_dat_prepare_start(dat, &req.bpr_req);
 304         if (!ret) {
 305                 nilfs_dat_commit_start(dat, &req.bpr_req, blocknr);
 306                 binfo->bi_v.bi_vblocknr = cpu_to_le64(ptr);
 307                 binfo->bi_v.bi_blkoff = cpu_to_le64(key);
 308         }
 309         return ret;
 310 }
 311
 312 static int nilfs_direct_assign_p(struct nilfs_bmap *direct,
 313                                  __u64 key, __u64 ptr,
 314                                  struct buffer_head **bh,
 315                                  sector_t blocknr,
 316                                  union nilfs_binfo *binfo)
 317 {
 318         nilfs_direct_set_ptr(direct, key, blocknr);
 319
 320         binfo->bi_dat.bi_blkoff = cpu_to_le64(key);
 321         binfo->bi_dat.bi_level = 0;
 322         memset(binfo->bi_dat.bi_pad, 0, sizeof(binfo->bi_dat.bi_pad));
 323
 324         return 0;
 325 }
 326
 327 static int nilfs_direct_assign(struct nilfs_bmap *bmap,
 328                                struct buffer_head **bh,
 329                                sector_t blocknr,
 330                                union nilfs_binfo *binfo)
 331 {
 332         __u64 key;
 333         __u64 ptr;
 334
 335         key = nilfs_bmap_data_get_key(bmap, *bh);
 336         if (unlikely(key > NILFS_DIRECT_KEY_MAX)) {
 337                 nilfs_crit(bmap->b_inode->i_sb,
 338                            "%s (ino=%lu): invalid key: %llu",
 339                            __func__,
 340                            bmap->b_inode->i_ino, (unsigned long long)key);
 341                 return -EINVAL;
 342         }
 343         ptr = nilfs_direct_get_ptr(bmap, key);
 344         if (unlikely(ptr == NILFS_BMAP_INVALID_PTR)) {
 345                 nilfs_crit(bmap->b_inode->i_sb,
 346                            "%s (ino=%lu): invalid pointer: %llu",
 347                            __func__,
 348                            bmap->b_inode->i_ino, (unsigned long long)ptr);
 349                 return -EINVAL;
 350         }
 351
 352         return NILFS_BMAP_USE_VBN(bmap) ?
 353                 nilfs_direct_assign_v(bmap, key, ptr, bh, blocknr, binfo) :
 354                 nilfs_direct_assign_p(bmap, key, ptr, bh, blocknr, binfo);
 355 }
 356
 357 static const struct nilfs_bmap_operations nilfs_direct_ops = {
 358         .bop_lookup             =       nilfs_direct_lookup,
 359         .bop_lookup_contig      =       nilfs_direct_lookup_contig,
 360         .bop_insert             =       nilfs_direct_insert,
 361         .bop_delete             =       nilfs_direct_delete,
 362         .bop_clear              =       NULL,
 363
 364         .bop_propagate          =       nilfs_direct_propagate,
 365
 366         .bop_lookup_dirty_buffers       =       NULL,
 367
 368         .bop_assign             =       nilfs_direct_assign,
 369         .bop_mark               =       NULL,
 370
 371         .bop_seek_key           =       nilfs_direct_seek_key,
 372         .bop_last_key           =       nilfs_direct_last_key,
 373
 374         .bop_check_insert       =       nilfs_direct_check_insert,
 375         .bop_check_delete       =       NULL,
 376         .bop_gather_data        =       nilfs_direct_gather_data,
 377 };
 378
 379
 380 int nilfs_direct_init(struct nilfs_bmap *bmap)
 381 {
 382         bmap->b_ops = &nilfs_direct_ops;
 383         return 0;
 384 }