4777 lines · 138.3 KB · C
RawDownload
/* *  linux/fs/ext4/inode.c * * Copyright (C) 1992, 1993, 1994, 1995 * Remy Card (card@masi.ibp.fr) * Laboratoire MASI - Institut Blaise Pascal * Universite Pierre et Marie Curie (Paris VI) * *  from * *  linux/fs/minix/inode.c * *  Copyright (C) 1991, 1992  Linus Torvalds * *  64-bit file support on 64-bit platforms by Jakub Jelinek *	(jj@sunsite.ms.mff.cuni.cz) * *  Assorted race fixes, rewrite of ext4_get_block() by Al Viro, 2000 */ #include <linux/fs.h>#include <linux/time.h>#include <linux/jbd2.h>#include <linux/highuid.h>#include <linux/pagemap.h>#include <linux/quotaops.h>#include <linux/string.h>#include <linux/buffer_head.h>#include <linux/writeback.h>#include <linux/pagevec.h>#include <linux/mpage.h>#include <linux/namei.h>#include <linux/uio.h>#include <linux/bio.h>#include <linux/workqueue.h>#include <linux/kernel.h>#include <linux/printk.h>#include <linux/slab.h>#include <linux/ratelimit.h> #include "ext4_jbd2.h"#include "xattr.h"#include "acl.h"#include "truncate.h" #include <trace/events/ext4.h> #define MPAGE_DA_EXTENT_TAIL 0x01 static __u32 ext4_inode_csum(struct inode *inode, struct ext4_inode *raw,			      struct ext4_inode_info *ei){	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);	__u16 csum_lo;	__u16 csum_hi = 0;	__u32 csum; 	csum_lo = raw->i_checksum_lo;	raw->i_checksum_lo = 0;	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&	    EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi)) {		csum_hi = raw->i_checksum_hi;		raw->i_checksum_hi = 0;	} 	csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)raw,			   EXT4_INODE_SIZE(inode->i_sb)); 	raw->i_checksum_lo = csum_lo;	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&	    EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi))		raw->i_checksum_hi = csum_hi; 	return csum;} static int ext4_inode_csum_verify(struct inode *inode, struct ext4_inode *raw,				  struct ext4_inode_info *ei){	__u32 provided, calculated; 	if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=	    cpu_to_le32(EXT4_OS_LINUX) ||	    !EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,		EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))		return 1; 	provided = le16_to_cpu(raw->i_checksum_lo);	calculated = ext4_inode_csum(inode, raw, ei);	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&	    EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi))		provided |= ((__u32)le16_to_cpu(raw->i_checksum_hi)) << 16;	else		calculated &= 0xFFFF; 	return provided == calculated;} static void ext4_inode_csum_set(struct inode *inode, struct ext4_inode *raw,				struct ext4_inode_info *ei){	__u32 csum; 	if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=	    cpu_to_le32(EXT4_OS_LINUX) ||	    !EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,		EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))		return; 	csum = ext4_inode_csum(inode, raw, ei);	raw->i_checksum_lo = cpu_to_le16(csum & 0xFFFF);	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&	    EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi))		raw->i_checksum_hi = cpu_to_le16(csum >> 16);} static inline int ext4_begin_ordered_truncate(struct inode *inode,					      loff_t new_size){	trace_ext4_begin_ordered_truncate(inode, new_size);	/*	 * If jinode is zero, then we never opened the file for	 * writing, so there's no need to call	 * jbd2_journal_begin_ordered_truncate() since there's no	 * outstanding writes we need to flush.	 */	if (!EXT4_I(inode)->jinode)		return 0;	return jbd2_journal_begin_ordered_truncate(EXT4_JOURNAL(inode),						   EXT4_I(inode)->jinode,						   new_size);} static void ext4_invalidatepage(struct page *page, unsigned long offset);static int noalloc_get_block_write(struct inode *inode, sector_t iblock,				   struct buffer_head *bh_result, int create);static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode);static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate);static int __ext4_journalled_writepage(struct page *page, unsigned int len);static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh);static int ext4_discard_partial_page_buffers_no_lock(handle_t *handle,		struct inode *inode, struct page *page, loff_t from,		loff_t length, int flags); /* * Test whether an inode is a fast symlink. */static int ext4_inode_is_fast_symlink(struct inode *inode){	int ea_blocks = EXT4_I(inode)->i_file_acl ?		(inode->i_sb->s_blocksize >> 9) : 0; 	return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);} /* * Restart the transaction associated with *handle.  This does a commit, * so before we call here everything must be consistently dirtied against * this transaction. */int ext4_truncate_restart_trans(handle_t *handle, struct inode *inode,				 int nblocks){	int ret; 	/*	 * Drop i_data_sem to avoid deadlock with ext4_map_blocks.  At this	 * moment, get_block can be called only for blocks inside i_size since	 * page cache has been already dropped and writes are blocked by	 * i_mutex. So we can safely drop the i_data_sem here.	 */	BUG_ON(EXT4_JOURNAL(inode) == NULL);	jbd_debug(2, "restarting handle %p\n", handle);	up_write(&EXT4_I(inode)->i_data_sem);	ret = ext4_journal_restart(handle, nblocks);	down_write(&EXT4_I(inode)->i_data_sem);	ext4_discard_preallocations(inode); 	return ret;} /* * Called at the last iput() if i_nlink is zero. */void ext4_evict_inode(struct inode *inode){	handle_t *handle;	int err; 	trace_ext4_evict_inode(inode); 	ext4_ioend_wait(inode); 	if (inode->i_nlink) {		/*		 * When journalling data dirty buffers are tracked only in the		 * journal. So although mm thinks everything is clean and		 * ready for reaping the inode might still have some pages to		 * write in the running transaction or waiting to be		 * checkpointed. Thus calling jbd2_journal_invalidatepage()		 * (via truncate_inode_pages()) to discard these buffers can		 * cause data loss. Also even if we did not discard these		 * buffers, we would have no way to find them after the inode		 * is reaped and thus user could see stale data if he tries to		 * read them before the transaction is checkpointed. So be		 * careful and force everything to disk here... We use		 * ei->i_datasync_tid to store the newest transaction		 * containing inode's data.		 *		 * Note that directories do not have this problem because they		 * don't use page cache.		 */		if (ext4_should_journal_data(inode) &&		    (S_ISLNK(inode->i_mode) || S_ISREG(inode->i_mode))) {			journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;			tid_t commit_tid = EXT4_I(inode)->i_datasync_tid; 			jbd2_log_start_commit(journal, commit_tid);			jbd2_log_wait_commit(journal, commit_tid);			filemap_write_and_wait(&inode->i_data);		}		truncate_inode_pages(&inode->i_data, 0);		goto no_delete;	} 	if (!is_bad_inode(inode))		dquot_initialize(inode); 	if (ext4_should_order_data(inode))		ext4_begin_ordered_truncate(inode, 0);	truncate_inode_pages(&inode->i_data, 0); 	if (is_bad_inode(inode))		goto no_delete; 	handle = ext4_journal_start(inode, ext4_blocks_for_truncate(inode)+3);	if (IS_ERR(handle)) {		ext4_std_error(inode->i_sb, PTR_ERR(handle));		/*		 * If we're going to skip the normal cleanup, we still need to		 * make sure that the in-core orphan linked list is properly		 * cleaned up.		 */		ext4_orphan_del(NULL, inode);		goto no_delete;	} 	if (IS_SYNC(inode))		ext4_handle_sync(handle);	inode->i_size = 0;	err = ext4_mark_inode_dirty(handle, inode);	if (err) {		ext4_warning(inode->i_sb,			     "couldn't mark inode dirty (err %d)", err);		goto stop_handle;	}	if (inode->i_blocks)		ext4_truncate(inode); 	/*	 * ext4_ext_truncate() doesn't reserve any slop when it	 * restarts journal transactions; therefore there may not be	 * enough credits left in the handle to remove the inode from	 * the orphan list and set the dtime field.	 */	if (!ext4_handle_has_enough_credits(handle, 3)) {		err = ext4_journal_extend(handle, 3);		if (err > 0)			err = ext4_journal_restart(handle, 3);		if (err != 0) {			ext4_warning(inode->i_sb,				     "couldn't extend journal (err %d)", err);		stop_handle:			ext4_journal_stop(handle);			ext4_orphan_del(NULL, inode);			goto no_delete;		}	} 	/*	 * Kill off the orphan record which ext4_truncate created.	 * AKPM: I think this can be inside the above `if'.	 * Note that ext4_orphan_del() has to be able to cope with the	 * deletion of a non-existent orphan - this is because we don't	 * know if ext4_truncate() actually created an orphan record.	 * (Well, we could do this if we need to, but heck - it works)	 */	ext4_orphan_del(handle, inode);	EXT4_I(inode)->i_dtime	= get_seconds(); 	/*	 * One subtle ordering requirement: if anything has gone wrong	 * (transaction abort, IO errors, whatever), then we can still	 * do these next steps (the fs will already have been marked as	 * having errors), but we can't free the inode if the mark_dirty	 * fails.	 */	if (ext4_mark_inode_dirty(handle, inode))		/* If that failed, just do the required in-core inode clear. */		ext4_clear_inode(inode);	else		ext4_free_inode(handle, inode);	ext4_journal_stop(handle);	return;no_delete:	ext4_clear_inode(inode);	/* We must guarantee clearing of inode... */} #ifdef CONFIG_QUOTAqsize_t *ext4_get_reserved_space(struct inode *inode){	return &EXT4_I(inode)->i_reserved_quota;}#endif /* * Calculate the number of metadata blocks need to reserve * to allocate a block located at @lblock */static int ext4_calc_metadata_amount(struct inode *inode, ext4_lblk_t lblock){	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))		return ext4_ext_calc_metadata_amount(inode, lblock); 	return ext4_ind_calc_metadata_amount(inode, lblock);} /* * Called with i_data_sem down, which is important since we can call * ext4_discard_preallocations() from here. */void ext4_da_update_reserve_space(struct inode *inode,					int used, int quota_claim){	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);	struct ext4_inode_info *ei = EXT4_I(inode); 	spin_lock(&ei->i_block_reservation_lock);	trace_ext4_da_update_reserve_space(inode, used, quota_claim);	if (unlikely(used > ei->i_reserved_data_blocks)) {		ext4_msg(inode->i_sb, KERN_NOTICE, "%s: ino %lu, used %d "			 "with only %d reserved data blocks",			 __func__, inode->i_ino, used,			 ei->i_reserved_data_blocks);		WARN_ON(1);		used = ei->i_reserved_data_blocks;	} 	/* Update per-inode reservations */	ei->i_reserved_data_blocks -= used;	ei->i_reserved_meta_blocks -= ei->i_allocated_meta_blocks;	percpu_counter_sub(&sbi->s_dirtyclusters_counter,			   used + ei->i_allocated_meta_blocks);	ei->i_allocated_meta_blocks = 0; 	if (ei->i_reserved_data_blocks == 0) {		/*		 * We can release all of the reserved metadata blocks		 * only when we have written all of the delayed		 * allocation blocks.		 */		percpu_counter_sub(&sbi->s_dirtyclusters_counter,				   ei->i_reserved_meta_blocks);		ei->i_reserved_meta_blocks = 0;		ei->i_da_metadata_calc_len = 0;	}	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 	/* Update quota subsystem for data blocks */	if (quota_claim)		dquot_claim_block(inode, EXT4_C2B(sbi, used));	else {		/*		 * We did fallocate with an offset that is already delayed		 * allocated. So on delayed allocated writeback we should		 * not re-claim the quota for fallocated blocks.		 */		dquot_release_reservation_block(inode, EXT4_C2B(sbi, used));	} 	/*	 * If we have done all the pending block allocations and if	 * there aren't any writers on the inode, we can discard the	 * inode's preallocations.	 */	if ((ei->i_reserved_data_blocks == 0) &&	    (atomic_read(&inode->i_writecount) == 0))		ext4_discard_preallocations(inode);} static int __check_block_validity(struct inode *inode, const char *func,				unsigned int line,				struct ext4_map_blocks *map){	if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk,				   map->m_len)) {		ext4_error_inode(inode, func, line, map->m_pblk,				 "lblock %lu mapped to illegal pblock "				 "(length %d)", (unsigned long) map->m_lblk,				 map->m_len);		return -EIO;	}	return 0;} #define check_block_validity(inode, map)	\	__check_block_validity((inode), __func__, __LINE__, (map)) /* * Return the number of contiguous dirty pages in a given inode * starting at page frame idx. */static pgoff_t ext4_num_dirty_pages(struct inode *inode, pgoff_t idx,				    unsigned int max_pages){	struct address_space *mapping = inode->i_mapping;	pgoff_t	index;	struct pagevec pvec;	pgoff_t num = 0;	int i, nr_pages, done = 0; 	if (max_pages == 0)		return 0;	pagevec_init(&pvec, 0);	while (!done) {		index = idx;		nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,					      PAGECACHE_TAG_DIRTY,					      (pgoff_t)PAGEVEC_SIZE);		if (nr_pages == 0)			break;		for (i = 0; i < nr_pages; i++) {			struct page *page = pvec.pages[i];			struct buffer_head *bh, *head; 			lock_page(page);			if (unlikely(page->mapping != mapping) ||			    !PageDirty(page) ||			    PageWriteback(page) ||			    page->index != idx) {				done = 1;				unlock_page(page);				break;			}			if (page_has_buffers(page)) {				bh = head = page_buffers(page);				do {					if (!buffer_delay(bh) &&					    !buffer_unwritten(bh))						done = 1;					bh = bh->b_this_page;				} while (!done && (bh != head));			}			unlock_page(page);			if (done)				break;			idx++;			num++;			if (num >= max_pages) {				done = 1;				break;			}		}		pagevec_release(&pvec);	}	return num;} /* * Sets the BH_Da_Mapped bit on the buffer heads corresponding to the given map. */static void set_buffers_da_mapped(struct inode *inode,				   struct ext4_map_blocks *map){	struct address_space *mapping = inode->i_mapping;	struct pagevec pvec;	int i, nr_pages;	pgoff_t index, end; 	index = map->m_lblk >> (PAGE_CACHE_SHIFT - inode->i_blkbits);	end = (map->m_lblk + map->m_len - 1) >>		(PAGE_CACHE_SHIFT - inode->i_blkbits); 	pagevec_init(&pvec, 0);	while (index <= end) {		nr_pages = pagevec_lookup(&pvec, mapping, index,					  min(end - index + 1,					      (pgoff_t)PAGEVEC_SIZE));		if (nr_pages == 0)			break;		for (i = 0; i < nr_pages; i++) {			struct page *page = pvec.pages[i];			struct buffer_head *bh, *head; 			if (unlikely(page->mapping != mapping) ||			    !PageDirty(page))				break; 			if (page_has_buffers(page)) {				bh = head = page_buffers(page);

Lines 1–500 of 4777.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t