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