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