fs/ext4/page-io.c

   1 /*
   2  * linux/fs/ext4/page-io.c
   3  *
   4  * This contains the new page_io functions for ext4
   5  *
   6  * Written by Theodore Ts'o, 2010.
   7  */
   8
   9 #include <linux/fs.h>
  10 #include <linux/time.h>
  11 #include <linux/jbd2.h>
  12 #include <linux/highuid.h>
  13 #include <linux/pagemap.h>
  14 #include <linux/quotaops.h>
  15 #include <linux/string.h>
  16 #include <linux/buffer_head.h>
  17 #include <linux/writeback.h>
  18 #include <linux/pagevec.h>
  19 #include <linux/mpage.h>
  20 #include <linux/namei.h>
  21 #include <linux/aio.h>
  22 #include <linux/uio.h>
  23 #include <linux/bio.h>
  24 #include <linux/workqueue.h>
  25 #include <linux/kernel.h>
  26 #include <linux/slab.h>
  27 #include <linux/mm.h>
  28
  29 #include "ext4_jbd2.h"
  30 #include "xattr.h"
  31 #include "acl.h"
  32
  33 static struct kmem_cache *io_end_cachep;
  34
  35 int __init ext4_init_pageio(void)
  36 {
  37         io_end_cachep = KMEM_CACHE(ext4_io_end, SLAB_RECLAIM_ACCOUNT);
  38         if (io_end_cachep == NULL)
  39                 return -ENOMEM;
  40         return 0;
  41 }
  42
  43 void ext4_exit_pageio(void)
  44 {
  45         kmem_cache_destroy(io_end_cachep);
  46 }
  47
  48 /*
  49  * This function is called by ext4_evict_inode() to make sure there is
  50  * no more pending I/O completion work left to do.
  51  */
  52 void ext4_ioend_shutdown(struct inode *inode)
  53 {
  54         wait_queue_head_t *wq = ext4_ioend_wq(inode);
  55
  56         wait_event(*wq, (atomic_read(&EXT4_I(inode)->i_ioend_count) == 0));
  57         /*
  58          * We need to make sure the work structure is finished being
  59          * used before we let the inode get destroyed.
  60          */
  61         if (work_pending(&EXT4_I(inode)->i_unwritten_work))
  62                 cancel_work_sync(&EXT4_I(inode)->i_unwritten_work);
  63 }
  64
  65 static void ext4_release_io_end(ext4_io_end_t *io_end)
  66 {
  67         BUG_ON(!list_empty(&io_end->list));
  68         BUG_ON(io_end->flag & EXT4_IO_END_UNWRITTEN);
  69         WARN_ON(io_end->handle);
  70
  71         if (atomic_dec_and_test(&EXT4_I(io_end->inode)->i_ioend_count))
  72                 wake_up_all(ext4_ioend_wq(io_end->inode));
  73         if (io_end->flag & EXT4_IO_END_DIRECT)
  74                 inode_dio_done(io_end->inode);
  75         if (io_end->iocb)
  76                 aio_complete(io_end->iocb, io_end->result, 0);
  77         kmem_cache_free(io_end_cachep, io_end);
  78 }
  79
  80 static void ext4_clear_io_unwritten_flag(ext4_io_end_t *io_end)
  81 {
  82         struct inode *inode = io_end->inode;
  83
  84         io_end->flag &= ~EXT4_IO_END_UNWRITTEN;
  85         /* Wake up anyone waiting on unwritten extent conversion */
  86         if (atomic_dec_and_test(&EXT4_I(inode)->i_unwritten))
  87                 wake_up_all(ext4_ioend_wq(inode));
  88 }
  89
  90 /* check a range of space and convert unwritten extents to written. */
  91 static int ext4_end_io(ext4_io_end_t *io)
  92 {
  93         struct inode *inode = io->inode;
  94         loff_t offset = io->offset;
  95         ssize_t size = io->size;
  96         handle_t *handle = io->handle;
  97         int ret = 0;
  98
  99         ext4_debug("ext4_end_io_nolock: io 0x%p from inode %lu,list->next 0x%p,"
 100                    "list->prev 0x%p\n",
 101                    io, inode->i_ino, io->list.next, io->list.prev);
 102
 103         io->handle = NULL;      /* Following call will use up the handle */
 104         ret = ext4_convert_unwritten_extents(handle, inode, offset, size);
 105         if (ret < 0) {
 106                 ext4_msg(inode->i_sb, KERN_EMERG,
 107                          "failed to convert unwritten extents to written "
 108                          "extents -- potential data loss!  "
 109                          "(inode %lu, offset %llu, size %zd, error %d)",
 110                          inode->i_ino, offset, size, ret);
 111         }
 112         ext4_clear_io_unwritten_flag(io);
 113         ext4_release_io_end(io);
 114         return ret;
 115 }
 116
 117 static void dump_completed_IO(struct inode *inode)
 118 {
 119 #ifdef  EXT4FS_DEBUG
 120         struct list_head *cur, *before, *after;
 121         ext4_io_end_t *io, *io0, *io1;
 122
 123         if (list_empty(&EXT4_I(inode)->i_completed_io_list)) {
 124                 ext4_debug("inode %lu completed_io list is empty\n",
 125                            inode->i_ino);
 126                 return;
 127         }
 128
 129         ext4_debug("Dump inode %lu completed_io list\n", inode->i_ino);
 130         list_for_each_entry(io, &EXT4_I(inode)->i_completed_io_list, list) {
 131                 cur = &io->list;
 132                 before = cur->prev;
 133                 io0 = container_of(before, ext4_io_end_t, list);
 134                 after = cur->next;
 135                 io1 = container_of(after, ext4_io_end_t, list);
 136
 137                 ext4_debug("io 0x%p from inode %lu,prev 0x%p,next 0x%p\n",
 138                             io, inode->i_ino, io0, io1);
 139         }
 140 #endif
 141 }
 142
 143 /* Add the io_end to per-inode completed end_io list. */
 144 static void ext4_add_complete_io(ext4_io_end_t *io_end)
 145 {
 146         struct ext4_inode_info *ei = EXT4_I(io_end->inode);
 147         struct workqueue_struct *wq;
 148         unsigned long flags;
 149
 150         BUG_ON(!(io_end->flag & EXT4_IO_END_UNWRITTEN));
 151         wq = EXT4_SB(io_end->inode->i_sb)->dio_unwritten_wq;
 152
 153         spin_lock_irqsave(&ei->i_completed_io_lock, flags);
 154         if (list_empty(&ei->i_completed_io_list))
 155                 queue_work(wq, &ei->i_unwritten_work);
 156         list_add_tail(&io_end->list, &ei->i_completed_io_list);
 157         spin_unlock_irqrestore(&ei->i_completed_io_lock, flags);
 158 }
 159
 160 static int ext4_do_flush_completed_IO(struct inode *inode)
 161 {
 162         ext4_io_end_t *io;
 163         struct list_head unwritten;
 164         unsigned long flags;
 165         struct ext4_inode_info *ei = EXT4_I(inode);
 166         int err, ret = 0;
 167
 168         spin_lock_irqsave(&ei->i_completed_io_lock, flags);
 169         dump_completed_IO(inode);
 170         list_replace_init(&ei->i_completed_io_list, &unwritten);
 171         spin_unlock_irqrestore(&ei->i_completed_io_lock, flags);
 172
 173         while (!list_empty(&unwritten)) {
 174                 io = list_entry(unwritten.next, ext4_io_end_t, list);
 175                 BUG_ON(!(io->flag & EXT4_IO_END_UNWRITTEN));
 176                 list_del_init(&io->list);
 177
 178                 err = ext4_end_io(io);
 179                 if (unlikely(!ret && err))
 180                         ret = err;
 181         }
 182         return ret;
 183 }
 184
 185 /*
 186  * work on completed aio dio IO, to convert unwritten extents to extents
 187  */
 188 void ext4_end_io_work(struct work_struct *work)
 189 {
 190         struct ext4_inode_info *ei = container_of(work, struct ext4_inode_info,
 191                                                   i_unwritten_work);
 192         ext4_do_flush_completed_IO(&ei->vfs_inode);
 193 }
 194
 195 int ext4_flush_unwritten_io(struct inode *inode)
 196 {
 197         int ret;
 198         WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex) &&
 199                      !(inode->i_state & I_FREEING));
 200         ret = ext4_do_flush_completed_IO(inode);
 201         ext4_unwritten_wait(inode);
 202         return ret;
 203 }
 204
 205 ext4_io_end_t *ext4_init_io_end(struct inode *inode, gfp_t flags)
 206 {
 207         ext4_io_end_t *io = kmem_cache_zalloc(io_end_cachep, flags);
 208         if (io) {
 209                 atomic_inc(&EXT4_I(inode)->i_ioend_count);
 210                 io->inode = inode;
 211                 INIT_LIST_HEAD(&io->list);
 212                 atomic_set(&io->count, 1);
 213         }
 214         return io;
 215 }
 216
 217 void ext4_put_io_end_defer(ext4_io_end_t *io_end)
 218 {
 219         if (atomic_dec_and_test(&io_end->count)) {
 220                 if (!(io_end->flag & EXT4_IO_END_UNWRITTEN) || !io_end->size) {
 221                         ext4_release_io_end(io_end);
 222                         return;
 223                 }
 224                 ext4_add_complete_io(io_end);
 225         }
 226 }
 227
 228 int ext4_put_io_end(ext4_io_end_t *io_end)
 229 {
 230         int err = 0;
 231
 232         if (atomic_dec_and_test(&io_end->count)) {
 233                 if (io_end->flag & EXT4_IO_END_UNWRITTEN) {
 234                         err = ext4_convert_unwritten_extents(io_end->handle,
 235                                                 io_end->inode, io_end->offset,
 236                                                 io_end->size);
 237                         io_end->handle = NULL;
 238                         ext4_clear_io_unwritten_flag(io_end);
 239                 }
 240                 ext4_release_io_end(io_end);
 241         }
 242         return err;
 243 }
 244
 245 ext4_io_end_t *ext4_get_io_end(ext4_io_end_t *io_end)
 246 {
 247         atomic_inc(&io_end->count);
 248         return io_end;
 249 }
 250
 251 /*
 252  * Print an buffer I/O error compatible with the fs/buffer.c.  This
 253  * provides compatibility with dmesg scrapers that look for a specific
 254  * buffer I/O error message.  We really need a unified error reporting
 255  * structure to userspace ala Digital Unix's uerf system, but it's
 256  * probably not going to happen in my lifetime, due to LKML politics...
 257  */
 258 static void buffer_io_error(struct buffer_head *bh)
 259 {
 260         char b[BDEVNAME_SIZE];
 261         printk(KERN_ERR "Buffer I/O error on device %s, logical block %llu\n",
 262                         bdevname(bh->b_bdev, b),
 263                         (unsigned long long)bh->b_blocknr);
 264 }
 265
 266 static void ext4_end_bio(struct bio *bio, int error)
 267 {
 268         ext4_io_end_t *io_end = bio->bi_private;
 269         struct inode *inode;
 270         int i;
 271         int blocksize;
 272         sector_t bi_sector = bio->bi_sector;
 273
 274         BUG_ON(!io_end);
 275         inode = io_end->inode;
 276         blocksize = 1 << inode->i_blkbits;
 277         bio->bi_private = NULL;
 278         bio->bi_end_io = NULL;
 279         if (test_bit(BIO_UPTODATE, &bio->bi_flags))
 280                 error = 0;
 281         for (i = 0; i < bio->bi_vcnt; i++) {
 282                 struct bio_vec *bvec = &bio->bi_io_vec[i];
 283                 struct page *page = bvec->bv_page;
 284                 struct buffer_head *bh, *head;
 285                 unsigned bio_start = bvec->bv_offset;
 286                 unsigned bio_end = bio_start + bvec->bv_len;
 287                 unsigned under_io = 0;
 288                 unsigned long flags;
 289
 290                 if (!page)
 291                         continue;
 292
 293                 if (error) {
 294                         SetPageError(page);
 295                         set_bit(AS_EIO, &page->mapping->flags);
 296                 }
 297                 bh = head = page_buffers(page);
 298                 /*
 299                  * We check all buffers in the page under BH_Uptodate_Lock
 300                  * to avoid races with other end io clearing async_write flags
 301                  */
 302                 local_irq_save(flags);
 303                 bit_spin_lock(BH_Uptodate_Lock, &head->b_state);
 304                 do {
 305                         if (bh_offset(bh) < bio_start ||
 306                             bh_offset(bh) + blocksize > bio_end) {
 307                                 if (buffer_async_write(bh))
 308                                         under_io++;
 309                                 continue;
 310                         }
 311                         clear_buffer_async_write(bh);
 312                         if (error)
 313                                 buffer_io_error(bh);
 314                 } while ((bh = bh->b_this_page) != head);
 315                 bit_spin_unlock(BH_Uptodate_Lock, &head->b_state);
 316                 local_irq_restore(flags);
 317                 if (!under_io)
 318                         end_page_writeback(page);
 319         }
 320         bio_put(bio);
 321
 322         if (error) {
 323                 io_end->flag |= EXT4_IO_END_ERROR;
 324                 ext4_warning(inode->i_sb, "I/O error writing to inode %lu "
 325                              "(offset %llu size %ld starting block %llu)",
 326                              inode->i_ino,
 327                              (unsigned long long) io_end->offset,
 328                              (long) io_end->size,
 329                              (unsigned long long)
 330                              bi_sector >> (inode->i_blkbits - 9));
 331         }
 332
 333         ext4_put_io_end_defer(io_end);
 334 }
 335
 336 void ext4_io_submit(struct ext4_io_submit *io)
 337 {
 338         struct bio *bio = io->io_bio;
 339
 340         if (bio) {
 341                 bio_get(io->io_bio);
 342                 submit_bio(io->io_op, io->io_bio);
 343                 BUG_ON(bio_flagged(io->io_bio, BIO_EOPNOTSUPP));
 344                 bio_put(io->io_bio);
 345         }
 346         io->io_bio = NULL;
 347 }
 348
 349 void ext4_io_submit_init(struct ext4_io_submit *io,
 350                          struct writeback_control *wbc)
 351 {
 352         io->io_op = (wbc->sync_mode == WB_SYNC_ALL ?  WRITE_SYNC : WRITE);
 353         io->io_bio = NULL;
 354         io->io_end = NULL;
 355 }
 356
 357 static int io_submit_init_bio(struct ext4_io_submit *io,
 358                               struct buffer_head *bh)
 359 {
 360         int nvecs = bio_get_nr_vecs(bh->b_bdev);
 361         struct bio *bio;
 362
 363         bio = bio_alloc(GFP_NOIO, min(nvecs, BIO_MAX_PAGES));
 364         bio->bi_sector = bh->b_blocknr * (bh->b_size >> 9);
 365         bio->bi_bdev = bh->b_bdev;
 366         bio->bi_end_io = ext4_end_bio;
 367         bio->bi_private = ext4_get_io_end(io->io_end);
 368         io->io_bio = bio;
 369         io->io_next_block = bh->b_blocknr;
 370         return 0;
 371 }
 372
 373 static int io_submit_add_bh(struct ext4_io_submit *io,
 374                             struct inode *inode,
 375                             struct buffer_head *bh)
 376 {
 377         int ret;
 378
 379         if (io->io_bio && bh->b_blocknr != io->io_next_block) {
 380 submit_and_retry:
 381                 ext4_io_submit(io);
 382         }
 383         if (io->io_bio == NULL) {
 384                 ret = io_submit_init_bio(io, bh);
 385                 if (ret)
 386                         return ret;
 387         }
 388         ret = bio_add_page(io->io_bio, bh->b_page, bh->b_size, bh_offset(bh));
 389         if (ret != bh->b_size)
 390                 goto submit_and_retry;
 391         io->io_next_block++;
 392         return 0;
 393 }
 394
 395 int ext4_bio_write_page(struct ext4_io_submit *io,
 396                         struct page *page,
 397                         int len,
 398                         struct writeback_control *wbc)
 399 {
 400         struct inode *inode = page->mapping->host;
 401         unsigned block_start, blocksize;
 402         struct buffer_head *bh, *head;
 403         int ret = 0;
 404         int nr_submitted = 0;
 405
 406         blocksize = 1 << inode->i_blkbits;
 407
 408         BUG_ON(!PageLocked(page));
 409         BUG_ON(PageWriteback(page));
 410
 411         set_page_writeback(page);
 412         ClearPageError(page);
 413
 414         /*
 415          * In the first loop we prepare and mark buffers to submit. We have to
 416          * mark all buffers in the page before submitting so that
 417          * end_page_writeback() cannot be called from ext4_bio_end_io() when IO
 418          * on the first buffer finishes and we are still working on submitting
 419          * the second buffer.
 420          */
 421         bh = head = page_buffers(page);
 422         do {
 423                 block_start = bh_offset(bh);
 424                 if (block_start >= len) {
 425                         /*
 426                          * Comments copied from block_write_full_page_endio:
 427                          *
 428                          * The page straddles i_size.  It must be zeroed out on
 429                          * each and every writepage invocation because it may
 430                          * be mmapped.  "A file is mapped in multiples of the
 431                          * page size.  For a file that is not a multiple of
 432                          * the  page size, the remaining memory is zeroed when
 433                          * mapped, and writes to that region are not written
 434                          * out to the file."
 435                          */
 436                         zero_user_segment(page, block_start,
 437                                           block_start + blocksize);
 438                         clear_buffer_dirty(bh);
 439                         set_buffer_uptodate(bh);
 440                         continue;
 441                 }
 442                 if (!buffer_dirty(bh) || buffer_delay(bh) ||
 443                     !buffer_mapped(bh) || buffer_unwritten(bh)) {
 444                         /* A hole? We can safely clear the dirty bit */
 445                         if (!buffer_mapped(bh))
 446                                 clear_buffer_dirty(bh);
 447                         if (io->io_bio)
 448                                 ext4_io_submit(io);
 449                         continue;
 450                 }
 451                 if (buffer_new(bh)) {
 452                         clear_buffer_new(bh);
 453                         unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr);
 454                 }
 455                 set_buffer_async_write(bh);
 456         } while ((bh = bh->b_this_page) != head);
 457
 458         /* Now submit buffers to write */
 459         bh = head = page_buffers(page);
 460         do {
 461                 if (!buffer_async_write(bh))
 462                         continue;
 463                 ret = io_submit_add_bh(io, inode, bh);
 464                 if (ret) {
 465                         /*
 466                          * We only get here on ENOMEM.  Not much else
 467                          * we can do but mark the page as dirty, and
 468                          * better luck next time.
 469                          */
 470                         redirty_page_for_writepage(wbc, page);
 471                         break;
 472                 }
 473                 nr_submitted++;
 474                 clear_buffer_dirty(bh);
 475         } while ((bh = bh->b_this_page) != head);
 476
 477         /* Error stopped previous loop? Clean up buffers... */
 478         if (ret) {
 479                 do {
 480                         clear_buffer_async_write(bh);
 481                         bh = bh->b_this_page;
 482                 } while (bh != head);
 483         }
 484         unlock_page(page);
 485         /* Nothing submitted - we have to end page writeback */
 486         if (!nr_submitted)
 487                 end_page_writeback(page);
 488         return ret;
 489 }