LCOV - code coverage report
Current view: top level - fs/ext4 - page-io.c (source / functions) Hit Total Coverage
Test: Real Lines: 119 204 58.3 %
Date: 2020-10-17 15:46:16 Functions: 0 19 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14