Merge to Fedora kernel-2.6.7-1.492

[linux-2.6.git] / fs / buffer.c

diff --git a/fs/buffer.c b/fs/buffer.c
index 0b84c0f..7e849b1 100644 (file)
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -1420,7 +1420,7 @@ struct bh_lru {
        struct buffer_head *bhs[BH_LRU_SIZE];
 };
 
-static DEFINE_PER_CPU(struct bh_lru, bh_lrus) = {{0}};
+static DEFINE_PER_CPU(struct bh_lru, bh_lrus) = {{ NULL }};
 
 #ifdef CONFIG_SMP
 #define bh_lru_lock()  local_irq_disable()
@@ -1551,6 +1551,7 @@ __getblk(struct block_device *bdev, sector_t block, int size)
 {
        struct buffer_head *bh = __find_get_block(bdev, block, size);
 
+       might_sleep();
        if (bh == NULL)
                bh = __getblk_slow(bdev, block, size);
        return bh;
@@ -1588,10 +1589,9 @@ __bread(struct block_device *bdev, sector_t block, int size)
 EXPORT_SYMBOL(__bread);
 
 /*
- * invalidate_bh_lrus() is called rarely - at unmount.  Because it is only for
- * unmount it only needs to ensure that all buffers from the target device are
- * invalidated on return and it doesn't need to worry about new buffers from
- * that device being added - the unmount code has to prevent that.
+ * invalidate_bh_lrus() is called rarely - but not only at unmount.
+ * This doesn't race because it runs in each cpu either in irq
+ * or with preempt disabled.
  */
 static void invalidate_bh_lru(void *arg)
 {
@@ -1777,6 +1777,8 @@ void unmap_underlying_metadata(struct block_device *bdev, sector_t block)
 {
        struct buffer_head *old_bh;
 
+       might_sleep();
+
        old_bh = __find_get_block_slow(bdev, block, 0);
        if (old_bh) {
                clear_buffer_dirty(old_bh);
@@ -1807,10 +1809,10 @@ EXPORT_SYMBOL(unmap_underlying_metadata);
  * state inside lock_buffer().
  *
  * If block_write_full_page() is called for regular writeback
- * (called_for_sync() is false) then it will redirty a page which has a locked
- * buffer.   This only can happen if someone has written the buffer directly,
- * with submit_bh().  At the address_space level PageWriteback prevents this
- * contention from occurring.
+ * (wbc->sync_mode == WB_SYNC_NONE) then it will redirty a page which has a
+ * locked buffer.   This only can happen if someone has written the buffer
+ * directly, with submit_bh().  At the address_space level PageWriteback
+ * prevents this contention from occurring.
  */
 static int __block_write_full_page(struct inode *inode, struct page *page,
                        get_block_t *get_block, struct writeback_control *wbc)
@@ -1899,14 +1901,14 @@ static int __block_write_full_page(struct inode *inode, struct page *page,
                }
        } while ((bh = bh->b_this_page) != head);
 
+       /*
+        * The page and its buffers are protected by PageWriteback(), so we can
+        * drop the bh refcounts early.
+        */
        BUG_ON(PageWriteback(page));
-       set_page_writeback(page);       /* Keeps try_to_free_buffers() away */
+       set_page_writeback(page);
        unlock_page(page);
 
-       /*
-        * The page may come unlocked any time after the *first* submit_bh()
-        * call.  Be careful with its buffers.
-        */
        do {
                struct buffer_head *next = bh->b_this_page;
                if (buffer_async_write(bh)) {
@@ -1936,6 +1938,10 @@ done:
                if (uptodate)
                        SetPageUptodate(page);
                end_page_writeback(page);
+               /*
+                * The page and buffer_heads can be released at any time from
+                * here on.
+                */
                wbc->pages_skipped++;   /* We didn't write this page */
        }
        return err;
@@ -2487,7 +2493,7 @@ int nobh_prepare_write(struct page *page, unsigned from, unsigned to,
                        }
                        bh->b_state = map_bh.b_state;
                        atomic_set(&bh->b_count, 0);
-                       bh->b_this_page = 0;
+                       bh->b_this_page = NULL;
                        bh->b_page = page;
                        bh->b_blocknr = map_bh.b_blocknr;
                        bh->b_size = blocksize;
@@ -2723,7 +2729,7 @@ int block_write_full_page(struct page *page, get_block_t *get_block,
 
        /*
         * The page straddles i_size.  It must be zeroed out on each and every
-        * writepage invocation because it may be mmapped.  "A file is mapped
+        * writepage invokation because it may be mmapped.  "A file is mapped
         * in multiples of the page size.  For a file that is not a multiple of
         * the  page size, the remaining memory is zeroed when mapped, and
         * writes to that region are not written out to the file."
@@ -2895,7 +2901,6 @@ drop_buffers(struct page *page, struct buffer_head **buffers_to_free)
 {
        struct buffer_head *head = page_buffers(page);
        struct buffer_head *bh;
-       int was_uptodate = 1;
 
        bh = head;
        do {
@@ -2903,8 +2908,6 @@ drop_buffers(struct page *page, struct buffer_head **buffers_to_free)
                        set_bit(AS_EIO, &page->mapping->flags);
                if (buffer_busy(bh))
                        goto failed;
-               if (!buffer_uptodate(bh) && !buffer_req(bh))
-                       was_uptodate = 0;
                bh = bh->b_this_page;
        } while (bh != head);