fs/gfs2/bmap.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
   4  *
   5  * This copyrighted material is made available to anyone wishing to use,
   6  * modify, copy, or redistribute it subject to the terms and conditions
   7  * of the GNU General Public License version 2.
   8  */
   9
  10 #include <linux/spinlock.h>
  11 #include <linux/completion.h>
  12 #include <linux/buffer_head.h>
  13 #include <linux/blkdev.h>
  14 #include <linux/gfs2_ondisk.h>
  15 #include <linux/crc32.h>
  16 #include <linux/iomap.h>
  17
  18 #include "gfs2.h"
  19 #include "incore.h"
  20 #include "bmap.h"
  21 #include "glock.h"
  22 #include "inode.h"
  23 #include "meta_io.h"
  24 #include "quota.h"
  25 #include "rgrp.h"
  26 #include "log.h"
  27 #include "super.h"
  28 #include "trans.h"
  29 #include "dir.h"
  30 #include "util.h"
  31 #include "trace_gfs2.h"
  32
  33 /* This doesn't need to be that large as max 64 bit pointers in a 4k
  34  * block is 512, so __u16 is fine for that. It saves stack space to
  35  * keep it small.
  36  */
  37 struct metapath {
  38         struct buffer_head *mp_bh[GFS2_MAX_META_HEIGHT];
  39         __u16 mp_list[GFS2_MAX_META_HEIGHT];
  40         int mp_fheight; /* find_metapath height */
  41         int mp_aheight; /* actual height (lookup height) */
  42 };
  43
  44 /**
  45  * gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page
  46  * @ip: the inode
  47  * @dibh: the dinode buffer
  48  * @block: the block number that was allocated
  49  * @page: The (optional) page. This is looked up if @page is NULL
  50  *
  51  * Returns: errno
  52  */
  53
  54 static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
  55                                u64 block, struct page *page)
  56 {
  57         struct inode *inode = &ip->i_inode;
  58         struct buffer_head *bh;
  59         int release = 0;
  60
  61         if (!page || page->index) {
  62                 page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);
  63                 if (!page)
  64                         return -ENOMEM;
  65                 release = 1;
  66         }
  67
  68         if (!PageUptodate(page)) {
  69                 void *kaddr = kmap(page);
  70                 u64 dsize = i_size_read(inode);
  71
  72                 if (dsize > (dibh->b_size - sizeof(struct gfs2_dinode)))
  73                         dsize = dibh->b_size - sizeof(struct gfs2_dinode);
  74
  75                 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);
  76                 memset(kaddr + dsize, 0, PAGE_SIZE - dsize);
  77                 kunmap(page);
  78
  79                 SetPageUptodate(page);
  80         }
  81
  82         if (!page_has_buffers(page))
  83                 create_empty_buffers(page, BIT(inode->i_blkbits),
  84                                      BIT(BH_Uptodate));
  85
  86         bh = page_buffers(page);
  87
  88         if (!buffer_mapped(bh))
  89                 map_bh(bh, inode->i_sb, block);
  90
  91         set_buffer_uptodate(bh);
  92         if (!gfs2_is_jdata(ip))
  93                 mark_buffer_dirty(bh);
  94         if (!gfs2_is_writeback(ip))
  95                 gfs2_trans_add_data(ip->i_gl, bh);
  96
  97         if (release) {
  98                 unlock_page(page);
  99                 put_page(page);
 100         }
 101
 102         return 0;
 103 }
 104
 105 /**
 106  * gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big
 107  * @ip: The GFS2 inode to unstuff
 108  * @page: The (optional) page. This is looked up if the @page is NULL
 109  *
 110  * This routine unstuffs a dinode and returns it to a "normal" state such
 111  * that the height can be grown in the traditional way.
 112  *
 113  * Returns: errno
 114  */
 115
 116 int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page)
 117 {
 118         struct buffer_head *bh, *dibh;
 119         struct gfs2_dinode *di;
 120         u64 block = 0;
 121         int isdir = gfs2_is_dir(ip);
 122         int error;
 123
 124         down_write(&ip->i_rw_mutex);
 125
 126         error = gfs2_meta_inode_buffer(ip, &dibh);
 127         if (error)
 128                 goto out;
 129
 130         if (i_size_read(&ip->i_inode)) {
 131                 /* Get a free block, fill it with the stuffed data,
 132                    and write it out to disk */
 133
 134                 unsigned int n = 1;
 135                 error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);
 136                 if (error)
 137                         goto out_brelse;
 138                 if (isdir) {
 139                         gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);
 140                         error = gfs2_dir_get_new_buffer(ip, block, &bh);
 141                         if (error)
 142                                 goto out_brelse;
 143                         gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_meta_header),
 144                                               dibh, sizeof(struct gfs2_dinode));
 145                         brelse(bh);
 146                 } else {
 147                         error = gfs2_unstuffer_page(ip, dibh, block, page);
 148                         if (error)
 149                                 goto out_brelse;
 150                 }
 151         }
 152
 153         /*  Set up the pointer to the new block  */
 154
 155         gfs2_trans_add_meta(ip->i_gl, dibh);
 156         di = (struct gfs2_dinode *)dibh->b_data;
 157         gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
 158
 159         if (i_size_read(&ip->i_inode)) {
 160                 *(__be64 *)(di + 1) = cpu_to_be64(block);
 161                 gfs2_add_inode_blocks(&ip->i_inode, 1);
 162                 di->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
 163         }
 164
 165         ip->i_height = 1;
 166         di->di_height = cpu_to_be16(1);
 167
 168 out_brelse:
 169         brelse(dibh);
 170 out:
 171         up_write(&ip->i_rw_mutex);
 172         return error;
 173 }
 174
 175
 176 /**
 177  * find_metapath - Find path through the metadata tree
 178  * @sdp: The superblock
 179  * @mp: The metapath to return the result in
 180  * @block: The disk block to look up
 181  * @height: The pre-calculated height of the metadata tree
 182  *
 183  *   This routine returns a struct metapath structure that defines a path
 184  *   through the metadata of inode "ip" to get to block "block".
 185  *
 186  *   Example:
 187  *   Given:  "ip" is a height 3 file, "offset" is 101342453, and this is a
 188  *   filesystem with a blocksize of 4096.
 189  *
 190  *   find_metapath() would return a struct metapath structure set to:
 191  *   mp_offset = 101342453, mp_height = 3, mp_list[0] = 0, mp_list[1] = 48,
 192  *   and mp_list[2] = 165.
 193  *
 194  *   That means that in order to get to the block containing the byte at
 195  *   offset 101342453, we would load the indirect block pointed to by pointer
 196  *   0 in the dinode.  We would then load the indirect block pointed to by
 197  *   pointer 48 in that indirect block.  We would then load the data block
 198  *   pointed to by pointer 165 in that indirect block.
 199  *
 200  *             ----------------------------------------
 201  *             | Dinode |                             |
 202  *             |        |                            4|
 203  *             |        |0 1 2 3 4 5                 9|
 204  *             |        |                            6|
 205  *             ----------------------------------------
 206  *                       |
 207  *                       |
 208  *                       V
 209  *             ----------------------------------------
 210  *             | Indirect Block                       |
 211  *             |                                     5|
 212  *             |            4 4 4 4 4 5 5            1|
 213  *             |0           5 6 7 8 9 0 1            2|
 214  *             ----------------------------------------
 215  *                                |
 216  *                                |
 217  *                                V
 218  *             ----------------------------------------
 219  *             | Indirect Block                       |
 220  *             |                         1 1 1 1 1   5|
 221  *             |                         6 6 6 6 6   1|
 222  *             |0                        3 4 5 6 7   2|
 223  *             ----------------------------------------
 224  *                                           |
 225  *                                           |
 226  *                                           V
 227  *             ----------------------------------------
 228  *             | Data block containing offset         |
 229  *             |            101342453                 |
 230  *             |                                      |
 231  *             |                                      |
 232  *             ----------------------------------------
 233  *
 234  */
 235
 236 static void find_metapath(const struct gfs2_sbd *sdp, u64 block,
 237                           struct metapath *mp, unsigned int height)
 238 {
 239         unsigned int i;
 240
 241         mp->mp_fheight = height;
 242         for (i = height; i--;)
 243                 mp->mp_list[i] = do_div(block, sdp->sd_inptrs);
 244 }
 245
 246 static inline unsigned int metapath_branch_start(const struct metapath *mp)
 247 {
 248         if (mp->mp_list[0] == 0)
 249                 return 2;
 250         return 1;
 251 }
 252
 253 /**
 254  * metaptr1 - Return the first possible metadata pointer in a metapath buffer
 255  * @height: The metadata height (0 = dinode)
 256  * @mp: The metapath
 257  */
 258 static inline __be64 *metaptr1(unsigned int height, const struct metapath *mp)
 259 {
 260         struct buffer_head *bh = mp->mp_bh[height];
 261         if (height == 0)
 262                 return ((__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)));
 263         return ((__be64 *)(bh->b_data + sizeof(struct gfs2_meta_header)));
 264 }
 265
 266 /**
 267  * metapointer - Return pointer to start of metadata in a buffer
 268  * @height: The metadata height (0 = dinode)
 269  * @mp: The metapath
 270  *
 271  * Return a pointer to the block number of the next height of the metadata
 272  * tree given a buffer containing the pointer to the current height of the
 273  * metadata tree.
 274  */
 275
 276 static inline __be64 *metapointer(unsigned int height, const struct metapath *mp)
 277 {
 278         __be64 *p = metaptr1(height, mp);
 279         return p + mp->mp_list[height];
 280 }
 281
 282 static void gfs2_metapath_ra(struct gfs2_glock *gl,
 283                              const struct buffer_head *bh, const __be64 *pos)
 284 {
 285         struct buffer_head *rabh;
 286         const __be64 *endp = (const __be64 *)(bh->b_data + bh->b_size);
 287         const __be64 *t;
 288
 289         for (t = pos; t < endp; t++) {
 290                 if (!*t)
 291                         continue;
 292
 293                 rabh = gfs2_getbuf(gl, be64_to_cpu(*t), CREATE);
 294                 if (trylock_buffer(rabh)) {
 295                         if (!buffer_uptodate(rabh)) {
 296                                 rabh->b_end_io = end_buffer_read_sync;
 297                                 submit_bh(REQ_OP_READ,
 298                                           REQ_RAHEAD | REQ_META | REQ_PRIO,
 299                                           rabh);
 300                                 continue;
 301                         }
 302                         unlock_buffer(rabh);
 303                 }
 304                 brelse(rabh);
 305         }
 306 }
 307
 308 /**
 309  * lookup_mp_height - helper function for lookup_metapath
 310  * @ip: the inode
 311  * @mp: the metapath
 312  * @h: the height which needs looking up
 313  */
 314 static int lookup_mp_height(struct gfs2_inode *ip, struct metapath *mp, int h)
 315 {
 316         __be64 *ptr = metapointer(h, mp);
 317         u64 dblock = be64_to_cpu(*ptr);
 318
 319         if (!dblock)
 320                 return h + 1;
 321
 322         return gfs2_meta_indirect_buffer(ip, h + 1, dblock, &mp->mp_bh[h + 1]);
 323 }
 324
 325 /**
 326  * lookup_metapath - Walk the metadata tree to a specific point
 327  * @ip: The inode
 328  * @mp: The metapath
 329  *
 330  * Assumes that the inode's buffer has already been looked up and
 331  * hooked onto mp->mp_bh[0] and that the metapath has been initialised
 332  * by find_metapath().
 333  *
 334  * If this function encounters part of the tree which has not been
 335  * allocated, it returns the current height of the tree at the point
 336  * at which it found the unallocated block. Blocks which are found are
 337  * added to the mp->mp_bh[] list.
 338  *
 339  * Returns: error or height of metadata tree
 340  */
 341
 342 static int lookup_metapath(struct gfs2_inode *ip, struct metapath *mp)
 343 {
 344         unsigned int end_of_metadata = ip->i_height - 1;
 345         unsigned int x;
 346         int ret;
 347
 348         for (x = 0; x < end_of_metadata; x++) {
 349                 ret = lookup_mp_height(ip, mp, x);
 350                 if (ret)
 351                         goto out;
 352         }
 353
 354         ret = ip->i_height;
 355 out:
 356         mp->mp_aheight = ret;
 357         return ret;
 358 }
 359
 360 /**
 361  * fillup_metapath - fill up buffers for the metadata path to a specific height
 362  * @ip: The inode
 363  * @mp: The metapath
 364  * @h: The height to which it should be mapped
 365  *
 366  * Similar to lookup_metapath, but does lookups for a range of heights
 367  *
 368  * Returns: error or height of metadata tree
 369  */
 370
 371 static int fillup_metapath(struct gfs2_inode *ip, struct metapath *mp, int h)
 372 {
 373         unsigned int start_h = h - 1;
 374         int ret;
 375
 376         if (h) {
 377                 /* find the first buffer we need to look up. */
 378                 while (start_h > 0 && mp->mp_bh[start_h] == NULL)
 379                         start_h--;
 380                 for (; start_h < h; start_h++) {
 381                         ret = lookup_mp_height(ip, mp, start_h);
 382                         if (ret)
 383                                 return ret;
 384                 }
 385         }
 386         return ip->i_height;
 387 }
 388
 389 static inline void release_metapath(struct metapath *mp)
 390 {
 391         int i;
 392
 393         for (i = 0; i < GFS2_MAX_META_HEIGHT; i++) {
 394                 if (mp->mp_bh[i] == NULL)
 395                         break;
 396                 brelse(mp->mp_bh[i]);
 397         }
 398 }
 399
 400 /**
 401  * gfs2_extent_length - Returns length of an extent of blocks
 402  * @start: Start of the buffer
 403  * @len: Length of the buffer in bytes
 404  * @ptr: Current position in the buffer
 405  * @limit: Max extent length to return (0 = unlimited)
 406  * @eob: Set to 1 if we hit "end of block"
 407  *
 408  * If the first block is zero (unallocated) it will return the number of
 409  * unallocated blocks in the extent, otherwise it will return the number
 410  * of contiguous blocks in the extent.
 411  *
 412  * Returns: The length of the extent (minimum of one block)
 413  */
 414
 415 static inline unsigned int gfs2_extent_length(void *start, unsigned int len, __be64 *ptr, size_t limit, int *eob)
 416 {
 417         const __be64 *end = (start + len);
 418         const __be64 *first = ptr;
 419         u64 d = be64_to_cpu(*ptr);
 420
 421         *eob = 0;
 422         do {
 423                 ptr++;
 424                 if (ptr >= end)
 425                         break;
 426                 if (limit && --limit == 0)
 427                         break;
 428                 if (d)
 429                         d++;
 430         } while(be64_to_cpu(*ptr) == d);
 431         if (ptr >= end)
 432                 *eob = 1;
 433         return (ptr - first);
 434 }
 435
 436 static inline void bmap_lock(struct gfs2_inode *ip, int create)
 437 {
 438         if (create)
 439                 down_write(&ip->i_rw_mutex);
 440         else
 441                 down_read(&ip->i_rw_mutex);
 442 }
 443
 444 static inline void bmap_unlock(struct gfs2_inode *ip, int create)
 445 {
 446         if (create)
 447                 up_write(&ip->i_rw_mutex);
 448         else
 449                 up_read(&ip->i_rw_mutex);
 450 }
 451
 452 static inline __be64 *gfs2_indirect_init(struct metapath *mp,
 453                                          struct gfs2_glock *gl, unsigned int i,
 454                                          unsigned offset, u64 bn)
 455 {
 456         __be64 *ptr = (__be64 *)(mp->mp_bh[i - 1]->b_data +
 457                        ((i > 1) ? sizeof(struct gfs2_meta_header) :
 458                                  sizeof(struct gfs2_dinode)));
 459         BUG_ON(i < 1);
 460         BUG_ON(mp->mp_bh[i] != NULL);
 461         mp->mp_bh[i] = gfs2_meta_new(gl, bn);
 462         gfs2_trans_add_meta(gl, mp->mp_bh[i]);
 463         gfs2_metatype_set(mp->mp_bh[i], GFS2_METATYPE_IN, GFS2_FORMAT_IN);
 464         gfs2_buffer_clear_tail(mp->mp_bh[i], sizeof(struct gfs2_meta_header));
 465         ptr += offset;
 466         *ptr = cpu_to_be64(bn);
 467         return ptr;
 468 }
 469
 470 enum alloc_state {
 471         ALLOC_DATA = 0,
 472         ALLOC_GROW_DEPTH = 1,
 473         ALLOC_GROW_HEIGHT = 2,
 474         /* ALLOC_UNSTUFF = 3,   TBD and rather complicated */
 475 };
 476
 477 static inline unsigned int hptrs(struct gfs2_sbd *sdp, const unsigned int hgt)
 478 {
 479         if (hgt)
 480                 return sdp->sd_inptrs;
 481         return sdp->sd_diptrs;
 482 }
 483
 484 /**
 485  * gfs2_bmap_alloc - Build a metadata tree of the requested height
 486  * @inode: The GFS2 inode
 487  * @lblock: The logical starting block of the extent
 488  * @bh_map: This is used to return the mapping details
 489  * @zero_new: True if newly allocated blocks should be zeroed
 490  * @mp: The metapath, with proper height information calculated
 491  * @maxlen: The max number of data blocks to alloc
 492  * @dblock: Pointer to return the resulting new block
 493  * @dblks: Pointer to return the number of blocks allocated
 494  *
 495  * In this routine we may have to alloc:
 496  *   i) Indirect blocks to grow the metadata tree height
 497  *  ii) Indirect blocks to fill in lower part of the metadata tree
 498  * iii) Data blocks
 499  *
 500  * The function is in two parts. The first part works out the total
 501  * number of blocks which we need. The second part does the actual
 502  * allocation asking for an extent at a time (if enough contiguous free
 503  * blocks are available, there will only be one request per bmap call)
 504  * and uses the state machine to initialise the blocks in order.
 505  *
 506  * Returns: errno on error
 507  */
 508
 509 static int gfs2_iomap_alloc(struct inode *inode, struct iomap *iomap,
 510                             unsigned flags, struct metapath *mp)
 511 {
 512         struct gfs2_inode *ip = GFS2_I(inode);
 513         struct gfs2_sbd *sdp = GFS2_SB(inode);
 514         struct super_block *sb = sdp->sd_vfs;
 515         struct buffer_head *dibh = mp->mp_bh[0];
 516         u64 bn;
 517         unsigned n, i, blks, alloced = 0, iblks = 0, branch_start = 0;
 518         unsigned dblks = 0;
 519         unsigned ptrs_per_blk;
 520         const unsigned end_of_metadata = mp->mp_fheight - 1;
 521         int ret;
 522         enum alloc_state state;
 523         __be64 *ptr;
 524         __be64 zero_bn = 0;
 525         size_t maxlen = iomap->length >> inode->i_blkbits;
 526
 527         BUG_ON(mp->mp_aheight < 1);
 528         BUG_ON(dibh == NULL);
 529
 530         gfs2_trans_add_meta(ip->i_gl, dibh);
 531
 532         if (mp->mp_fheight == mp->mp_aheight) {
 533                 struct buffer_head *bh;
 534                 int eob;
 535
 536                 /* Bottom indirect block exists, find unalloced extent size */
 537                 ptr = metapointer(end_of_metadata, mp);
 538                 bh = mp->mp_bh[end_of_metadata];
 539                 dblks = gfs2_extent_length(bh->b_data, bh->b_size, ptr,
 540                                            maxlen, &eob);
 541                 BUG_ON(dblks < 1);
 542                 state = ALLOC_DATA;
 543         } else {
 544                 /* Need to allocate indirect blocks */
 545                 ptrs_per_blk = mp->mp_fheight > 1 ? sdp->sd_inptrs :
 546                         sdp->sd_diptrs;
 547                 dblks = min(maxlen, (size_t)(ptrs_per_blk -
 548                                              mp->mp_list[end_of_metadata]));
 549                 if (mp->mp_fheight == ip->i_height) {
 550                         /* Writing into existing tree, extend tree down */
 551                         iblks = mp->mp_fheight - mp->mp_aheight;
 552                         state = ALLOC_GROW_DEPTH;
 553                 } else {
 554                         /* Building up tree height */
 555                         state = ALLOC_GROW_HEIGHT;
 556                         iblks = mp->mp_fheight - ip->i_height;
 557                         branch_start = metapath_branch_start(mp);
 558                         iblks += (mp->mp_fheight - branch_start);
 559                 }
 560         }
 561
 562         /* start of the second part of the function (state machine) */
 563
 564         blks = dblks + iblks;
 565         i = mp->mp_aheight;
 566         do {
 567                 int error;
 568                 n = blks - alloced;
 569                 error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
 570                 if (error)
 571                         return error;
 572                 alloced += n;
 573                 if (state != ALLOC_DATA || gfs2_is_jdata(ip))
 574                         gfs2_trans_add_unrevoke(sdp, bn, n);
 575                 switch (state) {
 576                 /* Growing height of tree */
 577                 case ALLOC_GROW_HEIGHT:
 578                         if (i == 1) {
 579                                 ptr = (__be64 *)(dibh->b_data +
 580                                                  sizeof(struct gfs2_dinode));
 581                                 zero_bn = *ptr;
 582                         }
 583                         for (; i - 1 < mp->mp_fheight - ip->i_height && n > 0;
 584                              i++, n--)
 585                                 gfs2_indirect_init(mp, ip->i_gl, i, 0, bn++);
 586                         if (i - 1 == mp->mp_fheight - ip->i_height) {
 587                                 i--;
 588                                 gfs2_buffer_copy_tail(mp->mp_bh[i],
 589                                                 sizeof(struct gfs2_meta_header),
 590                                                 dibh, sizeof(struct gfs2_dinode));
 591                                 gfs2_buffer_clear_tail(dibh,
 592                                                 sizeof(struct gfs2_dinode) +
 593                                                 sizeof(__be64));
 594                                 ptr = (__be64 *)(mp->mp_bh[i]->b_data +
 595                                         sizeof(struct gfs2_meta_header));
 596                                 *ptr = zero_bn;
 597                                 state = ALLOC_GROW_DEPTH;
 598                                 for(i = branch_start; i < mp->mp_fheight; i++) {
 599                                         if (mp->mp_bh[i] == NULL)
 600                                                 break;
 601                                         brelse(mp->mp_bh[i]);
 602                                         mp->mp_bh[i] = NULL;
 603                                 }
 604                                 i = branch_start;
 605                         }
 606                         if (n == 0)
 607                                 break;
 608                 /* Branching from existing tree */
 609                 case ALLOC_GROW_DEPTH:
 610                         if (i > 1 && i < mp->mp_fheight)
 611                                 gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[i-1]);
 612                         for (; i < mp->mp_fheight && n > 0; i++, n--)
 613                                 gfs2_indirect_init(mp, ip->i_gl, i,
 614                                                    mp->mp_list[i-1], bn++);
 615                         if (i == mp->mp_fheight)
 616                                 state = ALLOC_DATA;
 617                         if (n == 0)
 618                                 break;
 619                 /* Tree complete, adding data blocks */
 620                 case ALLOC_DATA:
 621                         BUG_ON(n > dblks);
 622                         BUG_ON(mp->mp_bh[end_of_metadata] == NULL);
 623                         gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[end_of_metadata]);
 624                         dblks = n;
 625                         ptr = metapointer(end_of_metadata, mp);
 626                         iomap->addr = bn << inode->i_blkbits;
 627                         iomap->flags |= IOMAP_F_NEW;
 628                         while (n-- > 0)
 629                                 *ptr++ = cpu_to_be64(bn++);
 630                         if (flags & IOMAP_ZERO) {
 631                                 ret = sb_issue_zeroout(sb, iomap->addr >> inode->i_blkbits,
 632                                                        dblks, GFP_NOFS);
 633                                 if (ret) {
 634                                         fs_err(sdp,
 635                                                "Failed to zero data buffers\n");
 636                                         flags &= ~IOMAP_ZERO;
 637                                 }
 638                         }
 639                         break;
 640                 }
 641         } while (iomap->addr == IOMAP_NULL_ADDR);
 642
 643         iomap->length = (u64)dblks << inode->i_blkbits;
 644         ip->i_height = mp->mp_fheight;
 645         gfs2_add_inode_blocks(&ip->i_inode, alloced);
 646         gfs2_dinode_out(ip, mp->mp_bh[0]->b_data);
 647         return 0;
 648 }
 649
 650 /**
 651  * hole_size - figure out the size of a hole
 652  * @inode: The inode
 653  * @lblock: The logical starting block number
 654  * @mp: The metapath
 655  *
 656  * Returns: The hole size in bytes
 657  *
 658  */
 659 static u64 hole_size(struct inode *inode, sector_t lblock, struct metapath *mp)
 660 {
 661         struct gfs2_inode *ip = GFS2_I(inode);
 662         struct gfs2_sbd *sdp = GFS2_SB(inode);
 663         struct metapath mp_eof;
 664         u64 factor = 1;
 665         int hgt;
 666         u64 holesz = 0;
 667         const __be64 *first, *end, *ptr;
 668         const struct buffer_head *bh;
 669         u64 lblock_stop = (i_size_read(inode) - 1) >> inode->i_blkbits;
 670         int zeroptrs;
 671         bool done = false;
 672
 673         /* Get another metapath, to the very last byte */
 674         find_metapath(sdp, lblock_stop, &mp_eof, ip->i_height);
 675         for (hgt = ip->i_height - 1; hgt >= 0 && !done; hgt--) {
 676                 bh = mp->mp_bh[hgt];
 677                 if (bh) {
 678                         zeroptrs = 0;
 679                         first = metapointer(hgt, mp);
 680                         end = (const __be64 *)(bh->b_data + bh->b_size);
 681
 682                         for (ptr = first; ptr < end; ptr++) {
 683                                 if (*ptr) {
 684                                         done = true;
 685                                         break;
 686                                 } else {
 687                                         zeroptrs++;
 688                                 }
 689                         }
 690                 } else {
 691                         zeroptrs = sdp->sd_inptrs;
 692                 }
 693                 if (factor * zeroptrs >= lblock_stop - lblock + 1) {
 694                         holesz = lblock_stop - lblock + 1;
 695                         break;
 696                 }
 697                 holesz += factor * zeroptrs;
 698
 699                 factor *= sdp->sd_inptrs;
 700                 if (hgt && (mp->mp_list[hgt - 1] < mp_eof.mp_list[hgt - 1]))
 701                         (mp->mp_list[hgt - 1])++;
 702         }
 703         return holesz << inode->i_blkbits;
 704 }
 705
 706 static void gfs2_stuffed_iomap(struct inode *inode, struct iomap *iomap)
 707 {
 708         struct gfs2_inode *ip = GFS2_I(inode);
 709
 710         iomap->addr = (ip->i_no_addr << inode->i_blkbits) +
 711                       sizeof(struct gfs2_dinode);
 712         iomap->offset = 0;
 713         iomap->length = i_size_read(inode);
 714         iomap->type = IOMAP_MAPPED;
 715         iomap->flags = IOMAP_F_DATA_INLINE;
 716 }
 717
 718 /**
 719  * gfs2_iomap_begin - Map blocks from an inode to disk blocks
 720  * @inode: The inode
 721  * @pos: Starting position in bytes
 722  * @length: Length to map, in bytes
 723  * @flags: iomap flags
 724  * @iomap: The iomap structure
 725  *
 726  * Returns: errno
 727  */
 728 int gfs2_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
 729                      unsigned flags, struct iomap *iomap)
 730 {
 731         struct gfs2_inode *ip = GFS2_I(inode);
 732         struct gfs2_sbd *sdp = GFS2_SB(inode);
 733         struct metapath mp = { .mp_aheight = 1, };
 734         unsigned int factor = sdp->sd_sb.sb_bsize;
 735         const u64 *arr = sdp->sd_heightsize;
 736         __be64 *ptr;
 737         sector_t lblock;
 738         sector_t lend;
 739         int ret;
 740         int eob;
 741         unsigned int len;
 742         struct buffer_head *bh;
 743         u8 height;
 744
 745         trace_gfs2_iomap_start(ip, pos, length, flags);
 746         if (!length) {
 747                 ret = -EINVAL;
 748                 goto out;
 749         }
 750
 751         if ((flags & IOMAP_REPORT) && gfs2_is_stuffed(ip)) {
 752                 gfs2_stuffed_iomap(inode, iomap);
 753                 if (pos >= iomap->length)
 754                         return -ENOENT;
 755                 ret = 0;
 756                 goto out;
 757         }
 758
 759         lblock = pos >> inode->i_blkbits;
 760         lend = (pos + length + sdp->sd_sb.sb_bsize - 1) >> inode->i_blkbits;
 761
 762         iomap->offset = lblock << inode->i_blkbits;
 763         iomap->addr = IOMAP_NULL_ADDR;
 764         iomap->type = IOMAP_HOLE;
 765         iomap->length = (u64)(lend - lblock) << inode->i_blkbits;
 766         iomap->flags = IOMAP_F_MERGED;
 767         bmap_lock(ip, 0);
 768
 769         /*
 770          * Directory data blocks have a struct gfs2_meta_header header, so the
 771          * remaining size is smaller than the filesystem block size.  Logical
 772          * block numbers for directories are in units of this remaining size!
 773          */
 774         if (gfs2_is_dir(ip)) {
 775                 factor = sdp->sd_jbsize;
 776                 arr = sdp->sd_jheightsize;
 777         }
 778
 779         ret = gfs2_meta_inode_buffer(ip, &mp.mp_bh[0]);
 780         if (ret)
 781                 goto out_release;
 782
 783         height = ip->i_height;
 784         while ((lblock + 1) * factor > arr[height])
 785                 height++;
 786         find_metapath(sdp, lblock, &mp, height);
 787         if (height > ip->i_height || gfs2_is_stuffed(ip))
 788                 goto do_alloc;
 789
 790         ret = lookup_metapath(ip, &mp);
 791         if (ret < 0)
 792                 goto out_release;
 793
 794         if (mp.mp_aheight != ip->i_height)
 795                 goto do_alloc;
 796
 797         ptr = metapointer(ip->i_height - 1, &mp);
 798         if (*ptr == 0)
 799                 goto do_alloc;
 800
 801         iomap->type = IOMAP_MAPPED;
 802         iomap->addr = be64_to_cpu(*ptr) << inode->i_blkbits;
 803
 804         bh = mp.mp_bh[ip->i_height - 1];
 805         len = gfs2_extent_length(bh->b_data, bh->b_size, ptr, lend - lblock, &eob);
 806         if (eob)
 807                 iomap->flags |= IOMAP_F_BOUNDARY;
 808         iomap->length = (u64)len << inode->i_blkbits;
 809
 810         ret = 0;
 811
 812 out_release:
 813         release_metapath(&mp);
 814         bmap_unlock(ip, 0);
 815 out:
 816         trace_gfs2_iomap_end(ip, iomap, ret);
 817         return ret;
 818
 819 do_alloc:
 820         if (!(flags & IOMAP_WRITE)) {
 821                 if (pos >= i_size_read(inode)) {
 822                         ret = -ENOENT;
 823                         goto out_release;
 824                 }
 825                 ret = 0;
 826                 iomap->length = hole_size(inode, lblock, &mp);
 827                 goto out_release;
 828         }
 829
 830         ret = gfs2_iomap_alloc(inode, iomap, flags, &mp);
 831         goto out_release;
 832 }
 833
 834 /**
 835  * gfs2_block_map - Map a block from an inode to a disk block
 836  * @inode: The inode
 837  * @lblock: The logical block number
 838  * @bh_map: The bh to be mapped
 839  * @create: True if its ok to alloc blocks to satify the request
 840  *
 841  * Sets buffer_mapped() if successful, sets buffer_boundary() if a
 842  * read of metadata will be required before the next block can be
 843  * mapped. Sets buffer_new() if new blocks were allocated.
 844  *
 845  * Returns: errno
 846  */
 847
 848 int gfs2_block_map(struct inode *inode, sector_t lblock,
 849                    struct buffer_head *bh_map, int create)
 850 {
 851         struct gfs2_inode *ip = GFS2_I(inode);
 852         struct iomap iomap;
 853         int ret, flags = 0;
 854
 855         clear_buffer_mapped(bh_map);
 856         clear_buffer_new(bh_map);
 857         clear_buffer_boundary(bh_map);
 858         trace_gfs2_bmap(ip, bh_map, lblock, create, 1);
 859
 860         if (create)
 861                 flags |= IOMAP_WRITE;
 862         if (buffer_zeronew(bh_map))
 863                 flags |= IOMAP_ZERO;
 864         ret = gfs2_iomap_begin(inode, (loff_t)lblock << inode->i_blkbits,
 865                                bh_map->b_size, flags, &iomap);
 866         if (ret) {
 867                 if (!create && ret == -ENOENT) {
 868                         /* Return unmapped buffer beyond the end of file.  */
 869                         ret = 0;
 870                 }
 871                 goto out;
 872         }
 873
 874         if (iomap.length > bh_map->b_size) {
 875                 iomap.length = bh_map->b_size;
 876                 iomap.flags &= ~IOMAP_F_BOUNDARY;
 877         }
 878         if (iomap.addr != IOMAP_NULL_ADDR)
 879                 map_bh(bh_map, inode->i_sb, iomap.addr >> inode->i_blkbits);
 880         bh_map->b_size = iomap.length;
 881         if (iomap.flags & IOMAP_F_BOUNDARY)
 882                 set_buffer_boundary(bh_map);
 883         if (iomap.flags & IOMAP_F_NEW)
 884                 set_buffer_new(bh_map);
 885
 886 out:
 887         trace_gfs2_bmap(ip, bh_map, lblock, create, ret);
 888         return ret;
 889 }
 890
 891 /*
 892  * Deprecated: do not use in new code
 893  */
 894 int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsigned *extlen)
 895 {
 896         struct buffer_head bh = { .b_state = 0, .b_blocknr = 0 };
 897         int ret;
 898         int create = *new;
 899
 900         BUG_ON(!extlen);
 901         BUG_ON(!dblock);
 902         BUG_ON(!new);
 903
 904         bh.b_size = BIT(inode->i_blkbits + (create ? 0 : 5));
 905         ret = gfs2_block_map(inode, lblock, &bh, create);
 906         *extlen = bh.b_size >> inode->i_blkbits;
 907         *dblock = bh.b_blocknr;
 908         if (buffer_new(&bh))
 909                 *new = 1;
 910         else
 911                 *new = 0;
 912         return ret;
 913 }
 914
 915 /**
 916  * gfs2_block_truncate_page - Deal with zeroing out data for truncate
 917  *
 918  * This is partly borrowed from ext3.
 919  */
 920 static int gfs2_block_truncate_page(struct address_space *mapping, loff_t from)
 921 {
 922         struct inode *inode = mapping->host;
 923         struct gfs2_inode *ip = GFS2_I(inode);
 924         unsigned long index = from >> PAGE_SHIFT;
 925         unsigned offset = from & (PAGE_SIZE-1);
 926         unsigned blocksize, iblock, length, pos;
 927         struct buffer_head *bh;
 928         struct page *page;
 929         int err;
 930
 931         page = find_or_create_page(mapping, index, GFP_NOFS);
 932         if (!page)
 933                 return 0;
 934
 935         blocksize = inode->i_sb->s_blocksize;
 936         length = blocksize - (offset & (blocksize - 1));
 937         iblock = index << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
 938
 939         if (!page_has_buffers(page))
 940                 create_empty_buffers(page, blocksize, 0);
 941
 942         /* Find the buffer that contains "offset" */
 943         bh = page_buffers(page);
 944         pos = blocksize;
 945         while (offset >= pos) {
 946                 bh = bh->b_this_page;
 947                 iblock++;
 948                 pos += blocksize;
 949         }
 950
 951         err = 0;
 952
 953         if (!buffer_mapped(bh)) {
 954                 gfs2_block_map(inode, iblock, bh, 0);
 955                 /* unmapped? It's a hole - nothing to do */
 956                 if (!buffer_mapped(bh))
 957                         goto unlock;
 958         }
 959
 960         /* Ok, it's mapped. Make sure it's up-to-date */
 961         if (PageUptodate(page))
 962                 set_buffer_uptodate(bh);
 963
 964         if (!buffer_uptodate(bh)) {
 965                 err = -EIO;
 966                 ll_rw_block(REQ_OP_READ, 0, 1, &bh);
 967                 wait_on_buffer(bh);
 968                 /* Uhhuh. Read error. Complain and punt. */
 969                 if (!buffer_uptodate(bh))
 970                         goto unlock;
 971                 err = 0;
 972         }
 973
 974         if (!gfs2_is_writeback(ip))
 975                 gfs2_trans_add_data(ip->i_gl, bh);
 976
 977         zero_user(page, offset, length);
 978         mark_buffer_dirty(bh);
 979 unlock:
 980         unlock_page(page);
 981         put_page(page);
 982         return err;
 983 }
 984
 985 #define GFS2_JTRUNC_REVOKES 8192
 986
 987 /**
 988  * gfs2_journaled_truncate - Wrapper for truncate_pagecache for jdata files
 989  * @inode: The inode being truncated
 990  * @oldsize: The original (larger) size
 991  * @newsize: The new smaller size
 992  *
 993  * With jdata files, we have to journal a revoke for each block which is
 994  * truncated. As a result, we need to split this into separate transactions
 995  * if the number of pages being truncated gets too large.
 996  */
 997
 998 static int gfs2_journaled_truncate(struct inode *inode, u64 oldsize, u64 newsize)
 999 {
1000         struct gfs2_sbd *sdp = GFS2_SB(inode);
1001         u64 max_chunk = GFS2_JTRUNC_REVOKES * sdp->sd_vfs->s_blocksize;
1002         u64 chunk;
1003         int error;
1004
1005         while (oldsize != newsize) {
1006                 chunk = oldsize - newsize;
1007                 if (chunk > max_chunk)
1008                         chunk = max_chunk;
1009                 truncate_pagecache(inode, oldsize - chunk);
1010                 oldsize -= chunk;
1011                 gfs2_trans_end(sdp);
1012                 error = gfs2_trans_begin(sdp, RES_DINODE, GFS2_JTRUNC_REVOKES);
1013                 if (error)
1014                         return error;
1015         }
1016
1017         return 0;
1018 }
1019
1020 static int trunc_start(struct inode *inode, u64 oldsize, u64 newsize)
1021 {
1022         struct gfs2_inode *ip = GFS2_I(inode);
1023         struct gfs2_sbd *sdp = GFS2_SB(inode);
1024         struct address_space *mapping = inode->i_mapping;
1025         struct buffer_head *dibh;
1026         int journaled = gfs2_is_jdata(ip);
1027         int error;
1028
1029         if (journaled)
1030                 error = gfs2_trans_begin(sdp, RES_DINODE + RES_JDATA, GFS2_JTRUNC_REVOKES);
1031         else
1032                 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1033         if (error)
1034                 return error;
1035
1036         error = gfs2_meta_inode_buffer(ip, &dibh);
1037         if (error)
1038                 goto out;
1039
1040         gfs2_trans_add_meta(ip->i_gl, dibh);
1041
1042         if (gfs2_is_stuffed(ip)) {
1043                 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + newsize);
1044         } else {
1045                 if (newsize & (u64)(sdp->sd_sb.sb_bsize - 1)) {
1046                         error = gfs2_block_truncate_page(mapping, newsize);
1047                         if (error)
1048                                 goto out_brelse;
1049                 }
1050                 ip->i_diskflags |= GFS2_DIF_TRUNC_IN_PROG;
1051         }
1052
1053         i_size_write(inode, newsize);
1054         ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
1055         gfs2_dinode_out(ip, dibh->b_data);
1056
1057         if (journaled)
1058                 error = gfs2_journaled_truncate(inode, oldsize, newsize);
1059         else
1060                 truncate_pagecache(inode, newsize);
1061
1062         if (error) {
1063                 brelse(dibh);
1064                 return error;
1065         }
1066
1067 out_brelse:
1068         brelse(dibh);
1069 out:
1070         gfs2_trans_end(sdp);
1071         return error;
1072 }
1073
1074 /**
1075  * sweep_bh_for_rgrps - find an rgrp in a meta buffer and free blocks therein
1076  * @ip: inode
1077  * @rg_gh: holder of resource group glock
1078  * @mp: current metapath fully populated with buffers
1079  * @btotal: place to keep count of total blocks freed
1080  * @hgt: height we're processing
1081  * @first: true if this is the first call to this function for this height
1082  *
1083  * We sweep a metadata buffer (provided by the metapath) for blocks we need to
1084  * free, and free them all. However, we do it one rgrp at a time. If this
1085  * block has references to multiple rgrps, we break it into individual
1086  * transactions. This allows other processes to use the rgrps while we're
1087  * focused on a single one, for better concurrency / performance.
1088  * At every transaction boundary, we rewrite the inode into the journal.
1089  * That way the bitmaps are kept consistent with the inode and we can recover
1090  * if we're interrupted by power-outages.
1091  *
1092  * Returns: 0, or return code if an error occurred.
1093  *          *btotal has the total number of blocks freed
1094  */
1095 static int sweep_bh_for_rgrps(struct gfs2_inode *ip, struct gfs2_holder *rd_gh,
1096                               const struct metapath *mp, u32 *btotal, int hgt,
1097                               bool preserve1)
1098 {
1099         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1100         struct gfs2_rgrpd *rgd;
1101         struct gfs2_trans *tr;
1102         struct buffer_head *bh = mp->mp_bh[hgt];
1103         __be64 *top, *bottom, *p;
1104         int blks_outside_rgrp;
1105         u64 bn, bstart, isize_blks;
1106         s64 blen; /* needs to be s64 or gfs2_add_inode_blocks breaks */
1107         int meta = ((hgt != ip->i_height - 1) ? 1 : 0);
1108         int ret = 0;
1109         bool buf_in_tr = false; /* buffer was added to transaction */
1110
1111         if (gfs2_metatype_check(sdp, bh,
1112                                 (hgt ? GFS2_METATYPE_IN : GFS2_METATYPE_DI)))
1113                 return -EIO;
1114
1115 more_rgrps:
1116         blks_outside_rgrp = 0;
1117         bstart = 0;
1118         blen = 0;
1119         top = metapointer(hgt, mp); /* first ptr from metapath */
1120         /* If we're keeping some data at the truncation point, we've got to
1121            preserve the metadata tree by adding 1 to the starting metapath. */
1122         if (preserve1)
1123                 top++;
1124
1125         bottom = (__be64 *)(bh->b_data + bh->b_size);
1126
1127         for (p = top; p < bottom; p++) {
1128                 if (!*p)
1129                         continue;
1130                 bn = be64_to_cpu(*p);
1131                 if (gfs2_holder_initialized(rd_gh)) {
1132                         rgd = gfs2_glock2rgrp(rd_gh->gh_gl);
1133                         gfs2_assert_withdraw(sdp,
1134                                      gfs2_glock_is_locked_by_me(rd_gh->gh_gl));
1135                 } else {
1136                         rgd = gfs2_blk2rgrpd(sdp, bn, false);
1137                         ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,
1138                                                  0, rd_gh);
1139                         if (ret)
1140                                 goto out;
1141
1142                         /* Must be done with the rgrp glock held: */
1143                         if (gfs2_rs_active(&ip->i_res) &&
1144                             rgd == ip->i_res.rs_rbm.rgd)
1145                                 gfs2_rs_deltree(&ip->i_res);
1146                 }
1147
1148                 if (!rgrp_contains_block(rgd, bn)) {
1149                         blks_outside_rgrp++;
1150                         continue;
1151                 }
1152
1153                 /* The size of our transactions will be unknown until we
1154                    actually process all the metadata blocks that relate to
1155                    the rgrp. So we estimate. We know it can't be more than
1156                    the dinode's i_blocks and we don't want to exceed the
1157                    journal flush threshold, sd_log_thresh2. */
1158                 if (current->journal_info == NULL) {
1159                         unsigned int jblocks_rqsted, revokes;
1160
1161                         jblocks_rqsted = rgd->rd_length + RES_DINODE +
1162                                 RES_INDIRECT;
1163                         isize_blks = gfs2_get_inode_blocks(&ip->i_inode);
1164                         if (isize_blks > atomic_read(&sdp->sd_log_thresh2))
1165                                 jblocks_rqsted +=
1166                                         atomic_read(&sdp->sd_log_thresh2);
1167                         else
1168                                 jblocks_rqsted += isize_blks;
1169                         revokes = jblocks_rqsted;
1170                         if (meta)
1171                                 revokes += hptrs(sdp, hgt);
1172                         else if (ip->i_depth)
1173                                 revokes += sdp->sd_inptrs;
1174                         ret = gfs2_trans_begin(sdp, jblocks_rqsted, revokes);
1175                         if (ret)
1176                                 goto out_unlock;
1177                         down_write(&ip->i_rw_mutex);
1178                 }
1179                 /* check if we will exceed the transaction blocks requested */
1180                 tr = current->journal_info;
1181                 if (tr->tr_num_buf_new + RES_STATFS +
1182                     RES_QUOTA >= atomic_read(&sdp->sd_log_thresh2)) {
1183                         /* We set blks_outside_rgrp to ensure the loop will
1184                            be repeated for the same rgrp, but with a new
1185                            transaction. */
1186                         blks_outside_rgrp++;
1187                         /* This next part is tricky. If the buffer was added
1188                            to the transaction, we've already set some block
1189                            pointers to 0, so we better follow through and free
1190                            them, or we will introduce corruption (so break).
1191                            This may be impossible, or at least rare, but I
1192                            decided to cover the case regardless.
1193
1194                            If the buffer was not added to the transaction
1195                            (this call), doing so would exceed our transaction
1196                            size, so we need to end the transaction and start a
1197                            new one (so goto). */
1198
1199                         if (buf_in_tr)
1200                                 break;
1201                         goto out_unlock;
1202                 }
1203
1204                 gfs2_trans_add_meta(ip->i_gl, bh);
1205                 buf_in_tr = true;
1206                 *p = 0;
1207                 if (bstart + blen == bn) {
1208                         blen++;
1209                         continue;
1210                 }
1211                 if (bstart) {
1212                         __gfs2_free_blocks(ip, bstart, (u32)blen, meta);
1213                         (*btotal) += blen;
1214                         gfs2_add_inode_blocks(&ip->i_inode, -blen);
1215                 }
1216                 bstart = bn;
1217                 blen = 1;
1218         }
1219         if (bstart) {
1220                 __gfs2_free_blocks(ip, bstart, (u32)blen, meta);
1221                 (*btotal) += blen;
1222                 gfs2_add_inode_blocks(&ip->i_inode, -blen);
1223         }
1224 out_unlock:
1225         if (!ret && blks_outside_rgrp) { /* If buffer still has non-zero blocks
1226                                             outside the rgrp we just processed,
1227                                             do it all over again. */
1228                 if (current->journal_info) {
1229                         struct buffer_head *dibh = mp->mp_bh[0];
1230
1231                         /* Every transaction boundary, we rewrite the dinode
1232                            to keep its di_blocks current in case of failure. */
1233                         ip->i_inode.i_mtime = ip->i_inode.i_ctime =
1234                                 current_time(&ip->i_inode);
1235                         gfs2_trans_add_meta(ip->i_gl, dibh);
1236                         gfs2_dinode_out(ip, dibh->b_data);
1237                         up_write(&ip->i_rw_mutex);
1238                         gfs2_trans_end(sdp);
1239                 }
1240                 gfs2_glock_dq_uninit(rd_gh);
1241                 cond_resched();
1242                 goto more_rgrps;
1243         }
1244 out:
1245         return ret;
1246 }
1247
1248 /**
1249  * find_nonnull_ptr - find a non-null pointer given a metapath and height
1250  * assumes the metapath is valid (with buffers) out to height h
1251  * @mp: starting metapath
1252  * @h: desired height to search
1253  *
1254  * Returns: true if a non-null pointer was found in the metapath buffer
1255  *          false if all remaining pointers are NULL in the buffer
1256  */
1257 static bool find_nonnull_ptr(struct gfs2_sbd *sdp, struct metapath *mp,
1258                              unsigned int h)
1259 {
1260         __be64 *ptr;
1261         unsigned int ptrs = hptrs(sdp, h) - 1;
1262
1263         while (true) {
1264                 ptr = metapointer(h, mp);
1265                 if (*ptr) { /* if we have a non-null pointer */
1266                         /* Now zero the metapath after the current height. */
1267                         h++;
1268                         if (h < GFS2_MAX_META_HEIGHT)
1269                                 memset(&mp->mp_list[h], 0,
1270                                        (GFS2_MAX_META_HEIGHT - h) *
1271                                        sizeof(mp->mp_list[0]));
1272                         return true;
1273                 }
1274
1275                 if (mp->mp_list[h] < ptrs)
1276                         mp->mp_list[h]++;
1277                 else
1278                         return false; /* no more pointers in this buffer */
1279         }
1280 }
1281
1282 enum dealloc_states {
1283         DEALLOC_MP_FULL = 0,    /* Strip a metapath with all buffers read in */
1284         DEALLOC_MP_LOWER = 1,   /* lower the metapath strip height */
1285         DEALLOC_FILL_MP = 2,  /* Fill in the metapath to the given height. */
1286         DEALLOC_DONE = 3,       /* process complete */
1287 };
1288
1289 static bool mp_eq_to_hgt(struct metapath *mp, __u16 *nbof, unsigned int h)
1290 {
1291         if (memcmp(mp->mp_list, nbof, h * sizeof(mp->mp_list[0])))
1292                 return false;
1293         return true;
1294 }
1295
1296 /**
1297  * trunc_dealloc - truncate a file down to a desired size
1298  * @ip: inode to truncate
1299  * @newsize: The desired size of the file
1300  *
1301  * This function truncates a file to newsize. It works from the
1302  * bottom up, and from the right to the left. In other words, it strips off
1303  * the highest layer (data) before stripping any of the metadata. Doing it
1304  * this way is best in case the operation is interrupted by power failure, etc.
1305  * The dinode is rewritten in every transaction to guarantee integrity.
1306  */
1307 static int trunc_dealloc(struct gfs2_inode *ip, u64 newsize)
1308 {
1309         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1310         struct metapath mp;
1311         struct buffer_head *dibh, *bh;
1312         struct gfs2_holder rd_gh;
1313         u64 lblock;
1314         __u16 nbof[GFS2_MAX_META_HEIGHT]; /* new beginning of truncation */
1315         unsigned int strip_h = ip->i_height - 1;
1316         u32 btotal = 0;
1317         int ret, state;
1318         int mp_h; /* metapath buffers are read in to this height */
1319         sector_t last_ra = 0;
1320         u64 prev_bnr = 0;
1321         bool preserve1; /* need to preserve the first meta pointer? */
1322
1323         if (!newsize)
1324                 lblock = 0;
1325         else
1326                 lblock = (newsize - 1) >> sdp->sd_sb.sb_bsize_shift;
1327
1328         memset(&mp, 0, sizeof(mp));
1329         find_metapath(sdp, lblock, &mp, ip->i_height);
1330
1331         memcpy(&nbof, &mp.mp_list, sizeof(nbof));
1332
1333         ret = gfs2_meta_inode_buffer(ip, &dibh);
1334         if (ret)
1335                 return ret;
1336
1337         mp.mp_bh[0] = dibh;
1338         ret = lookup_metapath(ip, &mp);
1339         if (ret == ip->i_height)
1340                 state = DEALLOC_MP_FULL; /* We have a complete metapath */
1341         else
1342                 state = DEALLOC_FILL_MP; /* deal with partial metapath */
1343
1344         ret = gfs2_rindex_update(sdp);
1345         if (ret)
1346                 goto out_metapath;
1347
1348         ret = gfs2_quota_hold(ip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE);
1349         if (ret)
1350                 goto out_metapath;
1351         gfs2_holder_mark_uninitialized(&rd_gh);
1352
1353         mp_h = strip_h;
1354
1355         while (state != DEALLOC_DONE) {
1356                 switch (state) {
1357                 /* Truncate a full metapath at the given strip height.
1358                  * Note that strip_h == mp_h in order to be in this state. */
1359                 case DEALLOC_MP_FULL:
1360                         if (mp_h > 0) { /* issue read-ahead on metadata */
1361                                 __be64 *top;
1362
1363                                 bh = mp.mp_bh[mp_h - 1];
1364                                 if (bh->b_blocknr != last_ra) {
1365                                         last_ra = bh->b_blocknr;
1366                                         top = metaptr1(mp_h - 1, &mp);
1367                                         gfs2_metapath_ra(ip->i_gl, bh, top);
1368                                 }
1369                         }
1370                         /* If we're truncating to a non-zero size and the mp is
1371                            at the beginning of file for the strip height, we
1372                            need to preserve the first metadata pointer. */
1373                         preserve1 = (newsize && mp_eq_to_hgt(&mp, nbof, mp_h));
1374                         bh = mp.mp_bh[mp_h];
1375                         gfs2_assert_withdraw(sdp, bh);
1376                         if (gfs2_assert_withdraw(sdp,
1377                                                  prev_bnr != bh->b_blocknr)) {
1378                                 printk(KERN_EMERG "GFS2: fsid=%s:inode %llu, "
1379                                        "block:%llu, i_h:%u, s_h:%u, mp_h:%u\n",
1380                                        sdp->sd_fsname,
1381                                        (unsigned long long)ip->i_no_addr,
1382                                        prev_bnr, ip->i_height, strip_h, mp_h);
1383                         }
1384                         prev_bnr = bh->b_blocknr;
1385                         ret = sweep_bh_for_rgrps(ip, &rd_gh, &mp, &btotal,
1386                                                  mp_h, preserve1);
1387                         /* If we hit an error or just swept dinode buffer,
1388                            just exit. */
1389                         if (ret || !mp_h) {
1390                                 state = DEALLOC_DONE;
1391                                 break;
1392                         }
1393                         state = DEALLOC_MP_LOWER;
1394                         break;
1395
1396                 /* lower the metapath strip height */
1397                 case DEALLOC_MP_LOWER:
1398                         /* We're done with the current buffer, so release it,
1399                            unless it's the dinode buffer. Then back up to the
1400                            previous pointer. */
1401                         if (mp_h) {
1402                                 brelse(mp.mp_bh[mp_h]);
1403                                 mp.mp_bh[mp_h] = NULL;
1404                         }
1405                         /* If we can't get any lower in height, we've stripped
1406                            off all we can. Next step is to back up and start
1407                            stripping the previous level of metadata. */
1408                         if (mp_h == 0) {
1409                                 strip_h--;
1410                                 memcpy(&mp.mp_list, &nbof, sizeof(nbof));
1411                                 mp_h = strip_h;
1412                                 state = DEALLOC_FILL_MP;
1413                                 break;
1414                         }
1415                         mp.mp_list[mp_h] = 0;
1416                         mp_h--; /* search one metadata height down */
1417                         if (mp.mp_list[mp_h] >= hptrs(sdp, mp_h) - 1)
1418                                 break; /* loop around in the same state */
1419                         mp.mp_list[mp_h]++;
1420                         /* Here we've found a part of the metapath that is not
1421                          * allocated. We need to search at that height for the
1422                          * next non-null pointer. */
1423                         if (find_nonnull_ptr(sdp, &mp, mp_h)) {
1424                                 state = DEALLOC_FILL_MP;
1425                                 mp_h++;
1426                         }
1427                         /* No more non-null pointers at this height. Back up
1428                            to the previous height and try again. */
1429                         break; /* loop around in the same state */
1430
1431                 /* Fill the metapath with buffers to the given height. */
1432                 case DEALLOC_FILL_MP:
1433                         /* Fill the buffers out to the current height. */
1434                         ret = fillup_metapath(ip, &mp, mp_h);
1435                         if (ret < 0)
1436                                 goto out;
1437
1438                         /* If buffers found for the entire strip height */
1439                         if ((ret == ip->i_height) && (mp_h == strip_h)) {
1440                                 state = DEALLOC_MP_FULL;
1441                                 break;
1442                         }
1443                         if (ret < ip->i_height) /* We have a partial height */
1444                                 mp_h = ret - 1;
1445
1446                         /* If we find a non-null block pointer, crawl a bit
1447                            higher up in the metapath and try again, otherwise
1448                            we need to look lower for a new starting point. */
1449                         if (find_nonnull_ptr(sdp, &mp, mp_h))
1450                                 mp_h++;
1451                         else
1452                                 state = DEALLOC_MP_LOWER;
1453                         break;
1454                 }
1455         }
1456
1457         if (btotal) {
1458                 if (current->journal_info == NULL) {
1459                         ret = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS +
1460                                                RES_QUOTA, 0);
1461                         if (ret)
1462                                 goto out;
1463                         down_write(&ip->i_rw_mutex);
1464                 }
1465                 gfs2_statfs_change(sdp, 0, +btotal, 0);
1466                 gfs2_quota_change(ip, -(s64)btotal, ip->i_inode.i_uid,
1467                                   ip->i_inode.i_gid);
1468                 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
1469                 gfs2_trans_add_meta(ip->i_gl, dibh);
1470                 gfs2_dinode_out(ip, dibh->b_data);
1471                 up_write(&ip->i_rw_mutex);
1472                 gfs2_trans_end(sdp);
1473         }
1474
1475 out:
1476         if (gfs2_holder_initialized(&rd_gh))
1477                 gfs2_glock_dq_uninit(&rd_gh);
1478         if (current->journal_info) {
1479                 up_write(&ip->i_rw_mutex);
1480                 gfs2_trans_end(sdp);
1481                 cond_resched();
1482         }
1483         gfs2_quota_unhold(ip);
1484 out_metapath:
1485         release_metapath(&mp);
1486         return ret;
1487 }
1488
1489 static int trunc_end(struct gfs2_inode *ip)
1490 {
1491         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1492         struct buffer_head *dibh;
1493         int error;
1494
1495         error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1496         if (error)
1497                 return error;
1498
1499         down_write(&ip->i_rw_mutex);
1500
1501         error = gfs2_meta_inode_buffer(ip, &dibh);
1502         if (error)
1503                 goto out;
1504
1505         if (!i_size_read(&ip->i_inode)) {
1506                 ip->i_height = 0;
1507                 ip->i_goal = ip->i_no_addr;
1508                 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
1509                 gfs2_ordered_del_inode(ip);
1510         }
1511         ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
1512         ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;
1513
1514         gfs2_trans_add_meta(ip->i_gl, dibh);
1515         gfs2_dinode_out(ip, dibh->b_data);
1516         brelse(dibh);
1517
1518 out:
1519         up_write(&ip->i_rw_mutex);
1520         gfs2_trans_end(sdp);
1521         return error;
1522 }
1523
1524 /**
1525  * do_shrink - make a file smaller
1526  * @inode: the inode
1527  * @oldsize: the current inode size
1528  * @newsize: the size to make the file
1529  *
1530  * Called with an exclusive lock on @inode. The @size must
1531  * be equal to or smaller than the current inode size.
1532  *
1533  * Returns: errno
1534  */
1535
1536 static int do_shrink(struct inode *inode, u64 oldsize, u64 newsize)
1537 {
1538         struct gfs2_inode *ip = GFS2_I(inode);
1539         int error;
1540
1541         error = trunc_start(inode, oldsize, newsize);
1542         if (error < 0)
1543                 return error;
1544         if (gfs2_is_stuffed(ip))
1545                 return 0;
1546
1547         error = trunc_dealloc(ip, newsize);
1548         if (error == 0)
1549                 error = trunc_end(ip);
1550
1551         return error;
1552 }
1553
1554 void gfs2_trim_blocks(struct inode *inode)
1555 {
1556         u64 size = inode->i_size;
1557         int ret;
1558
1559         ret = do_shrink(inode, size, size);
1560         WARN_ON(ret != 0);
1561 }
1562
1563 /**
1564  * do_grow - Touch and update inode size
1565  * @inode: The inode
1566  * @size: The new size
1567  *
1568  * This function updates the timestamps on the inode and
1569  * may also increase the size of the inode. This function
1570  * must not be called with @size any smaller than the current
1571  * inode size.
1572  *
1573  * Although it is not strictly required to unstuff files here,
1574  * earlier versions of GFS2 have a bug in the stuffed file reading
1575  * code which will result in a buffer overrun if the size is larger
1576  * than the max stuffed file size. In order to prevent this from
1577  * occurring, such files are unstuffed, but in other cases we can
1578  * just update the inode size directly.
1579  *
1580  * Returns: 0 on success, or -ve on error
1581  */
1582
1583 static int do_grow(struct inode *inode, u64 size)
1584 {
1585         struct gfs2_inode *ip = GFS2_I(inode);
1586         struct gfs2_sbd *sdp = GFS2_SB(inode);
1587         struct gfs2_alloc_parms ap = { .target = 1, };
1588         struct buffer_head *dibh;
1589         int error;
1590         int unstuff = 0;
1591
1592         if (gfs2_is_stuffed(ip) &&
1593             (size > (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)))) {
1594                 error = gfs2_quota_lock_check(ip, &ap);
1595                 if (error)
1596                         return error;
1597
1598                 error = gfs2_inplace_reserve(ip, &ap);
1599                 if (error)
1600                         goto do_grow_qunlock;
1601                 unstuff = 1;
1602         }
1603
1604         error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT +
1605                                  (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF ?
1606                                   0 : RES_QUOTA), 0);
1607         if (error)
1608                 goto do_grow_release;
1609
1610         if (unstuff) {
1611                 error = gfs2_unstuff_dinode(ip, NULL);
1612                 if (error)
1613                         goto do_end_trans;
1614         }
1615
1616         error = gfs2_meta_inode_buffer(ip, &dibh);
1617         if (error)
1618                 goto do_end_trans;
1619
1620         i_size_write(inode, size);
1621         ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
1622         gfs2_trans_add_meta(ip->i_gl, dibh);
1623         gfs2_dinode_out(ip, dibh->b_data);
1624         brelse(dibh);
1625
1626 do_end_trans:
1627         gfs2_trans_end(sdp);
1628 do_grow_release:
1629         if (unstuff) {
1630                 gfs2_inplace_release(ip);
1631 do_grow_qunlock:
1632                 gfs2_quota_unlock(ip);
1633         }
1634         return error;
1635 }
1636
1637 /**
1638  * gfs2_setattr_size - make a file a given size
1639  * @inode: the inode
1640  * @newsize: the size to make the file
1641  *
1642  * The file size can grow, shrink, or stay the same size. This
1643  * is called holding i_mutex and an exclusive glock on the inode
1644  * in question.
1645  *
1646  * Returns: errno
1647  */
1648
1649 int gfs2_setattr_size(struct inode *inode, u64 newsize)
1650 {
1651         struct gfs2_inode *ip = GFS2_I(inode);
1652         int ret;
1653         u64 oldsize;
1654
1655         BUG_ON(!S_ISREG(inode->i_mode));
1656
1657         ret = inode_newsize_ok(inode, newsize);
1658         if (ret)
1659                 return ret;
1660
1661         inode_dio_wait(inode);
1662
1663         ret = gfs2_rsqa_alloc(ip);
1664         if (ret)
1665                 goto out;
1666
1667         oldsize = inode->i_size;
1668         if (newsize >= oldsize) {
1669                 ret = do_grow(inode, newsize);
1670                 goto out;
1671         }
1672
1673         ret = do_shrink(inode, oldsize, newsize);
1674 out:
1675         gfs2_rsqa_delete(ip, NULL);
1676         return ret;
1677 }
1678
1679 int gfs2_truncatei_resume(struct gfs2_inode *ip)
1680 {
1681         int error;
1682         error = trunc_dealloc(ip, i_size_read(&ip->i_inode));
1683         if (!error)
1684                 error = trunc_end(ip);
1685         return error;
1686 }
1687
1688 int gfs2_file_dealloc(struct gfs2_inode *ip)
1689 {
1690         return trunc_dealloc(ip, 0);
1691 }
1692
1693 /**
1694  * gfs2_free_journal_extents - Free cached journal bmap info
1695  * @jd: The journal
1696  *
1697  */
1698
1699 void gfs2_free_journal_extents(struct gfs2_jdesc *jd)
1700 {
1701         struct gfs2_journal_extent *jext;
1702
1703         while(!list_empty(&jd->extent_list)) {
1704                 jext = list_entry(jd->extent_list.next, struct gfs2_journal_extent, list);
1705                 list_del(&jext->list);
1706                 kfree(jext);
1707         }
1708 }
1709
1710 /**
1711  * gfs2_add_jextent - Add or merge a new extent to extent cache
1712  * @jd: The journal descriptor
1713  * @lblock: The logical block at start of new extent
1714  * @dblock: The physical block at start of new extent
1715  * @blocks: Size of extent in fs blocks
1716  *
1717  * Returns: 0 on success or -ENOMEM
1718  */
1719
1720 static int gfs2_add_jextent(struct gfs2_jdesc *jd, u64 lblock, u64 dblock, u64 blocks)
1721 {
1722         struct gfs2_journal_extent *jext;
1723
1724         if (!list_empty(&jd->extent_list)) {
1725                 jext = list_entry(jd->extent_list.prev, struct gfs2_journal_extent, list);
1726                 if ((jext->dblock + jext->blocks) == dblock) {
1727                         jext->blocks += blocks;
1728                         return 0;
1729                 }
1730         }
1731
1732         jext = kzalloc(sizeof(struct gfs2_journal_extent), GFP_NOFS);
1733         if (jext == NULL)
1734                 return -ENOMEM;
1735         jext->dblock = dblock;
1736         jext->lblock = lblock;
1737         jext->blocks = blocks;
1738         list_add_tail(&jext->list, &jd->extent_list);
1739         jd->nr_extents++;
1740         return 0;
1741 }
1742
1743 /**
1744  * gfs2_map_journal_extents - Cache journal bmap info
1745  * @sdp: The super block
1746  * @jd: The journal to map
1747  *
1748  * Create a reusable "extent" mapping from all logical
1749  * blocks to all physical blocks for the given journal.  This will save
1750  * us time when writing journal blocks.  Most journals will have only one
1751  * extent that maps all their logical blocks.  That's because gfs2.mkfs
1752  * arranges the journal blocks sequentially to maximize performance.
1753  * So the extent would map the first block for the entire file length.
1754  * However, gfs2_jadd can happen while file activity is happening, so
1755  * those journals may not be sequential.  Less likely is the case where
1756  * the users created their own journals by mounting the metafs and
1757  * laying it out.  But it's still possible.  These journals might have
1758  * several extents.
1759  *
1760  * Returns: 0 on success, or error on failure
1761  */
1762
1763 int gfs2_map_journal_extents(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd)
1764 {
1765         u64 lblock = 0;
1766         u64 lblock_stop;
1767         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
1768         struct buffer_head bh;
1769         unsigned int shift = sdp->sd_sb.sb_bsize_shift;
1770         u64 size;
1771         int rc;
1772
1773         lblock_stop = i_size_read(jd->jd_inode) >> shift;
1774         size = (lblock_stop - lblock) << shift;
1775         jd->nr_extents = 0;
1776         WARN_ON(!list_empty(&jd->extent_list));
1777
1778         do {
1779                 bh.b_state = 0;
1780                 bh.b_blocknr = 0;
1781                 bh.b_size = size;
1782                 rc = gfs2_block_map(jd->jd_inode, lblock, &bh, 0);
1783                 if (rc || !buffer_mapped(&bh))
1784                         goto fail;
1785                 rc = gfs2_add_jextent(jd, lblock, bh.b_blocknr, bh.b_size >> shift);
1786                 if (rc)
1787                         goto fail;
1788                 size -= bh.b_size;
1789                 lblock += (bh.b_size >> ip->i_inode.i_blkbits);
1790         } while(size > 0);
1791
1792         fs_info(sdp, "journal %d mapped with %u extents\n", jd->jd_jid,
1793                 jd->nr_extents);
1794         return 0;
1795
1796 fail:
1797         fs_warn(sdp, "error %d mapping journal %u at offset %llu (extent %u)\n",
1798                 rc, jd->jd_jid,
1799                 (unsigned long long)(i_size_read(jd->jd_inode) - size),
1800                 jd->nr_extents);
1801         fs_warn(sdp, "bmap=%d lblock=%llu block=%llu, state=0x%08lx, size=%llu\n",
1802                 rc, (unsigned long long)lblock, (unsigned long long)bh.b_blocknr,
1803                 bh.b_state, (unsigned long long)bh.b_size);
1804         gfs2_free_journal_extents(jd);
1805         return rc;
1806 }
1807
1808 /**
1809  * gfs2_write_alloc_required - figure out if a write will require an allocation
1810  * @ip: the file being written to
1811  * @offset: the offset to write to
1812  * @len: the number of bytes being written
1813  *
1814  * Returns: 1 if an alloc is required, 0 otherwise
1815  */
1816
1817 int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,
1818                               unsigned int len)
1819 {
1820         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1821         struct buffer_head bh;
1822         unsigned int shift;
1823         u64 lblock, lblock_stop, size;
1824         u64 end_of_file;
1825
1826         if (!len)
1827                 return 0;
1828
1829         if (gfs2_is_stuffed(ip)) {
1830                 if (offset + len >
1831                     sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode))
1832                         return 1;
1833                 return 0;
1834         }
1835
1836         shift = sdp->sd_sb.sb_bsize_shift;
1837         BUG_ON(gfs2_is_dir(ip));
1838         end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift;
1839         lblock = offset >> shift;
1840         lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift;
1841         if (lblock_stop > end_of_file)
1842                 return 1;
1843
1844         size = (lblock_stop - lblock) << shift;
1845         do {
1846                 bh.b_state = 0;
1847                 bh.b_size = size;
1848                 gfs2_block_map(&ip->i_inode, lblock, &bh, 0);
1849                 if (!buffer_mapped(&bh))
1850                         return 1;
1851                 size -= bh.b_size;
1852                 lblock += (bh.b_size >> ip->i_inode.i_blkbits);
1853         } while(size > 0);
1854
1855         return 0;
1856 }
1857