1a86c6181SAlex Tomas /* 2a86c6181SAlex Tomas * Copyright (c) 2003-2006, Cluster File Systems, Inc, info@clusterfs.com 3a86c6181SAlex Tomas * Written by Alex Tomas <alex@clusterfs.com> 4a86c6181SAlex Tomas * 5a86c6181SAlex Tomas * Architecture independence: 6a86c6181SAlex Tomas * Copyright (c) 2005, Bull S.A. 7a86c6181SAlex Tomas * Written by Pierre Peiffer <pierre.peiffer@bull.net> 8a86c6181SAlex Tomas * 9a86c6181SAlex Tomas * This program is free software; you can redistribute it and/or modify 10a86c6181SAlex Tomas * it under the terms of the GNU General Public License version 2 as 11a86c6181SAlex Tomas * published by the Free Software Foundation. 12a86c6181SAlex Tomas * 13a86c6181SAlex Tomas * This program is distributed in the hope that it will be useful, 14a86c6181SAlex Tomas * but WITHOUT ANY WARRANTY; without even the implied warranty of 15a86c6181SAlex Tomas * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16a86c6181SAlex Tomas * GNU General Public License for more details. 17a86c6181SAlex Tomas * 18a86c6181SAlex Tomas * You should have received a copy of the GNU General Public Licens 19a86c6181SAlex Tomas * along with this program; if not, write to the Free Software 20a86c6181SAlex Tomas * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111- 21a86c6181SAlex Tomas */ 22a86c6181SAlex Tomas 23a86c6181SAlex Tomas /* 24a86c6181SAlex Tomas * Extents support for EXT4 25a86c6181SAlex Tomas * 26a86c6181SAlex Tomas * TODO: 27a86c6181SAlex Tomas * - ext4*_error() should be used in some situations 28a86c6181SAlex Tomas * - analyze all BUG()/BUG_ON(), use -EIO where appropriate 29a86c6181SAlex Tomas * - smart tree reduction 30a86c6181SAlex Tomas */ 31a86c6181SAlex Tomas 32a86c6181SAlex Tomas #include <linux/module.h> 33a86c6181SAlex Tomas #include <linux/fs.h> 34a86c6181SAlex Tomas #include <linux/time.h> 35cd02ff0bSMingming Cao #include <linux/jbd2.h> 36a86c6181SAlex Tomas #include <linux/highuid.h> 37a86c6181SAlex Tomas #include <linux/pagemap.h> 38a86c6181SAlex Tomas #include <linux/quotaops.h> 39a86c6181SAlex Tomas #include <linux/string.h> 40a86c6181SAlex Tomas #include <linux/slab.h> 41a2df2a63SAmit Arora #include <linux/falloc.h> 42a86c6181SAlex Tomas #include <asm/uaccess.h> 436873fa0dSEric Sandeen #include <linux/fiemap.h> 443dcf5451SChristoph Hellwig #include "ext4_jbd2.h" 45a86c6181SAlex Tomas 460562e0baSJiaying Zhang #include <trace/events/ext4.h> 470562e0baSJiaying Zhang 48d583fb87SAllison Henderson static int ext4_split_extent(handle_t *handle, 49d583fb87SAllison Henderson struct inode *inode, 50d583fb87SAllison Henderson struct ext4_ext_path *path, 51d583fb87SAllison Henderson struct ext4_map_blocks *map, 52d583fb87SAllison Henderson int split_flag, 53d583fb87SAllison Henderson int flags); 54d583fb87SAllison Henderson 55487caeefSJan Kara static int ext4_ext_truncate_extend_restart(handle_t *handle, 56487caeefSJan Kara struct inode *inode, 57487caeefSJan Kara int needed) 58a86c6181SAlex Tomas { 59a86c6181SAlex Tomas int err; 60a86c6181SAlex Tomas 610390131bSFrank Mayhar if (!ext4_handle_valid(handle)) 620390131bSFrank Mayhar return 0; 63a86c6181SAlex Tomas if (handle->h_buffer_credits > needed) 649102e4faSShen Feng return 0; 659102e4faSShen Feng err = ext4_journal_extend(handle, needed); 660123c939STheodore Ts'o if (err <= 0) 679102e4faSShen Feng return err; 68487caeefSJan Kara err = ext4_truncate_restart_trans(handle, inode, needed); 690617b83fSDmitry Monakhov if (err == 0) 700617b83fSDmitry Monakhov err = -EAGAIN; 71487caeefSJan Kara 72487caeefSJan Kara return err; 73a86c6181SAlex Tomas } 74a86c6181SAlex Tomas 75a86c6181SAlex Tomas /* 76a86c6181SAlex Tomas * could return: 77a86c6181SAlex Tomas * - EROFS 78a86c6181SAlex Tomas * - ENOMEM 79a86c6181SAlex Tomas */ 80a86c6181SAlex Tomas static int ext4_ext_get_access(handle_t *handle, struct inode *inode, 81a86c6181SAlex Tomas struct ext4_ext_path *path) 82a86c6181SAlex Tomas { 83a86c6181SAlex Tomas if (path->p_bh) { 84a86c6181SAlex Tomas /* path points to block */ 85a86c6181SAlex Tomas return ext4_journal_get_write_access(handle, path->p_bh); 86a86c6181SAlex Tomas } 87a86c6181SAlex Tomas /* path points to leaf/index in inode body */ 88a86c6181SAlex Tomas /* we use in-core data, no need to protect them */ 89a86c6181SAlex Tomas return 0; 90a86c6181SAlex Tomas } 91a86c6181SAlex Tomas 92a86c6181SAlex Tomas /* 93a86c6181SAlex Tomas * could return: 94a86c6181SAlex Tomas * - EROFS 95a86c6181SAlex Tomas * - ENOMEM 96a86c6181SAlex Tomas * - EIO 97a86c6181SAlex Tomas */ 989ea7a0dfSTheodore Ts'o #define ext4_ext_dirty(handle, inode, path) \ 999ea7a0dfSTheodore Ts'o __ext4_ext_dirty(__func__, __LINE__, (handle), (inode), (path)) 1009ea7a0dfSTheodore Ts'o static int __ext4_ext_dirty(const char *where, unsigned int line, 1019ea7a0dfSTheodore Ts'o handle_t *handle, struct inode *inode, 102a86c6181SAlex Tomas struct ext4_ext_path *path) 103a86c6181SAlex Tomas { 104a86c6181SAlex Tomas int err; 105a86c6181SAlex Tomas if (path->p_bh) { 106a86c6181SAlex Tomas /* path points to block */ 1079ea7a0dfSTheodore Ts'o err = __ext4_handle_dirty_metadata(where, line, handle, 1089ea7a0dfSTheodore Ts'o inode, path->p_bh); 109a86c6181SAlex Tomas } else { 110a86c6181SAlex Tomas /* path points to leaf/index in inode body */ 111a86c6181SAlex Tomas err = ext4_mark_inode_dirty(handle, inode); 112a86c6181SAlex Tomas } 113a86c6181SAlex Tomas return err; 114a86c6181SAlex Tomas } 115a86c6181SAlex Tomas 116f65e6fbaSAlex Tomas static ext4_fsblk_t ext4_ext_find_goal(struct inode *inode, 117a86c6181SAlex Tomas struct ext4_ext_path *path, 118725d26d3SAneesh Kumar K.V ext4_lblk_t block) 119a86c6181SAlex Tomas { 120a86c6181SAlex Tomas int depth; 121a86c6181SAlex Tomas 122a86c6181SAlex Tomas if (path) { 123a86c6181SAlex Tomas struct ext4_extent *ex; 124a86c6181SAlex Tomas depth = path->p_depth; 125a86c6181SAlex Tomas 126ad4fb9caSKazuya Mio /* 127ad4fb9caSKazuya Mio * Try to predict block placement assuming that we are 128ad4fb9caSKazuya Mio * filling in a file which will eventually be 129ad4fb9caSKazuya Mio * non-sparse --- i.e., in the case of libbfd writing 130ad4fb9caSKazuya Mio * an ELF object sections out-of-order but in a way 131ad4fb9caSKazuya Mio * the eventually results in a contiguous object or 132ad4fb9caSKazuya Mio * executable file, or some database extending a table 133ad4fb9caSKazuya Mio * space file. However, this is actually somewhat 134ad4fb9caSKazuya Mio * non-ideal if we are writing a sparse file such as 135ad4fb9caSKazuya Mio * qemu or KVM writing a raw image file that is going 136ad4fb9caSKazuya Mio * to stay fairly sparse, since it will end up 137ad4fb9caSKazuya Mio * fragmenting the file system's free space. Maybe we 138ad4fb9caSKazuya Mio * should have some hueristics or some way to allow 139ad4fb9caSKazuya Mio * userspace to pass a hint to file system, 140b8d6568aSTao Ma * especially if the latter case turns out to be 141ad4fb9caSKazuya Mio * common. 142ad4fb9caSKazuya Mio */ 1437e028976SAvantika Mathur ex = path[depth].p_ext; 144ad4fb9caSKazuya Mio if (ex) { 145ad4fb9caSKazuya Mio ext4_fsblk_t ext_pblk = ext4_ext_pblock(ex); 146ad4fb9caSKazuya Mio ext4_lblk_t ext_block = le32_to_cpu(ex->ee_block); 147ad4fb9caSKazuya Mio 148ad4fb9caSKazuya Mio if (block > ext_block) 149ad4fb9caSKazuya Mio return ext_pblk + (block - ext_block); 150ad4fb9caSKazuya Mio else 151ad4fb9caSKazuya Mio return ext_pblk - (ext_block - block); 152ad4fb9caSKazuya Mio } 153a86c6181SAlex Tomas 154d0d856e8SRandy Dunlap /* it looks like index is empty; 155d0d856e8SRandy Dunlap * try to find starting block from index itself */ 156a86c6181SAlex Tomas if (path[depth].p_bh) 157a86c6181SAlex Tomas return path[depth].p_bh->b_blocknr; 158a86c6181SAlex Tomas } 159a86c6181SAlex Tomas 160a86c6181SAlex Tomas /* OK. use inode's group */ 161f86186b4SEric Sandeen return ext4_inode_to_goal_block(inode); 162a86c6181SAlex Tomas } 163a86c6181SAlex Tomas 164654b4908SAneesh Kumar K.V /* 165654b4908SAneesh Kumar K.V * Allocation for a meta data block 166654b4908SAneesh Kumar K.V */ 167f65e6fbaSAlex Tomas static ext4_fsblk_t 168654b4908SAneesh Kumar K.V ext4_ext_new_meta_block(handle_t *handle, struct inode *inode, 169a86c6181SAlex Tomas struct ext4_ext_path *path, 17055f020dbSAllison Henderson struct ext4_extent *ex, int *err, unsigned int flags) 171a86c6181SAlex Tomas { 172f65e6fbaSAlex Tomas ext4_fsblk_t goal, newblock; 173a86c6181SAlex Tomas 174a86c6181SAlex Tomas goal = ext4_ext_find_goal(inode, path, le32_to_cpu(ex->ee_block)); 17555f020dbSAllison Henderson newblock = ext4_new_meta_blocks(handle, inode, goal, flags, 17655f020dbSAllison Henderson NULL, err); 177a86c6181SAlex Tomas return newblock; 178a86c6181SAlex Tomas } 179a86c6181SAlex Tomas 18055ad63bfSTheodore Ts'o static inline int ext4_ext_space_block(struct inode *inode, int check) 181a86c6181SAlex Tomas { 182a86c6181SAlex Tomas int size; 183a86c6181SAlex Tomas 184a86c6181SAlex Tomas size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) 185a86c6181SAlex Tomas / sizeof(struct ext4_extent); 18655ad63bfSTheodore Ts'o if (!check) { 187bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST 188a86c6181SAlex Tomas if (size > 6) 189a86c6181SAlex Tomas size = 6; 190a86c6181SAlex Tomas #endif 19155ad63bfSTheodore Ts'o } 192a86c6181SAlex Tomas return size; 193a86c6181SAlex Tomas } 194a86c6181SAlex Tomas 19555ad63bfSTheodore Ts'o static inline int ext4_ext_space_block_idx(struct inode *inode, int check) 196a86c6181SAlex Tomas { 197a86c6181SAlex Tomas int size; 198a86c6181SAlex Tomas 199a86c6181SAlex Tomas size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) 200a86c6181SAlex Tomas / sizeof(struct ext4_extent_idx); 20155ad63bfSTheodore Ts'o if (!check) { 202bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST 203a86c6181SAlex Tomas if (size > 5) 204a86c6181SAlex Tomas size = 5; 205a86c6181SAlex Tomas #endif 20655ad63bfSTheodore Ts'o } 207a86c6181SAlex Tomas return size; 208a86c6181SAlex Tomas } 209a86c6181SAlex Tomas 21055ad63bfSTheodore Ts'o static inline int ext4_ext_space_root(struct inode *inode, int check) 211a86c6181SAlex Tomas { 212a86c6181SAlex Tomas int size; 213a86c6181SAlex Tomas 214a86c6181SAlex Tomas size = sizeof(EXT4_I(inode)->i_data); 215a86c6181SAlex Tomas size -= sizeof(struct ext4_extent_header); 216a86c6181SAlex Tomas size /= sizeof(struct ext4_extent); 21755ad63bfSTheodore Ts'o if (!check) { 218bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST 219a86c6181SAlex Tomas if (size > 3) 220a86c6181SAlex Tomas size = 3; 221a86c6181SAlex Tomas #endif 22255ad63bfSTheodore Ts'o } 223a86c6181SAlex Tomas return size; 224a86c6181SAlex Tomas } 225a86c6181SAlex Tomas 22655ad63bfSTheodore Ts'o static inline int ext4_ext_space_root_idx(struct inode *inode, int check) 227a86c6181SAlex Tomas { 228a86c6181SAlex Tomas int size; 229a86c6181SAlex Tomas 230a86c6181SAlex Tomas size = sizeof(EXT4_I(inode)->i_data); 231a86c6181SAlex Tomas size -= sizeof(struct ext4_extent_header); 232a86c6181SAlex Tomas size /= sizeof(struct ext4_extent_idx); 23355ad63bfSTheodore Ts'o if (!check) { 234bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST 235a86c6181SAlex Tomas if (size > 4) 236a86c6181SAlex Tomas size = 4; 237a86c6181SAlex Tomas #endif 23855ad63bfSTheodore Ts'o } 239a86c6181SAlex Tomas return size; 240a86c6181SAlex Tomas } 241a86c6181SAlex Tomas 242d2a17637SMingming Cao /* 243d2a17637SMingming Cao * Calculate the number of metadata blocks needed 244d2a17637SMingming Cao * to allocate @blocks 245d2a17637SMingming Cao * Worse case is one block per extent 246d2a17637SMingming Cao */ 24701f49d0bSTheodore Ts'o int ext4_ext_calc_metadata_amount(struct inode *inode, ext4_lblk_t lblock) 248d2a17637SMingming Cao { 2499d0be502STheodore Ts'o struct ext4_inode_info *ei = EXT4_I(inode); 2509d0be502STheodore Ts'o int idxs, num = 0; 251d2a17637SMingming Cao 2529d0be502STheodore Ts'o idxs = ((inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) 2539d0be502STheodore Ts'o / sizeof(struct ext4_extent_idx)); 254d2a17637SMingming Cao 255d2a17637SMingming Cao /* 2569d0be502STheodore Ts'o * If the new delayed allocation block is contiguous with the 2579d0be502STheodore Ts'o * previous da block, it can share index blocks with the 2589d0be502STheodore Ts'o * previous block, so we only need to allocate a new index 2599d0be502STheodore Ts'o * block every idxs leaf blocks. At ldxs**2 blocks, we need 2609d0be502STheodore Ts'o * an additional index block, and at ldxs**3 blocks, yet 2619d0be502STheodore Ts'o * another index blocks. 262d2a17637SMingming Cao */ 2639d0be502STheodore Ts'o if (ei->i_da_metadata_calc_len && 2649d0be502STheodore Ts'o ei->i_da_metadata_calc_last_lblock+1 == lblock) { 2659d0be502STheodore Ts'o if ((ei->i_da_metadata_calc_len % idxs) == 0) 2669d0be502STheodore Ts'o num++; 2679d0be502STheodore Ts'o if ((ei->i_da_metadata_calc_len % (idxs*idxs)) == 0) 2689d0be502STheodore Ts'o num++; 2699d0be502STheodore Ts'o if ((ei->i_da_metadata_calc_len % (idxs*idxs*idxs)) == 0) { 2709d0be502STheodore Ts'o num++; 2719d0be502STheodore Ts'o ei->i_da_metadata_calc_len = 0; 2729d0be502STheodore Ts'o } else 2739d0be502STheodore Ts'o ei->i_da_metadata_calc_len++; 2749d0be502STheodore Ts'o ei->i_da_metadata_calc_last_lblock++; 275d2a17637SMingming Cao return num; 276d2a17637SMingming Cao } 277d2a17637SMingming Cao 2789d0be502STheodore Ts'o /* 2799d0be502STheodore Ts'o * In the worst case we need a new set of index blocks at 2809d0be502STheodore Ts'o * every level of the inode's extent tree. 2819d0be502STheodore Ts'o */ 2829d0be502STheodore Ts'o ei->i_da_metadata_calc_len = 1; 2839d0be502STheodore Ts'o ei->i_da_metadata_calc_last_lblock = lblock; 2849d0be502STheodore Ts'o return ext_depth(inode) + 1; 2859d0be502STheodore Ts'o } 2869d0be502STheodore Ts'o 287c29c0ae7SAlex Tomas static int 288c29c0ae7SAlex Tomas ext4_ext_max_entries(struct inode *inode, int depth) 289c29c0ae7SAlex Tomas { 290c29c0ae7SAlex Tomas int max; 291c29c0ae7SAlex Tomas 292c29c0ae7SAlex Tomas if (depth == ext_depth(inode)) { 293c29c0ae7SAlex Tomas if (depth == 0) 29455ad63bfSTheodore Ts'o max = ext4_ext_space_root(inode, 1); 295c29c0ae7SAlex Tomas else 29655ad63bfSTheodore Ts'o max = ext4_ext_space_root_idx(inode, 1); 297c29c0ae7SAlex Tomas } else { 298c29c0ae7SAlex Tomas if (depth == 0) 29955ad63bfSTheodore Ts'o max = ext4_ext_space_block(inode, 1); 300c29c0ae7SAlex Tomas else 30155ad63bfSTheodore Ts'o max = ext4_ext_space_block_idx(inode, 1); 302c29c0ae7SAlex Tomas } 303c29c0ae7SAlex Tomas 304c29c0ae7SAlex Tomas return max; 305c29c0ae7SAlex Tomas } 306c29c0ae7SAlex Tomas 30756b19868SAneesh Kumar K.V static int ext4_valid_extent(struct inode *inode, struct ext4_extent *ext) 30856b19868SAneesh Kumar K.V { 309bf89d16fSTheodore Ts'o ext4_fsblk_t block = ext4_ext_pblock(ext); 31056b19868SAneesh Kumar K.V int len = ext4_ext_get_actual_len(ext); 311e84a26ceSTheodore Ts'o 3126fd058f7STheodore Ts'o return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, len); 31356b19868SAneesh Kumar K.V } 31456b19868SAneesh Kumar K.V 31556b19868SAneesh Kumar K.V static int ext4_valid_extent_idx(struct inode *inode, 31656b19868SAneesh Kumar K.V struct ext4_extent_idx *ext_idx) 31756b19868SAneesh Kumar K.V { 318bf89d16fSTheodore Ts'o ext4_fsblk_t block = ext4_idx_pblock(ext_idx); 319e84a26ceSTheodore Ts'o 3206fd058f7STheodore Ts'o return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, 1); 32156b19868SAneesh Kumar K.V } 32256b19868SAneesh Kumar K.V 32356b19868SAneesh Kumar K.V static int ext4_valid_extent_entries(struct inode *inode, 32456b19868SAneesh Kumar K.V struct ext4_extent_header *eh, 32556b19868SAneesh Kumar K.V int depth) 32656b19868SAneesh Kumar K.V { 32756b19868SAneesh Kumar K.V struct ext4_extent *ext; 32856b19868SAneesh Kumar K.V struct ext4_extent_idx *ext_idx; 32956b19868SAneesh Kumar K.V unsigned short entries; 33056b19868SAneesh Kumar K.V if (eh->eh_entries == 0) 33156b19868SAneesh Kumar K.V return 1; 33256b19868SAneesh Kumar K.V 33356b19868SAneesh Kumar K.V entries = le16_to_cpu(eh->eh_entries); 33456b19868SAneesh Kumar K.V 33556b19868SAneesh Kumar K.V if (depth == 0) { 33656b19868SAneesh Kumar K.V /* leaf entries */ 33756b19868SAneesh Kumar K.V ext = EXT_FIRST_EXTENT(eh); 33856b19868SAneesh Kumar K.V while (entries) { 33956b19868SAneesh Kumar K.V if (!ext4_valid_extent(inode, ext)) 34056b19868SAneesh Kumar K.V return 0; 34156b19868SAneesh Kumar K.V ext++; 34256b19868SAneesh Kumar K.V entries--; 34356b19868SAneesh Kumar K.V } 34456b19868SAneesh Kumar K.V } else { 34556b19868SAneesh Kumar K.V ext_idx = EXT_FIRST_INDEX(eh); 34656b19868SAneesh Kumar K.V while (entries) { 34756b19868SAneesh Kumar K.V if (!ext4_valid_extent_idx(inode, ext_idx)) 34856b19868SAneesh Kumar K.V return 0; 34956b19868SAneesh Kumar K.V ext_idx++; 35056b19868SAneesh Kumar K.V entries--; 35156b19868SAneesh Kumar K.V } 35256b19868SAneesh Kumar K.V } 35356b19868SAneesh Kumar K.V return 1; 35456b19868SAneesh Kumar K.V } 35556b19868SAneesh Kumar K.V 356c398eda0STheodore Ts'o static int __ext4_ext_check(const char *function, unsigned int line, 357c398eda0STheodore Ts'o struct inode *inode, struct ext4_extent_header *eh, 358c29c0ae7SAlex Tomas int depth) 359c29c0ae7SAlex Tomas { 360c29c0ae7SAlex Tomas const char *error_msg; 361c29c0ae7SAlex Tomas int max = 0; 362c29c0ae7SAlex Tomas 363c29c0ae7SAlex Tomas if (unlikely(eh->eh_magic != EXT4_EXT_MAGIC)) { 364c29c0ae7SAlex Tomas error_msg = "invalid magic"; 365c29c0ae7SAlex Tomas goto corrupted; 366c29c0ae7SAlex Tomas } 367c29c0ae7SAlex Tomas if (unlikely(le16_to_cpu(eh->eh_depth) != depth)) { 368c29c0ae7SAlex Tomas error_msg = "unexpected eh_depth"; 369c29c0ae7SAlex Tomas goto corrupted; 370c29c0ae7SAlex Tomas } 371c29c0ae7SAlex Tomas if (unlikely(eh->eh_max == 0)) { 372c29c0ae7SAlex Tomas error_msg = "invalid eh_max"; 373c29c0ae7SAlex Tomas goto corrupted; 374c29c0ae7SAlex Tomas } 375c29c0ae7SAlex Tomas max = ext4_ext_max_entries(inode, depth); 376c29c0ae7SAlex Tomas if (unlikely(le16_to_cpu(eh->eh_max) > max)) { 377c29c0ae7SAlex Tomas error_msg = "too large eh_max"; 378c29c0ae7SAlex Tomas goto corrupted; 379c29c0ae7SAlex Tomas } 380c29c0ae7SAlex Tomas if (unlikely(le16_to_cpu(eh->eh_entries) > le16_to_cpu(eh->eh_max))) { 381c29c0ae7SAlex Tomas error_msg = "invalid eh_entries"; 382c29c0ae7SAlex Tomas goto corrupted; 383c29c0ae7SAlex Tomas } 38456b19868SAneesh Kumar K.V if (!ext4_valid_extent_entries(inode, eh, depth)) { 38556b19868SAneesh Kumar K.V error_msg = "invalid extent entries"; 38656b19868SAneesh Kumar K.V goto corrupted; 38756b19868SAneesh Kumar K.V } 388c29c0ae7SAlex Tomas return 0; 389c29c0ae7SAlex Tomas 390c29c0ae7SAlex Tomas corrupted: 391c398eda0STheodore Ts'o ext4_error_inode(inode, function, line, 0, 39224676da4STheodore Ts'o "bad header/extent: %s - magic %x, " 393c29c0ae7SAlex Tomas "entries %u, max %u(%u), depth %u(%u)", 39424676da4STheodore Ts'o error_msg, le16_to_cpu(eh->eh_magic), 395c29c0ae7SAlex Tomas le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max), 396c29c0ae7SAlex Tomas max, le16_to_cpu(eh->eh_depth), depth); 397c29c0ae7SAlex Tomas 398c29c0ae7SAlex Tomas return -EIO; 399c29c0ae7SAlex Tomas } 400c29c0ae7SAlex Tomas 40156b19868SAneesh Kumar K.V #define ext4_ext_check(inode, eh, depth) \ 402c398eda0STheodore Ts'o __ext4_ext_check(__func__, __LINE__, inode, eh, depth) 403c29c0ae7SAlex Tomas 4047a262f7cSAneesh Kumar K.V int ext4_ext_check_inode(struct inode *inode) 4057a262f7cSAneesh Kumar K.V { 4067a262f7cSAneesh Kumar K.V return ext4_ext_check(inode, ext_inode_hdr(inode), ext_depth(inode)); 4077a262f7cSAneesh Kumar K.V } 4087a262f7cSAneesh Kumar K.V 409a86c6181SAlex Tomas #ifdef EXT_DEBUG 410a86c6181SAlex Tomas static void ext4_ext_show_path(struct inode *inode, struct ext4_ext_path *path) 411a86c6181SAlex Tomas { 412a86c6181SAlex Tomas int k, l = path->p_depth; 413a86c6181SAlex Tomas 414a86c6181SAlex Tomas ext_debug("path:"); 415a86c6181SAlex Tomas for (k = 0; k <= l; k++, path++) { 416a86c6181SAlex Tomas if (path->p_idx) { 4172ae02107SMingming Cao ext_debug(" %d->%llu", le32_to_cpu(path->p_idx->ei_block), 418bf89d16fSTheodore Ts'o ext4_idx_pblock(path->p_idx)); 419a86c6181SAlex Tomas } else if (path->p_ext) { 420553f9008SMingming ext_debug(" %d:[%d]%d:%llu ", 421a86c6181SAlex Tomas le32_to_cpu(path->p_ext->ee_block), 422553f9008SMingming ext4_ext_is_uninitialized(path->p_ext), 423a2df2a63SAmit Arora ext4_ext_get_actual_len(path->p_ext), 424bf89d16fSTheodore Ts'o ext4_ext_pblock(path->p_ext)); 425a86c6181SAlex Tomas } else 426a86c6181SAlex Tomas ext_debug(" []"); 427a86c6181SAlex Tomas } 428a86c6181SAlex Tomas ext_debug("\n"); 429a86c6181SAlex Tomas } 430a86c6181SAlex Tomas 431a86c6181SAlex Tomas static void ext4_ext_show_leaf(struct inode *inode, struct ext4_ext_path *path) 432a86c6181SAlex Tomas { 433a86c6181SAlex Tomas int depth = ext_depth(inode); 434a86c6181SAlex Tomas struct ext4_extent_header *eh; 435a86c6181SAlex Tomas struct ext4_extent *ex; 436a86c6181SAlex Tomas int i; 437a86c6181SAlex Tomas 438a86c6181SAlex Tomas if (!path) 439a86c6181SAlex Tomas return; 440a86c6181SAlex Tomas 441a86c6181SAlex Tomas eh = path[depth].p_hdr; 442a86c6181SAlex Tomas ex = EXT_FIRST_EXTENT(eh); 443a86c6181SAlex Tomas 444553f9008SMingming ext_debug("Displaying leaf extents for inode %lu\n", inode->i_ino); 445553f9008SMingming 446a86c6181SAlex Tomas for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ex++) { 447553f9008SMingming ext_debug("%d:[%d]%d:%llu ", le32_to_cpu(ex->ee_block), 448553f9008SMingming ext4_ext_is_uninitialized(ex), 449bf89d16fSTheodore Ts'o ext4_ext_get_actual_len(ex), ext4_ext_pblock(ex)); 450a86c6181SAlex Tomas } 451a86c6181SAlex Tomas ext_debug("\n"); 452a86c6181SAlex Tomas } 4531b16da77SYongqiang Yang 4541b16da77SYongqiang Yang static void ext4_ext_show_move(struct inode *inode, struct ext4_ext_path *path, 4551b16da77SYongqiang Yang ext4_fsblk_t newblock, int level) 4561b16da77SYongqiang Yang { 4571b16da77SYongqiang Yang int depth = ext_depth(inode); 4581b16da77SYongqiang Yang struct ext4_extent *ex; 4591b16da77SYongqiang Yang 4601b16da77SYongqiang Yang if (depth != level) { 4611b16da77SYongqiang Yang struct ext4_extent_idx *idx; 4621b16da77SYongqiang Yang idx = path[level].p_idx; 4631b16da77SYongqiang Yang while (idx <= EXT_MAX_INDEX(path[level].p_hdr)) { 4641b16da77SYongqiang Yang ext_debug("%d: move %d:%llu in new index %llu\n", level, 4651b16da77SYongqiang Yang le32_to_cpu(idx->ei_block), 4661b16da77SYongqiang Yang ext4_idx_pblock(idx), 4671b16da77SYongqiang Yang newblock); 4681b16da77SYongqiang Yang idx++; 4691b16da77SYongqiang Yang } 4701b16da77SYongqiang Yang 4711b16da77SYongqiang Yang return; 4721b16da77SYongqiang Yang } 4731b16da77SYongqiang Yang 4741b16da77SYongqiang Yang ex = path[depth].p_ext; 4751b16da77SYongqiang Yang while (ex <= EXT_MAX_EXTENT(path[depth].p_hdr)) { 4761b16da77SYongqiang Yang ext_debug("move %d:%llu:[%d]%d in new leaf %llu\n", 4771b16da77SYongqiang Yang le32_to_cpu(ex->ee_block), 4781b16da77SYongqiang Yang ext4_ext_pblock(ex), 4791b16da77SYongqiang Yang ext4_ext_is_uninitialized(ex), 4801b16da77SYongqiang Yang ext4_ext_get_actual_len(ex), 4811b16da77SYongqiang Yang newblock); 4821b16da77SYongqiang Yang ex++; 4831b16da77SYongqiang Yang } 4841b16da77SYongqiang Yang } 4851b16da77SYongqiang Yang 486a86c6181SAlex Tomas #else 487a86c6181SAlex Tomas #define ext4_ext_show_path(inode, path) 488a86c6181SAlex Tomas #define ext4_ext_show_leaf(inode, path) 4891b16da77SYongqiang Yang #define ext4_ext_show_move(inode, path, newblock, level) 490a86c6181SAlex Tomas #endif 491a86c6181SAlex Tomas 492b35905c1SAneesh Kumar K.V void ext4_ext_drop_refs(struct ext4_ext_path *path) 493a86c6181SAlex Tomas { 494a86c6181SAlex Tomas int depth = path->p_depth; 495a86c6181SAlex Tomas int i; 496a86c6181SAlex Tomas 497a86c6181SAlex Tomas for (i = 0; i <= depth; i++, path++) 498a86c6181SAlex Tomas if (path->p_bh) { 499a86c6181SAlex Tomas brelse(path->p_bh); 500a86c6181SAlex Tomas path->p_bh = NULL; 501a86c6181SAlex Tomas } 502a86c6181SAlex Tomas } 503a86c6181SAlex Tomas 504a86c6181SAlex Tomas /* 505d0d856e8SRandy Dunlap * ext4_ext_binsearch_idx: 506d0d856e8SRandy Dunlap * binary search for the closest index of the given block 507c29c0ae7SAlex Tomas * the header must be checked before calling this 508a86c6181SAlex Tomas */ 509a86c6181SAlex Tomas static void 510725d26d3SAneesh Kumar K.V ext4_ext_binsearch_idx(struct inode *inode, 511725d26d3SAneesh Kumar K.V struct ext4_ext_path *path, ext4_lblk_t block) 512a86c6181SAlex Tomas { 513a86c6181SAlex Tomas struct ext4_extent_header *eh = path->p_hdr; 514a86c6181SAlex Tomas struct ext4_extent_idx *r, *l, *m; 515a86c6181SAlex Tomas 516a86c6181SAlex Tomas 517bba90743SEric Sandeen ext_debug("binsearch for %u(idx): ", block); 518a86c6181SAlex Tomas 519a86c6181SAlex Tomas l = EXT_FIRST_INDEX(eh) + 1; 520e9f410b1SDmitry Monakhov r = EXT_LAST_INDEX(eh); 521a86c6181SAlex Tomas while (l <= r) { 522a86c6181SAlex Tomas m = l + (r - l) / 2; 523a86c6181SAlex Tomas if (block < le32_to_cpu(m->ei_block)) 524a86c6181SAlex Tomas r = m - 1; 525a86c6181SAlex Tomas else 526a86c6181SAlex Tomas l = m + 1; 52726d535edSDmitry Monakhov ext_debug("%p(%u):%p(%u):%p(%u) ", l, le32_to_cpu(l->ei_block), 52826d535edSDmitry Monakhov m, le32_to_cpu(m->ei_block), 52926d535edSDmitry Monakhov r, le32_to_cpu(r->ei_block)); 530a86c6181SAlex Tomas } 531a86c6181SAlex Tomas 532a86c6181SAlex Tomas path->p_idx = l - 1; 533f65e6fbaSAlex Tomas ext_debug(" -> %d->%lld ", le32_to_cpu(path->p_idx->ei_block), 534bf89d16fSTheodore Ts'o ext4_idx_pblock(path->p_idx)); 535a86c6181SAlex Tomas 536a86c6181SAlex Tomas #ifdef CHECK_BINSEARCH 537a86c6181SAlex Tomas { 538a86c6181SAlex Tomas struct ext4_extent_idx *chix, *ix; 539a86c6181SAlex Tomas int k; 540a86c6181SAlex Tomas 541a86c6181SAlex Tomas chix = ix = EXT_FIRST_INDEX(eh); 542a86c6181SAlex Tomas for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ix++) { 543a86c6181SAlex Tomas if (k != 0 && 544a86c6181SAlex Tomas le32_to_cpu(ix->ei_block) <= le32_to_cpu(ix[-1].ei_block)) { 5454776004fSTheodore Ts'o printk(KERN_DEBUG "k=%d, ix=0x%p, " 5464776004fSTheodore Ts'o "first=0x%p\n", k, 547a86c6181SAlex Tomas ix, EXT_FIRST_INDEX(eh)); 5484776004fSTheodore Ts'o printk(KERN_DEBUG "%u <= %u\n", 549a86c6181SAlex Tomas le32_to_cpu(ix->ei_block), 550a86c6181SAlex Tomas le32_to_cpu(ix[-1].ei_block)); 551a86c6181SAlex Tomas } 552a86c6181SAlex Tomas BUG_ON(k && le32_to_cpu(ix->ei_block) 553a86c6181SAlex Tomas <= le32_to_cpu(ix[-1].ei_block)); 554a86c6181SAlex Tomas if (block < le32_to_cpu(ix->ei_block)) 555a86c6181SAlex Tomas break; 556a86c6181SAlex Tomas chix = ix; 557a86c6181SAlex Tomas } 558a86c6181SAlex Tomas BUG_ON(chix != path->p_idx); 559a86c6181SAlex Tomas } 560a86c6181SAlex Tomas #endif 561a86c6181SAlex Tomas 562a86c6181SAlex Tomas } 563a86c6181SAlex Tomas 564a86c6181SAlex Tomas /* 565d0d856e8SRandy Dunlap * ext4_ext_binsearch: 566d0d856e8SRandy Dunlap * binary search for closest extent of the given block 567c29c0ae7SAlex Tomas * the header must be checked before calling this 568a86c6181SAlex Tomas */ 569a86c6181SAlex Tomas static void 570725d26d3SAneesh Kumar K.V ext4_ext_binsearch(struct inode *inode, 571725d26d3SAneesh Kumar K.V struct ext4_ext_path *path, ext4_lblk_t block) 572a86c6181SAlex Tomas { 573a86c6181SAlex Tomas struct ext4_extent_header *eh = path->p_hdr; 574a86c6181SAlex Tomas struct ext4_extent *r, *l, *m; 575a86c6181SAlex Tomas 576a86c6181SAlex Tomas if (eh->eh_entries == 0) { 577a86c6181SAlex Tomas /* 578d0d856e8SRandy Dunlap * this leaf is empty: 579a86c6181SAlex Tomas * we get such a leaf in split/add case 580a86c6181SAlex Tomas */ 581a86c6181SAlex Tomas return; 582a86c6181SAlex Tomas } 583a86c6181SAlex Tomas 584bba90743SEric Sandeen ext_debug("binsearch for %u: ", block); 585a86c6181SAlex Tomas 586a86c6181SAlex Tomas l = EXT_FIRST_EXTENT(eh) + 1; 587e9f410b1SDmitry Monakhov r = EXT_LAST_EXTENT(eh); 588a86c6181SAlex Tomas 589a86c6181SAlex Tomas while (l <= r) { 590a86c6181SAlex Tomas m = l + (r - l) / 2; 591a86c6181SAlex Tomas if (block < le32_to_cpu(m->ee_block)) 592a86c6181SAlex Tomas r = m - 1; 593a86c6181SAlex Tomas else 594a86c6181SAlex Tomas l = m + 1; 59526d535edSDmitry Monakhov ext_debug("%p(%u):%p(%u):%p(%u) ", l, le32_to_cpu(l->ee_block), 59626d535edSDmitry Monakhov m, le32_to_cpu(m->ee_block), 59726d535edSDmitry Monakhov r, le32_to_cpu(r->ee_block)); 598a86c6181SAlex Tomas } 599a86c6181SAlex Tomas 600a86c6181SAlex Tomas path->p_ext = l - 1; 601553f9008SMingming ext_debug(" -> %d:%llu:[%d]%d ", 602a86c6181SAlex Tomas le32_to_cpu(path->p_ext->ee_block), 603bf89d16fSTheodore Ts'o ext4_ext_pblock(path->p_ext), 604553f9008SMingming ext4_ext_is_uninitialized(path->p_ext), 605a2df2a63SAmit Arora ext4_ext_get_actual_len(path->p_ext)); 606a86c6181SAlex Tomas 607a86c6181SAlex Tomas #ifdef CHECK_BINSEARCH 608a86c6181SAlex Tomas { 609a86c6181SAlex Tomas struct ext4_extent *chex, *ex; 610a86c6181SAlex Tomas int k; 611a86c6181SAlex Tomas 612a86c6181SAlex Tomas chex = ex = EXT_FIRST_EXTENT(eh); 613a86c6181SAlex Tomas for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ex++) { 614a86c6181SAlex Tomas BUG_ON(k && le32_to_cpu(ex->ee_block) 615a86c6181SAlex Tomas <= le32_to_cpu(ex[-1].ee_block)); 616a86c6181SAlex Tomas if (block < le32_to_cpu(ex->ee_block)) 617a86c6181SAlex Tomas break; 618a86c6181SAlex Tomas chex = ex; 619a86c6181SAlex Tomas } 620a86c6181SAlex Tomas BUG_ON(chex != path->p_ext); 621a86c6181SAlex Tomas } 622a86c6181SAlex Tomas #endif 623a86c6181SAlex Tomas 624a86c6181SAlex Tomas } 625a86c6181SAlex Tomas 626a86c6181SAlex Tomas int ext4_ext_tree_init(handle_t *handle, struct inode *inode) 627a86c6181SAlex Tomas { 628a86c6181SAlex Tomas struct ext4_extent_header *eh; 629a86c6181SAlex Tomas 630a86c6181SAlex Tomas eh = ext_inode_hdr(inode); 631a86c6181SAlex Tomas eh->eh_depth = 0; 632a86c6181SAlex Tomas eh->eh_entries = 0; 633a86c6181SAlex Tomas eh->eh_magic = EXT4_EXT_MAGIC; 63455ad63bfSTheodore Ts'o eh->eh_max = cpu_to_le16(ext4_ext_space_root(inode, 0)); 635a86c6181SAlex Tomas ext4_mark_inode_dirty(handle, inode); 636a86c6181SAlex Tomas ext4_ext_invalidate_cache(inode); 637a86c6181SAlex Tomas return 0; 638a86c6181SAlex Tomas } 639a86c6181SAlex Tomas 640a86c6181SAlex Tomas struct ext4_ext_path * 641725d26d3SAneesh Kumar K.V ext4_ext_find_extent(struct inode *inode, ext4_lblk_t block, 642725d26d3SAneesh Kumar K.V struct ext4_ext_path *path) 643a86c6181SAlex Tomas { 644a86c6181SAlex Tomas struct ext4_extent_header *eh; 645a86c6181SAlex Tomas struct buffer_head *bh; 646a86c6181SAlex Tomas short int depth, i, ppos = 0, alloc = 0; 647a86c6181SAlex Tomas 648a86c6181SAlex Tomas eh = ext_inode_hdr(inode); 649c29c0ae7SAlex Tomas depth = ext_depth(inode); 650a86c6181SAlex Tomas 651a86c6181SAlex Tomas /* account possible depth increase */ 652a86c6181SAlex Tomas if (!path) { 6535d4958f9SAvantika Mathur path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 2), 654a86c6181SAlex Tomas GFP_NOFS); 655a86c6181SAlex Tomas if (!path) 656a86c6181SAlex Tomas return ERR_PTR(-ENOMEM); 657a86c6181SAlex Tomas alloc = 1; 658a86c6181SAlex Tomas } 659a86c6181SAlex Tomas path[0].p_hdr = eh; 6601973adcbSShen Feng path[0].p_bh = NULL; 661a86c6181SAlex Tomas 662c29c0ae7SAlex Tomas i = depth; 663a86c6181SAlex Tomas /* walk through the tree */ 664a86c6181SAlex Tomas while (i) { 6657a262f7cSAneesh Kumar K.V int need_to_validate = 0; 6667a262f7cSAneesh Kumar K.V 667a86c6181SAlex Tomas ext_debug("depth %d: num %d, max %d\n", 668a86c6181SAlex Tomas ppos, le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max)); 669c29c0ae7SAlex Tomas 670a86c6181SAlex Tomas ext4_ext_binsearch_idx(inode, path + ppos, block); 671bf89d16fSTheodore Ts'o path[ppos].p_block = ext4_idx_pblock(path[ppos].p_idx); 672a86c6181SAlex Tomas path[ppos].p_depth = i; 673a86c6181SAlex Tomas path[ppos].p_ext = NULL; 674a86c6181SAlex Tomas 6757a262f7cSAneesh Kumar K.V bh = sb_getblk(inode->i_sb, path[ppos].p_block); 6767a262f7cSAneesh Kumar K.V if (unlikely(!bh)) 677a86c6181SAlex Tomas goto err; 6787a262f7cSAneesh Kumar K.V if (!bh_uptodate_or_lock(bh)) { 6790562e0baSJiaying Zhang trace_ext4_ext_load_extent(inode, block, 6800562e0baSJiaying Zhang path[ppos].p_block); 6817a262f7cSAneesh Kumar K.V if (bh_submit_read(bh) < 0) { 6827a262f7cSAneesh Kumar K.V put_bh(bh); 6837a262f7cSAneesh Kumar K.V goto err; 6847a262f7cSAneesh Kumar K.V } 6857a262f7cSAneesh Kumar K.V /* validate the extent entries */ 6867a262f7cSAneesh Kumar K.V need_to_validate = 1; 6877a262f7cSAneesh Kumar K.V } 688a86c6181SAlex Tomas eh = ext_block_hdr(bh); 689a86c6181SAlex Tomas ppos++; 690273df556SFrank Mayhar if (unlikely(ppos > depth)) { 691273df556SFrank Mayhar put_bh(bh); 692273df556SFrank Mayhar EXT4_ERROR_INODE(inode, 693273df556SFrank Mayhar "ppos %d > depth %d", ppos, depth); 694273df556SFrank Mayhar goto err; 695273df556SFrank Mayhar } 696a86c6181SAlex Tomas path[ppos].p_bh = bh; 697a86c6181SAlex Tomas path[ppos].p_hdr = eh; 698a86c6181SAlex Tomas i--; 699a86c6181SAlex Tomas 7007a262f7cSAneesh Kumar K.V if (need_to_validate && ext4_ext_check(inode, eh, i)) 701a86c6181SAlex Tomas goto err; 702a86c6181SAlex Tomas } 703a86c6181SAlex Tomas 704a86c6181SAlex Tomas path[ppos].p_depth = i; 705a86c6181SAlex Tomas path[ppos].p_ext = NULL; 706a86c6181SAlex Tomas path[ppos].p_idx = NULL; 707a86c6181SAlex Tomas 708a86c6181SAlex Tomas /* find extent */ 709a86c6181SAlex Tomas ext4_ext_binsearch(inode, path + ppos, block); 7101973adcbSShen Feng /* if not an empty leaf */ 7111973adcbSShen Feng if (path[ppos].p_ext) 712bf89d16fSTheodore Ts'o path[ppos].p_block = ext4_ext_pblock(path[ppos].p_ext); 713a86c6181SAlex Tomas 714a86c6181SAlex Tomas ext4_ext_show_path(inode, path); 715a86c6181SAlex Tomas 716a86c6181SAlex Tomas return path; 717a86c6181SAlex Tomas 718a86c6181SAlex Tomas err: 719a86c6181SAlex Tomas ext4_ext_drop_refs(path); 720a86c6181SAlex Tomas if (alloc) 721a86c6181SAlex Tomas kfree(path); 722a86c6181SAlex Tomas return ERR_PTR(-EIO); 723a86c6181SAlex Tomas } 724a86c6181SAlex Tomas 725a86c6181SAlex Tomas /* 726d0d856e8SRandy Dunlap * ext4_ext_insert_index: 727d0d856e8SRandy Dunlap * insert new index [@logical;@ptr] into the block at @curp; 728d0d856e8SRandy Dunlap * check where to insert: before @curp or after @curp 729a86c6181SAlex Tomas */ 7301f109d5aSTheodore Ts'o static int ext4_ext_insert_index(handle_t *handle, struct inode *inode, 731a86c6181SAlex Tomas struct ext4_ext_path *curp, 732f65e6fbaSAlex Tomas int logical, ext4_fsblk_t ptr) 733a86c6181SAlex Tomas { 734a86c6181SAlex Tomas struct ext4_extent_idx *ix; 735a86c6181SAlex Tomas int len, err; 736a86c6181SAlex Tomas 7377e028976SAvantika Mathur err = ext4_ext_get_access(handle, inode, curp); 7387e028976SAvantika Mathur if (err) 739a86c6181SAlex Tomas return err; 740a86c6181SAlex Tomas 741273df556SFrank Mayhar if (unlikely(logical == le32_to_cpu(curp->p_idx->ei_block))) { 742273df556SFrank Mayhar EXT4_ERROR_INODE(inode, 743273df556SFrank Mayhar "logical %d == ei_block %d!", 744273df556SFrank Mayhar logical, le32_to_cpu(curp->p_idx->ei_block)); 745273df556SFrank Mayhar return -EIO; 746273df556SFrank Mayhar } 747d4620315SRobin Dong 748d4620315SRobin Dong if (unlikely(le16_to_cpu(curp->p_hdr->eh_entries) 749d4620315SRobin Dong >= le16_to_cpu(curp->p_hdr->eh_max))) { 750d4620315SRobin Dong EXT4_ERROR_INODE(inode, 751d4620315SRobin Dong "eh_entries %d >= eh_max %d!", 752d4620315SRobin Dong le16_to_cpu(curp->p_hdr->eh_entries), 753d4620315SRobin Dong le16_to_cpu(curp->p_hdr->eh_max)); 754d4620315SRobin Dong return -EIO; 755d4620315SRobin Dong } 756d4620315SRobin Dong 757a86c6181SAlex Tomas len = EXT_MAX_INDEX(curp->p_hdr) - curp->p_idx; 758a86c6181SAlex Tomas if (logical > le32_to_cpu(curp->p_idx->ei_block)) { 759a86c6181SAlex Tomas /* insert after */ 760a86c6181SAlex Tomas if (curp->p_idx != EXT_LAST_INDEX(curp->p_hdr)) { 761a86c6181SAlex Tomas len = (len - 1) * sizeof(struct ext4_extent_idx); 762a86c6181SAlex Tomas len = len < 0 ? 0 : len; 76326d535edSDmitry Monakhov ext_debug("insert new index %d after: %llu. " 764a86c6181SAlex Tomas "move %d from 0x%p to 0x%p\n", 765a86c6181SAlex Tomas logical, ptr, len, 766a86c6181SAlex Tomas (curp->p_idx + 1), (curp->p_idx + 2)); 767a86c6181SAlex Tomas memmove(curp->p_idx + 2, curp->p_idx + 1, len); 768a86c6181SAlex Tomas } 769a86c6181SAlex Tomas ix = curp->p_idx + 1; 770a86c6181SAlex Tomas } else { 771a86c6181SAlex Tomas /* insert before */ 772a86c6181SAlex Tomas len = len * sizeof(struct ext4_extent_idx); 773a86c6181SAlex Tomas len = len < 0 ? 0 : len; 77426d535edSDmitry Monakhov ext_debug("insert new index %d before: %llu. " 775a86c6181SAlex Tomas "move %d from 0x%p to 0x%p\n", 776a86c6181SAlex Tomas logical, ptr, len, 777a86c6181SAlex Tomas curp->p_idx, (curp->p_idx + 1)); 778a86c6181SAlex Tomas memmove(curp->p_idx + 1, curp->p_idx, len); 779a86c6181SAlex Tomas ix = curp->p_idx; 780a86c6181SAlex Tomas } 781a86c6181SAlex Tomas 782f472e026STao Ma if (unlikely(ix > EXT_MAX_INDEX(curp->p_hdr))) { 783f472e026STao Ma EXT4_ERROR_INODE(inode, "ix > EXT_MAX_INDEX!"); 784f472e026STao Ma return -EIO; 785f472e026STao Ma } 786f472e026STao Ma 787a86c6181SAlex Tomas ix->ei_block = cpu_to_le32(logical); 788f65e6fbaSAlex Tomas ext4_idx_store_pblock(ix, ptr); 789e8546d06SMarcin Slusarz le16_add_cpu(&curp->p_hdr->eh_entries, 1); 790a86c6181SAlex Tomas 791273df556SFrank Mayhar if (unlikely(ix > EXT_LAST_INDEX(curp->p_hdr))) { 792273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "ix > EXT_LAST_INDEX!"); 793273df556SFrank Mayhar return -EIO; 794273df556SFrank Mayhar } 795a86c6181SAlex Tomas 796a86c6181SAlex Tomas err = ext4_ext_dirty(handle, inode, curp); 797a86c6181SAlex Tomas ext4_std_error(inode->i_sb, err); 798a86c6181SAlex Tomas 799a86c6181SAlex Tomas return err; 800a86c6181SAlex Tomas } 801a86c6181SAlex Tomas 802a86c6181SAlex Tomas /* 803d0d856e8SRandy Dunlap * ext4_ext_split: 804d0d856e8SRandy Dunlap * inserts new subtree into the path, using free index entry 805d0d856e8SRandy Dunlap * at depth @at: 806a86c6181SAlex Tomas * - allocates all needed blocks (new leaf and all intermediate index blocks) 807a86c6181SAlex Tomas * - makes decision where to split 808d0d856e8SRandy Dunlap * - moves remaining extents and index entries (right to the split point) 809a86c6181SAlex Tomas * into the newly allocated blocks 810d0d856e8SRandy Dunlap * - initializes subtree 811a86c6181SAlex Tomas */ 812a86c6181SAlex Tomas static int ext4_ext_split(handle_t *handle, struct inode *inode, 81355f020dbSAllison Henderson unsigned int flags, 814a86c6181SAlex Tomas struct ext4_ext_path *path, 815a86c6181SAlex Tomas struct ext4_extent *newext, int at) 816a86c6181SAlex Tomas { 817a86c6181SAlex Tomas struct buffer_head *bh = NULL; 818a86c6181SAlex Tomas int depth = ext_depth(inode); 819a86c6181SAlex Tomas struct ext4_extent_header *neh; 820a86c6181SAlex Tomas struct ext4_extent_idx *fidx; 821a86c6181SAlex Tomas int i = at, k, m, a; 822f65e6fbaSAlex Tomas ext4_fsblk_t newblock, oldblock; 823a86c6181SAlex Tomas __le32 border; 824f65e6fbaSAlex Tomas ext4_fsblk_t *ablocks = NULL; /* array of allocated blocks */ 825a86c6181SAlex Tomas int err = 0; 826a86c6181SAlex Tomas 827a86c6181SAlex Tomas /* make decision: where to split? */ 828d0d856e8SRandy Dunlap /* FIXME: now decision is simplest: at current extent */ 829a86c6181SAlex Tomas 830d0d856e8SRandy Dunlap /* if current leaf will be split, then we should use 831a86c6181SAlex Tomas * border from split point */ 832273df556SFrank Mayhar if (unlikely(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr))) { 833273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "p_ext > EXT_MAX_EXTENT!"); 834273df556SFrank Mayhar return -EIO; 835273df556SFrank Mayhar } 836a86c6181SAlex Tomas if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) { 837a86c6181SAlex Tomas border = path[depth].p_ext[1].ee_block; 838d0d856e8SRandy Dunlap ext_debug("leaf will be split." 839a86c6181SAlex Tomas " next leaf starts at %d\n", 840a86c6181SAlex Tomas le32_to_cpu(border)); 841a86c6181SAlex Tomas } else { 842a86c6181SAlex Tomas border = newext->ee_block; 843a86c6181SAlex Tomas ext_debug("leaf will be added." 844a86c6181SAlex Tomas " next leaf starts at %d\n", 845a86c6181SAlex Tomas le32_to_cpu(border)); 846a86c6181SAlex Tomas } 847a86c6181SAlex Tomas 848a86c6181SAlex Tomas /* 849d0d856e8SRandy Dunlap * If error occurs, then we break processing 850d0d856e8SRandy Dunlap * and mark filesystem read-only. index won't 851a86c6181SAlex Tomas * be inserted and tree will be in consistent 852d0d856e8SRandy Dunlap * state. Next mount will repair buffers too. 853a86c6181SAlex Tomas */ 854a86c6181SAlex Tomas 855a86c6181SAlex Tomas /* 856d0d856e8SRandy Dunlap * Get array to track all allocated blocks. 857d0d856e8SRandy Dunlap * We need this to handle errors and free blocks 858d0d856e8SRandy Dunlap * upon them. 859a86c6181SAlex Tomas */ 8605d4958f9SAvantika Mathur ablocks = kzalloc(sizeof(ext4_fsblk_t) * depth, GFP_NOFS); 861a86c6181SAlex Tomas if (!ablocks) 862a86c6181SAlex Tomas return -ENOMEM; 863a86c6181SAlex Tomas 864a86c6181SAlex Tomas /* allocate all needed blocks */ 865a86c6181SAlex Tomas ext_debug("allocate %d blocks for indexes/leaf\n", depth - at); 866a86c6181SAlex Tomas for (a = 0; a < depth - at; a++) { 867654b4908SAneesh Kumar K.V newblock = ext4_ext_new_meta_block(handle, inode, path, 86855f020dbSAllison Henderson newext, &err, flags); 869a86c6181SAlex Tomas if (newblock == 0) 870a86c6181SAlex Tomas goto cleanup; 871a86c6181SAlex Tomas ablocks[a] = newblock; 872a86c6181SAlex Tomas } 873a86c6181SAlex Tomas 874a86c6181SAlex Tomas /* initialize new leaf */ 875a86c6181SAlex Tomas newblock = ablocks[--a]; 876273df556SFrank Mayhar if (unlikely(newblock == 0)) { 877273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "newblock == 0!"); 878273df556SFrank Mayhar err = -EIO; 879273df556SFrank Mayhar goto cleanup; 880273df556SFrank Mayhar } 881a86c6181SAlex Tomas bh = sb_getblk(inode->i_sb, newblock); 882a86c6181SAlex Tomas if (!bh) { 883a86c6181SAlex Tomas err = -EIO; 884a86c6181SAlex Tomas goto cleanup; 885a86c6181SAlex Tomas } 886a86c6181SAlex Tomas lock_buffer(bh); 887a86c6181SAlex Tomas 8887e028976SAvantika Mathur err = ext4_journal_get_create_access(handle, bh); 8897e028976SAvantika Mathur if (err) 890a86c6181SAlex Tomas goto cleanup; 891a86c6181SAlex Tomas 892a86c6181SAlex Tomas neh = ext_block_hdr(bh); 893a86c6181SAlex Tomas neh->eh_entries = 0; 89455ad63bfSTheodore Ts'o neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0)); 895a86c6181SAlex Tomas neh->eh_magic = EXT4_EXT_MAGIC; 896a86c6181SAlex Tomas neh->eh_depth = 0; 897a86c6181SAlex Tomas 898d0d856e8SRandy Dunlap /* move remainder of path[depth] to the new leaf */ 899273df556SFrank Mayhar if (unlikely(path[depth].p_hdr->eh_entries != 900273df556SFrank Mayhar path[depth].p_hdr->eh_max)) { 901273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "eh_entries %d != eh_max %d!", 902273df556SFrank Mayhar path[depth].p_hdr->eh_entries, 903273df556SFrank Mayhar path[depth].p_hdr->eh_max); 904273df556SFrank Mayhar err = -EIO; 905273df556SFrank Mayhar goto cleanup; 906273df556SFrank Mayhar } 907a86c6181SAlex Tomas /* start copy from next extent */ 9081b16da77SYongqiang Yang m = EXT_MAX_EXTENT(path[depth].p_hdr) - path[depth].p_ext++; 9091b16da77SYongqiang Yang ext4_ext_show_move(inode, path, newblock, depth); 910a86c6181SAlex Tomas if (m) { 9111b16da77SYongqiang Yang struct ext4_extent *ex; 9121b16da77SYongqiang Yang ex = EXT_FIRST_EXTENT(neh); 9131b16da77SYongqiang Yang memmove(ex, path[depth].p_ext, sizeof(struct ext4_extent) * m); 914e8546d06SMarcin Slusarz le16_add_cpu(&neh->eh_entries, m); 915a86c6181SAlex Tomas } 916a86c6181SAlex Tomas 917a86c6181SAlex Tomas set_buffer_uptodate(bh); 918a86c6181SAlex Tomas unlock_buffer(bh); 919a86c6181SAlex Tomas 9200390131bSFrank Mayhar err = ext4_handle_dirty_metadata(handle, inode, bh); 9217e028976SAvantika Mathur if (err) 922a86c6181SAlex Tomas goto cleanup; 923a86c6181SAlex Tomas brelse(bh); 924a86c6181SAlex Tomas bh = NULL; 925a86c6181SAlex Tomas 926a86c6181SAlex Tomas /* correct old leaf */ 927a86c6181SAlex Tomas if (m) { 9287e028976SAvantika Mathur err = ext4_ext_get_access(handle, inode, path + depth); 9297e028976SAvantika Mathur if (err) 930a86c6181SAlex Tomas goto cleanup; 931e8546d06SMarcin Slusarz le16_add_cpu(&path[depth].p_hdr->eh_entries, -m); 9327e028976SAvantika Mathur err = ext4_ext_dirty(handle, inode, path + depth); 9337e028976SAvantika Mathur if (err) 934a86c6181SAlex Tomas goto cleanup; 935a86c6181SAlex Tomas 936a86c6181SAlex Tomas } 937a86c6181SAlex Tomas 938a86c6181SAlex Tomas /* create intermediate indexes */ 939a86c6181SAlex Tomas k = depth - at - 1; 940273df556SFrank Mayhar if (unlikely(k < 0)) { 941273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "k %d < 0!", k); 942273df556SFrank Mayhar err = -EIO; 943273df556SFrank Mayhar goto cleanup; 944273df556SFrank Mayhar } 945a86c6181SAlex Tomas if (k) 946a86c6181SAlex Tomas ext_debug("create %d intermediate indices\n", k); 947a86c6181SAlex Tomas /* insert new index into current index block */ 948a86c6181SAlex Tomas /* current depth stored in i var */ 949a86c6181SAlex Tomas i = depth - 1; 950a86c6181SAlex Tomas while (k--) { 951a86c6181SAlex Tomas oldblock = newblock; 952a86c6181SAlex Tomas newblock = ablocks[--a]; 953bba90743SEric Sandeen bh = sb_getblk(inode->i_sb, newblock); 954a86c6181SAlex Tomas if (!bh) { 955a86c6181SAlex Tomas err = -EIO; 956a86c6181SAlex Tomas goto cleanup; 957a86c6181SAlex Tomas } 958a86c6181SAlex Tomas lock_buffer(bh); 959a86c6181SAlex Tomas 9607e028976SAvantika Mathur err = ext4_journal_get_create_access(handle, bh); 9617e028976SAvantika Mathur if (err) 962a86c6181SAlex Tomas goto cleanup; 963a86c6181SAlex Tomas 964a86c6181SAlex Tomas neh = ext_block_hdr(bh); 965a86c6181SAlex Tomas neh->eh_entries = cpu_to_le16(1); 966a86c6181SAlex Tomas neh->eh_magic = EXT4_EXT_MAGIC; 96755ad63bfSTheodore Ts'o neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0)); 968a86c6181SAlex Tomas neh->eh_depth = cpu_to_le16(depth - i); 969a86c6181SAlex Tomas fidx = EXT_FIRST_INDEX(neh); 970a86c6181SAlex Tomas fidx->ei_block = border; 971f65e6fbaSAlex Tomas ext4_idx_store_pblock(fidx, oldblock); 972a86c6181SAlex Tomas 973bba90743SEric Sandeen ext_debug("int.index at %d (block %llu): %u -> %llu\n", 974bba90743SEric Sandeen i, newblock, le32_to_cpu(border), oldblock); 975a86c6181SAlex Tomas 9761b16da77SYongqiang Yang /* move remainder of path[i] to the new index block */ 977273df556SFrank Mayhar if (unlikely(EXT_MAX_INDEX(path[i].p_hdr) != 978273df556SFrank Mayhar EXT_LAST_INDEX(path[i].p_hdr))) { 979273df556SFrank Mayhar EXT4_ERROR_INODE(inode, 980273df556SFrank Mayhar "EXT_MAX_INDEX != EXT_LAST_INDEX ee_block %d!", 981273df556SFrank Mayhar le32_to_cpu(path[i].p_ext->ee_block)); 982273df556SFrank Mayhar err = -EIO; 983273df556SFrank Mayhar goto cleanup; 984273df556SFrank Mayhar } 9851b16da77SYongqiang Yang /* start copy indexes */ 9861b16da77SYongqiang Yang m = EXT_MAX_INDEX(path[i].p_hdr) - path[i].p_idx++; 9871b16da77SYongqiang Yang ext_debug("cur 0x%p, last 0x%p\n", path[i].p_idx, 9881b16da77SYongqiang Yang EXT_MAX_INDEX(path[i].p_hdr)); 9891b16da77SYongqiang Yang ext4_ext_show_move(inode, path, newblock, i); 990a86c6181SAlex Tomas if (m) { 9911b16da77SYongqiang Yang memmove(++fidx, path[i].p_idx, 992a86c6181SAlex Tomas sizeof(struct ext4_extent_idx) * m); 993e8546d06SMarcin Slusarz le16_add_cpu(&neh->eh_entries, m); 994a86c6181SAlex Tomas } 995a86c6181SAlex Tomas set_buffer_uptodate(bh); 996a86c6181SAlex Tomas unlock_buffer(bh); 997a86c6181SAlex Tomas 9980390131bSFrank Mayhar err = ext4_handle_dirty_metadata(handle, inode, bh); 9997e028976SAvantika Mathur if (err) 1000a86c6181SAlex Tomas goto cleanup; 1001a86c6181SAlex Tomas brelse(bh); 1002a86c6181SAlex Tomas bh = NULL; 1003a86c6181SAlex Tomas 1004a86c6181SAlex Tomas /* correct old index */ 1005a86c6181SAlex Tomas if (m) { 1006a86c6181SAlex Tomas err = ext4_ext_get_access(handle, inode, path + i); 1007a86c6181SAlex Tomas if (err) 1008a86c6181SAlex Tomas goto cleanup; 1009e8546d06SMarcin Slusarz le16_add_cpu(&path[i].p_hdr->eh_entries, -m); 1010a86c6181SAlex Tomas err = ext4_ext_dirty(handle, inode, path + i); 1011a86c6181SAlex Tomas if (err) 1012a86c6181SAlex Tomas goto cleanup; 1013a86c6181SAlex Tomas } 1014a86c6181SAlex Tomas 1015a86c6181SAlex Tomas i--; 1016a86c6181SAlex Tomas } 1017a86c6181SAlex Tomas 1018a86c6181SAlex Tomas /* insert new index */ 1019a86c6181SAlex Tomas err = ext4_ext_insert_index(handle, inode, path + at, 1020a86c6181SAlex Tomas le32_to_cpu(border), newblock); 1021a86c6181SAlex Tomas 1022a86c6181SAlex Tomas cleanup: 1023a86c6181SAlex Tomas if (bh) { 1024a86c6181SAlex Tomas if (buffer_locked(bh)) 1025a86c6181SAlex Tomas unlock_buffer(bh); 1026a86c6181SAlex Tomas brelse(bh); 1027a86c6181SAlex Tomas } 1028a86c6181SAlex Tomas 1029a86c6181SAlex Tomas if (err) { 1030a86c6181SAlex Tomas /* free all allocated blocks in error case */ 1031a86c6181SAlex Tomas for (i = 0; i < depth; i++) { 1032a86c6181SAlex Tomas if (!ablocks[i]) 1033a86c6181SAlex Tomas continue; 10347dc57615SPeter Huewe ext4_free_blocks(handle, inode, NULL, ablocks[i], 1, 1035e6362609STheodore Ts'o EXT4_FREE_BLOCKS_METADATA); 1036a86c6181SAlex Tomas } 1037a86c6181SAlex Tomas } 1038a86c6181SAlex Tomas kfree(ablocks); 1039a86c6181SAlex Tomas 1040a86c6181SAlex Tomas return err; 1041a86c6181SAlex Tomas } 1042a86c6181SAlex Tomas 1043a86c6181SAlex Tomas /* 1044d0d856e8SRandy Dunlap * ext4_ext_grow_indepth: 1045d0d856e8SRandy Dunlap * implements tree growing procedure: 1046a86c6181SAlex Tomas * - allocates new block 1047a86c6181SAlex Tomas * - moves top-level data (index block or leaf) into the new block 1048d0d856e8SRandy Dunlap * - initializes new top-level, creating index that points to the 1049a86c6181SAlex Tomas * just created block 1050a86c6181SAlex Tomas */ 1051a86c6181SAlex Tomas static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode, 105255f020dbSAllison Henderson unsigned int flags, 1053a86c6181SAlex Tomas struct ext4_extent *newext) 1054a86c6181SAlex Tomas { 1055a86c6181SAlex Tomas struct ext4_extent_header *neh; 1056a86c6181SAlex Tomas struct buffer_head *bh; 1057f65e6fbaSAlex Tomas ext4_fsblk_t newblock; 1058a86c6181SAlex Tomas int err = 0; 1059a86c6181SAlex Tomas 10601939dd84SDmitry Monakhov newblock = ext4_ext_new_meta_block(handle, inode, NULL, 106155f020dbSAllison Henderson newext, &err, flags); 1062a86c6181SAlex Tomas if (newblock == 0) 1063a86c6181SAlex Tomas return err; 1064a86c6181SAlex Tomas 1065a86c6181SAlex Tomas bh = sb_getblk(inode->i_sb, newblock); 1066a86c6181SAlex Tomas if (!bh) { 1067a86c6181SAlex Tomas err = -EIO; 1068a86c6181SAlex Tomas ext4_std_error(inode->i_sb, err); 1069a86c6181SAlex Tomas return err; 1070a86c6181SAlex Tomas } 1071a86c6181SAlex Tomas lock_buffer(bh); 1072a86c6181SAlex Tomas 10737e028976SAvantika Mathur err = ext4_journal_get_create_access(handle, bh); 10747e028976SAvantika Mathur if (err) { 1075a86c6181SAlex Tomas unlock_buffer(bh); 1076a86c6181SAlex Tomas goto out; 1077a86c6181SAlex Tomas } 1078a86c6181SAlex Tomas 1079a86c6181SAlex Tomas /* move top-level index/leaf into new block */ 10801939dd84SDmitry Monakhov memmove(bh->b_data, EXT4_I(inode)->i_data, 10811939dd84SDmitry Monakhov sizeof(EXT4_I(inode)->i_data)); 1082a86c6181SAlex Tomas 1083a86c6181SAlex Tomas /* set size of new block */ 1084a86c6181SAlex Tomas neh = ext_block_hdr(bh); 1085a86c6181SAlex Tomas /* old root could have indexes or leaves 1086a86c6181SAlex Tomas * so calculate e_max right way */ 1087a86c6181SAlex Tomas if (ext_depth(inode)) 108855ad63bfSTheodore Ts'o neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0)); 1089a86c6181SAlex Tomas else 109055ad63bfSTheodore Ts'o neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0)); 1091a86c6181SAlex Tomas neh->eh_magic = EXT4_EXT_MAGIC; 1092a86c6181SAlex Tomas set_buffer_uptodate(bh); 1093a86c6181SAlex Tomas unlock_buffer(bh); 1094a86c6181SAlex Tomas 10950390131bSFrank Mayhar err = ext4_handle_dirty_metadata(handle, inode, bh); 10967e028976SAvantika Mathur if (err) 1097a86c6181SAlex Tomas goto out; 1098a86c6181SAlex Tomas 10991939dd84SDmitry Monakhov /* Update top-level index: num,max,pointer */ 1100a86c6181SAlex Tomas neh = ext_inode_hdr(inode); 11011939dd84SDmitry Monakhov neh->eh_entries = cpu_to_le16(1); 11021939dd84SDmitry Monakhov ext4_idx_store_pblock(EXT_FIRST_INDEX(neh), newblock); 11031939dd84SDmitry Monakhov if (neh->eh_depth == 0) { 11041939dd84SDmitry Monakhov /* Root extent block becomes index block */ 11051939dd84SDmitry Monakhov neh->eh_max = cpu_to_le16(ext4_ext_space_root_idx(inode, 0)); 11061939dd84SDmitry Monakhov EXT_FIRST_INDEX(neh)->ei_block = 11071939dd84SDmitry Monakhov EXT_FIRST_EXTENT(neh)->ee_block; 11081939dd84SDmitry Monakhov } 11092ae02107SMingming Cao ext_debug("new root: num %d(%d), lblock %d, ptr %llu\n", 1110a86c6181SAlex Tomas le16_to_cpu(neh->eh_entries), le16_to_cpu(neh->eh_max), 11115a0790c2SAndi Kleen le32_to_cpu(EXT_FIRST_INDEX(neh)->ei_block), 1112bf89d16fSTheodore Ts'o ext4_idx_pblock(EXT_FIRST_INDEX(neh))); 1113a86c6181SAlex Tomas 11141939dd84SDmitry Monakhov neh->eh_depth = cpu_to_le16(neh->eh_depth + 1); 11151939dd84SDmitry Monakhov ext4_mark_inode_dirty(handle, inode); 1116a86c6181SAlex Tomas out: 1117a86c6181SAlex Tomas brelse(bh); 1118a86c6181SAlex Tomas 1119a86c6181SAlex Tomas return err; 1120a86c6181SAlex Tomas } 1121a86c6181SAlex Tomas 1122a86c6181SAlex Tomas /* 1123d0d856e8SRandy Dunlap * ext4_ext_create_new_leaf: 1124d0d856e8SRandy Dunlap * finds empty index and adds new leaf. 1125d0d856e8SRandy Dunlap * if no free index is found, then it requests in-depth growing. 1126a86c6181SAlex Tomas */ 1127a86c6181SAlex Tomas static int ext4_ext_create_new_leaf(handle_t *handle, struct inode *inode, 112855f020dbSAllison Henderson unsigned int flags, 1129a86c6181SAlex Tomas struct ext4_ext_path *path, 1130a86c6181SAlex Tomas struct ext4_extent *newext) 1131a86c6181SAlex Tomas { 1132a86c6181SAlex Tomas struct ext4_ext_path *curp; 1133a86c6181SAlex Tomas int depth, i, err = 0; 1134a86c6181SAlex Tomas 1135a86c6181SAlex Tomas repeat: 1136a86c6181SAlex Tomas i = depth = ext_depth(inode); 1137a86c6181SAlex Tomas 1138a86c6181SAlex Tomas /* walk up to the tree and look for free index entry */ 1139a86c6181SAlex Tomas curp = path + depth; 1140a86c6181SAlex Tomas while (i > 0 && !EXT_HAS_FREE_INDEX(curp)) { 1141a86c6181SAlex Tomas i--; 1142a86c6181SAlex Tomas curp--; 1143a86c6181SAlex Tomas } 1144a86c6181SAlex Tomas 1145d0d856e8SRandy Dunlap /* we use already allocated block for index block, 1146d0d856e8SRandy Dunlap * so subsequent data blocks should be contiguous */ 1147a86c6181SAlex Tomas if (EXT_HAS_FREE_INDEX(curp)) { 1148a86c6181SAlex Tomas /* if we found index with free entry, then use that 1149a86c6181SAlex Tomas * entry: create all needed subtree and add new leaf */ 115055f020dbSAllison Henderson err = ext4_ext_split(handle, inode, flags, path, newext, i); 1151787e0981SShen Feng if (err) 1152787e0981SShen Feng goto out; 1153a86c6181SAlex Tomas 1154a86c6181SAlex Tomas /* refill path */ 1155a86c6181SAlex Tomas ext4_ext_drop_refs(path); 1156a86c6181SAlex Tomas path = ext4_ext_find_extent(inode, 1157725d26d3SAneesh Kumar K.V (ext4_lblk_t)le32_to_cpu(newext->ee_block), 1158a86c6181SAlex Tomas path); 1159a86c6181SAlex Tomas if (IS_ERR(path)) 1160a86c6181SAlex Tomas err = PTR_ERR(path); 1161a86c6181SAlex Tomas } else { 1162a86c6181SAlex Tomas /* tree is full, time to grow in depth */ 11631939dd84SDmitry Monakhov err = ext4_ext_grow_indepth(handle, inode, flags, newext); 1164a86c6181SAlex Tomas if (err) 1165a86c6181SAlex Tomas goto out; 1166a86c6181SAlex Tomas 1167a86c6181SAlex Tomas /* refill path */ 1168a86c6181SAlex Tomas ext4_ext_drop_refs(path); 1169a86c6181SAlex Tomas path = ext4_ext_find_extent(inode, 1170725d26d3SAneesh Kumar K.V (ext4_lblk_t)le32_to_cpu(newext->ee_block), 1171a86c6181SAlex Tomas path); 1172a86c6181SAlex Tomas if (IS_ERR(path)) { 1173a86c6181SAlex Tomas err = PTR_ERR(path); 1174a86c6181SAlex Tomas goto out; 1175a86c6181SAlex Tomas } 1176a86c6181SAlex Tomas 1177a86c6181SAlex Tomas /* 1178d0d856e8SRandy Dunlap * only first (depth 0 -> 1) produces free space; 1179d0d856e8SRandy Dunlap * in all other cases we have to split the grown tree 1180a86c6181SAlex Tomas */ 1181a86c6181SAlex Tomas depth = ext_depth(inode); 1182a86c6181SAlex Tomas if (path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max) { 1183d0d856e8SRandy Dunlap /* now we need to split */ 1184a86c6181SAlex Tomas goto repeat; 1185a86c6181SAlex Tomas } 1186a86c6181SAlex Tomas } 1187a86c6181SAlex Tomas 1188a86c6181SAlex Tomas out: 1189a86c6181SAlex Tomas return err; 1190a86c6181SAlex Tomas } 1191a86c6181SAlex Tomas 1192a86c6181SAlex Tomas /* 11931988b51eSAlex Tomas * search the closest allocated block to the left for *logical 11941988b51eSAlex Tomas * and returns it at @logical + it's physical address at @phys 11951988b51eSAlex Tomas * if *logical is the smallest allocated block, the function 11961988b51eSAlex Tomas * returns 0 at @phys 11971988b51eSAlex Tomas * return value contains 0 (success) or error code 11981988b51eSAlex Tomas */ 11991f109d5aSTheodore Ts'o static int ext4_ext_search_left(struct inode *inode, 12001f109d5aSTheodore Ts'o struct ext4_ext_path *path, 12011988b51eSAlex Tomas ext4_lblk_t *logical, ext4_fsblk_t *phys) 12021988b51eSAlex Tomas { 12031988b51eSAlex Tomas struct ext4_extent_idx *ix; 12041988b51eSAlex Tomas struct ext4_extent *ex; 1205b939e376SAneesh Kumar K.V int depth, ee_len; 12061988b51eSAlex Tomas 1207273df556SFrank Mayhar if (unlikely(path == NULL)) { 1208273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical); 1209273df556SFrank Mayhar return -EIO; 1210273df556SFrank Mayhar } 12111988b51eSAlex Tomas depth = path->p_depth; 12121988b51eSAlex Tomas *phys = 0; 12131988b51eSAlex Tomas 12141988b51eSAlex Tomas if (depth == 0 && path->p_ext == NULL) 12151988b51eSAlex Tomas return 0; 12161988b51eSAlex Tomas 12171988b51eSAlex Tomas /* usually extent in the path covers blocks smaller 12181988b51eSAlex Tomas * then *logical, but it can be that extent is the 12191988b51eSAlex Tomas * first one in the file */ 12201988b51eSAlex Tomas 12211988b51eSAlex Tomas ex = path[depth].p_ext; 1222b939e376SAneesh Kumar K.V ee_len = ext4_ext_get_actual_len(ex); 12231988b51eSAlex Tomas if (*logical < le32_to_cpu(ex->ee_block)) { 1224273df556SFrank Mayhar if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) { 1225273df556SFrank Mayhar EXT4_ERROR_INODE(inode, 1226273df556SFrank Mayhar "EXT_FIRST_EXTENT != ex *logical %d ee_block %d!", 1227273df556SFrank Mayhar *logical, le32_to_cpu(ex->ee_block)); 1228273df556SFrank Mayhar return -EIO; 1229273df556SFrank Mayhar } 12301988b51eSAlex Tomas while (--depth >= 0) { 12311988b51eSAlex Tomas ix = path[depth].p_idx; 1232273df556SFrank Mayhar if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) { 1233273df556SFrank Mayhar EXT4_ERROR_INODE(inode, 1234273df556SFrank Mayhar "ix (%d) != EXT_FIRST_INDEX (%d) (depth %d)!", 12356ee3b212STao Ma ix != NULL ? le32_to_cpu(ix->ei_block) : 0, 1236273df556SFrank Mayhar EXT_FIRST_INDEX(path[depth].p_hdr) != NULL ? 12376ee3b212STao Ma le32_to_cpu(EXT_FIRST_INDEX(path[depth].p_hdr)->ei_block) : 0, 1238273df556SFrank Mayhar depth); 1239273df556SFrank Mayhar return -EIO; 1240273df556SFrank Mayhar } 12411988b51eSAlex Tomas } 12421988b51eSAlex Tomas return 0; 12431988b51eSAlex Tomas } 12441988b51eSAlex Tomas 1245273df556SFrank Mayhar if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) { 1246273df556SFrank Mayhar EXT4_ERROR_INODE(inode, 1247273df556SFrank Mayhar "logical %d < ee_block %d + ee_len %d!", 1248273df556SFrank Mayhar *logical, le32_to_cpu(ex->ee_block), ee_len); 1249273df556SFrank Mayhar return -EIO; 1250273df556SFrank Mayhar } 12511988b51eSAlex Tomas 1252b939e376SAneesh Kumar K.V *logical = le32_to_cpu(ex->ee_block) + ee_len - 1; 1253bf89d16fSTheodore Ts'o *phys = ext4_ext_pblock(ex) + ee_len - 1; 12541988b51eSAlex Tomas return 0; 12551988b51eSAlex Tomas } 12561988b51eSAlex Tomas 12571988b51eSAlex Tomas /* 12581988b51eSAlex Tomas * search the closest allocated block to the right for *logical 12591988b51eSAlex Tomas * and returns it at @logical + it's physical address at @phys 1260df3ab170STao Ma * if *logical is the largest allocated block, the function 12611988b51eSAlex Tomas * returns 0 at @phys 12621988b51eSAlex Tomas * return value contains 0 (success) or error code 12631988b51eSAlex Tomas */ 12641f109d5aSTheodore Ts'o static int ext4_ext_search_right(struct inode *inode, 12651f109d5aSTheodore Ts'o struct ext4_ext_path *path, 12664d33b1efSTheodore Ts'o ext4_lblk_t *logical, ext4_fsblk_t *phys, 12674d33b1efSTheodore Ts'o struct ext4_extent **ret_ex) 12681988b51eSAlex Tomas { 12691988b51eSAlex Tomas struct buffer_head *bh = NULL; 12701988b51eSAlex Tomas struct ext4_extent_header *eh; 12711988b51eSAlex Tomas struct ext4_extent_idx *ix; 12721988b51eSAlex Tomas struct ext4_extent *ex; 12731988b51eSAlex Tomas ext4_fsblk_t block; 1274395a87bfSEric Sandeen int depth; /* Note, NOT eh_depth; depth from top of tree */ 1275395a87bfSEric Sandeen int ee_len; 12761988b51eSAlex Tomas 1277273df556SFrank Mayhar if (unlikely(path == NULL)) { 1278273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical); 1279273df556SFrank Mayhar return -EIO; 1280273df556SFrank Mayhar } 12811988b51eSAlex Tomas depth = path->p_depth; 12821988b51eSAlex Tomas *phys = 0; 12831988b51eSAlex Tomas 12841988b51eSAlex Tomas if (depth == 0 && path->p_ext == NULL) 12851988b51eSAlex Tomas return 0; 12861988b51eSAlex Tomas 12871988b51eSAlex Tomas /* usually extent in the path covers blocks smaller 12881988b51eSAlex Tomas * then *logical, but it can be that extent is the 12891988b51eSAlex Tomas * first one in the file */ 12901988b51eSAlex Tomas 12911988b51eSAlex Tomas ex = path[depth].p_ext; 1292b939e376SAneesh Kumar K.V ee_len = ext4_ext_get_actual_len(ex); 12931988b51eSAlex Tomas if (*logical < le32_to_cpu(ex->ee_block)) { 1294273df556SFrank Mayhar if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) { 1295273df556SFrank Mayhar EXT4_ERROR_INODE(inode, 1296273df556SFrank Mayhar "first_extent(path[%d].p_hdr) != ex", 1297273df556SFrank Mayhar depth); 1298273df556SFrank Mayhar return -EIO; 1299273df556SFrank Mayhar } 13001988b51eSAlex Tomas while (--depth >= 0) { 13011988b51eSAlex Tomas ix = path[depth].p_idx; 1302273df556SFrank Mayhar if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) { 1303273df556SFrank Mayhar EXT4_ERROR_INODE(inode, 1304273df556SFrank Mayhar "ix != EXT_FIRST_INDEX *logical %d!", 1305273df556SFrank Mayhar *logical); 1306273df556SFrank Mayhar return -EIO; 1307273df556SFrank Mayhar } 13081988b51eSAlex Tomas } 13094d33b1efSTheodore Ts'o goto found_extent; 13101988b51eSAlex Tomas } 13111988b51eSAlex Tomas 1312273df556SFrank Mayhar if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) { 1313273df556SFrank Mayhar EXT4_ERROR_INODE(inode, 1314273df556SFrank Mayhar "logical %d < ee_block %d + ee_len %d!", 1315273df556SFrank Mayhar *logical, le32_to_cpu(ex->ee_block), ee_len); 1316273df556SFrank Mayhar return -EIO; 1317273df556SFrank Mayhar } 13181988b51eSAlex Tomas 13191988b51eSAlex Tomas if (ex != EXT_LAST_EXTENT(path[depth].p_hdr)) { 13201988b51eSAlex Tomas /* next allocated block in this leaf */ 13211988b51eSAlex Tomas ex++; 13224d33b1efSTheodore Ts'o goto found_extent; 13231988b51eSAlex Tomas } 13241988b51eSAlex Tomas 13251988b51eSAlex Tomas /* go up and search for index to the right */ 13261988b51eSAlex Tomas while (--depth >= 0) { 13271988b51eSAlex Tomas ix = path[depth].p_idx; 13281988b51eSAlex Tomas if (ix != EXT_LAST_INDEX(path[depth].p_hdr)) 132925f1ee3aSWu Fengguang goto got_index; 13301988b51eSAlex Tomas } 13311988b51eSAlex Tomas 133225f1ee3aSWu Fengguang /* we've gone up to the root and found no index to the right */ 13331988b51eSAlex Tomas return 0; 13341988b51eSAlex Tomas 133525f1ee3aSWu Fengguang got_index: 13361988b51eSAlex Tomas /* we've found index to the right, let's 13371988b51eSAlex Tomas * follow it and find the closest allocated 13381988b51eSAlex Tomas * block to the right */ 13391988b51eSAlex Tomas ix++; 1340bf89d16fSTheodore Ts'o block = ext4_idx_pblock(ix); 13411988b51eSAlex Tomas while (++depth < path->p_depth) { 13421988b51eSAlex Tomas bh = sb_bread(inode->i_sb, block); 13431988b51eSAlex Tomas if (bh == NULL) 13441988b51eSAlex Tomas return -EIO; 13451988b51eSAlex Tomas eh = ext_block_hdr(bh); 1346395a87bfSEric Sandeen /* subtract from p_depth to get proper eh_depth */ 134756b19868SAneesh Kumar K.V if (ext4_ext_check(inode, eh, path->p_depth - depth)) { 13481988b51eSAlex Tomas put_bh(bh); 13491988b51eSAlex Tomas return -EIO; 13501988b51eSAlex Tomas } 13511988b51eSAlex Tomas ix = EXT_FIRST_INDEX(eh); 1352bf89d16fSTheodore Ts'o block = ext4_idx_pblock(ix); 13531988b51eSAlex Tomas put_bh(bh); 13541988b51eSAlex Tomas } 13551988b51eSAlex Tomas 13561988b51eSAlex Tomas bh = sb_bread(inode->i_sb, block); 13571988b51eSAlex Tomas if (bh == NULL) 13581988b51eSAlex Tomas return -EIO; 13591988b51eSAlex Tomas eh = ext_block_hdr(bh); 136056b19868SAneesh Kumar K.V if (ext4_ext_check(inode, eh, path->p_depth - depth)) { 13611988b51eSAlex Tomas put_bh(bh); 13621988b51eSAlex Tomas return -EIO; 13631988b51eSAlex Tomas } 13641988b51eSAlex Tomas ex = EXT_FIRST_EXTENT(eh); 13654d33b1efSTheodore Ts'o found_extent: 13661988b51eSAlex Tomas *logical = le32_to_cpu(ex->ee_block); 1367bf89d16fSTheodore Ts'o *phys = ext4_ext_pblock(ex); 13684d33b1efSTheodore Ts'o *ret_ex = ex; 13694d33b1efSTheodore Ts'o if (bh) 13701988b51eSAlex Tomas put_bh(bh); 13711988b51eSAlex Tomas return 0; 13721988b51eSAlex Tomas } 13731988b51eSAlex Tomas 13741988b51eSAlex Tomas /* 1375d0d856e8SRandy Dunlap * ext4_ext_next_allocated_block: 1376f17722f9SLukas Czerner * returns allocated block in subsequent extent or EXT_MAX_BLOCKS. 1377d0d856e8SRandy Dunlap * NOTE: it considers block number from index entry as 1378d0d856e8SRandy Dunlap * allocated block. Thus, index entries have to be consistent 1379d0d856e8SRandy Dunlap * with leaves. 1380a86c6181SAlex Tomas */ 1381725d26d3SAneesh Kumar K.V static ext4_lblk_t 1382a86c6181SAlex Tomas ext4_ext_next_allocated_block(struct ext4_ext_path *path) 1383a86c6181SAlex Tomas { 1384a86c6181SAlex Tomas int depth; 1385a86c6181SAlex Tomas 1386a86c6181SAlex Tomas BUG_ON(path == NULL); 1387a86c6181SAlex Tomas depth = path->p_depth; 1388a86c6181SAlex Tomas 1389a86c6181SAlex Tomas if (depth == 0 && path->p_ext == NULL) 1390f17722f9SLukas Czerner return EXT_MAX_BLOCKS; 1391a86c6181SAlex Tomas 1392a86c6181SAlex Tomas while (depth >= 0) { 1393a86c6181SAlex Tomas if (depth == path->p_depth) { 1394a86c6181SAlex Tomas /* leaf */ 1395a86c6181SAlex Tomas if (path[depth].p_ext != 1396a86c6181SAlex Tomas EXT_LAST_EXTENT(path[depth].p_hdr)) 1397a86c6181SAlex Tomas return le32_to_cpu(path[depth].p_ext[1].ee_block); 1398a86c6181SAlex Tomas } else { 1399a86c6181SAlex Tomas /* index */ 1400a86c6181SAlex Tomas if (path[depth].p_idx != 1401a86c6181SAlex Tomas EXT_LAST_INDEX(path[depth].p_hdr)) 1402a86c6181SAlex Tomas return le32_to_cpu(path[depth].p_idx[1].ei_block); 1403a86c6181SAlex Tomas } 1404a86c6181SAlex Tomas depth--; 1405a86c6181SAlex Tomas } 1406a86c6181SAlex Tomas 1407f17722f9SLukas Czerner return EXT_MAX_BLOCKS; 1408a86c6181SAlex Tomas } 1409a86c6181SAlex Tomas 1410a86c6181SAlex Tomas /* 1411d0d856e8SRandy Dunlap * ext4_ext_next_leaf_block: 1412f17722f9SLukas Czerner * returns first allocated block from next leaf or EXT_MAX_BLOCKS 1413a86c6181SAlex Tomas */ 14145718789dSRobin Dong static ext4_lblk_t ext4_ext_next_leaf_block(struct ext4_ext_path *path) 1415a86c6181SAlex Tomas { 1416a86c6181SAlex Tomas int depth; 1417a86c6181SAlex Tomas 1418a86c6181SAlex Tomas BUG_ON(path == NULL); 1419a86c6181SAlex Tomas depth = path->p_depth; 1420a86c6181SAlex Tomas 1421a86c6181SAlex Tomas /* zero-tree has no leaf blocks at all */ 1422a86c6181SAlex Tomas if (depth == 0) 1423f17722f9SLukas Czerner return EXT_MAX_BLOCKS; 1424a86c6181SAlex Tomas 1425a86c6181SAlex Tomas /* go to index block */ 1426a86c6181SAlex Tomas depth--; 1427a86c6181SAlex Tomas 1428a86c6181SAlex Tomas while (depth >= 0) { 1429a86c6181SAlex Tomas if (path[depth].p_idx != 1430a86c6181SAlex Tomas EXT_LAST_INDEX(path[depth].p_hdr)) 1431725d26d3SAneesh Kumar K.V return (ext4_lblk_t) 1432725d26d3SAneesh Kumar K.V le32_to_cpu(path[depth].p_idx[1].ei_block); 1433a86c6181SAlex Tomas depth--; 1434a86c6181SAlex Tomas } 1435a86c6181SAlex Tomas 1436f17722f9SLukas Czerner return EXT_MAX_BLOCKS; 1437a86c6181SAlex Tomas } 1438a86c6181SAlex Tomas 1439a86c6181SAlex Tomas /* 1440d0d856e8SRandy Dunlap * ext4_ext_correct_indexes: 1441d0d856e8SRandy Dunlap * if leaf gets modified and modified extent is first in the leaf, 1442d0d856e8SRandy Dunlap * then we have to correct all indexes above. 1443a86c6181SAlex Tomas * TODO: do we need to correct tree in all cases? 1444a86c6181SAlex Tomas */ 14451d03ec98SAneesh Kumar K.V static int ext4_ext_correct_indexes(handle_t *handle, struct inode *inode, 1446a86c6181SAlex Tomas struct ext4_ext_path *path) 1447a86c6181SAlex Tomas { 1448a86c6181SAlex Tomas struct ext4_extent_header *eh; 1449a86c6181SAlex Tomas int depth = ext_depth(inode); 1450a86c6181SAlex Tomas struct ext4_extent *ex; 1451a86c6181SAlex Tomas __le32 border; 1452a86c6181SAlex Tomas int k, err = 0; 1453a86c6181SAlex Tomas 1454a86c6181SAlex Tomas eh = path[depth].p_hdr; 1455a86c6181SAlex Tomas ex = path[depth].p_ext; 1456273df556SFrank Mayhar 1457273df556SFrank Mayhar if (unlikely(ex == NULL || eh == NULL)) { 1458273df556SFrank Mayhar EXT4_ERROR_INODE(inode, 1459273df556SFrank Mayhar "ex %p == NULL or eh %p == NULL", ex, eh); 1460273df556SFrank Mayhar return -EIO; 1461273df556SFrank Mayhar } 1462a86c6181SAlex Tomas 1463a86c6181SAlex Tomas if (depth == 0) { 1464a86c6181SAlex Tomas /* there is no tree at all */ 1465a86c6181SAlex Tomas return 0; 1466a86c6181SAlex Tomas } 1467a86c6181SAlex Tomas 1468a86c6181SAlex Tomas if (ex != EXT_FIRST_EXTENT(eh)) { 1469a86c6181SAlex Tomas /* we correct tree if first leaf got modified only */ 1470a86c6181SAlex Tomas return 0; 1471a86c6181SAlex Tomas } 1472a86c6181SAlex Tomas 1473a86c6181SAlex Tomas /* 1474d0d856e8SRandy Dunlap * TODO: we need correction if border is smaller than current one 1475a86c6181SAlex Tomas */ 1476a86c6181SAlex Tomas k = depth - 1; 1477a86c6181SAlex Tomas border = path[depth].p_ext->ee_block; 14787e028976SAvantika Mathur err = ext4_ext_get_access(handle, inode, path + k); 14797e028976SAvantika Mathur if (err) 1480a86c6181SAlex Tomas return err; 1481a86c6181SAlex Tomas path[k].p_idx->ei_block = border; 14827e028976SAvantika Mathur err = ext4_ext_dirty(handle, inode, path + k); 14837e028976SAvantika Mathur if (err) 1484a86c6181SAlex Tomas return err; 1485a86c6181SAlex Tomas 1486a86c6181SAlex Tomas while (k--) { 1487a86c6181SAlex Tomas /* change all left-side indexes */ 1488a86c6181SAlex Tomas if (path[k+1].p_idx != EXT_FIRST_INDEX(path[k+1].p_hdr)) 1489a86c6181SAlex Tomas break; 14907e028976SAvantika Mathur err = ext4_ext_get_access(handle, inode, path + k); 14917e028976SAvantika Mathur if (err) 1492a86c6181SAlex Tomas break; 1493a86c6181SAlex Tomas path[k].p_idx->ei_block = border; 14947e028976SAvantika Mathur err = ext4_ext_dirty(handle, inode, path + k); 14957e028976SAvantika Mathur if (err) 1496a86c6181SAlex Tomas break; 1497a86c6181SAlex Tomas } 1498a86c6181SAlex Tomas 1499a86c6181SAlex Tomas return err; 1500a86c6181SAlex Tomas } 1501a86c6181SAlex Tomas 1502748de673SAkira Fujita int 1503a86c6181SAlex Tomas ext4_can_extents_be_merged(struct inode *inode, struct ext4_extent *ex1, 1504a86c6181SAlex Tomas struct ext4_extent *ex2) 1505a86c6181SAlex Tomas { 1506749269faSAmit Arora unsigned short ext1_ee_len, ext2_ee_len, max_len; 1507a2df2a63SAmit Arora 1508a2df2a63SAmit Arora /* 1509a2df2a63SAmit Arora * Make sure that either both extents are uninitialized, or 1510a2df2a63SAmit Arora * both are _not_. 1511a2df2a63SAmit Arora */ 1512a2df2a63SAmit Arora if (ext4_ext_is_uninitialized(ex1) ^ ext4_ext_is_uninitialized(ex2)) 1513a2df2a63SAmit Arora return 0; 1514a2df2a63SAmit Arora 1515749269faSAmit Arora if (ext4_ext_is_uninitialized(ex1)) 1516749269faSAmit Arora max_len = EXT_UNINIT_MAX_LEN; 1517749269faSAmit Arora else 1518749269faSAmit Arora max_len = EXT_INIT_MAX_LEN; 1519749269faSAmit Arora 1520a2df2a63SAmit Arora ext1_ee_len = ext4_ext_get_actual_len(ex1); 1521a2df2a63SAmit Arora ext2_ee_len = ext4_ext_get_actual_len(ex2); 1522a2df2a63SAmit Arora 1523a2df2a63SAmit Arora if (le32_to_cpu(ex1->ee_block) + ext1_ee_len != 152463f57933SAndrew Morton le32_to_cpu(ex2->ee_block)) 1525a86c6181SAlex Tomas return 0; 1526a86c6181SAlex Tomas 1527471d4011SSuparna Bhattacharya /* 1528471d4011SSuparna Bhattacharya * To allow future support for preallocated extents to be added 1529471d4011SSuparna Bhattacharya * as an RO_COMPAT feature, refuse to merge to extents if 1530d0d856e8SRandy Dunlap * this can result in the top bit of ee_len being set. 1531471d4011SSuparna Bhattacharya */ 1532749269faSAmit Arora if (ext1_ee_len + ext2_ee_len > max_len) 1533471d4011SSuparna Bhattacharya return 0; 1534bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST 1535b939e376SAneesh Kumar K.V if (ext1_ee_len >= 4) 1536a86c6181SAlex Tomas return 0; 1537a86c6181SAlex Tomas #endif 1538a86c6181SAlex Tomas 1539bf89d16fSTheodore Ts'o if (ext4_ext_pblock(ex1) + ext1_ee_len == ext4_ext_pblock(ex2)) 1540a86c6181SAlex Tomas return 1; 1541a86c6181SAlex Tomas return 0; 1542a86c6181SAlex Tomas } 1543a86c6181SAlex Tomas 1544a86c6181SAlex Tomas /* 154556055d3aSAmit Arora * This function tries to merge the "ex" extent to the next extent in the tree. 154656055d3aSAmit Arora * It always tries to merge towards right. If you want to merge towards 154756055d3aSAmit Arora * left, pass "ex - 1" as argument instead of "ex". 154856055d3aSAmit Arora * Returns 0 if the extents (ex and ex+1) were _not_ merged and returns 154956055d3aSAmit Arora * 1 if they got merged. 155056055d3aSAmit Arora */ 1551197217a5SYongqiang Yang static int ext4_ext_try_to_merge_right(struct inode *inode, 155256055d3aSAmit Arora struct ext4_ext_path *path, 155356055d3aSAmit Arora struct ext4_extent *ex) 155456055d3aSAmit Arora { 155556055d3aSAmit Arora struct ext4_extent_header *eh; 155656055d3aSAmit Arora unsigned int depth, len; 155756055d3aSAmit Arora int merge_done = 0; 155856055d3aSAmit Arora int uninitialized = 0; 155956055d3aSAmit Arora 156056055d3aSAmit Arora depth = ext_depth(inode); 156156055d3aSAmit Arora BUG_ON(path[depth].p_hdr == NULL); 156256055d3aSAmit Arora eh = path[depth].p_hdr; 156356055d3aSAmit Arora 156456055d3aSAmit Arora while (ex < EXT_LAST_EXTENT(eh)) { 156556055d3aSAmit Arora if (!ext4_can_extents_be_merged(inode, ex, ex + 1)) 156656055d3aSAmit Arora break; 156756055d3aSAmit Arora /* merge with next extent! */ 156856055d3aSAmit Arora if (ext4_ext_is_uninitialized(ex)) 156956055d3aSAmit Arora uninitialized = 1; 157056055d3aSAmit Arora ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex) 157156055d3aSAmit Arora + ext4_ext_get_actual_len(ex + 1)); 157256055d3aSAmit Arora if (uninitialized) 157356055d3aSAmit Arora ext4_ext_mark_uninitialized(ex); 157456055d3aSAmit Arora 157556055d3aSAmit Arora if (ex + 1 < EXT_LAST_EXTENT(eh)) { 157656055d3aSAmit Arora len = (EXT_LAST_EXTENT(eh) - ex - 1) 157756055d3aSAmit Arora * sizeof(struct ext4_extent); 157856055d3aSAmit Arora memmove(ex + 1, ex + 2, len); 157956055d3aSAmit Arora } 1580e8546d06SMarcin Slusarz le16_add_cpu(&eh->eh_entries, -1); 158156055d3aSAmit Arora merge_done = 1; 158256055d3aSAmit Arora WARN_ON(eh->eh_entries == 0); 158356055d3aSAmit Arora if (!eh->eh_entries) 158424676da4STheodore Ts'o EXT4_ERROR_INODE(inode, "eh->eh_entries = 0!"); 158556055d3aSAmit Arora } 158656055d3aSAmit Arora 158756055d3aSAmit Arora return merge_done; 158856055d3aSAmit Arora } 158956055d3aSAmit Arora 159056055d3aSAmit Arora /* 1591197217a5SYongqiang Yang * This function tries to merge the @ex extent to neighbours in the tree. 1592197217a5SYongqiang Yang * return 1 if merge left else 0. 1593197217a5SYongqiang Yang */ 1594197217a5SYongqiang Yang static int ext4_ext_try_to_merge(struct inode *inode, 1595197217a5SYongqiang Yang struct ext4_ext_path *path, 1596197217a5SYongqiang Yang struct ext4_extent *ex) { 1597197217a5SYongqiang Yang struct ext4_extent_header *eh; 1598197217a5SYongqiang Yang unsigned int depth; 1599197217a5SYongqiang Yang int merge_done = 0; 1600197217a5SYongqiang Yang int ret = 0; 1601197217a5SYongqiang Yang 1602197217a5SYongqiang Yang depth = ext_depth(inode); 1603197217a5SYongqiang Yang BUG_ON(path[depth].p_hdr == NULL); 1604197217a5SYongqiang Yang eh = path[depth].p_hdr; 1605197217a5SYongqiang Yang 1606197217a5SYongqiang Yang if (ex > EXT_FIRST_EXTENT(eh)) 1607197217a5SYongqiang Yang merge_done = ext4_ext_try_to_merge_right(inode, path, ex - 1); 1608197217a5SYongqiang Yang 1609197217a5SYongqiang Yang if (!merge_done) 1610197217a5SYongqiang Yang ret = ext4_ext_try_to_merge_right(inode, path, ex); 1611197217a5SYongqiang Yang 1612197217a5SYongqiang Yang return ret; 1613197217a5SYongqiang Yang } 1614197217a5SYongqiang Yang 1615197217a5SYongqiang Yang /* 161625d14f98SAmit Arora * check if a portion of the "newext" extent overlaps with an 161725d14f98SAmit Arora * existing extent. 161825d14f98SAmit Arora * 161925d14f98SAmit Arora * If there is an overlap discovered, it updates the length of the newext 162025d14f98SAmit Arora * such that there will be no overlap, and then returns 1. 162125d14f98SAmit Arora * If there is no overlap found, it returns 0. 162225d14f98SAmit Arora */ 16234d33b1efSTheodore Ts'o static unsigned int ext4_ext_check_overlap(struct ext4_sb_info *sbi, 16244d33b1efSTheodore Ts'o struct inode *inode, 162525d14f98SAmit Arora struct ext4_extent *newext, 162625d14f98SAmit Arora struct ext4_ext_path *path) 162725d14f98SAmit Arora { 1628725d26d3SAneesh Kumar K.V ext4_lblk_t b1, b2; 162925d14f98SAmit Arora unsigned int depth, len1; 163025d14f98SAmit Arora unsigned int ret = 0; 163125d14f98SAmit Arora 163225d14f98SAmit Arora b1 = le32_to_cpu(newext->ee_block); 1633a2df2a63SAmit Arora len1 = ext4_ext_get_actual_len(newext); 163425d14f98SAmit Arora depth = ext_depth(inode); 163525d14f98SAmit Arora if (!path[depth].p_ext) 163625d14f98SAmit Arora goto out; 163725d14f98SAmit Arora b2 = le32_to_cpu(path[depth].p_ext->ee_block); 16384d33b1efSTheodore Ts'o b2 &= ~(sbi->s_cluster_ratio - 1); 163925d14f98SAmit Arora 164025d14f98SAmit Arora /* 164125d14f98SAmit Arora * get the next allocated block if the extent in the path 164225d14f98SAmit Arora * is before the requested block(s) 164325d14f98SAmit Arora */ 164425d14f98SAmit Arora if (b2 < b1) { 164525d14f98SAmit Arora b2 = ext4_ext_next_allocated_block(path); 1646f17722f9SLukas Czerner if (b2 == EXT_MAX_BLOCKS) 164725d14f98SAmit Arora goto out; 16484d33b1efSTheodore Ts'o b2 &= ~(sbi->s_cluster_ratio - 1); 164925d14f98SAmit Arora } 165025d14f98SAmit Arora 1651725d26d3SAneesh Kumar K.V /* check for wrap through zero on extent logical start block*/ 165225d14f98SAmit Arora if (b1 + len1 < b1) { 1653f17722f9SLukas Czerner len1 = EXT_MAX_BLOCKS - b1; 165425d14f98SAmit Arora newext->ee_len = cpu_to_le16(len1); 165525d14f98SAmit Arora ret = 1; 165625d14f98SAmit Arora } 165725d14f98SAmit Arora 165825d14f98SAmit Arora /* check for overlap */ 165925d14f98SAmit Arora if (b1 + len1 > b2) { 166025d14f98SAmit Arora newext->ee_len = cpu_to_le16(b2 - b1); 166125d14f98SAmit Arora ret = 1; 166225d14f98SAmit Arora } 166325d14f98SAmit Arora out: 166425d14f98SAmit Arora return ret; 166525d14f98SAmit Arora } 166625d14f98SAmit Arora 166725d14f98SAmit Arora /* 1668d0d856e8SRandy Dunlap * ext4_ext_insert_extent: 1669d0d856e8SRandy Dunlap * tries to merge requsted extent into the existing extent or 1670d0d856e8SRandy Dunlap * inserts requested extent as new one into the tree, 1671d0d856e8SRandy Dunlap * creating new leaf in the no-space case. 1672a86c6181SAlex Tomas */ 1673a86c6181SAlex Tomas int ext4_ext_insert_extent(handle_t *handle, struct inode *inode, 1674a86c6181SAlex Tomas struct ext4_ext_path *path, 16750031462bSMingming Cao struct ext4_extent *newext, int flag) 1676a86c6181SAlex Tomas { 1677a86c6181SAlex Tomas struct ext4_extent_header *eh; 1678a86c6181SAlex Tomas struct ext4_extent *ex, *fex; 1679a86c6181SAlex Tomas struct ext4_extent *nearex; /* nearest extent */ 1680a86c6181SAlex Tomas struct ext4_ext_path *npath = NULL; 1681725d26d3SAneesh Kumar K.V int depth, len, err; 1682725d26d3SAneesh Kumar K.V ext4_lblk_t next; 1683a2df2a63SAmit Arora unsigned uninitialized = 0; 168455f020dbSAllison Henderson int flags = 0; 1685a86c6181SAlex Tomas 1686273df556SFrank Mayhar if (unlikely(ext4_ext_get_actual_len(newext) == 0)) { 1687273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "ext4_ext_get_actual_len(newext) == 0"); 1688273df556SFrank Mayhar return -EIO; 1689273df556SFrank Mayhar } 1690a86c6181SAlex Tomas depth = ext_depth(inode); 1691a86c6181SAlex Tomas ex = path[depth].p_ext; 1692273df556SFrank Mayhar if (unlikely(path[depth].p_hdr == NULL)) { 1693273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth); 1694273df556SFrank Mayhar return -EIO; 1695273df556SFrank Mayhar } 1696a86c6181SAlex Tomas 1697a86c6181SAlex Tomas /* try to insert block into found extent and return */ 1698744692dcSJiaying Zhang if (ex && !(flag & EXT4_GET_BLOCKS_PRE_IO) 16990031462bSMingming Cao && ext4_can_extents_be_merged(inode, ex, newext)) { 1700553f9008SMingming ext_debug("append [%d]%d block to %d:[%d]%d (from %llu)\n", 1701553f9008SMingming ext4_ext_is_uninitialized(newext), 1702a2df2a63SAmit Arora ext4_ext_get_actual_len(newext), 1703a86c6181SAlex Tomas le32_to_cpu(ex->ee_block), 1704553f9008SMingming ext4_ext_is_uninitialized(ex), 1705bf89d16fSTheodore Ts'o ext4_ext_get_actual_len(ex), 1706bf89d16fSTheodore Ts'o ext4_ext_pblock(ex)); 17077e028976SAvantika Mathur err = ext4_ext_get_access(handle, inode, path + depth); 17087e028976SAvantika Mathur if (err) 1709a86c6181SAlex Tomas return err; 1710a2df2a63SAmit Arora 1711a2df2a63SAmit Arora /* 1712a2df2a63SAmit Arora * ext4_can_extents_be_merged should have checked that either 1713a2df2a63SAmit Arora * both extents are uninitialized, or both aren't. Thus we 1714a2df2a63SAmit Arora * need to check only one of them here. 1715a2df2a63SAmit Arora */ 1716a2df2a63SAmit Arora if (ext4_ext_is_uninitialized(ex)) 1717a2df2a63SAmit Arora uninitialized = 1; 1718a2df2a63SAmit Arora ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex) 1719a2df2a63SAmit Arora + ext4_ext_get_actual_len(newext)); 1720a2df2a63SAmit Arora if (uninitialized) 1721a2df2a63SAmit Arora ext4_ext_mark_uninitialized(ex); 1722a86c6181SAlex Tomas eh = path[depth].p_hdr; 1723a86c6181SAlex Tomas nearex = ex; 1724a86c6181SAlex Tomas goto merge; 1725a86c6181SAlex Tomas } 1726a86c6181SAlex Tomas 1727a86c6181SAlex Tomas depth = ext_depth(inode); 1728a86c6181SAlex Tomas eh = path[depth].p_hdr; 1729a86c6181SAlex Tomas if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max)) 1730a86c6181SAlex Tomas goto has_space; 1731a86c6181SAlex Tomas 1732a86c6181SAlex Tomas /* probably next leaf has space for us? */ 1733a86c6181SAlex Tomas fex = EXT_LAST_EXTENT(eh); 1734598dbdf2SRobin Dong next = EXT_MAX_BLOCKS; 1735598dbdf2SRobin Dong if (le32_to_cpu(newext->ee_block) > le32_to_cpu(fex->ee_block)) 17365718789dSRobin Dong next = ext4_ext_next_leaf_block(path); 1737598dbdf2SRobin Dong if (next != EXT_MAX_BLOCKS) { 1738a86c6181SAlex Tomas ext_debug("next leaf block - %d\n", next); 1739a86c6181SAlex Tomas BUG_ON(npath != NULL); 1740a86c6181SAlex Tomas npath = ext4_ext_find_extent(inode, next, NULL); 1741a86c6181SAlex Tomas if (IS_ERR(npath)) 1742a86c6181SAlex Tomas return PTR_ERR(npath); 1743a86c6181SAlex Tomas BUG_ON(npath->p_depth != path->p_depth); 1744a86c6181SAlex Tomas eh = npath[depth].p_hdr; 1745a86c6181SAlex Tomas if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max)) { 174625985edcSLucas De Marchi ext_debug("next leaf isn't full(%d)\n", 1747a86c6181SAlex Tomas le16_to_cpu(eh->eh_entries)); 1748a86c6181SAlex Tomas path = npath; 1749ffb505ffSRobin Dong goto has_space; 1750a86c6181SAlex Tomas } 1751a86c6181SAlex Tomas ext_debug("next leaf has no free space(%d,%d)\n", 1752a86c6181SAlex Tomas le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max)); 1753a86c6181SAlex Tomas } 1754a86c6181SAlex Tomas 1755a86c6181SAlex Tomas /* 1756d0d856e8SRandy Dunlap * There is no free space in the found leaf. 1757d0d856e8SRandy Dunlap * We're gonna add a new leaf in the tree. 1758a86c6181SAlex Tomas */ 175955f020dbSAllison Henderson if (flag & EXT4_GET_BLOCKS_PUNCH_OUT_EXT) 176055f020dbSAllison Henderson flags = EXT4_MB_USE_ROOT_BLOCKS; 176155f020dbSAllison Henderson err = ext4_ext_create_new_leaf(handle, inode, flags, path, newext); 1762a86c6181SAlex Tomas if (err) 1763a86c6181SAlex Tomas goto cleanup; 1764a86c6181SAlex Tomas depth = ext_depth(inode); 1765a86c6181SAlex Tomas eh = path[depth].p_hdr; 1766a86c6181SAlex Tomas 1767a86c6181SAlex Tomas has_space: 1768a86c6181SAlex Tomas nearex = path[depth].p_ext; 1769a86c6181SAlex Tomas 17707e028976SAvantika Mathur err = ext4_ext_get_access(handle, inode, path + depth); 17717e028976SAvantika Mathur if (err) 1772a86c6181SAlex Tomas goto cleanup; 1773a86c6181SAlex Tomas 1774a86c6181SAlex Tomas if (!nearex) { 1775a86c6181SAlex Tomas /* there is no extent in this leaf, create first one */ 1776553f9008SMingming ext_debug("first extent in the leaf: %d:%llu:[%d]%d\n", 1777a86c6181SAlex Tomas le32_to_cpu(newext->ee_block), 1778bf89d16fSTheodore Ts'o ext4_ext_pblock(newext), 1779553f9008SMingming ext4_ext_is_uninitialized(newext), 1780a2df2a63SAmit Arora ext4_ext_get_actual_len(newext)); 1781a86c6181SAlex Tomas path[depth].p_ext = EXT_FIRST_EXTENT(eh); 1782a86c6181SAlex Tomas } else if (le32_to_cpu(newext->ee_block) 1783a86c6181SAlex Tomas > le32_to_cpu(nearex->ee_block)) { 1784a86c6181SAlex Tomas /* BUG_ON(newext->ee_block == nearex->ee_block); */ 1785a86c6181SAlex Tomas if (nearex != EXT_LAST_EXTENT(eh)) { 1786a86c6181SAlex Tomas len = EXT_MAX_EXTENT(eh) - nearex; 1787a86c6181SAlex Tomas len = (len - 1) * sizeof(struct ext4_extent); 1788a86c6181SAlex Tomas len = len < 0 ? 0 : len; 1789553f9008SMingming ext_debug("insert %d:%llu:[%d]%d after: nearest 0x%p, " 1790a86c6181SAlex Tomas "move %d from 0x%p to 0x%p\n", 1791a86c6181SAlex Tomas le32_to_cpu(newext->ee_block), 1792bf89d16fSTheodore Ts'o ext4_ext_pblock(newext), 1793553f9008SMingming ext4_ext_is_uninitialized(newext), 1794a2df2a63SAmit Arora ext4_ext_get_actual_len(newext), 1795a86c6181SAlex Tomas nearex, len, nearex + 1, nearex + 2); 1796a86c6181SAlex Tomas memmove(nearex + 2, nearex + 1, len); 1797a86c6181SAlex Tomas } 1798a86c6181SAlex Tomas path[depth].p_ext = nearex + 1; 1799a86c6181SAlex Tomas } else { 1800a86c6181SAlex Tomas BUG_ON(newext->ee_block == nearex->ee_block); 1801a86c6181SAlex Tomas len = (EXT_MAX_EXTENT(eh) - nearex) * sizeof(struct ext4_extent); 1802a86c6181SAlex Tomas len = len < 0 ? 0 : len; 1803553f9008SMingming ext_debug("insert %d:%llu:[%d]%d before: nearest 0x%p, " 1804a86c6181SAlex Tomas "move %d from 0x%p to 0x%p\n", 1805a86c6181SAlex Tomas le32_to_cpu(newext->ee_block), 1806bf89d16fSTheodore Ts'o ext4_ext_pblock(newext), 1807553f9008SMingming ext4_ext_is_uninitialized(newext), 1808a2df2a63SAmit Arora ext4_ext_get_actual_len(newext), 18090737964bSRobin Dong nearex, len, nearex, nearex + 1); 1810a86c6181SAlex Tomas memmove(nearex + 1, nearex, len); 1811a86c6181SAlex Tomas path[depth].p_ext = nearex; 1812a86c6181SAlex Tomas } 1813a86c6181SAlex Tomas 1814e8546d06SMarcin Slusarz le16_add_cpu(&eh->eh_entries, 1); 1815a86c6181SAlex Tomas nearex = path[depth].p_ext; 1816a86c6181SAlex Tomas nearex->ee_block = newext->ee_block; 1817bf89d16fSTheodore Ts'o ext4_ext_store_pblock(nearex, ext4_ext_pblock(newext)); 1818a86c6181SAlex Tomas nearex->ee_len = newext->ee_len; 1819a86c6181SAlex Tomas 1820a86c6181SAlex Tomas merge: 1821a86c6181SAlex Tomas /* try to merge extents to the right */ 1822744692dcSJiaying Zhang if (!(flag & EXT4_GET_BLOCKS_PRE_IO)) 182356055d3aSAmit Arora ext4_ext_try_to_merge(inode, path, nearex); 1824a86c6181SAlex Tomas 1825a86c6181SAlex Tomas /* try to merge extents to the left */ 1826a86c6181SAlex Tomas 1827a86c6181SAlex Tomas /* time to correct all indexes above */ 1828a86c6181SAlex Tomas err = ext4_ext_correct_indexes(handle, inode, path); 1829a86c6181SAlex Tomas if (err) 1830a86c6181SAlex Tomas goto cleanup; 1831a86c6181SAlex Tomas 1832a86c6181SAlex Tomas err = ext4_ext_dirty(handle, inode, path + depth); 1833a86c6181SAlex Tomas 1834a86c6181SAlex Tomas cleanup: 1835a86c6181SAlex Tomas if (npath) { 1836a86c6181SAlex Tomas ext4_ext_drop_refs(npath); 1837a86c6181SAlex Tomas kfree(npath); 1838a86c6181SAlex Tomas } 1839a86c6181SAlex Tomas ext4_ext_invalidate_cache(inode); 1840a86c6181SAlex Tomas return err; 1841a86c6181SAlex Tomas } 1842a86c6181SAlex Tomas 18431f109d5aSTheodore Ts'o static int ext4_ext_walk_space(struct inode *inode, ext4_lblk_t block, 18446873fa0dSEric Sandeen ext4_lblk_t num, ext_prepare_callback func, 18456873fa0dSEric Sandeen void *cbdata) 18466873fa0dSEric Sandeen { 18476873fa0dSEric Sandeen struct ext4_ext_path *path = NULL; 18486873fa0dSEric Sandeen struct ext4_ext_cache cbex; 18496873fa0dSEric Sandeen struct ext4_extent *ex; 18506873fa0dSEric Sandeen ext4_lblk_t next, start = 0, end = 0; 18516873fa0dSEric Sandeen ext4_lblk_t last = block + num; 18526873fa0dSEric Sandeen int depth, exists, err = 0; 18536873fa0dSEric Sandeen 18546873fa0dSEric Sandeen BUG_ON(func == NULL); 18556873fa0dSEric Sandeen BUG_ON(inode == NULL); 18566873fa0dSEric Sandeen 1857f17722f9SLukas Czerner while (block < last && block != EXT_MAX_BLOCKS) { 18586873fa0dSEric Sandeen num = last - block; 18596873fa0dSEric Sandeen /* find extent for this block */ 1860fab3a549STheodore Ts'o down_read(&EXT4_I(inode)->i_data_sem); 18616873fa0dSEric Sandeen path = ext4_ext_find_extent(inode, block, path); 1862fab3a549STheodore Ts'o up_read(&EXT4_I(inode)->i_data_sem); 18636873fa0dSEric Sandeen if (IS_ERR(path)) { 18646873fa0dSEric Sandeen err = PTR_ERR(path); 18656873fa0dSEric Sandeen path = NULL; 18666873fa0dSEric Sandeen break; 18676873fa0dSEric Sandeen } 18686873fa0dSEric Sandeen 18696873fa0dSEric Sandeen depth = ext_depth(inode); 1870273df556SFrank Mayhar if (unlikely(path[depth].p_hdr == NULL)) { 1871273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth); 1872273df556SFrank Mayhar err = -EIO; 1873273df556SFrank Mayhar break; 1874273df556SFrank Mayhar } 18756873fa0dSEric Sandeen ex = path[depth].p_ext; 18766873fa0dSEric Sandeen next = ext4_ext_next_allocated_block(path); 18776873fa0dSEric Sandeen 18786873fa0dSEric Sandeen exists = 0; 18796873fa0dSEric Sandeen if (!ex) { 18806873fa0dSEric Sandeen /* there is no extent yet, so try to allocate 18816873fa0dSEric Sandeen * all requested space */ 18826873fa0dSEric Sandeen start = block; 18836873fa0dSEric Sandeen end = block + num; 18846873fa0dSEric Sandeen } else if (le32_to_cpu(ex->ee_block) > block) { 18856873fa0dSEric Sandeen /* need to allocate space before found extent */ 18866873fa0dSEric Sandeen start = block; 18876873fa0dSEric Sandeen end = le32_to_cpu(ex->ee_block); 18886873fa0dSEric Sandeen if (block + num < end) 18896873fa0dSEric Sandeen end = block + num; 18906873fa0dSEric Sandeen } else if (block >= le32_to_cpu(ex->ee_block) 18916873fa0dSEric Sandeen + ext4_ext_get_actual_len(ex)) { 18926873fa0dSEric Sandeen /* need to allocate space after found extent */ 18936873fa0dSEric Sandeen start = block; 18946873fa0dSEric Sandeen end = block + num; 18956873fa0dSEric Sandeen if (end >= next) 18966873fa0dSEric Sandeen end = next; 18976873fa0dSEric Sandeen } else if (block >= le32_to_cpu(ex->ee_block)) { 18986873fa0dSEric Sandeen /* 18996873fa0dSEric Sandeen * some part of requested space is covered 19006873fa0dSEric Sandeen * by found extent 19016873fa0dSEric Sandeen */ 19026873fa0dSEric Sandeen start = block; 19036873fa0dSEric Sandeen end = le32_to_cpu(ex->ee_block) 19046873fa0dSEric Sandeen + ext4_ext_get_actual_len(ex); 19056873fa0dSEric Sandeen if (block + num < end) 19066873fa0dSEric Sandeen end = block + num; 19076873fa0dSEric Sandeen exists = 1; 19086873fa0dSEric Sandeen } else { 19096873fa0dSEric Sandeen BUG(); 19106873fa0dSEric Sandeen } 19116873fa0dSEric Sandeen BUG_ON(end <= start); 19126873fa0dSEric Sandeen 19136873fa0dSEric Sandeen if (!exists) { 19146873fa0dSEric Sandeen cbex.ec_block = start; 19156873fa0dSEric Sandeen cbex.ec_len = end - start; 19166873fa0dSEric Sandeen cbex.ec_start = 0; 19176873fa0dSEric Sandeen } else { 19186873fa0dSEric Sandeen cbex.ec_block = le32_to_cpu(ex->ee_block); 19196873fa0dSEric Sandeen cbex.ec_len = ext4_ext_get_actual_len(ex); 1920bf89d16fSTheodore Ts'o cbex.ec_start = ext4_ext_pblock(ex); 19216873fa0dSEric Sandeen } 19226873fa0dSEric Sandeen 1923273df556SFrank Mayhar if (unlikely(cbex.ec_len == 0)) { 1924273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "cbex.ec_len == 0"); 1925273df556SFrank Mayhar err = -EIO; 1926273df556SFrank Mayhar break; 1927273df556SFrank Mayhar } 1928c03f8aa9SLukas Czerner err = func(inode, next, &cbex, ex, cbdata); 19296873fa0dSEric Sandeen ext4_ext_drop_refs(path); 19306873fa0dSEric Sandeen 19316873fa0dSEric Sandeen if (err < 0) 19326873fa0dSEric Sandeen break; 19336873fa0dSEric Sandeen 19346873fa0dSEric Sandeen if (err == EXT_REPEAT) 19356873fa0dSEric Sandeen continue; 19366873fa0dSEric Sandeen else if (err == EXT_BREAK) { 19376873fa0dSEric Sandeen err = 0; 19386873fa0dSEric Sandeen break; 19396873fa0dSEric Sandeen } 19406873fa0dSEric Sandeen 19416873fa0dSEric Sandeen if (ext_depth(inode) != depth) { 19426873fa0dSEric Sandeen /* depth was changed. we have to realloc path */ 19436873fa0dSEric Sandeen kfree(path); 19446873fa0dSEric Sandeen path = NULL; 19456873fa0dSEric Sandeen } 19466873fa0dSEric Sandeen 19476873fa0dSEric Sandeen block = cbex.ec_block + cbex.ec_len; 19486873fa0dSEric Sandeen } 19496873fa0dSEric Sandeen 19506873fa0dSEric Sandeen if (path) { 19516873fa0dSEric Sandeen ext4_ext_drop_refs(path); 19526873fa0dSEric Sandeen kfree(path); 19536873fa0dSEric Sandeen } 19546873fa0dSEric Sandeen 19556873fa0dSEric Sandeen return err; 19566873fa0dSEric Sandeen } 19576873fa0dSEric Sandeen 195809b88252SAvantika Mathur static void 1959725d26d3SAneesh Kumar K.V ext4_ext_put_in_cache(struct inode *inode, ext4_lblk_t block, 1960b05e6ae5STheodore Ts'o __u32 len, ext4_fsblk_t start) 1961a86c6181SAlex Tomas { 1962a86c6181SAlex Tomas struct ext4_ext_cache *cex; 1963a86c6181SAlex Tomas BUG_ON(len == 0); 19642ec0ae3aSTheodore Ts'o spin_lock(&EXT4_I(inode)->i_block_reservation_lock); 1965d8990240SAditya Kali trace_ext4_ext_put_in_cache(inode, block, len, start); 1966a86c6181SAlex Tomas cex = &EXT4_I(inode)->i_cached_extent; 1967a86c6181SAlex Tomas cex->ec_block = block; 1968a86c6181SAlex Tomas cex->ec_len = len; 1969a86c6181SAlex Tomas cex->ec_start = start; 19702ec0ae3aSTheodore Ts'o spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 1971a86c6181SAlex Tomas } 1972a86c6181SAlex Tomas 1973a86c6181SAlex Tomas /* 1974d0d856e8SRandy Dunlap * ext4_ext_put_gap_in_cache: 1975d0d856e8SRandy Dunlap * calculate boundaries of the gap that the requested block fits into 1976a86c6181SAlex Tomas * and cache this gap 1977a86c6181SAlex Tomas */ 197809b88252SAvantika Mathur static void 1979a86c6181SAlex Tomas ext4_ext_put_gap_in_cache(struct inode *inode, struct ext4_ext_path *path, 1980725d26d3SAneesh Kumar K.V ext4_lblk_t block) 1981a86c6181SAlex Tomas { 1982a86c6181SAlex Tomas int depth = ext_depth(inode); 1983725d26d3SAneesh Kumar K.V unsigned long len; 1984725d26d3SAneesh Kumar K.V ext4_lblk_t lblock; 1985a86c6181SAlex Tomas struct ext4_extent *ex; 1986a86c6181SAlex Tomas 1987a86c6181SAlex Tomas ex = path[depth].p_ext; 1988a86c6181SAlex Tomas if (ex == NULL) { 1989a86c6181SAlex Tomas /* there is no extent yet, so gap is [0;-] */ 1990a86c6181SAlex Tomas lblock = 0; 1991f17722f9SLukas Czerner len = EXT_MAX_BLOCKS; 1992a86c6181SAlex Tomas ext_debug("cache gap(whole file):"); 1993a86c6181SAlex Tomas } else if (block < le32_to_cpu(ex->ee_block)) { 1994a86c6181SAlex Tomas lblock = block; 1995a86c6181SAlex Tomas len = le32_to_cpu(ex->ee_block) - block; 1996bba90743SEric Sandeen ext_debug("cache gap(before): %u [%u:%u]", 1997bba90743SEric Sandeen block, 1998bba90743SEric Sandeen le32_to_cpu(ex->ee_block), 1999bba90743SEric Sandeen ext4_ext_get_actual_len(ex)); 2000a86c6181SAlex Tomas } else if (block >= le32_to_cpu(ex->ee_block) 2001a2df2a63SAmit Arora + ext4_ext_get_actual_len(ex)) { 2002725d26d3SAneesh Kumar K.V ext4_lblk_t next; 2003a86c6181SAlex Tomas lblock = le32_to_cpu(ex->ee_block) 2004a2df2a63SAmit Arora + ext4_ext_get_actual_len(ex); 2005725d26d3SAneesh Kumar K.V 2006725d26d3SAneesh Kumar K.V next = ext4_ext_next_allocated_block(path); 2007bba90743SEric Sandeen ext_debug("cache gap(after): [%u:%u] %u", 2008bba90743SEric Sandeen le32_to_cpu(ex->ee_block), 2009bba90743SEric Sandeen ext4_ext_get_actual_len(ex), 2010bba90743SEric Sandeen block); 2011725d26d3SAneesh Kumar K.V BUG_ON(next == lblock); 2012725d26d3SAneesh Kumar K.V len = next - lblock; 2013a86c6181SAlex Tomas } else { 2014a86c6181SAlex Tomas lblock = len = 0; 2015a86c6181SAlex Tomas BUG(); 2016a86c6181SAlex Tomas } 2017a86c6181SAlex Tomas 2018bba90743SEric Sandeen ext_debug(" -> %u:%lu\n", lblock, len); 2019b05e6ae5STheodore Ts'o ext4_ext_put_in_cache(inode, lblock, len, 0); 2020a86c6181SAlex Tomas } 2021a86c6181SAlex Tomas 2022b05e6ae5STheodore Ts'o /* 2023b7ca1e8eSRobin Dong * ext4_ext_check_cache() 2024a4bb6b64SAllison Henderson * Checks to see if the given block is in the cache. 2025a4bb6b64SAllison Henderson * If it is, the cached extent is stored in the given 2026a4bb6b64SAllison Henderson * cache extent pointer. If the cached extent is a hole, 2027a4bb6b64SAllison Henderson * this routine should be used instead of 2028a4bb6b64SAllison Henderson * ext4_ext_in_cache if the calling function needs to 2029a4bb6b64SAllison Henderson * know the size of the hole. 2030a4bb6b64SAllison Henderson * 2031a4bb6b64SAllison Henderson * @inode: The files inode 2032a4bb6b64SAllison Henderson * @block: The block to look for in the cache 2033a4bb6b64SAllison Henderson * @ex: Pointer where the cached extent will be stored 2034a4bb6b64SAllison Henderson * if it contains block 2035a4bb6b64SAllison Henderson * 2036b05e6ae5STheodore Ts'o * Return 0 if cache is invalid; 1 if the cache is valid 2037b05e6ae5STheodore Ts'o */ 2038a4bb6b64SAllison Henderson static int ext4_ext_check_cache(struct inode *inode, ext4_lblk_t block, 2039a4bb6b64SAllison Henderson struct ext4_ext_cache *ex){ 2040a86c6181SAlex Tomas struct ext4_ext_cache *cex; 204177f4135fSVivek Haldar struct ext4_sb_info *sbi; 2042b05e6ae5STheodore Ts'o int ret = 0; 2043a86c6181SAlex Tomas 20442ec0ae3aSTheodore Ts'o /* 20452ec0ae3aSTheodore Ts'o * We borrow i_block_reservation_lock to protect i_cached_extent 20462ec0ae3aSTheodore Ts'o */ 20472ec0ae3aSTheodore Ts'o spin_lock(&EXT4_I(inode)->i_block_reservation_lock); 2048a86c6181SAlex Tomas cex = &EXT4_I(inode)->i_cached_extent; 204977f4135fSVivek Haldar sbi = EXT4_SB(inode->i_sb); 2050a86c6181SAlex Tomas 2051a86c6181SAlex Tomas /* has cache valid data? */ 2052b05e6ae5STheodore Ts'o if (cex->ec_len == 0) 20532ec0ae3aSTheodore Ts'o goto errout; 2054a86c6181SAlex Tomas 2055731eb1a0SAkinobu Mita if (in_range(block, cex->ec_block, cex->ec_len)) { 2056a4bb6b64SAllison Henderson memcpy(ex, cex, sizeof(struct ext4_ext_cache)); 2057bba90743SEric Sandeen ext_debug("%u cached by %u:%u:%llu\n", 2058bba90743SEric Sandeen block, 2059bba90743SEric Sandeen cex->ec_block, cex->ec_len, cex->ec_start); 2060b05e6ae5STheodore Ts'o ret = 1; 2061a86c6181SAlex Tomas } 20622ec0ae3aSTheodore Ts'o errout: 206377f4135fSVivek Haldar if (!ret) 206477f4135fSVivek Haldar sbi->extent_cache_misses++; 206577f4135fSVivek Haldar else 206677f4135fSVivek Haldar sbi->extent_cache_hits++; 2067d8990240SAditya Kali trace_ext4_ext_in_cache(inode, block, ret); 20682ec0ae3aSTheodore Ts'o spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 20692ec0ae3aSTheodore Ts'o return ret; 2070a86c6181SAlex Tomas } 2071a86c6181SAlex Tomas 2072a86c6181SAlex Tomas /* 2073a4bb6b64SAllison Henderson * ext4_ext_in_cache() 2074a4bb6b64SAllison Henderson * Checks to see if the given block is in the cache. 2075a4bb6b64SAllison Henderson * If it is, the cached extent is stored in the given 2076a4bb6b64SAllison Henderson * extent pointer. 2077a4bb6b64SAllison Henderson * 2078a4bb6b64SAllison Henderson * @inode: The files inode 2079a4bb6b64SAllison Henderson * @block: The block to look for in the cache 2080a4bb6b64SAllison Henderson * @ex: Pointer where the cached extent will be stored 2081a4bb6b64SAllison Henderson * if it contains block 2082a4bb6b64SAllison Henderson * 2083a4bb6b64SAllison Henderson * Return 0 if cache is invalid; 1 if the cache is valid 2084a4bb6b64SAllison Henderson */ 2085a4bb6b64SAllison Henderson static int 2086a4bb6b64SAllison Henderson ext4_ext_in_cache(struct inode *inode, ext4_lblk_t block, 2087a4bb6b64SAllison Henderson struct ext4_extent *ex) 2088a4bb6b64SAllison Henderson { 2089a4bb6b64SAllison Henderson struct ext4_ext_cache cex; 2090a4bb6b64SAllison Henderson int ret = 0; 2091a4bb6b64SAllison Henderson 2092a4bb6b64SAllison Henderson if (ext4_ext_check_cache(inode, block, &cex)) { 2093a4bb6b64SAllison Henderson ex->ee_block = cpu_to_le32(cex.ec_block); 2094a4bb6b64SAllison Henderson ext4_ext_store_pblock(ex, cex.ec_start); 2095a4bb6b64SAllison Henderson ex->ee_len = cpu_to_le16(cex.ec_len); 2096a4bb6b64SAllison Henderson ret = 1; 2097a4bb6b64SAllison Henderson } 2098a4bb6b64SAllison Henderson 2099a4bb6b64SAllison Henderson return ret; 2100a4bb6b64SAllison Henderson } 2101a4bb6b64SAllison Henderson 2102a4bb6b64SAllison Henderson 2103a4bb6b64SAllison Henderson /* 2104d0d856e8SRandy Dunlap * ext4_ext_rm_idx: 2105d0d856e8SRandy Dunlap * removes index from the index block. 2106a86c6181SAlex Tomas */ 21071d03ec98SAneesh Kumar K.V static int ext4_ext_rm_idx(handle_t *handle, struct inode *inode, 2108a86c6181SAlex Tomas struct ext4_ext_path *path) 2109a86c6181SAlex Tomas { 2110a86c6181SAlex Tomas int err; 2111f65e6fbaSAlex Tomas ext4_fsblk_t leaf; 2112a86c6181SAlex Tomas 2113a86c6181SAlex Tomas /* free index block */ 2114a86c6181SAlex Tomas path--; 2115bf89d16fSTheodore Ts'o leaf = ext4_idx_pblock(path->p_idx); 2116273df556SFrank Mayhar if (unlikely(path->p_hdr->eh_entries == 0)) { 2117273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "path->p_hdr->eh_entries == 0"); 2118273df556SFrank Mayhar return -EIO; 2119273df556SFrank Mayhar } 21207e028976SAvantika Mathur err = ext4_ext_get_access(handle, inode, path); 21217e028976SAvantika Mathur if (err) 2122a86c6181SAlex Tomas return err; 21230e1147b0SRobin Dong 21240e1147b0SRobin Dong if (path->p_idx != EXT_LAST_INDEX(path->p_hdr)) { 21250e1147b0SRobin Dong int len = EXT_LAST_INDEX(path->p_hdr) - path->p_idx; 21260e1147b0SRobin Dong len *= sizeof(struct ext4_extent_idx); 21270e1147b0SRobin Dong memmove(path->p_idx, path->p_idx + 1, len); 21280e1147b0SRobin Dong } 21290e1147b0SRobin Dong 2130e8546d06SMarcin Slusarz le16_add_cpu(&path->p_hdr->eh_entries, -1); 21317e028976SAvantika Mathur err = ext4_ext_dirty(handle, inode, path); 21327e028976SAvantika Mathur if (err) 2133a86c6181SAlex Tomas return err; 21342ae02107SMingming Cao ext_debug("index is empty, remove it, free block %llu\n", leaf); 2135d8990240SAditya Kali trace_ext4_ext_rm_idx(inode, leaf); 2136d8990240SAditya Kali 21377dc57615SPeter Huewe ext4_free_blocks(handle, inode, NULL, leaf, 1, 2138e6362609STheodore Ts'o EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET); 2139a86c6181SAlex Tomas return err; 2140a86c6181SAlex Tomas } 2141a86c6181SAlex Tomas 2142a86c6181SAlex Tomas /* 2143ee12b630SMingming Cao * ext4_ext_calc_credits_for_single_extent: 2144ee12b630SMingming Cao * This routine returns max. credits that needed to insert an extent 2145ee12b630SMingming Cao * to the extent tree. 2146ee12b630SMingming Cao * When pass the actual path, the caller should calculate credits 2147ee12b630SMingming Cao * under i_data_sem. 2148a86c6181SAlex Tomas */ 2149525f4ed8SMingming Cao int ext4_ext_calc_credits_for_single_extent(struct inode *inode, int nrblocks, 2150a86c6181SAlex Tomas struct ext4_ext_path *path) 2151a86c6181SAlex Tomas { 2152a86c6181SAlex Tomas if (path) { 2153ee12b630SMingming Cao int depth = ext_depth(inode); 2154f3bd1f3fSMingming Cao int ret = 0; 2155ee12b630SMingming Cao 2156a86c6181SAlex Tomas /* probably there is space in leaf? */ 2157a86c6181SAlex Tomas if (le16_to_cpu(path[depth].p_hdr->eh_entries) 2158ee12b630SMingming Cao < le16_to_cpu(path[depth].p_hdr->eh_max)) { 2159ee12b630SMingming Cao 2160ee12b630SMingming Cao /* 2161ee12b630SMingming Cao * There are some space in the leaf tree, no 2162ee12b630SMingming Cao * need to account for leaf block credit 2163ee12b630SMingming Cao * 2164ee12b630SMingming Cao * bitmaps and block group descriptor blocks 2165df3ab170STao Ma * and other metadata blocks still need to be 2166ee12b630SMingming Cao * accounted. 2167ee12b630SMingming Cao */ 2168525f4ed8SMingming Cao /* 1 bitmap, 1 block group descriptor */ 2169ee12b630SMingming Cao ret = 2 + EXT4_META_TRANS_BLOCKS(inode->i_sb); 21705887e98bSAneesh Kumar K.V return ret; 2171ee12b630SMingming Cao } 2172ee12b630SMingming Cao } 2173ee12b630SMingming Cao 2174525f4ed8SMingming Cao return ext4_chunk_trans_blocks(inode, nrblocks); 2175a86c6181SAlex Tomas } 2176a86c6181SAlex Tomas 2177a86c6181SAlex Tomas /* 2178ee12b630SMingming Cao * How many index/leaf blocks need to change/allocate to modify nrblocks? 2179ee12b630SMingming Cao * 2180ee12b630SMingming Cao * if nrblocks are fit in a single extent (chunk flag is 1), then 2181ee12b630SMingming Cao * in the worse case, each tree level index/leaf need to be changed 2182ee12b630SMingming Cao * if the tree split due to insert a new extent, then the old tree 2183ee12b630SMingming Cao * index/leaf need to be updated too 2184ee12b630SMingming Cao * 2185ee12b630SMingming Cao * If the nrblocks are discontiguous, they could cause 2186ee12b630SMingming Cao * the whole tree split more than once, but this is really rare. 2187a86c6181SAlex Tomas */ 2188525f4ed8SMingming Cao int ext4_ext_index_trans_blocks(struct inode *inode, int nrblocks, int chunk) 2189ee12b630SMingming Cao { 2190ee12b630SMingming Cao int index; 2191ee12b630SMingming Cao int depth = ext_depth(inode); 2192a86c6181SAlex Tomas 2193ee12b630SMingming Cao if (chunk) 2194ee12b630SMingming Cao index = depth * 2; 2195ee12b630SMingming Cao else 2196ee12b630SMingming Cao index = depth * 3; 2197a86c6181SAlex Tomas 2198ee12b630SMingming Cao return index; 2199a86c6181SAlex Tomas } 2200a86c6181SAlex Tomas 2201a86c6181SAlex Tomas static int ext4_remove_blocks(handle_t *handle, struct inode *inode, 2202a86c6181SAlex Tomas struct ext4_extent *ex, 22030aa06000STheodore Ts'o ext4_fsblk_t *partial_cluster, 2204725d26d3SAneesh Kumar K.V ext4_lblk_t from, ext4_lblk_t to) 2205a86c6181SAlex Tomas { 22060aa06000STheodore Ts'o struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 2207a2df2a63SAmit Arora unsigned short ee_len = ext4_ext_get_actual_len(ex); 22080aa06000STheodore Ts'o ext4_fsblk_t pblk; 2209e6362609STheodore Ts'o int flags = EXT4_FREE_BLOCKS_FORGET; 2210a86c6181SAlex Tomas 2211c9de560dSAlex Tomas if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) 2212e6362609STheodore Ts'o flags |= EXT4_FREE_BLOCKS_METADATA; 22130aa06000STheodore Ts'o /* 22140aa06000STheodore Ts'o * For bigalloc file systems, we never free a partial cluster 22150aa06000STheodore Ts'o * at the beginning of the extent. Instead, we make a note 22160aa06000STheodore Ts'o * that we tried freeing the cluster, and check to see if we 22170aa06000STheodore Ts'o * need to free it on a subsequent call to ext4_remove_blocks, 22180aa06000STheodore Ts'o * or at the end of the ext4_truncate() operation. 22190aa06000STheodore Ts'o */ 22200aa06000STheodore Ts'o flags |= EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER; 22210aa06000STheodore Ts'o 2222d8990240SAditya Kali trace_ext4_remove_blocks(inode, ex, from, to, *partial_cluster); 22230aa06000STheodore Ts'o /* 22240aa06000STheodore Ts'o * If we have a partial cluster, and it's different from the 22250aa06000STheodore Ts'o * cluster of the last block, we need to explicitly free the 22260aa06000STheodore Ts'o * partial cluster here. 22270aa06000STheodore Ts'o */ 22280aa06000STheodore Ts'o pblk = ext4_ext_pblock(ex) + ee_len - 1; 22290aa06000STheodore Ts'o if (*partial_cluster && (EXT4_B2C(sbi, pblk) != *partial_cluster)) { 22300aa06000STheodore Ts'o ext4_free_blocks(handle, inode, NULL, 22310aa06000STheodore Ts'o EXT4_C2B(sbi, *partial_cluster), 22320aa06000STheodore Ts'o sbi->s_cluster_ratio, flags); 22330aa06000STheodore Ts'o *partial_cluster = 0; 22340aa06000STheodore Ts'o } 22350aa06000STheodore Ts'o 2236a86c6181SAlex Tomas #ifdef EXTENTS_STATS 2237a86c6181SAlex Tomas { 2238a86c6181SAlex Tomas struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 2239a86c6181SAlex Tomas spin_lock(&sbi->s_ext_stats_lock); 2240a86c6181SAlex Tomas sbi->s_ext_blocks += ee_len; 2241a86c6181SAlex Tomas sbi->s_ext_extents++; 2242a86c6181SAlex Tomas if (ee_len < sbi->s_ext_min) 2243a86c6181SAlex Tomas sbi->s_ext_min = ee_len; 2244a86c6181SAlex Tomas if (ee_len > sbi->s_ext_max) 2245a86c6181SAlex Tomas sbi->s_ext_max = ee_len; 2246a86c6181SAlex Tomas if (ext_depth(inode) > sbi->s_depth_max) 2247a86c6181SAlex Tomas sbi->s_depth_max = ext_depth(inode); 2248a86c6181SAlex Tomas spin_unlock(&sbi->s_ext_stats_lock); 2249a86c6181SAlex Tomas } 2250a86c6181SAlex Tomas #endif 2251a86c6181SAlex Tomas if (from >= le32_to_cpu(ex->ee_block) 2252a2df2a63SAmit Arora && to == le32_to_cpu(ex->ee_block) + ee_len - 1) { 2253a86c6181SAlex Tomas /* tail removal */ 2254725d26d3SAneesh Kumar K.V ext4_lblk_t num; 2255725d26d3SAneesh Kumar K.V 2256a2df2a63SAmit Arora num = le32_to_cpu(ex->ee_block) + ee_len - from; 22570aa06000STheodore Ts'o pblk = ext4_ext_pblock(ex) + ee_len - num; 22580aa06000STheodore Ts'o ext_debug("free last %u blocks starting %llu\n", num, pblk); 22590aa06000STheodore Ts'o ext4_free_blocks(handle, inode, NULL, pblk, num, flags); 22600aa06000STheodore Ts'o /* 22610aa06000STheodore Ts'o * If the block range to be freed didn't start at the 22620aa06000STheodore Ts'o * beginning of a cluster, and we removed the entire 22630aa06000STheodore Ts'o * extent, save the partial cluster here, since we 22640aa06000STheodore Ts'o * might need to delete if we determine that the 22650aa06000STheodore Ts'o * truncate operation has removed all of the blocks in 22660aa06000STheodore Ts'o * the cluster. 22670aa06000STheodore Ts'o */ 22680aa06000STheodore Ts'o if (pblk & (sbi->s_cluster_ratio - 1) && 22690aa06000STheodore Ts'o (ee_len == num)) 22700aa06000STheodore Ts'o *partial_cluster = EXT4_B2C(sbi, pblk); 22710aa06000STheodore Ts'o else 22720aa06000STheodore Ts'o *partial_cluster = 0; 2273a86c6181SAlex Tomas } else if (from == le32_to_cpu(ex->ee_block) 2274a2df2a63SAmit Arora && to <= le32_to_cpu(ex->ee_block) + ee_len - 1) { 2275d583fb87SAllison Henderson /* head removal */ 2276d583fb87SAllison Henderson ext4_lblk_t num; 2277d583fb87SAllison Henderson ext4_fsblk_t start; 2278d583fb87SAllison Henderson 2279d583fb87SAllison Henderson num = to - from; 2280d583fb87SAllison Henderson start = ext4_ext_pblock(ex); 2281d583fb87SAllison Henderson 2282d583fb87SAllison Henderson ext_debug("free first %u blocks starting %llu\n", num, start); 2283ee90d57eSH Hartley Sweeten ext4_free_blocks(handle, inode, NULL, start, num, flags); 2284d583fb87SAllison Henderson 2285a86c6181SAlex Tomas } else { 2286725d26d3SAneesh Kumar K.V printk(KERN_INFO "strange request: removal(2) " 2287725d26d3SAneesh Kumar K.V "%u-%u from %u:%u\n", 2288a2df2a63SAmit Arora from, to, le32_to_cpu(ex->ee_block), ee_len); 2289a86c6181SAlex Tomas } 2290a86c6181SAlex Tomas return 0; 2291a86c6181SAlex Tomas } 2292a86c6181SAlex Tomas 2293d583fb87SAllison Henderson 2294d583fb87SAllison Henderson /* 2295d583fb87SAllison Henderson * ext4_ext_rm_leaf() Removes the extents associated with the 2296d583fb87SAllison Henderson * blocks appearing between "start" and "end", and splits the extents 2297d583fb87SAllison Henderson * if "start" and "end" appear in the same extent 2298d583fb87SAllison Henderson * 2299d583fb87SAllison Henderson * @handle: The journal handle 2300d583fb87SAllison Henderson * @inode: The files inode 2301d583fb87SAllison Henderson * @path: The path to the leaf 2302d583fb87SAllison Henderson * @start: The first block to remove 2303d583fb87SAllison Henderson * @end: The last block to remove 2304d583fb87SAllison Henderson */ 2305a86c6181SAlex Tomas static int 2306a86c6181SAlex Tomas ext4_ext_rm_leaf(handle_t *handle, struct inode *inode, 23070aa06000STheodore Ts'o struct ext4_ext_path *path, ext4_fsblk_t *partial_cluster, 23080aa06000STheodore Ts'o ext4_lblk_t start, ext4_lblk_t end) 2309a86c6181SAlex Tomas { 23100aa06000STheodore Ts'o struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 2311a86c6181SAlex Tomas int err = 0, correct_index = 0; 2312a86c6181SAlex Tomas int depth = ext_depth(inode), credits; 2313a86c6181SAlex Tomas struct ext4_extent_header *eh; 2314750c9c47SDmitry Monakhov ext4_lblk_t a, b; 2315725d26d3SAneesh Kumar K.V unsigned num; 2316725d26d3SAneesh Kumar K.V ext4_lblk_t ex_ee_block; 2317a86c6181SAlex Tomas unsigned short ex_ee_len; 2318a2df2a63SAmit Arora unsigned uninitialized = 0; 2319a86c6181SAlex Tomas struct ext4_extent *ex; 2320a86c6181SAlex Tomas 2321c29c0ae7SAlex Tomas /* the header must be checked already in ext4_ext_remove_space() */ 2322725d26d3SAneesh Kumar K.V ext_debug("truncate since %u in leaf\n", start); 2323a86c6181SAlex Tomas if (!path[depth].p_hdr) 2324a86c6181SAlex Tomas path[depth].p_hdr = ext_block_hdr(path[depth].p_bh); 2325a86c6181SAlex Tomas eh = path[depth].p_hdr; 2326273df556SFrank Mayhar if (unlikely(path[depth].p_hdr == NULL)) { 2327273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth); 2328273df556SFrank Mayhar return -EIO; 2329273df556SFrank Mayhar } 2330a86c6181SAlex Tomas /* find where to start removing */ 2331a86c6181SAlex Tomas ex = EXT_LAST_EXTENT(eh); 2332a86c6181SAlex Tomas 2333a86c6181SAlex Tomas ex_ee_block = le32_to_cpu(ex->ee_block); 2334a2df2a63SAmit Arora ex_ee_len = ext4_ext_get_actual_len(ex); 2335a86c6181SAlex Tomas 2336d8990240SAditya Kali trace_ext4_ext_rm_leaf(inode, start, ex, *partial_cluster); 2337d8990240SAditya Kali 2338a86c6181SAlex Tomas while (ex >= EXT_FIRST_EXTENT(eh) && 2339a86c6181SAlex Tomas ex_ee_block + ex_ee_len > start) { 2340a41f2071SAneesh Kumar K.V 2341a41f2071SAneesh Kumar K.V if (ext4_ext_is_uninitialized(ex)) 2342a41f2071SAneesh Kumar K.V uninitialized = 1; 2343a41f2071SAneesh Kumar K.V else 2344a41f2071SAneesh Kumar K.V uninitialized = 0; 2345a41f2071SAneesh Kumar K.V 2346553f9008SMingming ext_debug("remove ext %u:[%d]%d\n", ex_ee_block, 2347553f9008SMingming uninitialized, ex_ee_len); 2348a86c6181SAlex Tomas path[depth].p_ext = ex; 2349a86c6181SAlex Tomas 2350a86c6181SAlex Tomas a = ex_ee_block > start ? ex_ee_block : start; 2351d583fb87SAllison Henderson b = ex_ee_block+ex_ee_len - 1 < end ? 2352d583fb87SAllison Henderson ex_ee_block+ex_ee_len - 1 : end; 2353a86c6181SAlex Tomas 2354a86c6181SAlex Tomas ext_debug(" border %u:%u\n", a, b); 2355a86c6181SAlex Tomas 2356d583fb87SAllison Henderson /* If this extent is beyond the end of the hole, skip it */ 2357d583fb87SAllison Henderson if (end <= ex_ee_block) { 2358d583fb87SAllison Henderson ex--; 2359d583fb87SAllison Henderson ex_ee_block = le32_to_cpu(ex->ee_block); 2360d583fb87SAllison Henderson ex_ee_len = ext4_ext_get_actual_len(ex); 2361d583fb87SAllison Henderson continue; 2362750c9c47SDmitry Monakhov } else if (b != ex_ee_block + ex_ee_len - 1) { 2363750c9c47SDmitry Monakhov EXT4_ERROR_INODE(inode," bad truncate %u:%u\n", 2364d583fb87SAllison Henderson start, end); 2365d583fb87SAllison Henderson err = -EIO; 2366d583fb87SAllison Henderson goto out; 2367a86c6181SAlex Tomas } else if (a != ex_ee_block) { 2368a86c6181SAlex Tomas /* remove tail of the extent */ 2369750c9c47SDmitry Monakhov num = a - ex_ee_block; 2370a86c6181SAlex Tomas } else { 2371a86c6181SAlex Tomas /* remove whole extent: excellent! */ 2372a86c6181SAlex Tomas num = 0; 2373d583fb87SAllison Henderson } 237434071da7STheodore Ts'o /* 237534071da7STheodore Ts'o * 3 for leaf, sb, and inode plus 2 (bmap and group 237634071da7STheodore Ts'o * descriptor) for each block group; assume two block 237734071da7STheodore Ts'o * groups plus ex_ee_len/blocks_per_block_group for 237834071da7STheodore Ts'o * the worst case 237934071da7STheodore Ts'o */ 238034071da7STheodore Ts'o credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode->i_sb)); 2381a86c6181SAlex Tomas if (ex == EXT_FIRST_EXTENT(eh)) { 2382a86c6181SAlex Tomas correct_index = 1; 2383a86c6181SAlex Tomas credits += (ext_depth(inode)) + 1; 2384a86c6181SAlex Tomas } 23855aca07ebSDmitry Monakhov credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb); 2386a86c6181SAlex Tomas 2387487caeefSJan Kara err = ext4_ext_truncate_extend_restart(handle, inode, credits); 23889102e4faSShen Feng if (err) 2389a86c6181SAlex Tomas goto out; 2390a86c6181SAlex Tomas 2391a86c6181SAlex Tomas err = ext4_ext_get_access(handle, inode, path + depth); 2392a86c6181SAlex Tomas if (err) 2393a86c6181SAlex Tomas goto out; 2394a86c6181SAlex Tomas 23950aa06000STheodore Ts'o err = ext4_remove_blocks(handle, inode, ex, partial_cluster, 23960aa06000STheodore Ts'o a, b); 2397a86c6181SAlex Tomas if (err) 2398a86c6181SAlex Tomas goto out; 2399a86c6181SAlex Tomas 2400750c9c47SDmitry Monakhov if (num == 0) 2401d0d856e8SRandy Dunlap /* this extent is removed; mark slot entirely unused */ 2402f65e6fbaSAlex Tomas ext4_ext_store_pblock(ex, 0); 2403a86c6181SAlex Tomas 2404a86c6181SAlex Tomas ex->ee_len = cpu_to_le16(num); 2405749269faSAmit Arora /* 2406749269faSAmit Arora * Do not mark uninitialized if all the blocks in the 2407749269faSAmit Arora * extent have been removed. 2408749269faSAmit Arora */ 2409749269faSAmit Arora if (uninitialized && num) 2410a2df2a63SAmit Arora ext4_ext_mark_uninitialized(ex); 2411d583fb87SAllison Henderson /* 2412d583fb87SAllison Henderson * If the extent was completely released, 2413d583fb87SAllison Henderson * we need to remove it from the leaf 2414d583fb87SAllison Henderson */ 2415d583fb87SAllison Henderson if (num == 0) { 2416f17722f9SLukas Czerner if (end != EXT_MAX_BLOCKS - 1) { 2417d583fb87SAllison Henderson /* 2418d583fb87SAllison Henderson * For hole punching, we need to scoot all the 2419d583fb87SAllison Henderson * extents up when an extent is removed so that 2420d583fb87SAllison Henderson * we dont have blank extents in the middle 2421d583fb87SAllison Henderson */ 2422d583fb87SAllison Henderson memmove(ex, ex+1, (EXT_LAST_EXTENT(eh) - ex) * 2423d583fb87SAllison Henderson sizeof(struct ext4_extent)); 2424d583fb87SAllison Henderson 2425d583fb87SAllison Henderson /* Now get rid of the one at the end */ 2426d583fb87SAllison Henderson memset(EXT_LAST_EXTENT(eh), 0, 2427d583fb87SAllison Henderson sizeof(struct ext4_extent)); 2428d583fb87SAllison Henderson } 2429d583fb87SAllison Henderson le16_add_cpu(&eh->eh_entries, -1); 24300aa06000STheodore Ts'o } else 24310aa06000STheodore Ts'o *partial_cluster = 0; 2432d583fb87SAllison Henderson 2433750c9c47SDmitry Monakhov err = ext4_ext_dirty(handle, inode, path + depth); 2434750c9c47SDmitry Monakhov if (err) 2435750c9c47SDmitry Monakhov goto out; 2436750c9c47SDmitry Monakhov 24372ae02107SMingming Cao ext_debug("new extent: %u:%u:%llu\n", block, num, 2438bf89d16fSTheodore Ts'o ext4_ext_pblock(ex)); 2439a86c6181SAlex Tomas ex--; 2440a86c6181SAlex Tomas ex_ee_block = le32_to_cpu(ex->ee_block); 2441a2df2a63SAmit Arora ex_ee_len = ext4_ext_get_actual_len(ex); 2442a86c6181SAlex Tomas } 2443a86c6181SAlex Tomas 2444a86c6181SAlex Tomas if (correct_index && eh->eh_entries) 2445a86c6181SAlex Tomas err = ext4_ext_correct_indexes(handle, inode, path); 2446a86c6181SAlex Tomas 24470aa06000STheodore Ts'o /* 24480aa06000STheodore Ts'o * If there is still a entry in the leaf node, check to see if 24490aa06000STheodore Ts'o * it references the partial cluster. This is the only place 24500aa06000STheodore Ts'o * where it could; if it doesn't, we can free the cluster. 24510aa06000STheodore Ts'o */ 24520aa06000STheodore Ts'o if (*partial_cluster && ex >= EXT_FIRST_EXTENT(eh) && 24530aa06000STheodore Ts'o (EXT4_B2C(sbi, ext4_ext_pblock(ex) + ex_ee_len - 1) != 24540aa06000STheodore Ts'o *partial_cluster)) { 24550aa06000STheodore Ts'o int flags = EXT4_FREE_BLOCKS_FORGET; 24560aa06000STheodore Ts'o 24570aa06000STheodore Ts'o if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) 24580aa06000STheodore Ts'o flags |= EXT4_FREE_BLOCKS_METADATA; 24590aa06000STheodore Ts'o 24600aa06000STheodore Ts'o ext4_free_blocks(handle, inode, NULL, 24610aa06000STheodore Ts'o EXT4_C2B(sbi, *partial_cluster), 24620aa06000STheodore Ts'o sbi->s_cluster_ratio, flags); 24630aa06000STheodore Ts'o *partial_cluster = 0; 24640aa06000STheodore Ts'o } 24650aa06000STheodore Ts'o 2466a86c6181SAlex Tomas /* if this leaf is free, then we should 2467a86c6181SAlex Tomas * remove it from index block above */ 2468a86c6181SAlex Tomas if (err == 0 && eh->eh_entries == 0 && path[depth].p_bh != NULL) 2469a86c6181SAlex Tomas err = ext4_ext_rm_idx(handle, inode, path + depth); 2470a86c6181SAlex Tomas 2471a86c6181SAlex Tomas out: 2472a86c6181SAlex Tomas return err; 2473a86c6181SAlex Tomas } 2474a86c6181SAlex Tomas 2475a86c6181SAlex Tomas /* 2476d0d856e8SRandy Dunlap * ext4_ext_more_to_rm: 2477d0d856e8SRandy Dunlap * returns 1 if current index has to be freed (even partial) 2478a86c6181SAlex Tomas */ 247909b88252SAvantika Mathur static int 2480a86c6181SAlex Tomas ext4_ext_more_to_rm(struct ext4_ext_path *path) 2481a86c6181SAlex Tomas { 2482a86c6181SAlex Tomas BUG_ON(path->p_idx == NULL); 2483a86c6181SAlex Tomas 2484a86c6181SAlex Tomas if (path->p_idx < EXT_FIRST_INDEX(path->p_hdr)) 2485a86c6181SAlex Tomas return 0; 2486a86c6181SAlex Tomas 2487a86c6181SAlex Tomas /* 2488d0d856e8SRandy Dunlap * if truncate on deeper level happened, it wasn't partial, 2489a86c6181SAlex Tomas * so we have to consider current index for truncation 2490a86c6181SAlex Tomas */ 2491a86c6181SAlex Tomas if (le16_to_cpu(path->p_hdr->eh_entries) == path->p_block) 2492a86c6181SAlex Tomas return 0; 2493a86c6181SAlex Tomas return 1; 2494a86c6181SAlex Tomas } 2495a86c6181SAlex Tomas 2496c6a0371cSAllison Henderson static int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start) 2497a86c6181SAlex Tomas { 2498a86c6181SAlex Tomas struct super_block *sb = inode->i_sb; 2499a86c6181SAlex Tomas int depth = ext_depth(inode); 2500a86c6181SAlex Tomas struct ext4_ext_path *path; 25010aa06000STheodore Ts'o ext4_fsblk_t partial_cluster = 0; 2502a86c6181SAlex Tomas handle_t *handle; 25030617b83fSDmitry Monakhov int i, err; 2504a86c6181SAlex Tomas 2505725d26d3SAneesh Kumar K.V ext_debug("truncate since %u\n", start); 2506a86c6181SAlex Tomas 2507a86c6181SAlex Tomas /* probably first extent we're gonna free will be last in block */ 2508a86c6181SAlex Tomas handle = ext4_journal_start(inode, depth + 1); 2509a86c6181SAlex Tomas if (IS_ERR(handle)) 2510a86c6181SAlex Tomas return PTR_ERR(handle); 2511a86c6181SAlex Tomas 25120617b83fSDmitry Monakhov again: 2513a86c6181SAlex Tomas ext4_ext_invalidate_cache(inode); 2514a86c6181SAlex Tomas 2515d8990240SAditya Kali trace_ext4_ext_remove_space(inode, start, depth); 2516d8990240SAditya Kali 2517a86c6181SAlex Tomas /* 2518d0d856e8SRandy Dunlap * We start scanning from right side, freeing all the blocks 2519d0d856e8SRandy Dunlap * after i_size and walking into the tree depth-wise. 2520a86c6181SAlex Tomas */ 25210617b83fSDmitry Monakhov depth = ext_depth(inode); 2522216553c4SJosef Bacik path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 1), GFP_NOFS); 2523a86c6181SAlex Tomas if (path == NULL) { 2524a86c6181SAlex Tomas ext4_journal_stop(handle); 2525a86c6181SAlex Tomas return -ENOMEM; 2526a86c6181SAlex Tomas } 25270617b83fSDmitry Monakhov path[0].p_depth = depth; 2528a86c6181SAlex Tomas path[0].p_hdr = ext_inode_hdr(inode); 252956b19868SAneesh Kumar K.V if (ext4_ext_check(inode, path[0].p_hdr, depth)) { 2530a86c6181SAlex Tomas err = -EIO; 2531a86c6181SAlex Tomas goto out; 2532a86c6181SAlex Tomas } 25330617b83fSDmitry Monakhov i = err = 0; 2534a86c6181SAlex Tomas 2535a86c6181SAlex Tomas while (i >= 0 && err == 0) { 2536a86c6181SAlex Tomas if (i == depth) { 2537a86c6181SAlex Tomas /* this is leaf block */ 2538d583fb87SAllison Henderson err = ext4_ext_rm_leaf(handle, inode, path, 25390aa06000STheodore Ts'o &partial_cluster, start, 25400aa06000STheodore Ts'o EXT_MAX_BLOCKS - 1); 2541d0d856e8SRandy Dunlap /* root level has p_bh == NULL, brelse() eats this */ 2542a86c6181SAlex Tomas brelse(path[i].p_bh); 2543a86c6181SAlex Tomas path[i].p_bh = NULL; 2544a86c6181SAlex Tomas i--; 2545a86c6181SAlex Tomas continue; 2546a86c6181SAlex Tomas } 2547a86c6181SAlex Tomas 2548a86c6181SAlex Tomas /* this is index block */ 2549a86c6181SAlex Tomas if (!path[i].p_hdr) { 2550a86c6181SAlex Tomas ext_debug("initialize header\n"); 2551a86c6181SAlex Tomas path[i].p_hdr = ext_block_hdr(path[i].p_bh); 2552a86c6181SAlex Tomas } 2553a86c6181SAlex Tomas 2554a86c6181SAlex Tomas if (!path[i].p_idx) { 2555d0d856e8SRandy Dunlap /* this level hasn't been touched yet */ 2556a86c6181SAlex Tomas path[i].p_idx = EXT_LAST_INDEX(path[i].p_hdr); 2557a86c6181SAlex Tomas path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries)+1; 2558a86c6181SAlex Tomas ext_debug("init index ptr: hdr 0x%p, num %d\n", 2559a86c6181SAlex Tomas path[i].p_hdr, 2560a86c6181SAlex Tomas le16_to_cpu(path[i].p_hdr->eh_entries)); 2561a86c6181SAlex Tomas } else { 2562d0d856e8SRandy Dunlap /* we were already here, see at next index */ 2563a86c6181SAlex Tomas path[i].p_idx--; 2564a86c6181SAlex Tomas } 2565a86c6181SAlex Tomas 2566a86c6181SAlex Tomas ext_debug("level %d - index, first 0x%p, cur 0x%p\n", 2567a86c6181SAlex Tomas i, EXT_FIRST_INDEX(path[i].p_hdr), 2568a86c6181SAlex Tomas path[i].p_idx); 2569a86c6181SAlex Tomas if (ext4_ext_more_to_rm(path + i)) { 2570c29c0ae7SAlex Tomas struct buffer_head *bh; 2571a86c6181SAlex Tomas /* go to the next level */ 25722ae02107SMingming Cao ext_debug("move to level %d (block %llu)\n", 2573bf89d16fSTheodore Ts'o i + 1, ext4_idx_pblock(path[i].p_idx)); 2574a86c6181SAlex Tomas memset(path + i + 1, 0, sizeof(*path)); 2575bf89d16fSTheodore Ts'o bh = sb_bread(sb, ext4_idx_pblock(path[i].p_idx)); 2576c29c0ae7SAlex Tomas if (!bh) { 2577a86c6181SAlex Tomas /* should we reset i_size? */ 2578a86c6181SAlex Tomas err = -EIO; 2579a86c6181SAlex Tomas break; 2580a86c6181SAlex Tomas } 2581c29c0ae7SAlex Tomas if (WARN_ON(i + 1 > depth)) { 2582c29c0ae7SAlex Tomas err = -EIO; 2583c29c0ae7SAlex Tomas break; 2584c29c0ae7SAlex Tomas } 258556b19868SAneesh Kumar K.V if (ext4_ext_check(inode, ext_block_hdr(bh), 2586c29c0ae7SAlex Tomas depth - i - 1)) { 2587c29c0ae7SAlex Tomas err = -EIO; 2588c29c0ae7SAlex Tomas break; 2589c29c0ae7SAlex Tomas } 2590c29c0ae7SAlex Tomas path[i + 1].p_bh = bh; 2591a86c6181SAlex Tomas 2592d0d856e8SRandy Dunlap /* save actual number of indexes since this 2593d0d856e8SRandy Dunlap * number is changed at the next iteration */ 2594a86c6181SAlex Tomas path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries); 2595a86c6181SAlex Tomas i++; 2596a86c6181SAlex Tomas } else { 2597d0d856e8SRandy Dunlap /* we finished processing this index, go up */ 2598a86c6181SAlex Tomas if (path[i].p_hdr->eh_entries == 0 && i > 0) { 2599d0d856e8SRandy Dunlap /* index is empty, remove it; 2600a86c6181SAlex Tomas * handle must be already prepared by the 2601a86c6181SAlex Tomas * truncatei_leaf() */ 2602a86c6181SAlex Tomas err = ext4_ext_rm_idx(handle, inode, path + i); 2603a86c6181SAlex Tomas } 2604d0d856e8SRandy Dunlap /* root level has p_bh == NULL, brelse() eats this */ 2605a86c6181SAlex Tomas brelse(path[i].p_bh); 2606a86c6181SAlex Tomas path[i].p_bh = NULL; 2607a86c6181SAlex Tomas i--; 2608a86c6181SAlex Tomas ext_debug("return to level %d\n", i); 2609a86c6181SAlex Tomas } 2610a86c6181SAlex Tomas } 2611a86c6181SAlex Tomas 2612d8990240SAditya Kali trace_ext4_ext_remove_space_done(inode, start, depth, partial_cluster, 2613d8990240SAditya Kali path->p_hdr->eh_entries); 2614d8990240SAditya Kali 26157b415bf6SAditya Kali /* If we still have something in the partial cluster and we have removed 26167b415bf6SAditya Kali * even the first extent, then we should free the blocks in the partial 26177b415bf6SAditya Kali * cluster as well. */ 26187b415bf6SAditya Kali if (partial_cluster && path->p_hdr->eh_entries == 0) { 26197b415bf6SAditya Kali int flags = EXT4_FREE_BLOCKS_FORGET; 26207b415bf6SAditya Kali 26217b415bf6SAditya Kali if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) 26227b415bf6SAditya Kali flags |= EXT4_FREE_BLOCKS_METADATA; 26237b415bf6SAditya Kali 26247b415bf6SAditya Kali ext4_free_blocks(handle, inode, NULL, 26257b415bf6SAditya Kali EXT4_C2B(EXT4_SB(sb), partial_cluster), 26267b415bf6SAditya Kali EXT4_SB(sb)->s_cluster_ratio, flags); 26277b415bf6SAditya Kali partial_cluster = 0; 26287b415bf6SAditya Kali } 26297b415bf6SAditya Kali 2630a86c6181SAlex Tomas /* TODO: flexible tree reduction should be here */ 2631a86c6181SAlex Tomas if (path->p_hdr->eh_entries == 0) { 2632a86c6181SAlex Tomas /* 2633d0d856e8SRandy Dunlap * truncate to zero freed all the tree, 2634d0d856e8SRandy Dunlap * so we need to correct eh_depth 2635a86c6181SAlex Tomas */ 2636a86c6181SAlex Tomas err = ext4_ext_get_access(handle, inode, path); 2637a86c6181SAlex Tomas if (err == 0) { 2638a86c6181SAlex Tomas ext_inode_hdr(inode)->eh_depth = 0; 2639a86c6181SAlex Tomas ext_inode_hdr(inode)->eh_max = 264055ad63bfSTheodore Ts'o cpu_to_le16(ext4_ext_space_root(inode, 0)); 2641a86c6181SAlex Tomas err = ext4_ext_dirty(handle, inode, path); 2642a86c6181SAlex Tomas } 2643a86c6181SAlex Tomas } 2644a86c6181SAlex Tomas out: 2645a86c6181SAlex Tomas ext4_ext_drop_refs(path); 2646a86c6181SAlex Tomas kfree(path); 26470617b83fSDmitry Monakhov if (err == -EAGAIN) 26480617b83fSDmitry Monakhov goto again; 2649a86c6181SAlex Tomas ext4_journal_stop(handle); 2650a86c6181SAlex Tomas 2651a86c6181SAlex Tomas return err; 2652a86c6181SAlex Tomas } 2653a86c6181SAlex Tomas 2654a86c6181SAlex Tomas /* 2655a86c6181SAlex Tomas * called at mount time 2656a86c6181SAlex Tomas */ 2657a86c6181SAlex Tomas void ext4_ext_init(struct super_block *sb) 2658a86c6181SAlex Tomas { 2659a86c6181SAlex Tomas /* 2660a86c6181SAlex Tomas * possible initialization would be here 2661a86c6181SAlex Tomas */ 2662a86c6181SAlex Tomas 266383982b6fSTheodore Ts'o if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS)) { 266490576c0bSTheodore Ts'o #if defined(AGGRESSIVE_TEST) || defined(CHECK_BINSEARCH) || defined(EXTENTS_STATS) 26654776004fSTheodore Ts'o printk(KERN_INFO "EXT4-fs: file extents enabled"); 2666bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST 2667bbf2f9fbSRobert P. J. Day printk(", aggressive tests"); 2668a86c6181SAlex Tomas #endif 2669a86c6181SAlex Tomas #ifdef CHECK_BINSEARCH 2670a86c6181SAlex Tomas printk(", check binsearch"); 2671a86c6181SAlex Tomas #endif 2672a86c6181SAlex Tomas #ifdef EXTENTS_STATS 2673a86c6181SAlex Tomas printk(", stats"); 2674a86c6181SAlex Tomas #endif 2675a86c6181SAlex Tomas printk("\n"); 267690576c0bSTheodore Ts'o #endif 2677a86c6181SAlex Tomas #ifdef EXTENTS_STATS 2678a86c6181SAlex Tomas spin_lock_init(&EXT4_SB(sb)->s_ext_stats_lock); 2679a86c6181SAlex Tomas EXT4_SB(sb)->s_ext_min = 1 << 30; 2680a86c6181SAlex Tomas EXT4_SB(sb)->s_ext_max = 0; 2681a86c6181SAlex Tomas #endif 2682a86c6181SAlex Tomas } 2683a86c6181SAlex Tomas } 2684a86c6181SAlex Tomas 2685a86c6181SAlex Tomas /* 2686a86c6181SAlex Tomas * called at umount time 2687a86c6181SAlex Tomas */ 2688a86c6181SAlex Tomas void ext4_ext_release(struct super_block *sb) 2689a86c6181SAlex Tomas { 269083982b6fSTheodore Ts'o if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS)) 2691a86c6181SAlex Tomas return; 2692a86c6181SAlex Tomas 2693a86c6181SAlex Tomas #ifdef EXTENTS_STATS 2694a86c6181SAlex Tomas if (EXT4_SB(sb)->s_ext_blocks && EXT4_SB(sb)->s_ext_extents) { 2695a86c6181SAlex Tomas struct ext4_sb_info *sbi = EXT4_SB(sb); 2696a86c6181SAlex Tomas printk(KERN_ERR "EXT4-fs: %lu blocks in %lu extents (%lu ave)\n", 2697a86c6181SAlex Tomas sbi->s_ext_blocks, sbi->s_ext_extents, 2698a86c6181SAlex Tomas sbi->s_ext_blocks / sbi->s_ext_extents); 2699a86c6181SAlex Tomas printk(KERN_ERR "EXT4-fs: extents: %lu min, %lu max, max depth %lu\n", 2700a86c6181SAlex Tomas sbi->s_ext_min, sbi->s_ext_max, sbi->s_depth_max); 2701a86c6181SAlex Tomas } 2702a86c6181SAlex Tomas #endif 2703a86c6181SAlex Tomas } 2704a86c6181SAlex Tomas 2705093a088bSAneesh Kumar K.V /* FIXME!! we need to try to merge to left or right after zero-out */ 2706093a088bSAneesh Kumar K.V static int ext4_ext_zeroout(struct inode *inode, struct ext4_extent *ex) 2707093a088bSAneesh Kumar K.V { 27082407518dSLukas Czerner ext4_fsblk_t ee_pblock; 27092407518dSLukas Czerner unsigned int ee_len; 2710b720303dSJing Zhang int ret; 2711093a088bSAneesh Kumar K.V 2712093a088bSAneesh Kumar K.V ee_len = ext4_ext_get_actual_len(ex); 2713bf89d16fSTheodore Ts'o ee_pblock = ext4_ext_pblock(ex); 2714093a088bSAneesh Kumar K.V 2715a107e5a3STheodore Ts'o ret = sb_issue_zeroout(inode->i_sb, ee_pblock, ee_len, GFP_NOFS); 27162407518dSLukas Czerner if (ret > 0) 27172407518dSLukas Czerner ret = 0; 2718093a088bSAneesh Kumar K.V 27192407518dSLukas Czerner return ret; 2720093a088bSAneesh Kumar K.V } 2721093a088bSAneesh Kumar K.V 272247ea3bb5SYongqiang Yang /* 272347ea3bb5SYongqiang Yang * used by extent splitting. 272447ea3bb5SYongqiang Yang */ 272547ea3bb5SYongqiang Yang #define EXT4_EXT_MAY_ZEROOUT 0x1 /* safe to zeroout if split fails \ 272647ea3bb5SYongqiang Yang due to ENOSPC */ 272747ea3bb5SYongqiang Yang #define EXT4_EXT_MARK_UNINIT1 0x2 /* mark first half uninitialized */ 272847ea3bb5SYongqiang Yang #define EXT4_EXT_MARK_UNINIT2 0x4 /* mark second half uninitialized */ 272947ea3bb5SYongqiang Yang 273047ea3bb5SYongqiang Yang /* 273147ea3bb5SYongqiang Yang * ext4_split_extent_at() splits an extent at given block. 273247ea3bb5SYongqiang Yang * 273347ea3bb5SYongqiang Yang * @handle: the journal handle 273447ea3bb5SYongqiang Yang * @inode: the file inode 273547ea3bb5SYongqiang Yang * @path: the path to the extent 273647ea3bb5SYongqiang Yang * @split: the logical block where the extent is splitted. 273747ea3bb5SYongqiang Yang * @split_flags: indicates if the extent could be zeroout if split fails, and 273847ea3bb5SYongqiang Yang * the states(init or uninit) of new extents. 273947ea3bb5SYongqiang Yang * @flags: flags used to insert new extent to extent tree. 274047ea3bb5SYongqiang Yang * 274147ea3bb5SYongqiang Yang * 274247ea3bb5SYongqiang Yang * Splits extent [a, b] into two extents [a, @split) and [@split, b], states 274347ea3bb5SYongqiang Yang * of which are deterimined by split_flag. 274447ea3bb5SYongqiang Yang * 274547ea3bb5SYongqiang Yang * There are two cases: 274647ea3bb5SYongqiang Yang * a> the extent are splitted into two extent. 274747ea3bb5SYongqiang Yang * b> split is not needed, and just mark the extent. 274847ea3bb5SYongqiang Yang * 274947ea3bb5SYongqiang Yang * return 0 on success. 275047ea3bb5SYongqiang Yang */ 275147ea3bb5SYongqiang Yang static int ext4_split_extent_at(handle_t *handle, 275247ea3bb5SYongqiang Yang struct inode *inode, 275347ea3bb5SYongqiang Yang struct ext4_ext_path *path, 275447ea3bb5SYongqiang Yang ext4_lblk_t split, 275547ea3bb5SYongqiang Yang int split_flag, 275647ea3bb5SYongqiang Yang int flags) 275747ea3bb5SYongqiang Yang { 275847ea3bb5SYongqiang Yang ext4_fsblk_t newblock; 275947ea3bb5SYongqiang Yang ext4_lblk_t ee_block; 276047ea3bb5SYongqiang Yang struct ext4_extent *ex, newex, orig_ex; 276147ea3bb5SYongqiang Yang struct ext4_extent *ex2 = NULL; 276247ea3bb5SYongqiang Yang unsigned int ee_len, depth; 276347ea3bb5SYongqiang Yang int err = 0; 276447ea3bb5SYongqiang Yang 276547ea3bb5SYongqiang Yang ext_debug("ext4_split_extents_at: inode %lu, logical" 276647ea3bb5SYongqiang Yang "block %llu\n", inode->i_ino, (unsigned long long)split); 276747ea3bb5SYongqiang Yang 276847ea3bb5SYongqiang Yang ext4_ext_show_leaf(inode, path); 276947ea3bb5SYongqiang Yang 277047ea3bb5SYongqiang Yang depth = ext_depth(inode); 277147ea3bb5SYongqiang Yang ex = path[depth].p_ext; 277247ea3bb5SYongqiang Yang ee_block = le32_to_cpu(ex->ee_block); 277347ea3bb5SYongqiang Yang ee_len = ext4_ext_get_actual_len(ex); 277447ea3bb5SYongqiang Yang newblock = split - ee_block + ext4_ext_pblock(ex); 277547ea3bb5SYongqiang Yang 277647ea3bb5SYongqiang Yang BUG_ON(split < ee_block || split >= (ee_block + ee_len)); 277747ea3bb5SYongqiang Yang 277847ea3bb5SYongqiang Yang err = ext4_ext_get_access(handle, inode, path + depth); 277947ea3bb5SYongqiang Yang if (err) 278047ea3bb5SYongqiang Yang goto out; 278147ea3bb5SYongqiang Yang 278247ea3bb5SYongqiang Yang if (split == ee_block) { 278347ea3bb5SYongqiang Yang /* 278447ea3bb5SYongqiang Yang * case b: block @split is the block that the extent begins with 278547ea3bb5SYongqiang Yang * then we just change the state of the extent, and splitting 278647ea3bb5SYongqiang Yang * is not needed. 278747ea3bb5SYongqiang Yang */ 278847ea3bb5SYongqiang Yang if (split_flag & EXT4_EXT_MARK_UNINIT2) 278947ea3bb5SYongqiang Yang ext4_ext_mark_uninitialized(ex); 279047ea3bb5SYongqiang Yang else 279147ea3bb5SYongqiang Yang ext4_ext_mark_initialized(ex); 279247ea3bb5SYongqiang Yang 279347ea3bb5SYongqiang Yang if (!(flags & EXT4_GET_BLOCKS_PRE_IO)) 279447ea3bb5SYongqiang Yang ext4_ext_try_to_merge(inode, path, ex); 279547ea3bb5SYongqiang Yang 279647ea3bb5SYongqiang Yang err = ext4_ext_dirty(handle, inode, path + depth); 279747ea3bb5SYongqiang Yang goto out; 279847ea3bb5SYongqiang Yang } 279947ea3bb5SYongqiang Yang 280047ea3bb5SYongqiang Yang /* case a */ 280147ea3bb5SYongqiang Yang memcpy(&orig_ex, ex, sizeof(orig_ex)); 280247ea3bb5SYongqiang Yang ex->ee_len = cpu_to_le16(split - ee_block); 280347ea3bb5SYongqiang Yang if (split_flag & EXT4_EXT_MARK_UNINIT1) 280447ea3bb5SYongqiang Yang ext4_ext_mark_uninitialized(ex); 280547ea3bb5SYongqiang Yang 280647ea3bb5SYongqiang Yang /* 280747ea3bb5SYongqiang Yang * path may lead to new leaf, not to original leaf any more 280847ea3bb5SYongqiang Yang * after ext4_ext_insert_extent() returns, 280947ea3bb5SYongqiang Yang */ 281047ea3bb5SYongqiang Yang err = ext4_ext_dirty(handle, inode, path + depth); 281147ea3bb5SYongqiang Yang if (err) 281247ea3bb5SYongqiang Yang goto fix_extent_len; 281347ea3bb5SYongqiang Yang 281447ea3bb5SYongqiang Yang ex2 = &newex; 281547ea3bb5SYongqiang Yang ex2->ee_block = cpu_to_le32(split); 281647ea3bb5SYongqiang Yang ex2->ee_len = cpu_to_le16(ee_len - (split - ee_block)); 281747ea3bb5SYongqiang Yang ext4_ext_store_pblock(ex2, newblock); 281847ea3bb5SYongqiang Yang if (split_flag & EXT4_EXT_MARK_UNINIT2) 281947ea3bb5SYongqiang Yang ext4_ext_mark_uninitialized(ex2); 282047ea3bb5SYongqiang Yang 282147ea3bb5SYongqiang Yang err = ext4_ext_insert_extent(handle, inode, path, &newex, flags); 282247ea3bb5SYongqiang Yang if (err == -ENOSPC && (EXT4_EXT_MAY_ZEROOUT & split_flag)) { 282347ea3bb5SYongqiang Yang err = ext4_ext_zeroout(inode, &orig_ex); 282447ea3bb5SYongqiang Yang if (err) 282547ea3bb5SYongqiang Yang goto fix_extent_len; 282647ea3bb5SYongqiang Yang /* update the extent length and mark as initialized */ 282747ea3bb5SYongqiang Yang ex->ee_len = cpu_to_le32(ee_len); 282847ea3bb5SYongqiang Yang ext4_ext_try_to_merge(inode, path, ex); 282947ea3bb5SYongqiang Yang err = ext4_ext_dirty(handle, inode, path + depth); 283047ea3bb5SYongqiang Yang goto out; 283147ea3bb5SYongqiang Yang } else if (err) 283247ea3bb5SYongqiang Yang goto fix_extent_len; 283347ea3bb5SYongqiang Yang 283447ea3bb5SYongqiang Yang out: 283547ea3bb5SYongqiang Yang ext4_ext_show_leaf(inode, path); 283647ea3bb5SYongqiang Yang return err; 283747ea3bb5SYongqiang Yang 283847ea3bb5SYongqiang Yang fix_extent_len: 283947ea3bb5SYongqiang Yang ex->ee_len = orig_ex.ee_len; 284047ea3bb5SYongqiang Yang ext4_ext_dirty(handle, inode, path + depth); 284147ea3bb5SYongqiang Yang return err; 284247ea3bb5SYongqiang Yang } 284347ea3bb5SYongqiang Yang 284447ea3bb5SYongqiang Yang /* 284547ea3bb5SYongqiang Yang * ext4_split_extents() splits an extent and mark extent which is covered 284647ea3bb5SYongqiang Yang * by @map as split_flags indicates 284747ea3bb5SYongqiang Yang * 284847ea3bb5SYongqiang Yang * It may result in splitting the extent into multiple extents (upto three) 284947ea3bb5SYongqiang Yang * There are three possibilities: 285047ea3bb5SYongqiang Yang * a> There is no split required 285147ea3bb5SYongqiang Yang * b> Splits in two extents: Split is happening at either end of the extent 285247ea3bb5SYongqiang Yang * c> Splits in three extents: Somone is splitting in middle of the extent 285347ea3bb5SYongqiang Yang * 285447ea3bb5SYongqiang Yang */ 285547ea3bb5SYongqiang Yang static int ext4_split_extent(handle_t *handle, 285647ea3bb5SYongqiang Yang struct inode *inode, 285747ea3bb5SYongqiang Yang struct ext4_ext_path *path, 285847ea3bb5SYongqiang Yang struct ext4_map_blocks *map, 285947ea3bb5SYongqiang Yang int split_flag, 286047ea3bb5SYongqiang Yang int flags) 286147ea3bb5SYongqiang Yang { 286247ea3bb5SYongqiang Yang ext4_lblk_t ee_block; 286347ea3bb5SYongqiang Yang struct ext4_extent *ex; 286447ea3bb5SYongqiang Yang unsigned int ee_len, depth; 286547ea3bb5SYongqiang Yang int err = 0; 286647ea3bb5SYongqiang Yang int uninitialized; 286747ea3bb5SYongqiang Yang int split_flag1, flags1; 286847ea3bb5SYongqiang Yang 286947ea3bb5SYongqiang Yang depth = ext_depth(inode); 287047ea3bb5SYongqiang Yang ex = path[depth].p_ext; 287147ea3bb5SYongqiang Yang ee_block = le32_to_cpu(ex->ee_block); 287247ea3bb5SYongqiang Yang ee_len = ext4_ext_get_actual_len(ex); 287347ea3bb5SYongqiang Yang uninitialized = ext4_ext_is_uninitialized(ex); 287447ea3bb5SYongqiang Yang 287547ea3bb5SYongqiang Yang if (map->m_lblk + map->m_len < ee_block + ee_len) { 287647ea3bb5SYongqiang Yang split_flag1 = split_flag & EXT4_EXT_MAY_ZEROOUT ? 287747ea3bb5SYongqiang Yang EXT4_EXT_MAY_ZEROOUT : 0; 287847ea3bb5SYongqiang Yang flags1 = flags | EXT4_GET_BLOCKS_PRE_IO; 287947ea3bb5SYongqiang Yang if (uninitialized) 288047ea3bb5SYongqiang Yang split_flag1 |= EXT4_EXT_MARK_UNINIT1 | 288147ea3bb5SYongqiang Yang EXT4_EXT_MARK_UNINIT2; 288247ea3bb5SYongqiang Yang err = ext4_split_extent_at(handle, inode, path, 288347ea3bb5SYongqiang Yang map->m_lblk + map->m_len, split_flag1, flags1); 288493917411SYongqiang Yang if (err) 288593917411SYongqiang Yang goto out; 288647ea3bb5SYongqiang Yang } 288747ea3bb5SYongqiang Yang 288847ea3bb5SYongqiang Yang ext4_ext_drop_refs(path); 288947ea3bb5SYongqiang Yang path = ext4_ext_find_extent(inode, map->m_lblk, path); 289047ea3bb5SYongqiang Yang if (IS_ERR(path)) 289147ea3bb5SYongqiang Yang return PTR_ERR(path); 289247ea3bb5SYongqiang Yang 289347ea3bb5SYongqiang Yang if (map->m_lblk >= ee_block) { 289447ea3bb5SYongqiang Yang split_flag1 = split_flag & EXT4_EXT_MAY_ZEROOUT ? 289547ea3bb5SYongqiang Yang EXT4_EXT_MAY_ZEROOUT : 0; 289647ea3bb5SYongqiang Yang if (uninitialized) 289747ea3bb5SYongqiang Yang split_flag1 |= EXT4_EXT_MARK_UNINIT1; 289847ea3bb5SYongqiang Yang if (split_flag & EXT4_EXT_MARK_UNINIT2) 289947ea3bb5SYongqiang Yang split_flag1 |= EXT4_EXT_MARK_UNINIT2; 290047ea3bb5SYongqiang Yang err = ext4_split_extent_at(handle, inode, path, 290147ea3bb5SYongqiang Yang map->m_lblk, split_flag1, flags); 290247ea3bb5SYongqiang Yang if (err) 290347ea3bb5SYongqiang Yang goto out; 290447ea3bb5SYongqiang Yang } 290547ea3bb5SYongqiang Yang 290647ea3bb5SYongqiang Yang ext4_ext_show_leaf(inode, path); 290747ea3bb5SYongqiang Yang out: 290847ea3bb5SYongqiang Yang return err ? err : map->m_len; 290947ea3bb5SYongqiang Yang } 291047ea3bb5SYongqiang Yang 29113977c965SAneesh Kumar K.V #define EXT4_EXT_ZERO_LEN 7 291256055d3aSAmit Arora /* 2913e35fd660STheodore Ts'o * This function is called by ext4_ext_map_blocks() if someone tries to write 291456055d3aSAmit Arora * to an uninitialized extent. It may result in splitting the uninitialized 291556055d3aSAmit Arora * extent into multiple extents (up to three - one initialized and two 291656055d3aSAmit Arora * uninitialized). 291756055d3aSAmit Arora * There are three possibilities: 291856055d3aSAmit Arora * a> There is no split required: Entire extent should be initialized 291956055d3aSAmit Arora * b> Splits in two extents: Write is happening at either end of the extent 292056055d3aSAmit Arora * c> Splits in three extents: Somone is writing in middle of the extent 292156055d3aSAmit Arora */ 2922725d26d3SAneesh Kumar K.V static int ext4_ext_convert_to_initialized(handle_t *handle, 2923725d26d3SAneesh Kumar K.V struct inode *inode, 2924e35fd660STheodore Ts'o struct ext4_map_blocks *map, 2925e35fd660STheodore Ts'o struct ext4_ext_path *path) 292656055d3aSAmit Arora { 2927667eff35SYongqiang Yang struct ext4_map_blocks split_map; 2928667eff35SYongqiang Yang struct ext4_extent zero_ex; 2929667eff35SYongqiang Yang struct ext4_extent *ex; 293021ca087aSDmitry Monakhov ext4_lblk_t ee_block, eof_block; 2931*f85b287aSDan Carpenter unsigned int ee_len, depth; 2932*f85b287aSDan Carpenter int allocated; 293356055d3aSAmit Arora int err = 0; 2934667eff35SYongqiang Yang int split_flag = 0; 293521ca087aSDmitry Monakhov 293621ca087aSDmitry Monakhov ext_debug("ext4_ext_convert_to_initialized: inode %lu, logical" 293721ca087aSDmitry Monakhov "block %llu, max_blocks %u\n", inode->i_ino, 2938e35fd660STheodore Ts'o (unsigned long long)map->m_lblk, map->m_len); 293921ca087aSDmitry Monakhov 294021ca087aSDmitry Monakhov eof_block = (inode->i_size + inode->i_sb->s_blocksize - 1) >> 294121ca087aSDmitry Monakhov inode->i_sb->s_blocksize_bits; 2942e35fd660STheodore Ts'o if (eof_block < map->m_lblk + map->m_len) 2943e35fd660STheodore Ts'o eof_block = map->m_lblk + map->m_len; 294456055d3aSAmit Arora 294556055d3aSAmit Arora depth = ext_depth(inode); 294656055d3aSAmit Arora ex = path[depth].p_ext; 294756055d3aSAmit Arora ee_block = le32_to_cpu(ex->ee_block); 294856055d3aSAmit Arora ee_len = ext4_ext_get_actual_len(ex); 2949e35fd660STheodore Ts'o allocated = ee_len - (map->m_lblk - ee_block); 295021ca087aSDmitry Monakhov 2951667eff35SYongqiang Yang WARN_ON(map->m_lblk < ee_block); 295221ca087aSDmitry Monakhov /* 295321ca087aSDmitry Monakhov * It is safe to convert extent to initialized via explicit 295421ca087aSDmitry Monakhov * zeroout only if extent is fully insde i_size or new_size. 295521ca087aSDmitry Monakhov */ 2956667eff35SYongqiang Yang split_flag |= ee_block + ee_len <= eof_block ? EXT4_EXT_MAY_ZEROOUT : 0; 295721ca087aSDmitry Monakhov 29583977c965SAneesh Kumar K.V /* If extent has less than 2*EXT4_EXT_ZERO_LEN zerout directly */ 2959667eff35SYongqiang Yang if (ee_len <= 2*EXT4_EXT_ZERO_LEN && 2960667eff35SYongqiang Yang (EXT4_EXT_MAY_ZEROOUT & split_flag)) { 2961667eff35SYongqiang Yang err = ext4_ext_zeroout(inode, ex); 29623977c965SAneesh Kumar K.V if (err) 296356055d3aSAmit Arora goto out; 29649df5643aSAneesh Kumar K.V 29659df5643aSAneesh Kumar K.V err = ext4_ext_get_access(handle, inode, path + depth); 29669df5643aSAneesh Kumar K.V if (err) 29679df5643aSAneesh Kumar K.V goto out; 2968667eff35SYongqiang Yang ext4_ext_mark_initialized(ex); 2969667eff35SYongqiang Yang ext4_ext_try_to_merge(inode, path, ex); 297056055d3aSAmit Arora err = ext4_ext_dirty(handle, inode, path + depth); 297156055d3aSAmit Arora goto out; 2972667eff35SYongqiang Yang } 2973093a088bSAneesh Kumar K.V 2974667eff35SYongqiang Yang /* 2975667eff35SYongqiang Yang * four cases: 2976667eff35SYongqiang Yang * 1. split the extent into three extents. 2977667eff35SYongqiang Yang * 2. split the extent into two extents, zeroout the first half. 2978667eff35SYongqiang Yang * 3. split the extent into two extents, zeroout the second half. 2979667eff35SYongqiang Yang * 4. split the extent into two extents with out zeroout. 2980667eff35SYongqiang Yang */ 2981667eff35SYongqiang Yang split_map.m_lblk = map->m_lblk; 2982667eff35SYongqiang Yang split_map.m_len = map->m_len; 2983667eff35SYongqiang Yang 2984667eff35SYongqiang Yang if (allocated > map->m_len) { 2985667eff35SYongqiang Yang if (allocated <= EXT4_EXT_ZERO_LEN && 2986667eff35SYongqiang Yang (EXT4_EXT_MAY_ZEROOUT & split_flag)) { 2987667eff35SYongqiang Yang /* case 3 */ 2988667eff35SYongqiang Yang zero_ex.ee_block = 29899b940f8eSAllison Henderson cpu_to_le32(map->m_lblk); 29909b940f8eSAllison Henderson zero_ex.ee_len = cpu_to_le16(allocated); 2991667eff35SYongqiang Yang ext4_ext_store_pblock(&zero_ex, 2992667eff35SYongqiang Yang ext4_ext_pblock(ex) + map->m_lblk - ee_block); 2993667eff35SYongqiang Yang err = ext4_ext_zeroout(inode, &zero_ex); 2994667eff35SYongqiang Yang if (err) 2995667eff35SYongqiang Yang goto out; 2996667eff35SYongqiang Yang split_map.m_lblk = map->m_lblk; 2997667eff35SYongqiang Yang split_map.m_len = allocated; 2998667eff35SYongqiang Yang } else if ((map->m_lblk - ee_block + map->m_len < 2999667eff35SYongqiang Yang EXT4_EXT_ZERO_LEN) && 3000667eff35SYongqiang Yang (EXT4_EXT_MAY_ZEROOUT & split_flag)) { 3001667eff35SYongqiang Yang /* case 2 */ 3002667eff35SYongqiang Yang if (map->m_lblk != ee_block) { 3003667eff35SYongqiang Yang zero_ex.ee_block = ex->ee_block; 3004667eff35SYongqiang Yang zero_ex.ee_len = cpu_to_le16(map->m_lblk - 3005667eff35SYongqiang Yang ee_block); 3006667eff35SYongqiang Yang ext4_ext_store_pblock(&zero_ex, 3007667eff35SYongqiang Yang ext4_ext_pblock(ex)); 3008667eff35SYongqiang Yang err = ext4_ext_zeroout(inode, &zero_ex); 3009667eff35SYongqiang Yang if (err) 3010667eff35SYongqiang Yang goto out; 3011667eff35SYongqiang Yang } 3012667eff35SYongqiang Yang 3013667eff35SYongqiang Yang split_map.m_lblk = ee_block; 30149b940f8eSAllison Henderson split_map.m_len = map->m_lblk - ee_block + map->m_len; 30159b940f8eSAllison Henderson allocated = map->m_len; 3016667eff35SYongqiang Yang } 3017667eff35SYongqiang Yang } 3018667eff35SYongqiang Yang 3019667eff35SYongqiang Yang allocated = ext4_split_extent(handle, inode, path, 3020667eff35SYongqiang Yang &split_map, split_flag, 0); 3021667eff35SYongqiang Yang if (allocated < 0) 3022667eff35SYongqiang Yang err = allocated; 3023667eff35SYongqiang Yang 3024667eff35SYongqiang Yang out: 3025667eff35SYongqiang Yang return err ? err : allocated; 302656055d3aSAmit Arora } 302756055d3aSAmit Arora 3028c278bfecSAneesh Kumar K.V /* 3029e35fd660STheodore Ts'o * This function is called by ext4_ext_map_blocks() from 30300031462bSMingming Cao * ext4_get_blocks_dio_write() when DIO to write 30310031462bSMingming Cao * to an uninitialized extent. 30320031462bSMingming Cao * 3033fd018fe8SPaul Bolle * Writing to an uninitialized extent may result in splitting the uninitialized 3034b595076aSUwe Kleine-König * extent into multiple /initialized uninitialized extents (up to three) 30350031462bSMingming Cao * There are three possibilities: 30360031462bSMingming Cao * a> There is no split required: Entire extent should be uninitialized 30370031462bSMingming Cao * b> Splits in two extents: Write is happening at either end of the extent 30380031462bSMingming Cao * c> Splits in three extents: Somone is writing in middle of the extent 30390031462bSMingming Cao * 30400031462bSMingming Cao * One of more index blocks maybe needed if the extent tree grow after 3041b595076aSUwe Kleine-König * the uninitialized extent split. To prevent ENOSPC occur at the IO 30420031462bSMingming Cao * complete, we need to split the uninitialized extent before DIO submit 3043421f91d2SUwe Kleine-König * the IO. The uninitialized extent called at this time will be split 30440031462bSMingming Cao * into three uninitialized extent(at most). After IO complete, the part 30450031462bSMingming Cao * being filled will be convert to initialized by the end_io callback function 30460031462bSMingming Cao * via ext4_convert_unwritten_extents(). 3047ba230c3fSMingming * 3048ba230c3fSMingming * Returns the size of uninitialized extent to be written on success. 30490031462bSMingming Cao */ 30500031462bSMingming Cao static int ext4_split_unwritten_extents(handle_t *handle, 30510031462bSMingming Cao struct inode *inode, 3052e35fd660STheodore Ts'o struct ext4_map_blocks *map, 30530031462bSMingming Cao struct ext4_ext_path *path, 30540031462bSMingming Cao int flags) 30550031462bSMingming Cao { 3056667eff35SYongqiang Yang ext4_lblk_t eof_block; 3057667eff35SYongqiang Yang ext4_lblk_t ee_block; 3058667eff35SYongqiang Yang struct ext4_extent *ex; 3059667eff35SYongqiang Yang unsigned int ee_len; 3060667eff35SYongqiang Yang int split_flag = 0, depth; 30610031462bSMingming Cao 306221ca087aSDmitry Monakhov ext_debug("ext4_split_unwritten_extents: inode %lu, logical" 306321ca087aSDmitry Monakhov "block %llu, max_blocks %u\n", inode->i_ino, 3064e35fd660STheodore Ts'o (unsigned long long)map->m_lblk, map->m_len); 306521ca087aSDmitry Monakhov 306621ca087aSDmitry Monakhov eof_block = (inode->i_size + inode->i_sb->s_blocksize - 1) >> 306721ca087aSDmitry Monakhov inode->i_sb->s_blocksize_bits; 3068e35fd660STheodore Ts'o if (eof_block < map->m_lblk + map->m_len) 3069e35fd660STheodore Ts'o eof_block = map->m_lblk + map->m_len; 30700031462bSMingming Cao /* 307121ca087aSDmitry Monakhov * It is safe to convert extent to initialized via explicit 307221ca087aSDmitry Monakhov * zeroout only if extent is fully insde i_size or new_size. 307321ca087aSDmitry Monakhov */ 3074667eff35SYongqiang Yang depth = ext_depth(inode); 30750031462bSMingming Cao ex = path[depth].p_ext; 3076667eff35SYongqiang Yang ee_block = le32_to_cpu(ex->ee_block); 3077667eff35SYongqiang Yang ee_len = ext4_ext_get_actual_len(ex); 30780031462bSMingming Cao 3079667eff35SYongqiang Yang split_flag |= ee_block + ee_len <= eof_block ? EXT4_EXT_MAY_ZEROOUT : 0; 3080667eff35SYongqiang Yang split_flag |= EXT4_EXT_MARK_UNINIT2; 30810031462bSMingming Cao 3082667eff35SYongqiang Yang flags |= EXT4_GET_BLOCKS_PRE_IO; 3083667eff35SYongqiang Yang return ext4_split_extent(handle, inode, path, map, split_flag, flags); 30840031462bSMingming Cao } 3085197217a5SYongqiang Yang 3086c7064ef1SJiaying Zhang static int ext4_convert_unwritten_extents_endio(handle_t *handle, 30870031462bSMingming Cao struct inode *inode, 30880031462bSMingming Cao struct ext4_ext_path *path) 30890031462bSMingming Cao { 30900031462bSMingming Cao struct ext4_extent *ex; 30910031462bSMingming Cao int depth; 30920031462bSMingming Cao int err = 0; 30930031462bSMingming Cao 30940031462bSMingming Cao depth = ext_depth(inode); 30950031462bSMingming Cao ex = path[depth].p_ext; 30960031462bSMingming Cao 3097197217a5SYongqiang Yang ext_debug("ext4_convert_unwritten_extents_endio: inode %lu, logical" 3098197217a5SYongqiang Yang "block %llu, max_blocks %u\n", inode->i_ino, 3099197217a5SYongqiang Yang (unsigned long long)le32_to_cpu(ex->ee_block), 3100197217a5SYongqiang Yang ext4_ext_get_actual_len(ex)); 3101197217a5SYongqiang Yang 31020031462bSMingming Cao err = ext4_ext_get_access(handle, inode, path + depth); 31030031462bSMingming Cao if (err) 31040031462bSMingming Cao goto out; 31050031462bSMingming Cao /* first mark the extent as initialized */ 31060031462bSMingming Cao ext4_ext_mark_initialized(ex); 31070031462bSMingming Cao 3108197217a5SYongqiang Yang /* note: ext4_ext_correct_indexes() isn't needed here because 3109197217a5SYongqiang Yang * borders are not changed 31100031462bSMingming Cao */ 3111197217a5SYongqiang Yang ext4_ext_try_to_merge(inode, path, ex); 3112197217a5SYongqiang Yang 31130031462bSMingming Cao /* Mark modified extent as dirty */ 31140031462bSMingming Cao err = ext4_ext_dirty(handle, inode, path + depth); 31150031462bSMingming Cao out: 31160031462bSMingming Cao ext4_ext_show_leaf(inode, path); 31170031462bSMingming Cao return err; 31180031462bSMingming Cao } 31190031462bSMingming Cao 3120515f41c3SAneesh Kumar K.V static void unmap_underlying_metadata_blocks(struct block_device *bdev, 3121515f41c3SAneesh Kumar K.V sector_t block, int count) 3122515f41c3SAneesh Kumar K.V { 3123515f41c3SAneesh Kumar K.V int i; 3124515f41c3SAneesh Kumar K.V for (i = 0; i < count; i++) 3125515f41c3SAneesh Kumar K.V unmap_underlying_metadata(bdev, block + i); 3126515f41c3SAneesh Kumar K.V } 3127515f41c3SAneesh Kumar K.V 312858590b06STheodore Ts'o /* 312958590b06STheodore Ts'o * Handle EOFBLOCKS_FL flag, clearing it if necessary 313058590b06STheodore Ts'o */ 313158590b06STheodore Ts'o static int check_eofblocks_fl(handle_t *handle, struct inode *inode, 3132d002ebf1SEric Sandeen ext4_lblk_t lblk, 313358590b06STheodore Ts'o struct ext4_ext_path *path, 313458590b06STheodore Ts'o unsigned int len) 313558590b06STheodore Ts'o { 313658590b06STheodore Ts'o int i, depth; 313758590b06STheodore Ts'o struct ext4_extent_header *eh; 313865922cb5SSergey Senozhatsky struct ext4_extent *last_ex; 313958590b06STheodore Ts'o 314058590b06STheodore Ts'o if (!ext4_test_inode_flag(inode, EXT4_INODE_EOFBLOCKS)) 314158590b06STheodore Ts'o return 0; 314258590b06STheodore Ts'o 314358590b06STheodore Ts'o depth = ext_depth(inode); 314458590b06STheodore Ts'o eh = path[depth].p_hdr; 314558590b06STheodore Ts'o 314658590b06STheodore Ts'o if (unlikely(!eh->eh_entries)) { 314758590b06STheodore Ts'o EXT4_ERROR_INODE(inode, "eh->eh_entries == 0 and " 314858590b06STheodore Ts'o "EOFBLOCKS_FL set"); 314958590b06STheodore Ts'o return -EIO; 315058590b06STheodore Ts'o } 315158590b06STheodore Ts'o last_ex = EXT_LAST_EXTENT(eh); 315258590b06STheodore Ts'o /* 315358590b06STheodore Ts'o * We should clear the EOFBLOCKS_FL flag if we are writing the 315458590b06STheodore Ts'o * last block in the last extent in the file. We test this by 315558590b06STheodore Ts'o * first checking to see if the caller to 315658590b06STheodore Ts'o * ext4_ext_get_blocks() was interested in the last block (or 315758590b06STheodore Ts'o * a block beyond the last block) in the current extent. If 315858590b06STheodore Ts'o * this turns out to be false, we can bail out from this 315958590b06STheodore Ts'o * function immediately. 316058590b06STheodore Ts'o */ 3161d002ebf1SEric Sandeen if (lblk + len < le32_to_cpu(last_ex->ee_block) + 316258590b06STheodore Ts'o ext4_ext_get_actual_len(last_ex)) 316358590b06STheodore Ts'o return 0; 316458590b06STheodore Ts'o /* 316558590b06STheodore Ts'o * If the caller does appear to be planning to write at or 316658590b06STheodore Ts'o * beyond the end of the current extent, we then test to see 316758590b06STheodore Ts'o * if the current extent is the last extent in the file, by 316858590b06STheodore Ts'o * checking to make sure it was reached via the rightmost node 316958590b06STheodore Ts'o * at each level of the tree. 317058590b06STheodore Ts'o */ 317158590b06STheodore Ts'o for (i = depth-1; i >= 0; i--) 317258590b06STheodore Ts'o if (path[i].p_idx != EXT_LAST_INDEX(path[i].p_hdr)) 317358590b06STheodore Ts'o return 0; 317458590b06STheodore Ts'o ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS); 317558590b06STheodore Ts'o return ext4_mark_inode_dirty(handle, inode); 317658590b06STheodore Ts'o } 317758590b06STheodore Ts'o 31787b415bf6SAditya Kali /** 31797b415bf6SAditya Kali * ext4_find_delalloc_range: find delayed allocated block in the given range. 31807b415bf6SAditya Kali * 31817b415bf6SAditya Kali * Goes through the buffer heads in the range [lblk_start, lblk_end] and returns 31827b415bf6SAditya Kali * whether there are any buffers marked for delayed allocation. It returns '1' 31837b415bf6SAditya Kali * on the first delalloc'ed buffer head found. If no buffer head in the given 31847b415bf6SAditya Kali * range is marked for delalloc, it returns 0. 31857b415bf6SAditya Kali * lblk_start should always be <= lblk_end. 31867b415bf6SAditya Kali * search_hint_reverse is to indicate that searching in reverse from lblk_end to 31877b415bf6SAditya Kali * lblk_start might be more efficient (i.e., we will likely hit the delalloc'ed 31887b415bf6SAditya Kali * block sooner). This is useful when blocks are truncated sequentially from 31897b415bf6SAditya Kali * lblk_start towards lblk_end. 31907b415bf6SAditya Kali */ 31917b415bf6SAditya Kali static int ext4_find_delalloc_range(struct inode *inode, 31927b415bf6SAditya Kali ext4_lblk_t lblk_start, 31937b415bf6SAditya Kali ext4_lblk_t lblk_end, 31947b415bf6SAditya Kali int search_hint_reverse) 31957b415bf6SAditya Kali { 31967b415bf6SAditya Kali struct address_space *mapping = inode->i_mapping; 31977b415bf6SAditya Kali struct buffer_head *head, *bh = NULL; 31987b415bf6SAditya Kali struct page *page; 31997b415bf6SAditya Kali ext4_lblk_t i, pg_lblk; 32007b415bf6SAditya Kali pgoff_t index; 32017b415bf6SAditya Kali 32027b415bf6SAditya Kali /* reverse search wont work if fs block size is less than page size */ 32037b415bf6SAditya Kali if (inode->i_blkbits < PAGE_CACHE_SHIFT) 32047b415bf6SAditya Kali search_hint_reverse = 0; 32057b415bf6SAditya Kali 32067b415bf6SAditya Kali if (search_hint_reverse) 32077b415bf6SAditya Kali i = lblk_end; 32087b415bf6SAditya Kali else 32097b415bf6SAditya Kali i = lblk_start; 32107b415bf6SAditya Kali 32117b415bf6SAditya Kali index = i >> (PAGE_CACHE_SHIFT - inode->i_blkbits); 32127b415bf6SAditya Kali 32137b415bf6SAditya Kali while ((i >= lblk_start) && (i <= lblk_end)) { 32147b415bf6SAditya Kali page = find_get_page(mapping, index); 32155356f261SAditya Kali if (!page) 32167b415bf6SAditya Kali goto nextpage; 32177b415bf6SAditya Kali 32187b415bf6SAditya Kali if (!page_has_buffers(page)) 32197b415bf6SAditya Kali goto nextpage; 32207b415bf6SAditya Kali 32217b415bf6SAditya Kali head = page_buffers(page); 32227b415bf6SAditya Kali if (!head) 32237b415bf6SAditya Kali goto nextpage; 32247b415bf6SAditya Kali 32257b415bf6SAditya Kali bh = head; 32267b415bf6SAditya Kali pg_lblk = index << (PAGE_CACHE_SHIFT - 32277b415bf6SAditya Kali inode->i_blkbits); 32287b415bf6SAditya Kali do { 32297b415bf6SAditya Kali if (unlikely(pg_lblk < lblk_start)) { 32307b415bf6SAditya Kali /* 32317b415bf6SAditya Kali * This is possible when fs block size is less 32327b415bf6SAditya Kali * than page size and our cluster starts/ends in 32337b415bf6SAditya Kali * middle of the page. So we need to skip the 32347b415bf6SAditya Kali * initial few blocks till we reach the 'lblk' 32357b415bf6SAditya Kali */ 32367b415bf6SAditya Kali pg_lblk++; 32377b415bf6SAditya Kali continue; 32387b415bf6SAditya Kali } 32397b415bf6SAditya Kali 32405356f261SAditya Kali /* Check if the buffer is delayed allocated and that it 32415356f261SAditya Kali * is not yet mapped. (when da-buffers are mapped during 32425356f261SAditya Kali * their writeout, their da_mapped bit is set.) 32435356f261SAditya Kali */ 32445356f261SAditya Kali if (buffer_delay(bh) && !buffer_da_mapped(bh)) { 32457b415bf6SAditya Kali page_cache_release(page); 3246d8990240SAditya Kali trace_ext4_find_delalloc_range(inode, 3247d8990240SAditya Kali lblk_start, lblk_end, 3248d8990240SAditya Kali search_hint_reverse, 3249d8990240SAditya Kali 1, i); 32507b415bf6SAditya Kali return 1; 32517b415bf6SAditya Kali } 32527b415bf6SAditya Kali if (search_hint_reverse) 32537b415bf6SAditya Kali i--; 32547b415bf6SAditya Kali else 32557b415bf6SAditya Kali i++; 32567b415bf6SAditya Kali } while ((i >= lblk_start) && (i <= lblk_end) && 32577b415bf6SAditya Kali ((bh = bh->b_this_page) != head)); 32587b415bf6SAditya Kali nextpage: 32597b415bf6SAditya Kali if (page) 32607b415bf6SAditya Kali page_cache_release(page); 32617b415bf6SAditya Kali /* 32627b415bf6SAditya Kali * Move to next page. 'i' will be the first lblk in the next 32637b415bf6SAditya Kali * page. 32647b415bf6SAditya Kali */ 32657b415bf6SAditya Kali if (search_hint_reverse) 32667b415bf6SAditya Kali index--; 32677b415bf6SAditya Kali else 32687b415bf6SAditya Kali index++; 32697b415bf6SAditya Kali i = index << (PAGE_CACHE_SHIFT - inode->i_blkbits); 32707b415bf6SAditya Kali } 32717b415bf6SAditya Kali 3272d8990240SAditya Kali trace_ext4_find_delalloc_range(inode, lblk_start, lblk_end, 3273d8990240SAditya Kali search_hint_reverse, 0, 0); 32747b415bf6SAditya Kali return 0; 32757b415bf6SAditya Kali } 32767b415bf6SAditya Kali 32777b415bf6SAditya Kali int ext4_find_delalloc_cluster(struct inode *inode, ext4_lblk_t lblk, 32787b415bf6SAditya Kali int search_hint_reverse) 32797b415bf6SAditya Kali { 32807b415bf6SAditya Kali struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 32817b415bf6SAditya Kali ext4_lblk_t lblk_start, lblk_end; 32827b415bf6SAditya Kali lblk_start = lblk & (~(sbi->s_cluster_ratio - 1)); 32837b415bf6SAditya Kali lblk_end = lblk_start + sbi->s_cluster_ratio - 1; 32847b415bf6SAditya Kali 32857b415bf6SAditya Kali return ext4_find_delalloc_range(inode, lblk_start, lblk_end, 32867b415bf6SAditya Kali search_hint_reverse); 32877b415bf6SAditya Kali } 32887b415bf6SAditya Kali 32897b415bf6SAditya Kali /** 32907b415bf6SAditya Kali * Determines how many complete clusters (out of those specified by the 'map') 32917b415bf6SAditya Kali * are under delalloc and were reserved quota for. 32927b415bf6SAditya Kali * This function is called when we are writing out the blocks that were 32937b415bf6SAditya Kali * originally written with their allocation delayed, but then the space was 32947b415bf6SAditya Kali * allocated using fallocate() before the delayed allocation could be resolved. 32957b415bf6SAditya Kali * The cases to look for are: 32967b415bf6SAditya Kali * ('=' indicated delayed allocated blocks 32977b415bf6SAditya Kali * '-' indicates non-delayed allocated blocks) 32987b415bf6SAditya Kali * (a) partial clusters towards beginning and/or end outside of allocated range 32997b415bf6SAditya Kali * are not delalloc'ed. 33007b415bf6SAditya Kali * Ex: 33017b415bf6SAditya Kali * |----c---=|====c====|====c====|===-c----| 33027b415bf6SAditya Kali * |++++++ allocated ++++++| 33037b415bf6SAditya Kali * ==> 4 complete clusters in above example 33047b415bf6SAditya Kali * 33057b415bf6SAditya Kali * (b) partial cluster (outside of allocated range) towards either end is 33067b415bf6SAditya Kali * marked for delayed allocation. In this case, we will exclude that 33077b415bf6SAditya Kali * cluster. 33087b415bf6SAditya Kali * Ex: 33097b415bf6SAditya Kali * |----====c========|========c========| 33107b415bf6SAditya Kali * |++++++ allocated ++++++| 33117b415bf6SAditya Kali * ==> 1 complete clusters in above example 33127b415bf6SAditya Kali * 33137b415bf6SAditya Kali * Ex: 33147b415bf6SAditya Kali * |================c================| 33157b415bf6SAditya Kali * |++++++ allocated ++++++| 33167b415bf6SAditya Kali * ==> 0 complete clusters in above example 33177b415bf6SAditya Kali * 33187b415bf6SAditya Kali * The ext4_da_update_reserve_space will be called only if we 33197b415bf6SAditya Kali * determine here that there were some "entire" clusters that span 33207b415bf6SAditya Kali * this 'allocated' range. 33217b415bf6SAditya Kali * In the non-bigalloc case, this function will just end up returning num_blks 33227b415bf6SAditya Kali * without ever calling ext4_find_delalloc_range. 33237b415bf6SAditya Kali */ 33247b415bf6SAditya Kali static unsigned int 33257b415bf6SAditya Kali get_reserved_cluster_alloc(struct inode *inode, ext4_lblk_t lblk_start, 33267b415bf6SAditya Kali unsigned int num_blks) 33277b415bf6SAditya Kali { 33287b415bf6SAditya Kali struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 33297b415bf6SAditya Kali ext4_lblk_t alloc_cluster_start, alloc_cluster_end; 33307b415bf6SAditya Kali ext4_lblk_t lblk_from, lblk_to, c_offset; 33317b415bf6SAditya Kali unsigned int allocated_clusters = 0; 33327b415bf6SAditya Kali 33337b415bf6SAditya Kali alloc_cluster_start = EXT4_B2C(sbi, lblk_start); 33347b415bf6SAditya Kali alloc_cluster_end = EXT4_B2C(sbi, lblk_start + num_blks - 1); 33357b415bf6SAditya Kali 33367b415bf6SAditya Kali /* max possible clusters for this allocation */ 33377b415bf6SAditya Kali allocated_clusters = alloc_cluster_end - alloc_cluster_start + 1; 33387b415bf6SAditya Kali 3339d8990240SAditya Kali trace_ext4_get_reserved_cluster_alloc(inode, lblk_start, num_blks); 3340d8990240SAditya Kali 33417b415bf6SAditya Kali /* Check towards left side */ 33427b415bf6SAditya Kali c_offset = lblk_start & (sbi->s_cluster_ratio - 1); 33437b415bf6SAditya Kali if (c_offset) { 33447b415bf6SAditya Kali lblk_from = lblk_start & (~(sbi->s_cluster_ratio - 1)); 33457b415bf6SAditya Kali lblk_to = lblk_from + c_offset - 1; 33467b415bf6SAditya Kali 33477b415bf6SAditya Kali if (ext4_find_delalloc_range(inode, lblk_from, lblk_to, 0)) 33487b415bf6SAditya Kali allocated_clusters--; 33497b415bf6SAditya Kali } 33507b415bf6SAditya Kali 33517b415bf6SAditya Kali /* Now check towards right. */ 33527b415bf6SAditya Kali c_offset = (lblk_start + num_blks) & (sbi->s_cluster_ratio - 1); 33537b415bf6SAditya Kali if (allocated_clusters && c_offset) { 33547b415bf6SAditya Kali lblk_from = lblk_start + num_blks; 33557b415bf6SAditya Kali lblk_to = lblk_from + (sbi->s_cluster_ratio - c_offset) - 1; 33567b415bf6SAditya Kali 33577b415bf6SAditya Kali if (ext4_find_delalloc_range(inode, lblk_from, lblk_to, 0)) 33587b415bf6SAditya Kali allocated_clusters--; 33597b415bf6SAditya Kali } 33607b415bf6SAditya Kali 33617b415bf6SAditya Kali return allocated_clusters; 33627b415bf6SAditya Kali } 33637b415bf6SAditya Kali 33640031462bSMingming Cao static int 33650031462bSMingming Cao ext4_ext_handle_uninitialized_extents(handle_t *handle, struct inode *inode, 3366e35fd660STheodore Ts'o struct ext4_map_blocks *map, 33670031462bSMingming Cao struct ext4_ext_path *path, int flags, 3368e35fd660STheodore Ts'o unsigned int allocated, ext4_fsblk_t newblock) 33690031462bSMingming Cao { 33700031462bSMingming Cao int ret = 0; 33710031462bSMingming Cao int err = 0; 33728d5d02e6SMingming Cao ext4_io_end_t *io = EXT4_I(inode)->cur_aio_dio; 33730031462bSMingming Cao 33740031462bSMingming Cao ext_debug("ext4_ext_handle_uninitialized_extents: inode %lu, logical" 33750031462bSMingming Cao "block %llu, max_blocks %u, flags %d, allocated %u", 3376e35fd660STheodore Ts'o inode->i_ino, (unsigned long long)map->m_lblk, map->m_len, 33770031462bSMingming Cao flags, allocated); 33780031462bSMingming Cao ext4_ext_show_leaf(inode, path); 33790031462bSMingming Cao 3380d8990240SAditya Kali trace_ext4_ext_handle_uninitialized_extents(inode, map, allocated, 3381d8990240SAditya Kali newblock); 3382d8990240SAditya Kali 3383c7064ef1SJiaying Zhang /* get_block() before submit the IO, split the extent */ 3384744692dcSJiaying Zhang if ((flags & EXT4_GET_BLOCKS_PRE_IO)) { 3385e35fd660STheodore Ts'o ret = ext4_split_unwritten_extents(handle, inode, map, 3386e35fd660STheodore Ts'o path, flags); 33875f524950SMingming /* 33885f524950SMingming * Flag the inode(non aio case) or end_io struct (aio case) 338925985edcSLucas De Marchi * that this IO needs to conversion to written when IO is 33905f524950SMingming * completed 33915f524950SMingming */ 3392e9e3bcecSEric Sandeen if (io && !(io->flag & EXT4_IO_END_UNWRITTEN)) { 3393bd2d0210STheodore Ts'o io->flag = EXT4_IO_END_UNWRITTEN; 3394e9e3bcecSEric Sandeen atomic_inc(&EXT4_I(inode)->i_aiodio_unwritten); 3395e9e3bcecSEric Sandeen } else 339619f5fb7aSTheodore Ts'o ext4_set_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN); 3397744692dcSJiaying Zhang if (ext4_should_dioread_nolock(inode)) 3398e35fd660STheodore Ts'o map->m_flags |= EXT4_MAP_UNINIT; 33990031462bSMingming Cao goto out; 34000031462bSMingming Cao } 3401c7064ef1SJiaying Zhang /* IO end_io complete, convert the filled extent to written */ 3402744692dcSJiaying Zhang if ((flags & EXT4_GET_BLOCKS_CONVERT)) { 3403c7064ef1SJiaying Zhang ret = ext4_convert_unwritten_extents_endio(handle, inode, 34040031462bSMingming Cao path); 340558590b06STheodore Ts'o if (ret >= 0) { 3406b436b9beSJan Kara ext4_update_inode_fsync_trans(handle, inode, 1); 3407d002ebf1SEric Sandeen err = check_eofblocks_fl(handle, inode, map->m_lblk, 3408d002ebf1SEric Sandeen path, map->m_len); 340958590b06STheodore Ts'o } else 341058590b06STheodore Ts'o err = ret; 34110031462bSMingming Cao goto out2; 34120031462bSMingming Cao } 34130031462bSMingming Cao /* buffered IO case */ 34140031462bSMingming Cao /* 34150031462bSMingming Cao * repeat fallocate creation request 34160031462bSMingming Cao * we already have an unwritten extent 34170031462bSMingming Cao */ 34180031462bSMingming Cao if (flags & EXT4_GET_BLOCKS_UNINIT_EXT) 34190031462bSMingming Cao goto map_out; 34200031462bSMingming Cao 34210031462bSMingming Cao /* buffered READ or buffered write_begin() lookup */ 34220031462bSMingming Cao if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) { 34230031462bSMingming Cao /* 34240031462bSMingming Cao * We have blocks reserved already. We 34250031462bSMingming Cao * return allocated blocks so that delalloc 34260031462bSMingming Cao * won't do block reservation for us. But 34270031462bSMingming Cao * the buffer head will be unmapped so that 34280031462bSMingming Cao * a read from the block returns 0s. 34290031462bSMingming Cao */ 3430e35fd660STheodore Ts'o map->m_flags |= EXT4_MAP_UNWRITTEN; 34310031462bSMingming Cao goto out1; 34320031462bSMingming Cao } 34330031462bSMingming Cao 34340031462bSMingming Cao /* buffered write, writepage time, convert*/ 3435e35fd660STheodore Ts'o ret = ext4_ext_convert_to_initialized(handle, inode, map, path); 3436a4e5d88bSDmitry Monakhov if (ret >= 0) 3437b436b9beSJan Kara ext4_update_inode_fsync_trans(handle, inode, 1); 34380031462bSMingming Cao out: 34390031462bSMingming Cao if (ret <= 0) { 34400031462bSMingming Cao err = ret; 34410031462bSMingming Cao goto out2; 34420031462bSMingming Cao } else 34430031462bSMingming Cao allocated = ret; 3444e35fd660STheodore Ts'o map->m_flags |= EXT4_MAP_NEW; 3445515f41c3SAneesh Kumar K.V /* 3446515f41c3SAneesh Kumar K.V * if we allocated more blocks than requested 3447515f41c3SAneesh Kumar K.V * we need to make sure we unmap the extra block 3448515f41c3SAneesh Kumar K.V * allocated. The actual needed block will get 3449515f41c3SAneesh Kumar K.V * unmapped later when we find the buffer_head marked 3450515f41c3SAneesh Kumar K.V * new. 3451515f41c3SAneesh Kumar K.V */ 3452e35fd660STheodore Ts'o if (allocated > map->m_len) { 3453515f41c3SAneesh Kumar K.V unmap_underlying_metadata_blocks(inode->i_sb->s_bdev, 3454e35fd660STheodore Ts'o newblock + map->m_len, 3455e35fd660STheodore Ts'o allocated - map->m_len); 3456e35fd660STheodore Ts'o allocated = map->m_len; 3457515f41c3SAneesh Kumar K.V } 34585f634d06SAneesh Kumar K.V 34595f634d06SAneesh Kumar K.V /* 34605f634d06SAneesh Kumar K.V * If we have done fallocate with the offset that is already 34615f634d06SAneesh Kumar K.V * delayed allocated, we would have block reservation 34625f634d06SAneesh Kumar K.V * and quota reservation done in the delayed write path. 34635f634d06SAneesh Kumar K.V * But fallocate would have already updated quota and block 34645f634d06SAneesh Kumar K.V * count for this offset. So cancel these reservation 34655f634d06SAneesh Kumar K.V */ 34667b415bf6SAditya Kali if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) { 34677b415bf6SAditya Kali unsigned int reserved_clusters; 34687b415bf6SAditya Kali reserved_clusters = get_reserved_cluster_alloc(inode, 34697b415bf6SAditya Kali map->m_lblk, map->m_len); 34707b415bf6SAditya Kali if (reserved_clusters) 34717b415bf6SAditya Kali ext4_da_update_reserve_space(inode, 34727b415bf6SAditya Kali reserved_clusters, 34737b415bf6SAditya Kali 0); 34747b415bf6SAditya Kali } 34755f634d06SAneesh Kumar K.V 34760031462bSMingming Cao map_out: 3477e35fd660STheodore Ts'o map->m_flags |= EXT4_MAP_MAPPED; 3478a4e5d88bSDmitry Monakhov if ((flags & EXT4_GET_BLOCKS_KEEP_SIZE) == 0) { 3479a4e5d88bSDmitry Monakhov err = check_eofblocks_fl(handle, inode, map->m_lblk, path, 3480a4e5d88bSDmitry Monakhov map->m_len); 3481a4e5d88bSDmitry Monakhov if (err < 0) 3482a4e5d88bSDmitry Monakhov goto out2; 3483a4e5d88bSDmitry Monakhov } 34840031462bSMingming Cao out1: 3485e35fd660STheodore Ts'o if (allocated > map->m_len) 3486e35fd660STheodore Ts'o allocated = map->m_len; 34870031462bSMingming Cao ext4_ext_show_leaf(inode, path); 3488e35fd660STheodore Ts'o map->m_pblk = newblock; 3489e35fd660STheodore Ts'o map->m_len = allocated; 34900031462bSMingming Cao out2: 34910031462bSMingming Cao if (path) { 34920031462bSMingming Cao ext4_ext_drop_refs(path); 34930031462bSMingming Cao kfree(path); 34940031462bSMingming Cao } 34950031462bSMingming Cao return err ? err : allocated; 34960031462bSMingming Cao } 349758590b06STheodore Ts'o 34980031462bSMingming Cao /* 34994d33b1efSTheodore Ts'o * get_implied_cluster_alloc - check to see if the requested 35004d33b1efSTheodore Ts'o * allocation (in the map structure) overlaps with a cluster already 35014d33b1efSTheodore Ts'o * allocated in an extent. 3502d8990240SAditya Kali * @sb The filesystem superblock structure 35034d33b1efSTheodore Ts'o * @map The requested lblk->pblk mapping 35044d33b1efSTheodore Ts'o * @ex The extent structure which might contain an implied 35054d33b1efSTheodore Ts'o * cluster allocation 35064d33b1efSTheodore Ts'o * 35074d33b1efSTheodore Ts'o * This function is called by ext4_ext_map_blocks() after we failed to 35084d33b1efSTheodore Ts'o * find blocks that were already in the inode's extent tree. Hence, 35094d33b1efSTheodore Ts'o * we know that the beginning of the requested region cannot overlap 35104d33b1efSTheodore Ts'o * the extent from the inode's extent tree. There are three cases we 35114d33b1efSTheodore Ts'o * want to catch. The first is this case: 35124d33b1efSTheodore Ts'o * 35134d33b1efSTheodore Ts'o * |--- cluster # N--| 35144d33b1efSTheodore Ts'o * |--- extent ---| |---- requested region ---| 35154d33b1efSTheodore Ts'o * |==========| 35164d33b1efSTheodore Ts'o * 35174d33b1efSTheodore Ts'o * The second case that we need to test for is this one: 35184d33b1efSTheodore Ts'o * 35194d33b1efSTheodore Ts'o * |--------- cluster # N ----------------| 35204d33b1efSTheodore Ts'o * |--- requested region --| |------- extent ----| 35214d33b1efSTheodore Ts'o * |=======================| 35224d33b1efSTheodore Ts'o * 35234d33b1efSTheodore Ts'o * The third case is when the requested region lies between two extents 35244d33b1efSTheodore Ts'o * within the same cluster: 35254d33b1efSTheodore Ts'o * |------------- cluster # N-------------| 35264d33b1efSTheodore Ts'o * |----- ex -----| |---- ex_right ----| 35274d33b1efSTheodore Ts'o * |------ requested region ------| 35284d33b1efSTheodore Ts'o * |================| 35294d33b1efSTheodore Ts'o * 35304d33b1efSTheodore Ts'o * In each of the above cases, we need to set the map->m_pblk and 35314d33b1efSTheodore Ts'o * map->m_len so it corresponds to the return the extent labelled as 35324d33b1efSTheodore Ts'o * "|====|" from cluster #N, since it is already in use for data in 35334d33b1efSTheodore Ts'o * cluster EXT4_B2C(sbi, map->m_lblk). We will then return 1 to 35344d33b1efSTheodore Ts'o * signal to ext4_ext_map_blocks() that map->m_pblk should be treated 35354d33b1efSTheodore Ts'o * as a new "allocated" block region. Otherwise, we will return 0 and 35364d33b1efSTheodore Ts'o * ext4_ext_map_blocks() will then allocate one or more new clusters 35374d33b1efSTheodore Ts'o * by calling ext4_mb_new_blocks(). 35384d33b1efSTheodore Ts'o */ 3539d8990240SAditya Kali static int get_implied_cluster_alloc(struct super_block *sb, 35404d33b1efSTheodore Ts'o struct ext4_map_blocks *map, 35414d33b1efSTheodore Ts'o struct ext4_extent *ex, 35424d33b1efSTheodore Ts'o struct ext4_ext_path *path) 35434d33b1efSTheodore Ts'o { 3544d8990240SAditya Kali struct ext4_sb_info *sbi = EXT4_SB(sb); 35454d33b1efSTheodore Ts'o ext4_lblk_t c_offset = map->m_lblk & (sbi->s_cluster_ratio-1); 35464d33b1efSTheodore Ts'o ext4_lblk_t ex_cluster_start, ex_cluster_end; 35474d33b1efSTheodore Ts'o ext4_lblk_t rr_cluster_start, rr_cluster_end; 35484d33b1efSTheodore Ts'o ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block); 35494d33b1efSTheodore Ts'o ext4_fsblk_t ee_start = ext4_ext_pblock(ex); 35504d33b1efSTheodore Ts'o unsigned short ee_len = ext4_ext_get_actual_len(ex); 35514d33b1efSTheodore Ts'o 35524d33b1efSTheodore Ts'o /* The extent passed in that we are trying to match */ 35534d33b1efSTheodore Ts'o ex_cluster_start = EXT4_B2C(sbi, ee_block); 35544d33b1efSTheodore Ts'o ex_cluster_end = EXT4_B2C(sbi, ee_block + ee_len - 1); 35554d33b1efSTheodore Ts'o 35564d33b1efSTheodore Ts'o /* The requested region passed into ext4_map_blocks() */ 35574d33b1efSTheodore Ts'o rr_cluster_start = EXT4_B2C(sbi, map->m_lblk); 35584d33b1efSTheodore Ts'o rr_cluster_end = EXT4_B2C(sbi, map->m_lblk + map->m_len - 1); 35594d33b1efSTheodore Ts'o 35604d33b1efSTheodore Ts'o if ((rr_cluster_start == ex_cluster_end) || 35614d33b1efSTheodore Ts'o (rr_cluster_start == ex_cluster_start)) { 35624d33b1efSTheodore Ts'o if (rr_cluster_start == ex_cluster_end) 35634d33b1efSTheodore Ts'o ee_start += ee_len - 1; 35644d33b1efSTheodore Ts'o map->m_pblk = (ee_start & ~(sbi->s_cluster_ratio - 1)) + 35654d33b1efSTheodore Ts'o c_offset; 35664d33b1efSTheodore Ts'o map->m_len = min(map->m_len, 35674d33b1efSTheodore Ts'o (unsigned) sbi->s_cluster_ratio - c_offset); 35684d33b1efSTheodore Ts'o /* 35694d33b1efSTheodore Ts'o * Check for and handle this case: 35704d33b1efSTheodore Ts'o * 35714d33b1efSTheodore Ts'o * |--------- cluster # N-------------| 35724d33b1efSTheodore Ts'o * |------- extent ----| 35734d33b1efSTheodore Ts'o * |--- requested region ---| 35744d33b1efSTheodore Ts'o * |===========| 35754d33b1efSTheodore Ts'o */ 35764d33b1efSTheodore Ts'o 35774d33b1efSTheodore Ts'o if (map->m_lblk < ee_block) 35784d33b1efSTheodore Ts'o map->m_len = min(map->m_len, ee_block - map->m_lblk); 35794d33b1efSTheodore Ts'o 35804d33b1efSTheodore Ts'o /* 35814d33b1efSTheodore Ts'o * Check for the case where there is already another allocated 35824d33b1efSTheodore Ts'o * block to the right of 'ex' but before the end of the cluster. 35834d33b1efSTheodore Ts'o * 35844d33b1efSTheodore Ts'o * |------------- cluster # N-------------| 35854d33b1efSTheodore Ts'o * |----- ex -----| |---- ex_right ----| 35864d33b1efSTheodore Ts'o * |------ requested region ------| 35874d33b1efSTheodore Ts'o * |================| 35884d33b1efSTheodore Ts'o */ 35894d33b1efSTheodore Ts'o if (map->m_lblk > ee_block) { 35904d33b1efSTheodore Ts'o ext4_lblk_t next = ext4_ext_next_allocated_block(path); 35914d33b1efSTheodore Ts'o map->m_len = min(map->m_len, next - map->m_lblk); 35924d33b1efSTheodore Ts'o } 3593d8990240SAditya Kali 3594d8990240SAditya Kali trace_ext4_get_implied_cluster_alloc_exit(sb, map, 1); 35954d33b1efSTheodore Ts'o return 1; 35964d33b1efSTheodore Ts'o } 3597d8990240SAditya Kali 3598d8990240SAditya Kali trace_ext4_get_implied_cluster_alloc_exit(sb, map, 0); 35994d33b1efSTheodore Ts'o return 0; 36004d33b1efSTheodore Ts'o } 36014d33b1efSTheodore Ts'o 36024d33b1efSTheodore Ts'o 36034d33b1efSTheodore Ts'o /* 3604f5ab0d1fSMingming Cao * Block allocation/map/preallocation routine for extents based files 3605f5ab0d1fSMingming Cao * 3606f5ab0d1fSMingming Cao * 3607c278bfecSAneesh Kumar K.V * Need to be called with 36080e855ac8SAneesh Kumar K.V * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block 36090e855ac8SAneesh Kumar K.V * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem) 3610f5ab0d1fSMingming Cao * 3611f5ab0d1fSMingming Cao * return > 0, number of of blocks already mapped/allocated 3612f5ab0d1fSMingming Cao * if create == 0 and these are pre-allocated blocks 3613f5ab0d1fSMingming Cao * buffer head is unmapped 3614f5ab0d1fSMingming Cao * otherwise blocks are mapped 3615f5ab0d1fSMingming Cao * 3616f5ab0d1fSMingming Cao * return = 0, if plain look up failed (blocks have not been allocated) 3617f5ab0d1fSMingming Cao * buffer head is unmapped 3618f5ab0d1fSMingming Cao * 3619f5ab0d1fSMingming Cao * return < 0, error case. 3620c278bfecSAneesh Kumar K.V */ 3621e35fd660STheodore Ts'o int ext4_ext_map_blocks(handle_t *handle, struct inode *inode, 3622e35fd660STheodore Ts'o struct ext4_map_blocks *map, int flags) 3623a86c6181SAlex Tomas { 3624a86c6181SAlex Tomas struct ext4_ext_path *path = NULL; 36254d33b1efSTheodore Ts'o struct ext4_extent newex, *ex, *ex2; 36264d33b1efSTheodore Ts'o struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 36270562e0baSJiaying Zhang ext4_fsblk_t newblock = 0; 36284d33b1efSTheodore Ts'o int free_on_err = 0, err = 0, depth, ret; 36294d33b1efSTheodore Ts'o unsigned int allocated = 0, offset = 0; 36307b415bf6SAditya Kali unsigned int allocated_clusters = 0, reserved_clusters = 0; 3631e861304bSAllison Henderson unsigned int punched_out = 0; 3632e861304bSAllison Henderson unsigned int result = 0; 3633c9de560dSAlex Tomas struct ext4_allocation_request ar; 36348d5d02e6SMingming Cao ext4_io_end_t *io = EXT4_I(inode)->cur_aio_dio; 36354d33b1efSTheodore Ts'o ext4_lblk_t cluster_offset; 3636e861304bSAllison Henderson struct ext4_map_blocks punch_map; 3637a86c6181SAlex Tomas 363884fe3befSMingming ext_debug("blocks %u/%u requested for inode %lu\n", 3639e35fd660STheodore Ts'o map->m_lblk, map->m_len, inode->i_ino); 36400562e0baSJiaying Zhang trace_ext4_ext_map_blocks_enter(inode, map->m_lblk, map->m_len, flags); 3641a86c6181SAlex Tomas 3642a86c6181SAlex Tomas /* check in cache */ 3643015861baSRobin Dong if (!(flags & EXT4_GET_BLOCKS_PUNCH_OUT_EXT) && 3644015861baSRobin Dong ext4_ext_in_cache(inode, map->m_lblk, &newex)) { 3645b05e6ae5STheodore Ts'o if (!newex.ee_start_lo && !newex.ee_start_hi) { 36467b415bf6SAditya Kali if ((sbi->s_cluster_ratio > 1) && 36477b415bf6SAditya Kali ext4_find_delalloc_cluster(inode, map->m_lblk, 0)) 36487b415bf6SAditya Kali map->m_flags |= EXT4_MAP_FROM_CLUSTER; 36497b415bf6SAditya Kali 3650c2177057STheodore Ts'o if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) { 365156055d3aSAmit Arora /* 365256055d3aSAmit Arora * block isn't allocated yet and 365356055d3aSAmit Arora * user doesn't want to allocate it 365456055d3aSAmit Arora */ 3655a86c6181SAlex Tomas goto out2; 3656a86c6181SAlex Tomas } 3657a86c6181SAlex Tomas /* we should allocate requested block */ 3658b05e6ae5STheodore Ts'o } else { 3659a86c6181SAlex Tomas /* block is already allocated */ 36607b415bf6SAditya Kali if (sbi->s_cluster_ratio > 1) 36617b415bf6SAditya Kali map->m_flags |= EXT4_MAP_FROM_CLUSTER; 3662e35fd660STheodore Ts'o newblock = map->m_lblk 3663a86c6181SAlex Tomas - le32_to_cpu(newex.ee_block) 3664bf89d16fSTheodore Ts'o + ext4_ext_pblock(&newex); 3665d0d856e8SRandy Dunlap /* number of remaining blocks in the extent */ 3666b939e376SAneesh Kumar K.V allocated = ext4_ext_get_actual_len(&newex) - 3667e35fd660STheodore Ts'o (map->m_lblk - le32_to_cpu(newex.ee_block)); 3668a86c6181SAlex Tomas goto out; 3669a86c6181SAlex Tomas } 3670a86c6181SAlex Tomas } 3671a86c6181SAlex Tomas 3672a86c6181SAlex Tomas /* find extent for this block */ 3673e35fd660STheodore Ts'o path = ext4_ext_find_extent(inode, map->m_lblk, NULL); 3674a86c6181SAlex Tomas if (IS_ERR(path)) { 3675a86c6181SAlex Tomas err = PTR_ERR(path); 3676a86c6181SAlex Tomas path = NULL; 3677a86c6181SAlex Tomas goto out2; 3678a86c6181SAlex Tomas } 3679a86c6181SAlex Tomas 3680a86c6181SAlex Tomas depth = ext_depth(inode); 3681a86c6181SAlex Tomas 3682a86c6181SAlex Tomas /* 3683d0d856e8SRandy Dunlap * consistent leaf must not be empty; 3684d0d856e8SRandy Dunlap * this situation is possible, though, _during_ tree modification; 3685a86c6181SAlex Tomas * this is why assert can't be put in ext4_ext_find_extent() 3686a86c6181SAlex Tomas */ 3687273df556SFrank Mayhar if (unlikely(path[depth].p_ext == NULL && depth != 0)) { 3688273df556SFrank Mayhar EXT4_ERROR_INODE(inode, "bad extent address " 3689f70f362bSTheodore Ts'o "lblock: %lu, depth: %d pblock %lld", 3690f70f362bSTheodore Ts'o (unsigned long) map->m_lblk, depth, 3691f70f362bSTheodore Ts'o path[depth].p_block); 3692034fb4c9SSurbhi Palande err = -EIO; 3693034fb4c9SSurbhi Palande goto out2; 3694034fb4c9SSurbhi Palande } 3695a86c6181SAlex Tomas 36967e028976SAvantika Mathur ex = path[depth].p_ext; 36977e028976SAvantika Mathur if (ex) { 3698725d26d3SAneesh Kumar K.V ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block); 3699bf89d16fSTheodore Ts'o ext4_fsblk_t ee_start = ext4_ext_pblock(ex); 3700a2df2a63SAmit Arora unsigned short ee_len; 3701471d4011SSuparna Bhattacharya 3702471d4011SSuparna Bhattacharya /* 3703471d4011SSuparna Bhattacharya * Uninitialized extents are treated as holes, except that 370456055d3aSAmit Arora * we split out initialized portions during a write. 3705471d4011SSuparna Bhattacharya */ 3706a2df2a63SAmit Arora ee_len = ext4_ext_get_actual_len(ex); 3707d8990240SAditya Kali 3708d8990240SAditya Kali trace_ext4_ext_show_extent(inode, ee_block, ee_start, ee_len); 3709d8990240SAditya Kali 3710d0d856e8SRandy Dunlap /* if found extent covers block, simply return it */ 3711e35fd660STheodore Ts'o if (in_range(map->m_lblk, ee_block, ee_len)) { 37120aa06000STheodore Ts'o ext4_fsblk_t partial_cluster = 0; 37130aa06000STheodore Ts'o 3714e35fd660STheodore Ts'o newblock = map->m_lblk - ee_block + ee_start; 3715d0d856e8SRandy Dunlap /* number of remaining blocks in the extent */ 3716e35fd660STheodore Ts'o allocated = ee_len - (map->m_lblk - ee_block); 3717e35fd660STheodore Ts'o ext_debug("%u fit into %u:%d -> %llu\n", map->m_lblk, 3718a86c6181SAlex Tomas ee_block, ee_len, newblock); 371956055d3aSAmit Arora 3720e861304bSAllison Henderson if ((flags & EXT4_GET_BLOCKS_PUNCH_OUT_EXT) == 0) { 3721e861304bSAllison Henderson /* 3722e861304bSAllison Henderson * Do not put uninitialized extent 3723e861304bSAllison Henderson * in the cache 3724e861304bSAllison Henderson */ 372556055d3aSAmit Arora if (!ext4_ext_is_uninitialized(ex)) { 3726a2df2a63SAmit Arora ext4_ext_put_in_cache(inode, ee_block, 3727b05e6ae5STheodore Ts'o ee_len, ee_start); 3728a86c6181SAlex Tomas goto out; 3729a86c6181SAlex Tomas } 3730e861304bSAllison Henderson ret = ext4_ext_handle_uninitialized_extents( 3731e861304bSAllison Henderson handle, inode, map, path, flags, 3732e861304bSAllison Henderson allocated, newblock); 37330031462bSMingming Cao return ret; 373456055d3aSAmit Arora } 3735e861304bSAllison Henderson 3736e861304bSAllison Henderson /* 3737e861304bSAllison Henderson * Punch out the map length, but only to the 3738e861304bSAllison Henderson * end of the extent 3739e861304bSAllison Henderson */ 3740e861304bSAllison Henderson punched_out = allocated < map->m_len ? 3741e861304bSAllison Henderson allocated : map->m_len; 3742e861304bSAllison Henderson 3743e861304bSAllison Henderson /* 3744e861304bSAllison Henderson * Sense extents need to be converted to 3745e861304bSAllison Henderson * uninitialized, they must fit in an 3746e861304bSAllison Henderson * uninitialized extent 3747e861304bSAllison Henderson */ 3748e861304bSAllison Henderson if (punched_out > EXT_UNINIT_MAX_LEN) 3749e861304bSAllison Henderson punched_out = EXT_UNINIT_MAX_LEN; 3750e861304bSAllison Henderson 3751e861304bSAllison Henderson punch_map.m_lblk = map->m_lblk; 3752e861304bSAllison Henderson punch_map.m_pblk = newblock; 3753e861304bSAllison Henderson punch_map.m_len = punched_out; 3754e861304bSAllison Henderson punch_map.m_flags = 0; 3755e861304bSAllison Henderson 3756e861304bSAllison Henderson /* Check to see if the extent needs to be split */ 3757e861304bSAllison Henderson if (punch_map.m_len != ee_len || 3758e861304bSAllison Henderson punch_map.m_lblk != ee_block) { 3759e861304bSAllison Henderson 3760e861304bSAllison Henderson ret = ext4_split_extent(handle, inode, 3761e861304bSAllison Henderson path, &punch_map, 0, 3762e861304bSAllison Henderson EXT4_GET_BLOCKS_PUNCH_OUT_EXT | 3763e861304bSAllison Henderson EXT4_GET_BLOCKS_PRE_IO); 3764e861304bSAllison Henderson 3765e861304bSAllison Henderson if (ret < 0) { 3766e861304bSAllison Henderson err = ret; 3767e861304bSAllison Henderson goto out2; 3768e861304bSAllison Henderson } 3769e861304bSAllison Henderson /* 3770e861304bSAllison Henderson * find extent for the block at 3771e861304bSAllison Henderson * the start of the hole 3772e861304bSAllison Henderson */ 3773e861304bSAllison Henderson ext4_ext_drop_refs(path); 3774e861304bSAllison Henderson kfree(path); 3775e861304bSAllison Henderson 3776e861304bSAllison Henderson path = ext4_ext_find_extent(inode, 3777e861304bSAllison Henderson map->m_lblk, NULL); 3778e861304bSAllison Henderson if (IS_ERR(path)) { 3779e861304bSAllison Henderson err = PTR_ERR(path); 3780e861304bSAllison Henderson path = NULL; 3781e861304bSAllison Henderson goto out2; 3782e861304bSAllison Henderson } 3783e861304bSAllison Henderson 3784e861304bSAllison Henderson depth = ext_depth(inode); 3785e861304bSAllison Henderson ex = path[depth].p_ext; 3786e861304bSAllison Henderson ee_len = ext4_ext_get_actual_len(ex); 3787e861304bSAllison Henderson ee_block = le32_to_cpu(ex->ee_block); 3788e861304bSAllison Henderson ee_start = ext4_ext_pblock(ex); 3789e861304bSAllison Henderson 3790e861304bSAllison Henderson } 3791e861304bSAllison Henderson 3792e861304bSAllison Henderson ext4_ext_mark_uninitialized(ex); 3793e861304bSAllison Henderson 3794f7d0d379SAllison Henderson ext4_ext_invalidate_cache(inode); 3795f7d0d379SAllison Henderson 3796f7d0d379SAllison Henderson err = ext4_ext_rm_leaf(handle, inode, path, 37970aa06000STheodore Ts'o &partial_cluster, map->m_lblk, 37980aa06000STheodore Ts'o map->m_lblk + punched_out); 3799f7d0d379SAllison Henderson 3800f7d0d379SAllison Henderson if (!err && path->p_hdr->eh_entries == 0) { 3801f7d0d379SAllison Henderson /* 3802f7d0d379SAllison Henderson * Punch hole freed all of this sub tree, 3803f7d0d379SAllison Henderson * so we need to correct eh_depth 3804f7d0d379SAllison Henderson */ 3805f7d0d379SAllison Henderson err = ext4_ext_get_access(handle, inode, path); 3806f7d0d379SAllison Henderson if (err == 0) { 3807f7d0d379SAllison Henderson ext_inode_hdr(inode)->eh_depth = 0; 3808f7d0d379SAllison Henderson ext_inode_hdr(inode)->eh_max = 3809f7d0d379SAllison Henderson cpu_to_le16(ext4_ext_space_root( 3810f7d0d379SAllison Henderson inode, 0)); 3811f7d0d379SAllison Henderson 3812f7d0d379SAllison Henderson err = ext4_ext_dirty( 3813f7d0d379SAllison Henderson handle, inode, path); 3814f7d0d379SAllison Henderson } 3815f7d0d379SAllison Henderson } 3816e861304bSAllison Henderson 3817e861304bSAllison Henderson goto out2; 3818e861304bSAllison Henderson } 3819a86c6181SAlex Tomas } 3820a86c6181SAlex Tomas 38217b415bf6SAditya Kali if ((sbi->s_cluster_ratio > 1) && 38227b415bf6SAditya Kali ext4_find_delalloc_cluster(inode, map->m_lblk, 0)) 38237b415bf6SAditya Kali map->m_flags |= EXT4_MAP_FROM_CLUSTER; 38247b415bf6SAditya Kali 3825a86c6181SAlex Tomas /* 3826d0d856e8SRandy Dunlap * requested block isn't allocated yet; 3827a86c6181SAlex Tomas * we couldn't try to create block if create flag is zero 3828a86c6181SAlex Tomas */ 3829c2177057STheodore Ts'o if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) { 383056055d3aSAmit Arora /* 383156055d3aSAmit Arora * put just found gap into cache to speed up 383256055d3aSAmit Arora * subsequent requests 383356055d3aSAmit Arora */ 3834e35fd660STheodore Ts'o ext4_ext_put_gap_in_cache(inode, path, map->m_lblk); 3835a86c6181SAlex Tomas goto out2; 3836a86c6181SAlex Tomas } 38374d33b1efSTheodore Ts'o 3838a86c6181SAlex Tomas /* 3839c2ea3fdeSTheodore Ts'o * Okay, we need to do block allocation. 3840a86c6181SAlex Tomas */ 38417b415bf6SAditya Kali map->m_flags &= ~EXT4_MAP_FROM_CLUSTER; 38424d33b1efSTheodore Ts'o newex.ee_block = cpu_to_le32(map->m_lblk); 38434d33b1efSTheodore Ts'o cluster_offset = map->m_lblk & (sbi->s_cluster_ratio-1); 38444d33b1efSTheodore Ts'o 38454d33b1efSTheodore Ts'o /* 38464d33b1efSTheodore Ts'o * If we are doing bigalloc, check to see if the extent returned 38474d33b1efSTheodore Ts'o * by ext4_ext_find_extent() implies a cluster we can use. 38484d33b1efSTheodore Ts'o */ 38494d33b1efSTheodore Ts'o if (cluster_offset && ex && 3850d8990240SAditya Kali get_implied_cluster_alloc(inode->i_sb, map, ex, path)) { 38514d33b1efSTheodore Ts'o ar.len = allocated = map->m_len; 38524d33b1efSTheodore Ts'o newblock = map->m_pblk; 38537b415bf6SAditya Kali map->m_flags |= EXT4_MAP_FROM_CLUSTER; 38544d33b1efSTheodore Ts'o goto got_allocated_blocks; 38554d33b1efSTheodore Ts'o } 3856a86c6181SAlex Tomas 3857c9de560dSAlex Tomas /* find neighbour allocated blocks */ 3858e35fd660STheodore Ts'o ar.lleft = map->m_lblk; 3859c9de560dSAlex Tomas err = ext4_ext_search_left(inode, path, &ar.lleft, &ar.pleft); 3860c9de560dSAlex Tomas if (err) 3861c9de560dSAlex Tomas goto out2; 3862e35fd660STheodore Ts'o ar.lright = map->m_lblk; 38634d33b1efSTheodore Ts'o ex2 = NULL; 38644d33b1efSTheodore Ts'o err = ext4_ext_search_right(inode, path, &ar.lright, &ar.pright, &ex2); 3865c9de560dSAlex Tomas if (err) 3866c9de560dSAlex Tomas goto out2; 386725d14f98SAmit Arora 38684d33b1efSTheodore Ts'o /* Check if the extent after searching to the right implies a 38694d33b1efSTheodore Ts'o * cluster we can use. */ 38704d33b1efSTheodore Ts'o if ((sbi->s_cluster_ratio > 1) && ex2 && 3871d8990240SAditya Kali get_implied_cluster_alloc(inode->i_sb, map, ex2, path)) { 38724d33b1efSTheodore Ts'o ar.len = allocated = map->m_len; 38734d33b1efSTheodore Ts'o newblock = map->m_pblk; 38747b415bf6SAditya Kali map->m_flags |= EXT4_MAP_FROM_CLUSTER; 38754d33b1efSTheodore Ts'o goto got_allocated_blocks; 38764d33b1efSTheodore Ts'o } 38774d33b1efSTheodore Ts'o 3878749269faSAmit Arora /* 3879749269faSAmit Arora * See if request is beyond maximum number of blocks we can have in 3880749269faSAmit Arora * a single extent. For an initialized extent this limit is 3881749269faSAmit Arora * EXT_INIT_MAX_LEN and for an uninitialized extent this limit is 3882749269faSAmit Arora * EXT_UNINIT_MAX_LEN. 3883749269faSAmit Arora */ 3884e35fd660STheodore Ts'o if (map->m_len > EXT_INIT_MAX_LEN && 3885c2177057STheodore Ts'o !(flags & EXT4_GET_BLOCKS_UNINIT_EXT)) 3886e35fd660STheodore Ts'o map->m_len = EXT_INIT_MAX_LEN; 3887e35fd660STheodore Ts'o else if (map->m_len > EXT_UNINIT_MAX_LEN && 3888c2177057STheodore Ts'o (flags & EXT4_GET_BLOCKS_UNINIT_EXT)) 3889e35fd660STheodore Ts'o map->m_len = EXT_UNINIT_MAX_LEN; 3890749269faSAmit Arora 3891e35fd660STheodore Ts'o /* Check if we can really insert (m_lblk)::(m_lblk + m_len) extent */ 3892e35fd660STheodore Ts'o newex.ee_len = cpu_to_le16(map->m_len); 38934d33b1efSTheodore Ts'o err = ext4_ext_check_overlap(sbi, inode, &newex, path); 389425d14f98SAmit Arora if (err) 3895b939e376SAneesh Kumar K.V allocated = ext4_ext_get_actual_len(&newex); 389625d14f98SAmit Arora else 3897e35fd660STheodore Ts'o allocated = map->m_len; 3898c9de560dSAlex Tomas 3899c9de560dSAlex Tomas /* allocate new block */ 3900c9de560dSAlex Tomas ar.inode = inode; 3901e35fd660STheodore Ts'o ar.goal = ext4_ext_find_goal(inode, path, map->m_lblk); 3902e35fd660STheodore Ts'o ar.logical = map->m_lblk; 39034d33b1efSTheodore Ts'o /* 39044d33b1efSTheodore Ts'o * We calculate the offset from the beginning of the cluster 39054d33b1efSTheodore Ts'o * for the logical block number, since when we allocate a 39064d33b1efSTheodore Ts'o * physical cluster, the physical block should start at the 39074d33b1efSTheodore Ts'o * same offset from the beginning of the cluster. This is 39084d33b1efSTheodore Ts'o * needed so that future calls to get_implied_cluster_alloc() 39094d33b1efSTheodore Ts'o * work correctly. 39104d33b1efSTheodore Ts'o */ 39114d33b1efSTheodore Ts'o offset = map->m_lblk & (sbi->s_cluster_ratio - 1); 39124d33b1efSTheodore Ts'o ar.len = EXT4_NUM_B2C(sbi, offset+allocated); 39134d33b1efSTheodore Ts'o ar.goal -= offset; 39144d33b1efSTheodore Ts'o ar.logical -= offset; 3915c9de560dSAlex Tomas if (S_ISREG(inode->i_mode)) 3916c9de560dSAlex Tomas ar.flags = EXT4_MB_HINT_DATA; 3917c9de560dSAlex Tomas else 3918c9de560dSAlex Tomas /* disable in-core preallocation for non-regular files */ 3919c9de560dSAlex Tomas ar.flags = 0; 3920556b27abSVivek Haldar if (flags & EXT4_GET_BLOCKS_NO_NORMALIZE) 3921556b27abSVivek Haldar ar.flags |= EXT4_MB_HINT_NOPREALLOC; 3922c9de560dSAlex Tomas newblock = ext4_mb_new_blocks(handle, &ar, &err); 3923a86c6181SAlex Tomas if (!newblock) 3924a86c6181SAlex Tomas goto out2; 392584fe3befSMingming ext_debug("allocate new block: goal %llu, found %llu/%u\n", 3926498e5f24STheodore Ts'o ar.goal, newblock, allocated); 39274d33b1efSTheodore Ts'o free_on_err = 1; 39287b415bf6SAditya Kali allocated_clusters = ar.len; 39294d33b1efSTheodore Ts'o ar.len = EXT4_C2B(sbi, ar.len) - offset; 39304d33b1efSTheodore Ts'o if (ar.len > allocated) 39314d33b1efSTheodore Ts'o ar.len = allocated; 3932a86c6181SAlex Tomas 39334d33b1efSTheodore Ts'o got_allocated_blocks: 3934a86c6181SAlex Tomas /* try to insert new extent into found leaf and return */ 39354d33b1efSTheodore Ts'o ext4_ext_store_pblock(&newex, newblock + offset); 3936c9de560dSAlex Tomas newex.ee_len = cpu_to_le16(ar.len); 39378d5d02e6SMingming Cao /* Mark uninitialized */ 39388d5d02e6SMingming Cao if (flags & EXT4_GET_BLOCKS_UNINIT_EXT){ 3939a2df2a63SAmit Arora ext4_ext_mark_uninitialized(&newex); 39408d5d02e6SMingming Cao /* 3941744692dcSJiaying Zhang * io_end structure was created for every IO write to an 394225985edcSLucas De Marchi * uninitialized extent. To avoid unnecessary conversion, 3943744692dcSJiaying Zhang * here we flag the IO that really needs the conversion. 39445f524950SMingming * For non asycn direct IO case, flag the inode state 394525985edcSLucas De Marchi * that we need to perform conversion when IO is done. 39468d5d02e6SMingming Cao */ 3947744692dcSJiaying Zhang if ((flags & EXT4_GET_BLOCKS_PRE_IO)) { 3948e9e3bcecSEric Sandeen if (io && !(io->flag & EXT4_IO_END_UNWRITTEN)) { 3949bd2d0210STheodore Ts'o io->flag = EXT4_IO_END_UNWRITTEN; 3950e9e3bcecSEric Sandeen atomic_inc(&EXT4_I(inode)->i_aiodio_unwritten); 3951e9e3bcecSEric Sandeen } else 395219f5fb7aSTheodore Ts'o ext4_set_inode_state(inode, 395319f5fb7aSTheodore Ts'o EXT4_STATE_DIO_UNWRITTEN); 39545f524950SMingming } 3955744692dcSJiaying Zhang if (ext4_should_dioread_nolock(inode)) 3956e35fd660STheodore Ts'o map->m_flags |= EXT4_MAP_UNINIT; 39578d5d02e6SMingming Cao } 3958c8d46e41SJiaying Zhang 3959a4e5d88bSDmitry Monakhov err = 0; 3960a4e5d88bSDmitry Monakhov if ((flags & EXT4_GET_BLOCKS_KEEP_SIZE) == 0) 3961a4e5d88bSDmitry Monakhov err = check_eofblocks_fl(handle, inode, map->m_lblk, 3962a4e5d88bSDmitry Monakhov path, ar.len); 3963575a1d4bSJiaying Zhang if (!err) 3964575a1d4bSJiaying Zhang err = ext4_ext_insert_extent(handle, inode, path, 3965575a1d4bSJiaying Zhang &newex, flags); 39664d33b1efSTheodore Ts'o if (err && free_on_err) { 39677132de74SMaxim Patlasov int fb_flags = flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE ? 39687132de74SMaxim Patlasov EXT4_FREE_BLOCKS_NO_QUOT_UPDATE : 0; 3969315054f0SAlex Tomas /* free data blocks we just allocated */ 3970c9de560dSAlex Tomas /* not a good idea to call discard here directly, 3971c9de560dSAlex Tomas * but otherwise we'd need to call it every free() */ 3972c2ea3fdeSTheodore Ts'o ext4_discard_preallocations(inode); 39737dc57615SPeter Huewe ext4_free_blocks(handle, inode, NULL, ext4_ext_pblock(&newex), 39747132de74SMaxim Patlasov ext4_ext_get_actual_len(&newex), fb_flags); 3975a86c6181SAlex Tomas goto out2; 3976315054f0SAlex Tomas } 3977a86c6181SAlex Tomas 3978a86c6181SAlex Tomas /* previous routine could use block we allocated */ 3979bf89d16fSTheodore Ts'o newblock = ext4_ext_pblock(&newex); 3980b939e376SAneesh Kumar K.V allocated = ext4_ext_get_actual_len(&newex); 3981e35fd660STheodore Ts'o if (allocated > map->m_len) 3982e35fd660STheodore Ts'o allocated = map->m_len; 3983e35fd660STheodore Ts'o map->m_flags |= EXT4_MAP_NEW; 3984a86c6181SAlex Tomas 3985b436b9beSJan Kara /* 39865f634d06SAneesh Kumar K.V * Update reserved blocks/metadata blocks after successful 39875f634d06SAneesh Kumar K.V * block allocation which had been deferred till now. 39885f634d06SAneesh Kumar K.V */ 39897b415bf6SAditya Kali if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) { 39907b415bf6SAditya Kali /* 39917b415bf6SAditya Kali * Check how many clusters we had reserved this allocted range. 39927b415bf6SAditya Kali */ 39937b415bf6SAditya Kali reserved_clusters = get_reserved_cluster_alloc(inode, 39947b415bf6SAditya Kali map->m_lblk, allocated); 39957b415bf6SAditya Kali if (map->m_flags & EXT4_MAP_FROM_CLUSTER) { 39967b415bf6SAditya Kali if (reserved_clusters) { 39977b415bf6SAditya Kali /* 39987b415bf6SAditya Kali * We have clusters reserved for this range. 39997b415bf6SAditya Kali * But since we are not doing actual allocation 40007b415bf6SAditya Kali * and are simply using blocks from previously 40017b415bf6SAditya Kali * allocated cluster, we should release the 40027b415bf6SAditya Kali * reservation and not claim quota. 40037b415bf6SAditya Kali */ 40047b415bf6SAditya Kali ext4_da_update_reserve_space(inode, 40057b415bf6SAditya Kali reserved_clusters, 0); 40067b415bf6SAditya Kali } 40077b415bf6SAditya Kali } else { 40087b415bf6SAditya Kali BUG_ON(allocated_clusters < reserved_clusters); 40097b415bf6SAditya Kali /* We will claim quota for all newly allocated blocks.*/ 40107b415bf6SAditya Kali ext4_da_update_reserve_space(inode, allocated_clusters, 40117b415bf6SAditya Kali 1); 40127b415bf6SAditya Kali if (reserved_clusters < allocated_clusters) { 40135356f261SAditya Kali struct ext4_inode_info *ei = EXT4_I(inode); 40147b415bf6SAditya Kali int reservation = allocated_clusters - 40157b415bf6SAditya Kali reserved_clusters; 40167b415bf6SAditya Kali /* 40177b415bf6SAditya Kali * It seems we claimed few clusters outside of 40187b415bf6SAditya Kali * the range of this allocation. We should give 40197b415bf6SAditya Kali * it back to the reservation pool. This can 40207b415bf6SAditya Kali * happen in the following case: 40217b415bf6SAditya Kali * 40227b415bf6SAditya Kali * * Suppose s_cluster_ratio is 4 (i.e., each 40237b415bf6SAditya Kali * cluster has 4 blocks. Thus, the clusters 40247b415bf6SAditya Kali * are [0-3],[4-7],[8-11]... 40257b415bf6SAditya Kali * * First comes delayed allocation write for 40267b415bf6SAditya Kali * logical blocks 10 & 11. Since there were no 40277b415bf6SAditya Kali * previous delayed allocated blocks in the 40287b415bf6SAditya Kali * range [8-11], we would reserve 1 cluster 40297b415bf6SAditya Kali * for this write. 40307b415bf6SAditya Kali * * Next comes write for logical blocks 3 to 8. 40317b415bf6SAditya Kali * In this case, we will reserve 2 clusters 40327b415bf6SAditya Kali * (for [0-3] and [4-7]; and not for [8-11] as 40337b415bf6SAditya Kali * that range has a delayed allocated blocks. 40347b415bf6SAditya Kali * Thus total reserved clusters now becomes 3. 40357b415bf6SAditya Kali * * Now, during the delayed allocation writeout 40367b415bf6SAditya Kali * time, we will first write blocks [3-8] and 40377b415bf6SAditya Kali * allocate 3 clusters for writing these 40387b415bf6SAditya Kali * blocks. Also, we would claim all these 40397b415bf6SAditya Kali * three clusters above. 40407b415bf6SAditya Kali * * Now when we come here to writeout the 40417b415bf6SAditya Kali * blocks [10-11], we would expect to claim 40427b415bf6SAditya Kali * the reservation of 1 cluster we had made 40437b415bf6SAditya Kali * (and we would claim it since there are no 40447b415bf6SAditya Kali * more delayed allocated blocks in the range 40457b415bf6SAditya Kali * [8-11]. But our reserved cluster count had 40467b415bf6SAditya Kali * already gone to 0. 40477b415bf6SAditya Kali * 40487b415bf6SAditya Kali * Thus, at the step 4 above when we determine 40497b415bf6SAditya Kali * that there are still some unwritten delayed 40507b415bf6SAditya Kali * allocated blocks outside of our current 40517b415bf6SAditya Kali * block range, we should increment the 40527b415bf6SAditya Kali * reserved clusters count so that when the 40537b415bf6SAditya Kali * remaining blocks finally gets written, we 40547b415bf6SAditya Kali * could claim them. 40557b415bf6SAditya Kali */ 40565356f261SAditya Kali dquot_reserve_block(inode, 40575356f261SAditya Kali EXT4_C2B(sbi, reservation)); 40585356f261SAditya Kali spin_lock(&ei->i_block_reservation_lock); 40595356f261SAditya Kali ei->i_reserved_data_blocks += reservation; 40605356f261SAditya Kali spin_unlock(&ei->i_block_reservation_lock); 40617b415bf6SAditya Kali } 40627b415bf6SAditya Kali } 40637b415bf6SAditya Kali } 40645f634d06SAneesh Kumar K.V 40655f634d06SAneesh Kumar K.V /* 4066b436b9beSJan Kara * Cache the extent and update transaction to commit on fdatasync only 4067b436b9beSJan Kara * when it is _not_ an uninitialized extent. 4068b436b9beSJan Kara */ 4069b436b9beSJan Kara if ((flags & EXT4_GET_BLOCKS_UNINIT_EXT) == 0) { 4070b05e6ae5STheodore Ts'o ext4_ext_put_in_cache(inode, map->m_lblk, allocated, newblock); 4071b436b9beSJan Kara ext4_update_inode_fsync_trans(handle, inode, 1); 4072b436b9beSJan Kara } else 4073b436b9beSJan Kara ext4_update_inode_fsync_trans(handle, inode, 0); 4074a86c6181SAlex Tomas out: 4075e35fd660STheodore Ts'o if (allocated > map->m_len) 4076e35fd660STheodore Ts'o allocated = map->m_len; 4077a86c6181SAlex Tomas ext4_ext_show_leaf(inode, path); 4078e35fd660STheodore Ts'o map->m_flags |= EXT4_MAP_MAPPED; 4079e35fd660STheodore Ts'o map->m_pblk = newblock; 4080e35fd660STheodore Ts'o map->m_len = allocated; 4081a86c6181SAlex Tomas out2: 4082a86c6181SAlex Tomas if (path) { 4083a86c6181SAlex Tomas ext4_ext_drop_refs(path); 4084a86c6181SAlex Tomas kfree(path); 4085a86c6181SAlex Tomas } 40860562e0baSJiaying Zhang trace_ext4_ext_map_blocks_exit(inode, map->m_lblk, 40870562e0baSJiaying Zhang newblock, map->m_len, err ? err : allocated); 4088e861304bSAllison Henderson 4089e861304bSAllison Henderson result = (flags & EXT4_GET_BLOCKS_PUNCH_OUT_EXT) ? 4090e861304bSAllison Henderson punched_out : allocated; 4091e861304bSAllison Henderson 4092e861304bSAllison Henderson return err ? err : result; 4093a86c6181SAlex Tomas } 4094a86c6181SAlex Tomas 4095cf108bcaSJan Kara void ext4_ext_truncate(struct inode *inode) 4096a86c6181SAlex Tomas { 4097a86c6181SAlex Tomas struct address_space *mapping = inode->i_mapping; 4098a86c6181SAlex Tomas struct super_block *sb = inode->i_sb; 4099725d26d3SAneesh Kumar K.V ext4_lblk_t last_block; 4100a86c6181SAlex Tomas handle_t *handle; 4101189e868fSAllison Henderson loff_t page_len; 4102a86c6181SAlex Tomas int err = 0; 4103a86c6181SAlex Tomas 4104a86c6181SAlex Tomas /* 41053889fd57SJiaying Zhang * finish any pending end_io work so we won't run the risk of 41063889fd57SJiaying Zhang * converting any truncated blocks to initialized later 41073889fd57SJiaying Zhang */ 41083889fd57SJiaying Zhang ext4_flush_completed_IO(inode); 41093889fd57SJiaying Zhang 41103889fd57SJiaying Zhang /* 4111a86c6181SAlex Tomas * probably first extent we're gonna free will be last in block 4112a86c6181SAlex Tomas */ 4113f3bd1f3fSMingming Cao err = ext4_writepage_trans_blocks(inode); 4114a86c6181SAlex Tomas handle = ext4_journal_start(inode, err); 4115cf108bcaSJan Kara if (IS_ERR(handle)) 4116a86c6181SAlex Tomas return; 4117a86c6181SAlex Tomas 4118189e868fSAllison Henderson if (inode->i_size % PAGE_CACHE_SIZE != 0) { 4119189e868fSAllison Henderson page_len = PAGE_CACHE_SIZE - 4120189e868fSAllison Henderson (inode->i_size & (PAGE_CACHE_SIZE - 1)); 4121189e868fSAllison Henderson 4122189e868fSAllison Henderson err = ext4_discard_partial_page_buffers(handle, 4123189e868fSAllison Henderson mapping, inode->i_size, page_len, 0); 4124189e868fSAllison Henderson 4125189e868fSAllison Henderson if (err) 4126189e868fSAllison Henderson goto out_stop; 4127189e868fSAllison Henderson } 4128a86c6181SAlex Tomas 41299ddfc3dcSJan Kara if (ext4_orphan_add(handle, inode)) 41309ddfc3dcSJan Kara goto out_stop; 41319ddfc3dcSJan Kara 41320e855ac8SAneesh Kumar K.V down_write(&EXT4_I(inode)->i_data_sem); 4133a86c6181SAlex Tomas ext4_ext_invalidate_cache(inode); 4134a86c6181SAlex Tomas 4135c2ea3fdeSTheodore Ts'o ext4_discard_preallocations(inode); 4136c9de560dSAlex Tomas 4137a86c6181SAlex Tomas /* 4138d0d856e8SRandy Dunlap * TODO: optimization is possible here. 4139d0d856e8SRandy Dunlap * Probably we need not scan at all, 4140d0d856e8SRandy Dunlap * because page truncation is enough. 4141a86c6181SAlex Tomas */ 4142a86c6181SAlex Tomas 4143a86c6181SAlex Tomas /* we have to know where to truncate from in crash case */ 4144a86c6181SAlex Tomas EXT4_I(inode)->i_disksize = inode->i_size; 4145a86c6181SAlex Tomas ext4_mark_inode_dirty(handle, inode); 4146a86c6181SAlex Tomas 4147a86c6181SAlex Tomas last_block = (inode->i_size + sb->s_blocksize - 1) 4148a86c6181SAlex Tomas >> EXT4_BLOCK_SIZE_BITS(sb); 4149c6a0371cSAllison Henderson err = ext4_ext_remove_space(inode, last_block); 4150a86c6181SAlex Tomas 4151a86c6181SAlex Tomas /* In a multi-transaction truncate, we only make the final 415256055d3aSAmit Arora * transaction synchronous. 415356055d3aSAmit Arora */ 4154a86c6181SAlex Tomas if (IS_SYNC(inode)) 41550390131bSFrank Mayhar ext4_handle_sync(handle); 4156a86c6181SAlex Tomas 41579ddfc3dcSJan Kara up_write(&EXT4_I(inode)->i_data_sem); 4158f6d2f6b3SEric Gouriou 4159f6d2f6b3SEric Gouriou out_stop: 4160a86c6181SAlex Tomas /* 4161d0d856e8SRandy Dunlap * If this was a simple ftruncate() and the file will remain alive, 4162a86c6181SAlex Tomas * then we need to clear up the orphan record which we created above. 4163a86c6181SAlex Tomas * However, if this was a real unlink then we were called by 4164a86c6181SAlex Tomas * ext4_delete_inode(), and we allow that function to clean up the 4165a86c6181SAlex Tomas * orphan info for us. 4166a86c6181SAlex Tomas */ 4167a86c6181SAlex Tomas if (inode->i_nlink) 4168a86c6181SAlex Tomas ext4_orphan_del(handle, inode); 4169a86c6181SAlex Tomas 4170ef737728SSolofo Ramangalahy inode->i_mtime = inode->i_ctime = ext4_current_time(inode); 4171ef737728SSolofo Ramangalahy ext4_mark_inode_dirty(handle, inode); 4172a86c6181SAlex Tomas ext4_journal_stop(handle); 4173a86c6181SAlex Tomas } 4174a86c6181SAlex Tomas 4175fd28784aSAneesh Kumar K.V static void ext4_falloc_update_inode(struct inode *inode, 4176fd28784aSAneesh Kumar K.V int mode, loff_t new_size, int update_ctime) 4177fd28784aSAneesh Kumar K.V { 4178fd28784aSAneesh Kumar K.V struct timespec now; 4179fd28784aSAneesh Kumar K.V 4180fd28784aSAneesh Kumar K.V if (update_ctime) { 4181fd28784aSAneesh Kumar K.V now = current_fs_time(inode->i_sb); 4182fd28784aSAneesh Kumar K.V if (!timespec_equal(&inode->i_ctime, &now)) 4183fd28784aSAneesh Kumar K.V inode->i_ctime = now; 4184fd28784aSAneesh Kumar K.V } 4185fd28784aSAneesh Kumar K.V /* 4186fd28784aSAneesh Kumar K.V * Update only when preallocation was requested beyond 4187fd28784aSAneesh Kumar K.V * the file size. 4188fd28784aSAneesh Kumar K.V */ 4189cf17fea6SAneesh Kumar K.V if (!(mode & FALLOC_FL_KEEP_SIZE)) { 4190cf17fea6SAneesh Kumar K.V if (new_size > i_size_read(inode)) 4191fd28784aSAneesh Kumar K.V i_size_write(inode, new_size); 4192cf17fea6SAneesh Kumar K.V if (new_size > EXT4_I(inode)->i_disksize) 4193cf17fea6SAneesh Kumar K.V ext4_update_i_disksize(inode, new_size); 4194c8d46e41SJiaying Zhang } else { 4195c8d46e41SJiaying Zhang /* 4196c8d46e41SJiaying Zhang * Mark that we allocate beyond EOF so the subsequent truncate 4197c8d46e41SJiaying Zhang * can proceed even if the new size is the same as i_size. 4198c8d46e41SJiaying Zhang */ 4199c8d46e41SJiaying Zhang if (new_size > i_size_read(inode)) 420012e9b892SDmitry Monakhov ext4_set_inode_flag(inode, EXT4_INODE_EOFBLOCKS); 4201fd28784aSAneesh Kumar K.V } 4202fd28784aSAneesh Kumar K.V 4203fd28784aSAneesh Kumar K.V } 4204fd28784aSAneesh Kumar K.V 4205a2df2a63SAmit Arora /* 42062fe17c10SChristoph Hellwig * preallocate space for a file. This implements ext4's fallocate file 4207a2df2a63SAmit Arora * operation, which gets called from sys_fallocate system call. 4208a2df2a63SAmit Arora * For block-mapped files, posix_fallocate should fall back to the method 4209a2df2a63SAmit Arora * of writing zeroes to the required new blocks (the same behavior which is 4210a2df2a63SAmit Arora * expected for file systems which do not support fallocate() system call). 4211a2df2a63SAmit Arora */ 42122fe17c10SChristoph Hellwig long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len) 4213a2df2a63SAmit Arora { 42142fe17c10SChristoph Hellwig struct inode *inode = file->f_path.dentry->d_inode; 4215a2df2a63SAmit Arora handle_t *handle; 4216fd28784aSAneesh Kumar K.V loff_t new_size; 4217498e5f24STheodore Ts'o unsigned int max_blocks; 4218a2df2a63SAmit Arora int ret = 0; 4219a2df2a63SAmit Arora int ret2 = 0; 4220a2df2a63SAmit Arora int retries = 0; 4221a4e5d88bSDmitry Monakhov int flags; 42222ed88685STheodore Ts'o struct ext4_map_blocks map; 4223a2df2a63SAmit Arora unsigned int credits, blkbits = inode->i_blkbits; 4224a2df2a63SAmit Arora 4225a2df2a63SAmit Arora /* 4226a2df2a63SAmit Arora * currently supporting (pre)allocate mode for extent-based 4227a2df2a63SAmit Arora * files _only_ 4228a2df2a63SAmit Arora */ 422912e9b892SDmitry Monakhov if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) 4230a2df2a63SAmit Arora return -EOPNOTSUPP; 4231a2df2a63SAmit Arora 4232a4bb6b64SAllison Henderson /* Return error if mode is not supported */ 4233a4bb6b64SAllison Henderson if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE)) 4234a4bb6b64SAllison Henderson return -EOPNOTSUPP; 4235a4bb6b64SAllison Henderson 4236a4bb6b64SAllison Henderson if (mode & FALLOC_FL_PUNCH_HOLE) 4237a4bb6b64SAllison Henderson return ext4_punch_hole(file, offset, len); 4238a4bb6b64SAllison Henderson 42390562e0baSJiaying Zhang trace_ext4_fallocate_enter(inode, offset, len, mode); 42402ed88685STheodore Ts'o map.m_lblk = offset >> blkbits; 4241fd28784aSAneesh Kumar K.V /* 4242fd28784aSAneesh Kumar K.V * We can't just convert len to max_blocks because 4243fd28784aSAneesh Kumar K.V * If blocksize = 4096 offset = 3072 and len = 2048 4244fd28784aSAneesh Kumar K.V */ 4245a2df2a63SAmit Arora max_blocks = (EXT4_BLOCK_ALIGN(len + offset, blkbits) >> blkbits) 42462ed88685STheodore Ts'o - map.m_lblk; 4247a2df2a63SAmit Arora /* 4248f3bd1f3fSMingming Cao * credits to insert 1 extent into extent tree 4249a2df2a63SAmit Arora */ 4250f3bd1f3fSMingming Cao credits = ext4_chunk_trans_blocks(inode, max_blocks); 425155bd725aSAneesh Kumar K.V mutex_lock(&inode->i_mutex); 42526d19c42bSNikanth Karthikesan ret = inode_newsize_ok(inode, (len + offset)); 42536d19c42bSNikanth Karthikesan if (ret) { 42546d19c42bSNikanth Karthikesan mutex_unlock(&inode->i_mutex); 42550562e0baSJiaying Zhang trace_ext4_fallocate_exit(inode, offset, max_blocks, ret); 42566d19c42bSNikanth Karthikesan return ret; 42576d19c42bSNikanth Karthikesan } 4258a4e5d88bSDmitry Monakhov flags = EXT4_GET_BLOCKS_CREATE_UNINIT_EXT | 4259a4e5d88bSDmitry Monakhov EXT4_GET_BLOCKS_NO_NORMALIZE; 4260a4e5d88bSDmitry Monakhov if (mode & FALLOC_FL_KEEP_SIZE) 4261a4e5d88bSDmitry Monakhov flags |= EXT4_GET_BLOCKS_KEEP_SIZE; 4262a2df2a63SAmit Arora retry: 4263a2df2a63SAmit Arora while (ret >= 0 && ret < max_blocks) { 42642ed88685STheodore Ts'o map.m_lblk = map.m_lblk + ret; 42652ed88685STheodore Ts'o map.m_len = max_blocks = max_blocks - ret; 4266a2df2a63SAmit Arora handle = ext4_journal_start(inode, credits); 4267a2df2a63SAmit Arora if (IS_ERR(handle)) { 4268a2df2a63SAmit Arora ret = PTR_ERR(handle); 4269a2df2a63SAmit Arora break; 4270a2df2a63SAmit Arora } 4271a4e5d88bSDmitry Monakhov ret = ext4_map_blocks(handle, inode, &map, flags); 4272221879c9SAneesh Kumar K.V if (ret <= 0) { 42732c98615dSAneesh Kumar K.V #ifdef EXT4FS_DEBUG 42742c98615dSAneesh Kumar K.V WARN_ON(ret <= 0); 4275e35fd660STheodore Ts'o printk(KERN_ERR "%s: ext4_ext_map_blocks " 42762c98615dSAneesh Kumar K.V "returned error inode#%lu, block=%u, " 42779fd9784cSThadeu Lima de Souza Cascardo "max_blocks=%u", __func__, 4278a6371b63SKazuya Mio inode->i_ino, map.m_lblk, max_blocks); 42792c98615dSAneesh Kumar K.V #endif 4280a2df2a63SAmit Arora ext4_mark_inode_dirty(handle, inode); 4281a2df2a63SAmit Arora ret2 = ext4_journal_stop(handle); 4282a2df2a63SAmit Arora break; 4283a2df2a63SAmit Arora } 42842ed88685STheodore Ts'o if ((map.m_lblk + ret) >= (EXT4_BLOCK_ALIGN(offset + len, 4285fd28784aSAneesh Kumar K.V blkbits) >> blkbits)) 4286fd28784aSAneesh Kumar K.V new_size = offset + len; 4287fd28784aSAneesh Kumar K.V else 428829ae07b7SUtako Kusaka new_size = ((loff_t) map.m_lblk + ret) << blkbits; 4289a2df2a63SAmit Arora 4290fd28784aSAneesh Kumar K.V ext4_falloc_update_inode(inode, mode, new_size, 42912ed88685STheodore Ts'o (map.m_flags & EXT4_MAP_NEW)); 4292a2df2a63SAmit Arora ext4_mark_inode_dirty(handle, inode); 4293a2df2a63SAmit Arora ret2 = ext4_journal_stop(handle); 4294a2df2a63SAmit Arora if (ret2) 4295a2df2a63SAmit Arora break; 4296a2df2a63SAmit Arora } 4297fd28784aSAneesh Kumar K.V if (ret == -ENOSPC && 4298fd28784aSAneesh Kumar K.V ext4_should_retry_alloc(inode->i_sb, &retries)) { 4299fd28784aSAneesh Kumar K.V ret = 0; 4300a2df2a63SAmit Arora goto retry; 4301a2df2a63SAmit Arora } 430255bd725aSAneesh Kumar K.V mutex_unlock(&inode->i_mutex); 43030562e0baSJiaying Zhang trace_ext4_fallocate_exit(inode, offset, max_blocks, 43040562e0baSJiaying Zhang ret > 0 ? ret2 : ret); 4305a2df2a63SAmit Arora return ret > 0 ? ret2 : ret; 4306a2df2a63SAmit Arora } 43076873fa0dSEric Sandeen 43086873fa0dSEric Sandeen /* 43090031462bSMingming Cao * This function convert a range of blocks to written extents 43100031462bSMingming Cao * The caller of this function will pass the start offset and the size. 43110031462bSMingming Cao * all unwritten extents within this range will be converted to 43120031462bSMingming Cao * written extents. 43130031462bSMingming Cao * 43140031462bSMingming Cao * This function is called from the direct IO end io call back 43150031462bSMingming Cao * function, to convert the fallocated extents after IO is completed. 4316109f5565SMingming * Returns 0 on success. 43170031462bSMingming Cao */ 43180031462bSMingming Cao int ext4_convert_unwritten_extents(struct inode *inode, loff_t offset, 4319a1de02dcSEric Sandeen ssize_t len) 43200031462bSMingming Cao { 43210031462bSMingming Cao handle_t *handle; 43220031462bSMingming Cao unsigned int max_blocks; 43230031462bSMingming Cao int ret = 0; 43240031462bSMingming Cao int ret2 = 0; 43252ed88685STheodore Ts'o struct ext4_map_blocks map; 43260031462bSMingming Cao unsigned int credits, blkbits = inode->i_blkbits; 43270031462bSMingming Cao 43282ed88685STheodore Ts'o map.m_lblk = offset >> blkbits; 43290031462bSMingming Cao /* 43300031462bSMingming Cao * We can't just convert len to max_blocks because 43310031462bSMingming Cao * If blocksize = 4096 offset = 3072 and len = 2048 43320031462bSMingming Cao */ 43332ed88685STheodore Ts'o max_blocks = ((EXT4_BLOCK_ALIGN(len + offset, blkbits) >> blkbits) - 43342ed88685STheodore Ts'o map.m_lblk); 43350031462bSMingming Cao /* 43360031462bSMingming Cao * credits to insert 1 extent into extent tree 43370031462bSMingming Cao */ 43380031462bSMingming Cao credits = ext4_chunk_trans_blocks(inode, max_blocks); 43390031462bSMingming Cao while (ret >= 0 && ret < max_blocks) { 43402ed88685STheodore Ts'o map.m_lblk += ret; 43412ed88685STheodore Ts'o map.m_len = (max_blocks -= ret); 43420031462bSMingming Cao handle = ext4_journal_start(inode, credits); 43430031462bSMingming Cao if (IS_ERR(handle)) { 43440031462bSMingming Cao ret = PTR_ERR(handle); 43450031462bSMingming Cao break; 43460031462bSMingming Cao } 43472ed88685STheodore Ts'o ret = ext4_map_blocks(handle, inode, &map, 4348c7064ef1SJiaying Zhang EXT4_GET_BLOCKS_IO_CONVERT_EXT); 43490031462bSMingming Cao if (ret <= 0) { 43500031462bSMingming Cao WARN_ON(ret <= 0); 4351e35fd660STheodore Ts'o printk(KERN_ERR "%s: ext4_ext_map_blocks " 43520031462bSMingming Cao "returned error inode#%lu, block=%u, " 43530031462bSMingming Cao "max_blocks=%u", __func__, 43542ed88685STheodore Ts'o inode->i_ino, map.m_lblk, map.m_len); 43550031462bSMingming Cao } 43560031462bSMingming Cao ext4_mark_inode_dirty(handle, inode); 43570031462bSMingming Cao ret2 = ext4_journal_stop(handle); 43580031462bSMingming Cao if (ret <= 0 || ret2 ) 43590031462bSMingming Cao break; 43600031462bSMingming Cao } 43610031462bSMingming Cao return ret > 0 ? ret2 : ret; 43620031462bSMingming Cao } 43636d9c85ebSYongqiang Yang 43640031462bSMingming Cao /* 43656873fa0dSEric Sandeen * Callback function called for each extent to gather FIEMAP information. 43666873fa0dSEric Sandeen */ 4367c03f8aa9SLukas Czerner static int ext4_ext_fiemap_cb(struct inode *inode, ext4_lblk_t next, 43686873fa0dSEric Sandeen struct ext4_ext_cache *newex, struct ext4_extent *ex, 43696873fa0dSEric Sandeen void *data) 43706873fa0dSEric Sandeen { 43716873fa0dSEric Sandeen __u64 logical; 43726873fa0dSEric Sandeen __u64 physical; 43736873fa0dSEric Sandeen __u64 length; 43746873fa0dSEric Sandeen __u32 flags = 0; 43756d9c85ebSYongqiang Yang int ret = 0; 43766d9c85ebSYongqiang Yang struct fiemap_extent_info *fieinfo = data; 43776d9c85ebSYongqiang Yang unsigned char blksize_bits; 43786873fa0dSEric Sandeen 43796d9c85ebSYongqiang Yang blksize_bits = inode->i_sb->s_blocksize_bits; 43806873fa0dSEric Sandeen logical = (__u64)newex->ec_block << blksize_bits; 43816873fa0dSEric Sandeen 4382b05e6ae5STheodore Ts'o if (newex->ec_start == 0) { 43836d9c85ebSYongqiang Yang /* 43846d9c85ebSYongqiang Yang * No extent in extent-tree contains block @newex->ec_start, 43856d9c85ebSYongqiang Yang * then the block may stay in 1)a hole or 2)delayed-extent. 43866d9c85ebSYongqiang Yang * 43876d9c85ebSYongqiang Yang * Holes or delayed-extents are processed as follows. 43886d9c85ebSYongqiang Yang * 1. lookup dirty pages with specified range in pagecache. 43896d9c85ebSYongqiang Yang * If no page is got, then there is no delayed-extent and 43906d9c85ebSYongqiang Yang * return with EXT_CONTINUE. 43916d9c85ebSYongqiang Yang * 2. find the 1st mapped buffer, 43926d9c85ebSYongqiang Yang * 3. check if the mapped buffer is both in the request range 43936d9c85ebSYongqiang Yang * and a delayed buffer. If not, there is no delayed-extent, 43946d9c85ebSYongqiang Yang * then return. 43956d9c85ebSYongqiang Yang * 4. a delayed-extent is found, the extent will be collected. 43966d9c85ebSYongqiang Yang */ 43976d9c85ebSYongqiang Yang ext4_lblk_t end = 0; 43986d9c85ebSYongqiang Yang pgoff_t last_offset; 43996873fa0dSEric Sandeen pgoff_t offset; 44006d9c85ebSYongqiang Yang pgoff_t index; 4401b221349fSYongqiang Yang pgoff_t start_index = 0; 44026d9c85ebSYongqiang Yang struct page **pages = NULL; 44036873fa0dSEric Sandeen struct buffer_head *bh = NULL; 44046d9c85ebSYongqiang Yang struct buffer_head *head = NULL; 44056d9c85ebSYongqiang Yang unsigned int nr_pages = PAGE_SIZE / sizeof(struct page *); 44066d9c85ebSYongqiang Yang 44076d9c85ebSYongqiang Yang pages = kmalloc(PAGE_SIZE, GFP_KERNEL); 44086d9c85ebSYongqiang Yang if (pages == NULL) 44096d9c85ebSYongqiang Yang return -ENOMEM; 44106873fa0dSEric Sandeen 44116873fa0dSEric Sandeen offset = logical >> PAGE_SHIFT; 44126d9c85ebSYongqiang Yang repeat: 44136d9c85ebSYongqiang Yang last_offset = offset; 44146d9c85ebSYongqiang Yang head = NULL; 44156d9c85ebSYongqiang Yang ret = find_get_pages_tag(inode->i_mapping, &offset, 44166d9c85ebSYongqiang Yang PAGECACHE_TAG_DIRTY, nr_pages, pages); 44176873fa0dSEric Sandeen 44186d9c85ebSYongqiang Yang if (!(flags & FIEMAP_EXTENT_DELALLOC)) { 44196d9c85ebSYongqiang Yang /* First time, try to find a mapped buffer. */ 44206d9c85ebSYongqiang Yang if (ret == 0) { 44216d9c85ebSYongqiang Yang out: 44226d9c85ebSYongqiang Yang for (index = 0; index < ret; index++) 44236d9c85ebSYongqiang Yang page_cache_release(pages[index]); 44246d9c85ebSYongqiang Yang /* just a hole. */ 44256d9c85ebSYongqiang Yang kfree(pages); 44266873fa0dSEric Sandeen return EXT_CONTINUE; 44276873fa0dSEric Sandeen } 4428b221349fSYongqiang Yang index = 0; 44296d9c85ebSYongqiang Yang 4430b221349fSYongqiang Yang next_page: 44316d9c85ebSYongqiang Yang /* Try to find the 1st mapped buffer. */ 4432b221349fSYongqiang Yang end = ((__u64)pages[index]->index << PAGE_SHIFT) >> 44336d9c85ebSYongqiang Yang blksize_bits; 4434b221349fSYongqiang Yang if (!page_has_buffers(pages[index])) 44356d9c85ebSYongqiang Yang goto out; 4436b221349fSYongqiang Yang head = page_buffers(pages[index]); 44376d9c85ebSYongqiang Yang if (!head) 44386d9c85ebSYongqiang Yang goto out; 44396d9c85ebSYongqiang Yang 4440b221349fSYongqiang Yang index++; 44416d9c85ebSYongqiang Yang bh = head; 44426d9c85ebSYongqiang Yang do { 4443b221349fSYongqiang Yang if (end >= newex->ec_block + 44446d9c85ebSYongqiang Yang newex->ec_len) 44456d9c85ebSYongqiang Yang /* The buffer is out of 44466d9c85ebSYongqiang Yang * the request range. 44476d9c85ebSYongqiang Yang */ 44486d9c85ebSYongqiang Yang goto out; 4449b221349fSYongqiang Yang 4450b221349fSYongqiang Yang if (buffer_mapped(bh) && 4451b221349fSYongqiang Yang end >= newex->ec_block) { 4452b221349fSYongqiang Yang start_index = index - 1; 4453b221349fSYongqiang Yang /* get the 1st mapped buffer. */ 44546d9c85ebSYongqiang Yang goto found_mapped_buffer; 44556d9c85ebSYongqiang Yang } 4456b221349fSYongqiang Yang 44576d9c85ebSYongqiang Yang bh = bh->b_this_page; 44586d9c85ebSYongqiang Yang end++; 44596d9c85ebSYongqiang Yang } while (bh != head); 44606d9c85ebSYongqiang Yang 4461b221349fSYongqiang Yang /* No mapped buffer in the range found in this page, 4462b221349fSYongqiang Yang * We need to look up next page. 4463b221349fSYongqiang Yang */ 4464b221349fSYongqiang Yang if (index >= ret) { 4465b221349fSYongqiang Yang /* There is no page left, but we need to limit 4466b221349fSYongqiang Yang * newex->ec_len. 4467b221349fSYongqiang Yang */ 4468b221349fSYongqiang Yang newex->ec_len = end - newex->ec_block; 44696d9c85ebSYongqiang Yang goto out; 4470b221349fSYongqiang Yang } 4471b221349fSYongqiang Yang goto next_page; 44726d9c85ebSYongqiang Yang } else { 44736d9c85ebSYongqiang Yang /*Find contiguous delayed buffers. */ 44746d9c85ebSYongqiang Yang if (ret > 0 && pages[0]->index == last_offset) 44756d9c85ebSYongqiang Yang head = page_buffers(pages[0]); 44766d9c85ebSYongqiang Yang bh = head; 4477b221349fSYongqiang Yang index = 1; 4478b221349fSYongqiang Yang start_index = 0; 44796d9c85ebSYongqiang Yang } 44806d9c85ebSYongqiang Yang 44816d9c85ebSYongqiang Yang found_mapped_buffer: 44826d9c85ebSYongqiang Yang if (bh != NULL && buffer_delay(bh)) { 44836d9c85ebSYongqiang Yang /* 1st or contiguous delayed buffer found. */ 44846d9c85ebSYongqiang Yang if (!(flags & FIEMAP_EXTENT_DELALLOC)) { 44856d9c85ebSYongqiang Yang /* 44866d9c85ebSYongqiang Yang * 1st delayed buffer found, record 44876d9c85ebSYongqiang Yang * the start of extent. 44886d9c85ebSYongqiang Yang */ 44896d9c85ebSYongqiang Yang flags |= FIEMAP_EXTENT_DELALLOC; 44906d9c85ebSYongqiang Yang newex->ec_block = end; 44916d9c85ebSYongqiang Yang logical = (__u64)end << blksize_bits; 44926d9c85ebSYongqiang Yang } 44936d9c85ebSYongqiang Yang /* Find contiguous delayed buffers. */ 44946d9c85ebSYongqiang Yang do { 44956d9c85ebSYongqiang Yang if (!buffer_delay(bh)) 44966d9c85ebSYongqiang Yang goto found_delayed_extent; 44976d9c85ebSYongqiang Yang bh = bh->b_this_page; 44986d9c85ebSYongqiang Yang end++; 44996d9c85ebSYongqiang Yang } while (bh != head); 45006d9c85ebSYongqiang Yang 4501b221349fSYongqiang Yang for (; index < ret; index++) { 45026d9c85ebSYongqiang Yang if (!page_has_buffers(pages[index])) { 45036d9c85ebSYongqiang Yang bh = NULL; 45046d9c85ebSYongqiang Yang break; 45056d9c85ebSYongqiang Yang } 45066d9c85ebSYongqiang Yang head = page_buffers(pages[index]); 45076d9c85ebSYongqiang Yang if (!head) { 45086d9c85ebSYongqiang Yang bh = NULL; 45096d9c85ebSYongqiang Yang break; 45106d9c85ebSYongqiang Yang } 4511b221349fSYongqiang Yang 45126d9c85ebSYongqiang Yang if (pages[index]->index != 4513b221349fSYongqiang Yang pages[start_index]->index + index 4514b221349fSYongqiang Yang - start_index) { 45156d9c85ebSYongqiang Yang /* Blocks are not contiguous. */ 45166d9c85ebSYongqiang Yang bh = NULL; 45176d9c85ebSYongqiang Yang break; 45186d9c85ebSYongqiang Yang } 45196d9c85ebSYongqiang Yang bh = head; 45206d9c85ebSYongqiang Yang do { 45216d9c85ebSYongqiang Yang if (!buffer_delay(bh)) 45226d9c85ebSYongqiang Yang /* Delayed-extent ends. */ 45236d9c85ebSYongqiang Yang goto found_delayed_extent; 45246d9c85ebSYongqiang Yang bh = bh->b_this_page; 45256d9c85ebSYongqiang Yang end++; 45266d9c85ebSYongqiang Yang } while (bh != head); 45276d9c85ebSYongqiang Yang } 45286d9c85ebSYongqiang Yang } else if (!(flags & FIEMAP_EXTENT_DELALLOC)) 45296d9c85ebSYongqiang Yang /* a hole found. */ 45306d9c85ebSYongqiang Yang goto out; 45316d9c85ebSYongqiang Yang 45326d9c85ebSYongqiang Yang found_delayed_extent: 45336d9c85ebSYongqiang Yang newex->ec_len = min(end - newex->ec_block, 45346d9c85ebSYongqiang Yang (ext4_lblk_t)EXT_INIT_MAX_LEN); 45356d9c85ebSYongqiang Yang if (ret == nr_pages && bh != NULL && 45366d9c85ebSYongqiang Yang newex->ec_len < EXT_INIT_MAX_LEN && 45376d9c85ebSYongqiang Yang buffer_delay(bh)) { 45386d9c85ebSYongqiang Yang /* Have not collected an extent and continue. */ 45396d9c85ebSYongqiang Yang for (index = 0; index < ret; index++) 45406d9c85ebSYongqiang Yang page_cache_release(pages[index]); 45416d9c85ebSYongqiang Yang goto repeat; 45426d9c85ebSYongqiang Yang } 45436d9c85ebSYongqiang Yang 45446d9c85ebSYongqiang Yang for (index = 0; index < ret; index++) 45456d9c85ebSYongqiang Yang page_cache_release(pages[index]); 45466d9c85ebSYongqiang Yang kfree(pages); 45476873fa0dSEric Sandeen } 45486873fa0dSEric Sandeen 45496873fa0dSEric Sandeen physical = (__u64)newex->ec_start << blksize_bits; 45506873fa0dSEric Sandeen length = (__u64)newex->ec_len << blksize_bits; 45516873fa0dSEric Sandeen 45526873fa0dSEric Sandeen if (ex && ext4_ext_is_uninitialized(ex)) 45536873fa0dSEric Sandeen flags |= FIEMAP_EXTENT_UNWRITTEN; 45546873fa0dSEric Sandeen 4555c03f8aa9SLukas Czerner if (next == EXT_MAX_BLOCKS) 45566873fa0dSEric Sandeen flags |= FIEMAP_EXTENT_LAST; 45576873fa0dSEric Sandeen 45586d9c85ebSYongqiang Yang ret = fiemap_fill_next_extent(fieinfo, logical, physical, 45596873fa0dSEric Sandeen length, flags); 45606d9c85ebSYongqiang Yang if (ret < 0) 45616d9c85ebSYongqiang Yang return ret; 45626d9c85ebSYongqiang Yang if (ret == 1) 45636873fa0dSEric Sandeen return EXT_BREAK; 45646873fa0dSEric Sandeen return EXT_CONTINUE; 45656873fa0dSEric Sandeen } 45666873fa0dSEric Sandeen /* fiemap flags we can handle specified here */ 45676873fa0dSEric Sandeen #define EXT4_FIEMAP_FLAGS (FIEMAP_FLAG_SYNC|FIEMAP_FLAG_XATTR) 45686873fa0dSEric Sandeen 45693a06d778SAneesh Kumar K.V static int ext4_xattr_fiemap(struct inode *inode, 45703a06d778SAneesh Kumar K.V struct fiemap_extent_info *fieinfo) 45716873fa0dSEric Sandeen { 45726873fa0dSEric Sandeen __u64 physical = 0; 45736873fa0dSEric Sandeen __u64 length; 45746873fa0dSEric Sandeen __u32 flags = FIEMAP_EXTENT_LAST; 45756873fa0dSEric Sandeen int blockbits = inode->i_sb->s_blocksize_bits; 45766873fa0dSEric Sandeen int error = 0; 45776873fa0dSEric Sandeen 45786873fa0dSEric Sandeen /* in-inode? */ 457919f5fb7aSTheodore Ts'o if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) { 45806873fa0dSEric Sandeen struct ext4_iloc iloc; 45816873fa0dSEric Sandeen int offset; /* offset of xattr in inode */ 45826873fa0dSEric Sandeen 45836873fa0dSEric Sandeen error = ext4_get_inode_loc(inode, &iloc); 45846873fa0dSEric Sandeen if (error) 45856873fa0dSEric Sandeen return error; 45866873fa0dSEric Sandeen physical = iloc.bh->b_blocknr << blockbits; 45876873fa0dSEric Sandeen offset = EXT4_GOOD_OLD_INODE_SIZE + 45886873fa0dSEric Sandeen EXT4_I(inode)->i_extra_isize; 45896873fa0dSEric Sandeen physical += offset; 45906873fa0dSEric Sandeen length = EXT4_SB(inode->i_sb)->s_inode_size - offset; 45916873fa0dSEric Sandeen flags |= FIEMAP_EXTENT_DATA_INLINE; 4592fd2dd9fbSCurt Wohlgemuth brelse(iloc.bh); 45936873fa0dSEric Sandeen } else { /* external block */ 45946873fa0dSEric Sandeen physical = EXT4_I(inode)->i_file_acl << blockbits; 45956873fa0dSEric Sandeen length = inode->i_sb->s_blocksize; 45966873fa0dSEric Sandeen } 45976873fa0dSEric Sandeen 45986873fa0dSEric Sandeen if (physical) 45996873fa0dSEric Sandeen error = fiemap_fill_next_extent(fieinfo, 0, physical, 46006873fa0dSEric Sandeen length, flags); 46016873fa0dSEric Sandeen return (error < 0 ? error : 0); 46026873fa0dSEric Sandeen } 46036873fa0dSEric Sandeen 4604a4bb6b64SAllison Henderson /* 4605a4bb6b64SAllison Henderson * ext4_ext_punch_hole 4606a4bb6b64SAllison Henderson * 4607a4bb6b64SAllison Henderson * Punches a hole of "length" bytes in a file starting 4608a4bb6b64SAllison Henderson * at byte "offset" 4609a4bb6b64SAllison Henderson * 4610a4bb6b64SAllison Henderson * @inode: The inode of the file to punch a hole in 4611a4bb6b64SAllison Henderson * @offset: The starting byte offset of the hole 4612a4bb6b64SAllison Henderson * @length: The length of the hole 4613a4bb6b64SAllison Henderson * 4614a4bb6b64SAllison Henderson * Returns the number of blocks removed or negative on err 4615a4bb6b64SAllison Henderson */ 4616a4bb6b64SAllison Henderson int ext4_ext_punch_hole(struct file *file, loff_t offset, loff_t length) 4617a4bb6b64SAllison Henderson { 4618a4bb6b64SAllison Henderson struct inode *inode = file->f_path.dentry->d_inode; 4619a4bb6b64SAllison Henderson struct super_block *sb = inode->i_sb; 4620a4bb6b64SAllison Henderson struct ext4_ext_cache cache_ex; 4621a4bb6b64SAllison Henderson ext4_lblk_t first_block, last_block, num_blocks, iblock, max_blocks; 4622a4bb6b64SAllison Henderson struct address_space *mapping = inode->i_mapping; 4623a4bb6b64SAllison Henderson struct ext4_map_blocks map; 4624a4bb6b64SAllison Henderson handle_t *handle; 4625ba06208aSAllison Henderson loff_t first_page, last_page, page_len; 4626ba06208aSAllison Henderson loff_t first_page_offset, last_page_offset; 4627a4bb6b64SAllison Henderson int ret, credits, blocks_released, err = 0; 4628a4bb6b64SAllison Henderson 46292be4751bSAllison Henderson /* No need to punch hole beyond i_size */ 46302be4751bSAllison Henderson if (offset >= inode->i_size) 46312be4751bSAllison Henderson return 0; 46322be4751bSAllison Henderson 46332be4751bSAllison Henderson /* 46342be4751bSAllison Henderson * If the hole extends beyond i_size, set the hole 46352be4751bSAllison Henderson * to end after the page that contains i_size 46362be4751bSAllison Henderson */ 46372be4751bSAllison Henderson if (offset + length > inode->i_size) { 46382be4751bSAllison Henderson length = inode->i_size + 46392be4751bSAllison Henderson PAGE_CACHE_SIZE - (inode->i_size & (PAGE_CACHE_SIZE - 1)) - 46402be4751bSAllison Henderson offset; 46412be4751bSAllison Henderson } 46422be4751bSAllison Henderson 4643a4bb6b64SAllison Henderson first_block = (offset + sb->s_blocksize - 1) >> 4644a4bb6b64SAllison Henderson EXT4_BLOCK_SIZE_BITS(sb); 4645a4bb6b64SAllison Henderson last_block = (offset + length) >> EXT4_BLOCK_SIZE_BITS(sb); 4646a4bb6b64SAllison Henderson 4647a4bb6b64SAllison Henderson first_page = (offset + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; 4648a4bb6b64SAllison Henderson last_page = (offset + length) >> PAGE_CACHE_SHIFT; 4649a4bb6b64SAllison Henderson 4650a4bb6b64SAllison Henderson first_page_offset = first_page << PAGE_CACHE_SHIFT; 4651a4bb6b64SAllison Henderson last_page_offset = last_page << PAGE_CACHE_SHIFT; 4652a4bb6b64SAllison Henderson 4653a4bb6b64SAllison Henderson /* 4654a4bb6b64SAllison Henderson * Write out all dirty pages to avoid race conditions 4655a4bb6b64SAllison Henderson * Then release them. 4656a4bb6b64SAllison Henderson */ 4657a4bb6b64SAllison Henderson if (mapping->nrpages && mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) { 4658a4bb6b64SAllison Henderson err = filemap_write_and_wait_range(mapping, 46592be4751bSAllison Henderson offset, offset + length - 1); 4660a4bb6b64SAllison Henderson 4661a4bb6b64SAllison Henderson if (err) 4662a4bb6b64SAllison Henderson return err; 4663a4bb6b64SAllison Henderson } 4664a4bb6b64SAllison Henderson 4665a4bb6b64SAllison Henderson /* Now release the pages */ 4666a4bb6b64SAllison Henderson if (last_page_offset > first_page_offset) { 4667a4bb6b64SAllison Henderson truncate_inode_pages_range(mapping, first_page_offset, 4668a4bb6b64SAllison Henderson last_page_offset-1); 4669a4bb6b64SAllison Henderson } 4670a4bb6b64SAllison Henderson 4671a4bb6b64SAllison Henderson /* finish any pending end_io work */ 4672a4bb6b64SAllison Henderson ext4_flush_completed_IO(inode); 4673a4bb6b64SAllison Henderson 4674a4bb6b64SAllison Henderson credits = ext4_writepage_trans_blocks(inode); 4675a4bb6b64SAllison Henderson handle = ext4_journal_start(inode, credits); 4676a4bb6b64SAllison Henderson if (IS_ERR(handle)) 4677a4bb6b64SAllison Henderson return PTR_ERR(handle); 4678a4bb6b64SAllison Henderson 4679a4bb6b64SAllison Henderson err = ext4_orphan_add(handle, inode); 4680a4bb6b64SAllison Henderson if (err) 4681a4bb6b64SAllison Henderson goto out; 4682a4bb6b64SAllison Henderson 4683a4bb6b64SAllison Henderson /* 4684ba06208aSAllison Henderson * Now we need to zero out the non-page-aligned data in the 4685ba06208aSAllison Henderson * pages at the start and tail of the hole, and unmap the buffer 4686ba06208aSAllison Henderson * heads for the block aligned regions of the page that were 4687ba06208aSAllison Henderson * completely zeroed. 4688a4bb6b64SAllison Henderson */ 4689ba06208aSAllison Henderson if (first_page > last_page) { 4690ba06208aSAllison Henderson /* 4691ba06208aSAllison Henderson * If the file space being truncated is contained within a page 4692ba06208aSAllison Henderson * just zero out and unmap the middle of that page 4693ba06208aSAllison Henderson */ 4694ba06208aSAllison Henderson err = ext4_discard_partial_page_buffers(handle, 4695ba06208aSAllison Henderson mapping, offset, length, 0); 4696a4bb6b64SAllison Henderson 4697ba06208aSAllison Henderson if (err) 4698ba06208aSAllison Henderson goto out; 4699ba06208aSAllison Henderson } else { 4700ba06208aSAllison Henderson /* 4701ba06208aSAllison Henderson * zero out and unmap the partial page that contains 4702ba06208aSAllison Henderson * the start of the hole 4703ba06208aSAllison Henderson */ 4704ba06208aSAllison Henderson page_len = first_page_offset - offset; 4705ba06208aSAllison Henderson if (page_len > 0) { 4706ba06208aSAllison Henderson err = ext4_discard_partial_page_buffers(handle, mapping, 4707ba06208aSAllison Henderson offset, page_len, 0); 4708ba06208aSAllison Henderson if (err) 4709ba06208aSAllison Henderson goto out; 4710ba06208aSAllison Henderson } 4711ba06208aSAllison Henderson 4712ba06208aSAllison Henderson /* 4713ba06208aSAllison Henderson * zero out and unmap the partial page that contains 4714ba06208aSAllison Henderson * the end of the hole 4715ba06208aSAllison Henderson */ 4716ba06208aSAllison Henderson page_len = offset + length - last_page_offset; 4717ba06208aSAllison Henderson if (page_len > 0) { 4718ba06208aSAllison Henderson err = ext4_discard_partial_page_buffers(handle, mapping, 4719ba06208aSAllison Henderson last_page_offset, page_len, 0); 4720ba06208aSAllison Henderson if (err) 4721ba06208aSAllison Henderson goto out; 4722a4bb6b64SAllison Henderson } 4723a4bb6b64SAllison Henderson } 4724a4bb6b64SAllison Henderson 47252be4751bSAllison Henderson 47262be4751bSAllison Henderson /* 47272be4751bSAllison Henderson * If i_size is contained in the last page, we need to 47282be4751bSAllison Henderson * unmap and zero the partial page after i_size 47292be4751bSAllison Henderson */ 47302be4751bSAllison Henderson if (inode->i_size >> PAGE_CACHE_SHIFT == last_page && 47312be4751bSAllison Henderson inode->i_size % PAGE_CACHE_SIZE != 0) { 47322be4751bSAllison Henderson 47332be4751bSAllison Henderson page_len = PAGE_CACHE_SIZE - 47342be4751bSAllison Henderson (inode->i_size & (PAGE_CACHE_SIZE - 1)); 47352be4751bSAllison Henderson 47362be4751bSAllison Henderson if (page_len > 0) { 47372be4751bSAllison Henderson err = ext4_discard_partial_page_buffers(handle, 47382be4751bSAllison Henderson mapping, inode->i_size, page_len, 0); 47392be4751bSAllison Henderson 47402be4751bSAllison Henderson if (err) 47412be4751bSAllison Henderson goto out; 47422be4751bSAllison Henderson } 47432be4751bSAllison Henderson } 47442be4751bSAllison Henderson 4745a4bb6b64SAllison Henderson /* If there are no blocks to remove, return now */ 4746a4bb6b64SAllison Henderson if (first_block >= last_block) 4747a4bb6b64SAllison Henderson goto out; 4748a4bb6b64SAllison Henderson 4749a4bb6b64SAllison Henderson down_write(&EXT4_I(inode)->i_data_sem); 4750a4bb6b64SAllison Henderson ext4_ext_invalidate_cache(inode); 4751a4bb6b64SAllison Henderson ext4_discard_preallocations(inode); 4752a4bb6b64SAllison Henderson 4753a4bb6b64SAllison Henderson /* 4754a4bb6b64SAllison Henderson * Loop over all the blocks and identify blocks 4755a4bb6b64SAllison Henderson * that need to be punched out 4756a4bb6b64SAllison Henderson */ 4757a4bb6b64SAllison Henderson iblock = first_block; 4758a4bb6b64SAllison Henderson blocks_released = 0; 4759a4bb6b64SAllison Henderson while (iblock < last_block) { 4760a4bb6b64SAllison Henderson max_blocks = last_block - iblock; 4761a4bb6b64SAllison Henderson num_blocks = 1; 4762a4bb6b64SAllison Henderson memset(&map, 0, sizeof(map)); 4763a4bb6b64SAllison Henderson map.m_lblk = iblock; 4764a4bb6b64SAllison Henderson map.m_len = max_blocks; 4765a4bb6b64SAllison Henderson ret = ext4_ext_map_blocks(handle, inode, &map, 4766a4bb6b64SAllison Henderson EXT4_GET_BLOCKS_PUNCH_OUT_EXT); 4767a4bb6b64SAllison Henderson 4768a4bb6b64SAllison Henderson if (ret > 0) { 4769a4bb6b64SAllison Henderson blocks_released += ret; 4770a4bb6b64SAllison Henderson num_blocks = ret; 4771a4bb6b64SAllison Henderson } else if (ret == 0) { 4772a4bb6b64SAllison Henderson /* 4773a4bb6b64SAllison Henderson * If map blocks could not find the block, 4774a4bb6b64SAllison Henderson * then it is in a hole. If the hole was 4775a4bb6b64SAllison Henderson * not already cached, then map blocks should 4776a4bb6b64SAllison Henderson * put it in the cache. So we can get the hole 4777a4bb6b64SAllison Henderson * out of the cache 4778a4bb6b64SAllison Henderson */ 4779a4bb6b64SAllison Henderson memset(&cache_ex, 0, sizeof(cache_ex)); 4780a4bb6b64SAllison Henderson if ((ext4_ext_check_cache(inode, iblock, &cache_ex)) && 4781a4bb6b64SAllison Henderson !cache_ex.ec_start) { 4782a4bb6b64SAllison Henderson 4783a4bb6b64SAllison Henderson /* The hole is cached */ 4784a4bb6b64SAllison Henderson num_blocks = cache_ex.ec_block + 4785a4bb6b64SAllison Henderson cache_ex.ec_len - iblock; 4786a4bb6b64SAllison Henderson 4787a4bb6b64SAllison Henderson } else { 4788a4bb6b64SAllison Henderson /* The block could not be identified */ 4789a4bb6b64SAllison Henderson err = -EIO; 4790a4bb6b64SAllison Henderson break; 4791a4bb6b64SAllison Henderson } 4792a4bb6b64SAllison Henderson } else { 4793a4bb6b64SAllison Henderson /* Map blocks error */ 4794a4bb6b64SAllison Henderson err = ret; 4795a4bb6b64SAllison Henderson break; 4796a4bb6b64SAllison Henderson } 4797a4bb6b64SAllison Henderson 4798a4bb6b64SAllison Henderson if (num_blocks == 0) { 4799a4bb6b64SAllison Henderson /* This condition should never happen */ 4800a4bb6b64SAllison Henderson ext_debug("Block lookup failed"); 4801a4bb6b64SAllison Henderson err = -EIO; 4802a4bb6b64SAllison Henderson break; 4803a4bb6b64SAllison Henderson } 4804a4bb6b64SAllison Henderson 4805a4bb6b64SAllison Henderson iblock += num_blocks; 4806a4bb6b64SAllison Henderson } 4807a4bb6b64SAllison Henderson 4808a4bb6b64SAllison Henderson if (blocks_released > 0) { 4809a4bb6b64SAllison Henderson ext4_ext_invalidate_cache(inode); 4810a4bb6b64SAllison Henderson ext4_discard_preallocations(inode); 4811a4bb6b64SAllison Henderson } 4812a4bb6b64SAllison Henderson 4813a4bb6b64SAllison Henderson if (IS_SYNC(inode)) 4814a4bb6b64SAllison Henderson ext4_handle_sync(handle); 4815a4bb6b64SAllison Henderson 4816a4bb6b64SAllison Henderson up_write(&EXT4_I(inode)->i_data_sem); 4817a4bb6b64SAllison Henderson 4818a4bb6b64SAllison Henderson out: 4819a4bb6b64SAllison Henderson ext4_orphan_del(handle, inode); 4820a4bb6b64SAllison Henderson inode->i_mtime = inode->i_ctime = ext4_current_time(inode); 4821a4bb6b64SAllison Henderson ext4_mark_inode_dirty(handle, inode); 4822a4bb6b64SAllison Henderson ext4_journal_stop(handle); 4823a4bb6b64SAllison Henderson return err; 4824a4bb6b64SAllison Henderson } 48256873fa0dSEric Sandeen int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 48266873fa0dSEric Sandeen __u64 start, __u64 len) 48276873fa0dSEric Sandeen { 48286873fa0dSEric Sandeen ext4_lblk_t start_blk; 48296873fa0dSEric Sandeen int error = 0; 48306873fa0dSEric Sandeen 48316873fa0dSEric Sandeen /* fallback to generic here if not in extents fmt */ 483212e9b892SDmitry Monakhov if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) 48336873fa0dSEric Sandeen return generic_block_fiemap(inode, fieinfo, start, len, 48346873fa0dSEric Sandeen ext4_get_block); 48356873fa0dSEric Sandeen 48366873fa0dSEric Sandeen if (fiemap_check_flags(fieinfo, EXT4_FIEMAP_FLAGS)) 48376873fa0dSEric Sandeen return -EBADR; 48386873fa0dSEric Sandeen 48396873fa0dSEric Sandeen if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) { 48406873fa0dSEric Sandeen error = ext4_xattr_fiemap(inode, fieinfo); 48416873fa0dSEric Sandeen } else { 4842aca92ff6SLeonard Michlmayr ext4_lblk_t len_blks; 4843aca92ff6SLeonard Michlmayr __u64 last_blk; 4844aca92ff6SLeonard Michlmayr 48456873fa0dSEric Sandeen start_blk = start >> inode->i_sb->s_blocksize_bits; 4846aca92ff6SLeonard Michlmayr last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits; 4847f17722f9SLukas Czerner if (last_blk >= EXT_MAX_BLOCKS) 4848f17722f9SLukas Czerner last_blk = EXT_MAX_BLOCKS-1; 4849aca92ff6SLeonard Michlmayr len_blks = ((ext4_lblk_t) last_blk) - start_blk + 1; 48506873fa0dSEric Sandeen 48516873fa0dSEric Sandeen /* 48526873fa0dSEric Sandeen * Walk the extent tree gathering extent information. 48536873fa0dSEric Sandeen * ext4_ext_fiemap_cb will push extents back to user. 48546873fa0dSEric Sandeen */ 48556873fa0dSEric Sandeen error = ext4_ext_walk_space(inode, start_blk, len_blks, 48566873fa0dSEric Sandeen ext4_ext_fiemap_cb, fieinfo); 48576873fa0dSEric Sandeen } 48586873fa0dSEric Sandeen 48596873fa0dSEric Sandeen return error; 48606873fa0dSEric Sandeen } 4861