fs/ext4/inode.c

342 			 "with only %d reserved data blocks",
355 	/* Update quota subsystem for data blocks */
362 		 * not re-claim the quota for fallocated blocks.
457  * The ext4_map_blocks() function tries to look up the requested blocks,
458  * and returns if the blocks are already mapped.
460  * Otherwise it takes the write lock of the i_data_sem and allocate blocks
461  * and store the allocated blocks in the result buffer head and mark it
468  * On success, it returns the number of blocks being mapped or allocated.
469  * If flags doesn't contain EXT4_GET_BLOCKS_CREATE the blocks are
473  * It returns 0 if plain look up failed (blocks have not been allocated), in
590 	 * Returns if the blocks have already allocated
592 	 * Note that if blocks have been preallocated
611 	 * New blocks allocate and/or writing to unwritten extent
629 			 * We allocated new blocks which will result in
649 		 * We have to zeroout blocks before inserting them into extent
694 		 * Inodes with freshly allocated blocks where contents will be
788  * creating an unwritten extent if blocks haven't been allocated.  The extent
812 /* Maximum number of blocks we map for direct IO at once. */
903 /* Read a contiguous batch of blocks. */
1135 	 * we allocate blocks but write fails for some reason
1215 		 * __block_write_begin may have instantiated a few blocks
1295 	 * blocks are being written past EOF, so skip the i_size update.
1314 		/* if we have allocated more blocks and copied
1315 		 * less. We will have blocks allocated outside
1429 		/* if we have allocated more blocks and copied
1430 		 * less. We will have blocks allocated outside
1496 		 * if there aren't enough reserved blocks, then the
1503 			 "data blocks", inode->i_ino, to_free,
1510 	/* update fs dirty data blocks counter */
1526 	unsigned int can_map:1;	/* Can writepages call map blocks? */
1607 	ext4_msg(sb, KERN_CRIT, "Total free blocks count %lld",
1683  * time. This function looks up the requested blocks and sets the
1814 	 * preallocated blocks are unmapped but should treated
1815 	 * the same as allocated blocks.
1879  * mballoc gives us at most this number of blocks...
1886  * mpage_add_bh_to_extent - try to add bh to extent of blocks to map
1888  * @mpd - extent of blocks
1892  * The function is used to collect contig. blocks in the same state. If the
1940  * @mpd - extent of blocks for mapping
1960 	ext4_lblk_t blocks = (i_size_read(inode) + i_blocksize(inode) - 1)
1964 		blocks = EXT_MAX_BLOCKS;
1969 		if (lblk >= blocks || !mpage_add_bh_to_extent(mpd, lblk, bh)) {
1987 	if (lblk >= blocks) {
2140 	 * Call ext4_map_blocks() to allocate any delayed allocation blocks, or
2142 	 * where we have written into one or more preallocated blocks).  It is
2143 	 * possible that we're going to need more metadata blocks than
2146 	 * in data loss.  So use reserved blocks to allocate metadata if
2150 	 * the blocks in question are delalloc blocks.  This indicates
2151 	 * that the blocks and quotas has already been checked when
2190  * delayed, blocks are allocated, if it is unwritten, we may need to convert
2193  * can return less blocks or the range is covered by more unwritten extents. We
2225 			 * is non-zero, a commit should free up blocks.
2236 				 " max blocks %u with error %d",
2291  * up to MAX_WRITEPAGES_EXTENT_LEN blocks and then we go on and finish mapping
2293  * bpp - 1 blocks in bpp different extents.
2349  * IO immediately. If we cannot map blocks, we submit just already mapped
2350  * buffers in the page for IO and keep page dirty. When we can map blocks and
2355  * length mpd->len blocks).
2718 			 * free blocks released in the transaction
2837 	 * Start pushing delalloc when 1/2 of free blocks are dirty.
2845 		 * free block count is less than 150% of dirty blocks
2846 		 * or free blocks is less than watermark
2899 		 * block_write_begin may have instantiated a few blocks
2969 	 * ext4_writepages() paths not allocating blocks and update i_disksize.
3029  * Force all delayed allocation blocks to be allocated for a given inode.
3040 	 * also start triggering a write of the data blocks, which is
3066 	 * which will map the blocks, and start the I/O, but not
3084  * take extra steps to flush any blocks which might be in the cache.
3103 		 * that we can make sure we allocate blocks for file and data
3288 	 * Either we allocate blocks and then don't get an unwritten extent, so
3289 	 * in that case we have reserved enough credits. Or, the blocks are
3308 	 * happening and thus expose allocated blocks to direct I/O reads.
3347 	 * Calculate the first and last logical blocks respectively.
3355 		 * We check here if the blocks are already allocated, then we
3392 	 * Even for writes we don't need to allocate blocks, so just pretend
3406 	 * the allocated blocks. If so, return the magic error code so that we
3408 	 * the I/O. Any blocks that may have been allocated in preparation for
3857  * ext4_punch_hole: punches a hole in a file by releasing the blocks
3977 	/* If there are blocks to remove, do it */
4064  * ext4_truncate() to have another go.  So there will be instantiated blocks
4424 	 * blocks from the inode table.
5024 	 * (assuming 4k blocks and 256 byte inodes) is (n*16 + 1).
5248  * dirty pages and freeing of disk blocks, we can guarantee that any
5249  * commit will leave the blocks being flushed in an unused state on
5250  * disk.  (On recovery, the inode will get truncated and the blocks will
5252  * leave these blocks visible to the user.)
5444 		 * truncate possible preallocated blocks.
5568 	 * have data blocks allocated (it may have an external xattr block).
5573 		stat->blocks += (stat->size + 511) >> 9;
5579 	 * on-disk file blocks.
5582 	 * will return the blocks that include the delayed allocation
5583 	 * blocks for this file.
5587 	stat->blocks += delalloc_blocks << (inode->i_sb->s_blocksize_bits - 9);
5600  * Account for index blocks, block groups bitmaps and block group
5601  * descriptor blocks if modify datablocks and index blocks
5602  * worse case, the indexs blocks spread over different block groups
5608  * Also account for superblock, inode, quota and xattr blocks
5619 	 * How many index blocks need to touch to map @lblocks logical blocks
5637 	/* bitmaps and block group descriptor blocks */
5640 	/* Blocks for super block, inode, quota and xattr blocks */
5663 	/* Account for data blocks for journalled mode */
5673  * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
5675  * journal buffers for data blocks are not included here, as DIO
5921  * Also, dquot_alloc_block() will always dirty the inode when blocks