fs/gfs2/ops_address.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2005 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 v.2.
   8  */
   9
  10 #include <linux/sched.h>
  11 #include <linux/slab.h>
  12 #include <linux/spinlock.h>
  13 #include <linux/completion.h>
  14 #include <linux/buffer_head.h>
  15 #include <linux/pagemap.h>
  16 #include <linux/mpage.h>
  17 #include <asm/semaphore.h>
  18
  19 #include "gfs2.h"
  20 #include "bmap.h"
  21 #include "glock.h"
  22 #include "inode.h"
  23 #include "jdata.h"
  24 #include "log.h"
  25 #include "meta_io.h"
  26 #include "ops_address.h"
  27 #include "page.h"
  28 #include "quota.h"
  29 #include "trans.h"
  30
  31 /**
  32  * gfs2_get_block - Fills in a buffer head with details about a block
  33  * @inode: The inode
  34  * @lblock: The block number to look up
  35  * @bh_result: The buffer head to return the result in
  36  * @create: Non-zero if we may add block to the file
  37  *
  38  * Returns: errno
  39  */
  40
  41 int gfs2_get_block(struct inode *inode, sector_t lblock,
  42                    struct buffer_head *bh_result, int create)
  43 {
  44         struct gfs2_inode *ip = get_v2ip(inode);
  45         int new = create;
  46         uint64_t dblock;
  47         int error;
  48
  49         error = gfs2_block_map(ip, lblock, &new, &dblock, NULL);
  50         if (error)
  51                 return error;
  52
  53         if (!dblock)
  54                 return 0;
  55
  56         map_bh(bh_result, inode->i_sb, dblock);
  57         if (new)
  58                 set_buffer_new(bh_result);
  59
  60         return 0;
  61 }
  62
  63 /**
  64  * get_block_noalloc - Fills in a buffer head with details about a block
  65  * @inode: The inode
  66  * @lblock: The block number to look up
  67  * @bh_result: The buffer head to return the result in
  68  * @create: Non-zero if we may add block to the file
  69  *
  70  * Returns: errno
  71  */
  72
  73 static int get_block_noalloc(struct inode *inode, sector_t lblock,
  74                              struct buffer_head *bh_result, int create)
  75 {
  76         struct gfs2_inode *ip = get_v2ip(inode);
  77         int new = 0;
  78         uint64_t dblock;
  79         int error;
  80
  81         error = gfs2_block_map(ip, lblock, &new, &dblock, NULL);
  82         if (error)
  83                 return error;
  84
  85         if (dblock)
  86                 map_bh(bh_result, inode->i_sb, dblock);
  87         else if (gfs2_assert_withdraw(ip->i_sbd, !create))
  88                 error = -EIO;
  89
  90         return error;
  91 }
  92
  93 static int get_blocks(struct inode *inode, sector_t lblock,
  94                       unsigned long max_blocks, struct buffer_head *bh_result,
  95                       int create)
  96 {
  97         struct gfs2_inode *ip = get_v2ip(inode);
  98         int new = create;
  99         uint64_t dblock;
 100         uint32_t extlen;
 101         int error;
 102
 103         error = gfs2_block_map(ip, lblock, &new, &dblock, &extlen);
 104         if (error)
 105                 return error;
 106
 107         if (!dblock)
 108                 return 0;
 109
 110         map_bh(bh_result, inode->i_sb, dblock);
 111         if (new)
 112                 set_buffer_new(bh_result);
 113
 114         if (extlen > max_blocks)
 115                 extlen = max_blocks;
 116         bh_result->b_size = extlen << inode->i_blkbits;
 117
 118         return 0;
 119 }
 120
 121 static int get_blocks_noalloc(struct inode *inode, sector_t lblock,
 122                               unsigned long max_blocks,
 123                               struct buffer_head *bh_result, int create)
 124 {
 125         struct gfs2_inode *ip = get_v2ip(inode);
 126         int new = 0;
 127         uint64_t dblock;
 128         uint32_t extlen;
 129         int error;
 130
 131         error = gfs2_block_map(ip, lblock, &new, &dblock, &extlen);
 132         if (error)
 133                 return error;
 134
 135         if (dblock) {
 136                 map_bh(bh_result, inode->i_sb, dblock);
 137                 if (extlen > max_blocks)
 138                         extlen = max_blocks;
 139                 bh_result->b_size = extlen << inode->i_blkbits;
 140         } else if (gfs2_assert_withdraw(ip->i_sbd, !create))
 141                 error = -EIO;
 142
 143         return error;
 144 }
 145
 146 /**
 147  * gfs2_writepage - Write complete page
 148  * @page: Page to write
 149  *
 150  * Returns: errno
 151  *
 152  * Use Linux VFS block_write_full_page() to write one page,
 153  *   using GFS2's get_block_noalloc to find which blocks to write.
 154  */
 155
 156 static int gfs2_writepage(struct page *page, struct writeback_control *wbc)
 157 {
 158         struct gfs2_inode *ip = get_v2ip(page->mapping->host);
 159         struct gfs2_sbd *sdp = ip->i_sbd;
 160         int error;
 161
 162         atomic_inc(&sdp->sd_ops_address);
 163
 164         if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl))) {
 165                 unlock_page(page);
 166                 return -EIO;
 167         }
 168         if (get_transaction) {
 169                 redirty_page_for_writepage(wbc, page);
 170                 unlock_page(page);
 171                 return 0;
 172         }
 173
 174         error = block_write_full_page(page, get_block_noalloc, wbc);
 175
 176         gfs2_meta_cache_flush(ip);
 177
 178         return error;
 179 }
 180
 181 /**
 182  * stuffed_readpage - Fill in a Linux page with stuffed file data
 183  * @ip: the inode
 184  * @page: the page
 185  *
 186  * Returns: errno
 187  */
 188
 189 static int stuffed_readpage(struct gfs2_inode *ip, struct page *page)
 190 {
 191         struct buffer_head *dibh;
 192         void *kaddr;
 193         int error;
 194
 195         error = gfs2_meta_inode_buffer(ip, &dibh);
 196         if (error)
 197                 return error;
 198
 199         kaddr = kmap(page);
 200         memcpy((char *)kaddr,
 201                dibh->b_data + sizeof(struct gfs2_dinode),
 202                ip->i_di.di_size);
 203         memset((char *)kaddr + ip->i_di.di_size,
 204                0,
 205                PAGE_CACHE_SIZE - ip->i_di.di_size);
 206         kunmap(page);
 207
 208         brelse(dibh);
 209
 210         SetPageUptodate(page);
 211
 212         return 0;
 213 }
 214
 215 static int zero_readpage(struct page *page)
 216 {
 217         void *kaddr;
 218
 219         kaddr = kmap(page);
 220         memset(kaddr, 0, PAGE_CACHE_SIZE);
 221         kunmap(page);
 222
 223         SetPageUptodate(page);
 224         unlock_page(page);
 225
 226         return 0;
 227 }
 228
 229 /**
 230  * jdata_readpage - readpage that goes through gfs2_jdata_read_mem()
 231  * @ip:
 232  * @page: The page to read
 233  *
 234  * Returns: errno
 235  */
 236
 237 static int jdata_readpage(struct gfs2_inode *ip, struct page *page)
 238 {
 239         void *kaddr;
 240         int ret;
 241
 242         kaddr = kmap(page);
 243
 244         ret = gfs2_jdata_read_mem(ip, kaddr,
 245                                   (uint64_t)page->index << PAGE_CACHE_SHIFT,
 246                                   PAGE_CACHE_SIZE);
 247         if (ret >= 0) {
 248                 if (ret < PAGE_CACHE_SIZE)
 249                         memset(kaddr + ret, 0, PAGE_CACHE_SIZE - ret);
 250                 SetPageUptodate(page);
 251                 ret = 0;
 252         }
 253
 254         kunmap(page);
 255
 256         unlock_page(page);
 257
 258         return ret;
 259 }
 260
 261 /**
 262  * gfs2_readpage - readpage with locking
 263  * @file: The file to read a page for
 264  * @page: The page to read
 265  *
 266  * Returns: errno
 267  */
 268
 269 static int gfs2_readpage(struct file *file, struct page *page)
 270 {
 271         struct gfs2_inode *ip = get_v2ip(page->mapping->host);
 272         struct gfs2_sbd *sdp = ip->i_sbd;
 273         int error;
 274
 275         atomic_inc(&sdp->sd_ops_address);
 276
 277         if (gfs2_assert_warn(sdp, gfs2_glock_is_locked_by_me(ip->i_gl))) {
 278                 unlock_page(page);
 279                 return -EOPNOTSUPP;
 280         }
 281
 282         if (!gfs2_is_jdata(ip)) {
 283                 if (gfs2_is_stuffed(ip)) {
 284                         if (!page->index) {
 285                                 error = stuffed_readpage(ip, page);
 286                                 unlock_page(page);
 287                         } else
 288                                 error = zero_readpage(page);
 289                 } else
 290                         error = mpage_readpage(page, gfs2_get_block);
 291         } else
 292                 error = jdata_readpage(ip, page);
 293
 294         if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 295                 error = -EIO;
 296
 297         return error;
 298 }
 299
 300 /**
 301  * gfs2_prepare_write - Prepare to write a page to a file
 302  * @file: The file to write to
 303  * @page: The page which is to be prepared for writing
 304  * @from: From (byte range within page)
 305  * @to: To (byte range within page)
 306  *
 307  * Returns: errno
 308  */
 309
 310 static int gfs2_prepare_write(struct file *file, struct page *page,
 311                               unsigned from, unsigned to)
 312 {
 313         struct gfs2_inode *ip = get_v2ip(page->mapping->host);
 314         struct gfs2_sbd *sdp = ip->i_sbd;
 315         int error = 0;
 316
 317         atomic_inc(&sdp->sd_ops_address);
 318
 319         if (gfs2_assert_warn(sdp, gfs2_glock_is_locked_by_me(ip->i_gl)))
 320                 return -EOPNOTSUPP;
 321
 322         if (gfs2_is_stuffed(ip)) {
 323                 uint64_t file_size;
 324                 file_size = ((uint64_t)page->index << PAGE_CACHE_SHIFT) + to;
 325
 326                 if (file_size > sdp->sd_sb.sb_bsize -
 327                                 sizeof(struct gfs2_dinode)) {
 328                         error = gfs2_unstuff_dinode(ip, gfs2_unstuffer_page,
 329                                                     page);
 330                         if (!error)
 331                                 error = block_prepare_write(page, from, to,
 332                                                             gfs2_get_block);
 333                 } else if (!PageUptodate(page))
 334                         error = stuffed_readpage(ip, page);
 335         } else
 336                 error = block_prepare_write(page, from, to, gfs2_get_block);
 337
 338         return error;
 339 }
 340
 341 /**
 342  * gfs2_commit_write - Commit write to a file
 343  * @file: The file to write to
 344  * @page: The page containing the data
 345  * @from: From (byte range within page)
 346  * @to: To (byte range within page)
 347  *
 348  * Returns: errno
 349  */
 350
 351 static int gfs2_commit_write(struct file *file, struct page *page,
 352                              unsigned from, unsigned to)
 353 {
 354         struct inode *inode = page->mapping->host;
 355         struct gfs2_inode *ip = get_v2ip(inode);
 356         struct gfs2_sbd *sdp = ip->i_sbd;
 357         int error;
 358
 359         atomic_inc(&sdp->sd_ops_address);
 360
 361         if (gfs2_is_stuffed(ip)) {
 362                 struct buffer_head *dibh;
 363                 uint64_t file_size;
 364                 void *kaddr;
 365
 366                 file_size = ((uint64_t)page->index << PAGE_CACHE_SHIFT) + to;
 367
 368                 error = gfs2_meta_inode_buffer(ip, &dibh);
 369                 if (error)
 370                         goto fail;
 371
 372                 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 373
 374                 kaddr = kmap(page);
 375                 memcpy(dibh->b_data + sizeof(struct gfs2_dinode) + from,
 376                        (char *)kaddr + from,
 377                        to - from);
 378                 kunmap(page);
 379
 380                 brelse(dibh);
 381
 382                 SetPageUptodate(page);
 383
 384                 if (inode->i_size < file_size)
 385                         i_size_write(inode, file_size);
 386         } else {
 387                 if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED)
 388                         gfs2_page_add_databufs(ip, page, from, to);
 389                 error = generic_commit_write(file, page, from, to);
 390                 if (error)
 391                         goto fail;
 392         }
 393
 394         return 0;
 395
 396  fail:
 397         ClearPageUptodate(page);
 398
 399         return error;
 400 }
 401
 402 /**
 403  * gfs2_bmap - Block map function
 404  * @mapping: Address space info
 405  * @lblock: The block to map
 406  *
 407  * Returns: The disk address for the block or 0 on hole or error
 408  */
 409
 410 static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock)
 411 {
 412         struct gfs2_inode *ip = get_v2ip(mapping->host);
 413         struct gfs2_holder i_gh;
 414         sector_t dblock = 0;
 415         int error;
 416
 417         atomic_inc(&ip->i_sbd->sd_ops_address);
 418
 419         error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
 420         if (error)
 421                 return 0;
 422
 423         if (!gfs2_is_stuffed(ip))
 424                 dblock = generic_block_bmap(mapping, lblock, gfs2_get_block);
 425
 426         gfs2_glock_dq_uninit(&i_gh);
 427
 428         return dblock;
 429 }
 430
 431 static void discard_buffer(struct gfs2_sbd *sdp, struct buffer_head *bh)
 432 {
 433         struct gfs2_bufdata *bd;
 434
 435         gfs2_log_lock(sdp);
 436         bd = get_v2bd(bh);
 437         if (bd) {
 438                 bd->bd_bh = NULL;
 439                 set_v2bd(bh, NULL);
 440                 gfs2_log_unlock(sdp);
 441                 brelse(bh);
 442         } else
 443                 gfs2_log_unlock(sdp);
 444
 445         lock_buffer(bh);
 446         clear_buffer_dirty(bh);
 447         bh->b_bdev = NULL;
 448         clear_buffer_mapped(bh);
 449         clear_buffer_req(bh);
 450         clear_buffer_new(bh);
 451         clear_buffer_delay(bh);
 452         unlock_buffer(bh);
 453 }
 454
 455 static int gfs2_invalidatepage(struct page *page, unsigned long offset)
 456 {
 457         struct gfs2_sbd *sdp = get_v2sdp(page->mapping->host->i_sb);
 458         struct buffer_head *head, *bh, *next;
 459         unsigned int curr_off = 0;
 460         int ret = 1;
 461
 462         BUG_ON(!PageLocked(page));
 463         if (!page_has_buffers(page))
 464                 return 1;
 465
 466         bh = head = page_buffers(page);
 467         do {
 468                 unsigned int next_off = curr_off + bh->b_size;
 469                 next = bh->b_this_page;
 470
 471                 if (offset <= curr_off)
 472                         discard_buffer(sdp, bh);
 473
 474                 curr_off = next_off;
 475                 bh = next;
 476         } while (bh != head);
 477
 478         if (!offset)
 479                 ret = try_to_release_page(page, 0);
 480
 481         return ret;
 482 }
 483
 484 static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
 485                           loff_t offset, unsigned long nr_segs)
 486 {
 487         struct file *file = iocb->ki_filp;
 488         struct inode *inode = file->f_mapping->host;
 489         struct gfs2_inode *ip = get_v2ip(inode);
 490         struct gfs2_sbd *sdp = ip->i_sbd;
 491         get_blocks_t *gb = get_blocks;
 492
 493         atomic_inc(&sdp->sd_ops_address);
 494
 495         if (gfs2_assert_warn(sdp, gfs2_glock_is_locked_by_me(ip->i_gl)) ||
 496             gfs2_assert_warn(sdp, !gfs2_is_stuffed(ip)))
 497                 return -EINVAL;
 498
 499         if (rw == WRITE && !get_transaction)
 500                 gb = get_blocks_noalloc;
 501
 502         return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
 503                                   offset, nr_segs, gb, NULL);
 504 }
 505
 506 struct address_space_operations gfs2_file_aops = {
 507         .writepage = gfs2_writepage,
 508         .readpage = gfs2_readpage,
 509         .sync_page = block_sync_page,
 510         .prepare_write = gfs2_prepare_write,
 511         .commit_write = gfs2_commit_write,
 512         .bmap = gfs2_bmap,
 513         .invalidatepage = gfs2_invalidatepage,
 514         .direct_IO = gfs2_direct_IO,
 515 };
 516