自学教程：C++ zero_user_segment函数代码示例

/* * Zero an extent within a page vector.  Offset is relative to the * start of the first page. */static void zero_page_vector_range(int off, int len, struct page **pages){	int i = off >> PAGE_CACHE_SHIFT;	off &= ~PAGE_CACHE_MASK;	dout("zero_page_vector_page %u~%u/n", off, len);	/* leading partial page? */	if (off) {		int end = min((int)PAGE_CACHE_SIZE, off + len);		dout("zeroing %d %p head from %d/n", i, pages[i],		     (int)off);		zero_user_segment(pages[i], off, end);		len -= (end - off);		i++;	}	while (len >= PAGE_CACHE_SIZE) {		dout("zeroing %d %p len=%d/n", i, pages[i], len);		zero_user_segment(pages[i], 0, PAGE_CACHE_SIZE);		len -= PAGE_CACHE_SIZE;		i++;	}	/* trailing partial page? */	if (len) {		dout("zeroing %d %p tail to %d/n", i, pages[i], (int)len);		zero_user_segment(pages[i], 0, len);	}}

int f2fs_read_inline_data(struct inode *inode, struct page *page){	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);	struct page *ipage;	void *src_addr, *dst_addr;	if (page->index) {		zero_user_segment(page, 0, PAGE_CACHE_SIZE);		goto out;	}	ipage = get_node_page(sbi, inode->i_ino);	if (IS_ERR(ipage)) {		unlock_page(page);		return PTR_ERR(ipage);	}	zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);	/* Copy the whole inline data block */	src_addr = inline_data_addr(ipage);	dst_addr = kmap(page);	memcpy(dst_addr, src_addr, MAX_INLINE_DATA);	kunmap(page);	f2fs_put_page(ipage, 1);out:	SetPageUptodate(page);	unlock_page(page);	return 0;}

static int rawfs_writepage(struct page *page, struct writeback_control *wbc){	struct address_space *mapping = page->mapping;	struct inode *inode;	unsigned long end_index;	char *buffer;	int n_written = 0;	unsigned n_bytes;	loff_t i_size;	if (!mapping)		BUG();	inode = mapping->host;	if (!inode)		BUG();	i_size = i_size_read(inode);	end_index = i_size >> PAGE_CACHE_SHIFT;	if (page->index < end_index)		n_bytes = PAGE_CACHE_SIZE;	else {		n_bytes = i_size & (PAGE_CACHE_SIZE - 1);		if (page->index > end_index || !n_bytes) {			zero_user_segment(page, 0, PAGE_CACHE_SIZE);			set_page_writeback(page);			unlock_page(page);			end_page_writeback(page);			return 0;		}	}	if (n_bytes != PAGE_CACHE_SIZE)		zero_user_segment(page, n_bytes, PAGE_CACHE_SIZE);	get_page(page);	buffer = kmap(page);    /*	n_written = yaffs_wr_file(obj, buffer,				  page->index << PAGE_CACHE_SHIFT, n_bytes, 0);    */    n_written = rawfs_write_file(inode, buffer, n_bytes,        page->index << PAGE_CACHE_SHIFT);	kunmap(page);	set_page_writeback(page);	unlock_page(page);	end_page_writeback(page);	put_page(page);	return (n_written == n_bytes) ? 0 : -ENOSPC;}

int f2fs_read_inline_data(struct inode *inode, struct page *page){    struct page *ipage;    ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);    if (IS_ERR(ipage)) {        unlock_page(page);        return PTR_ERR(ipage);    }    if (!f2fs_has_inline_data(inode)) {        f2fs_put_page(ipage, 1);        return -EAGAIN;    }    if (page->index)        zero_user_segment(page, 0, PAGE_CACHE_SIZE);    else        read_inline_data(page, ipage);    SetPageUptodate(page);    f2fs_put_page(ipage, 1);    unlock_page(page);    return 0;}

int ext4_readpage_inline(struct inode *inode, struct page *page){	int ret = 0;	down_read(&EXT4_I(inode)->xattr_sem);	if (!ext4_has_inline_data(inode)) {		up_read(&EXT4_I(inode)->xattr_sem);		return -EAGAIN;	}	/*	 * Current inline data can only exist in the 1st page,	 * So for all the other pages, just set them uptodate.	 */	if (!page->index)		ret = ext4_read_inline_page(inode, page);	else if (!PageUptodate(page)) {		zero_user_segment(page, 0, PAGE_CACHE_SIZE);		SetPageUptodate(page);	}	up_read(&EXT4_I(inode)->xattr_sem);	unlock_page(page);	return ret >= 0 ? 0 : ret;}

static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,						struct vm_fault *vmf){	struct page *page = vmf->page;	struct inode *inode = file_inode(vma->vm_file);	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	struct dnode_of_data dn;	int err;	f2fs_balance_fs(sbi);	vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);	f2fs_bug_on(sbi, f2fs_has_inline_data(inode));	/* block allocation */	f2fs_lock_op(sbi);	set_new_dnode(&dn, inode, NULL, NULL, 0);	err = f2fs_reserve_block(&dn, page->index);	if (err) {		f2fs_unlock_op(sbi);		goto out;	}	f2fs_put_dnode(&dn);	f2fs_unlock_op(sbi);	file_update_time(vma->vm_file);	lock_page(page);	if (unlikely(page->mapping != inode->i_mapping ||			page_offset(page) > i_size_read(inode) ||			!PageUptodate(page))) {		unlock_page(page);		err = -EFAULT;		goto out;	}	/*	 * check to see if the page is mapped already (no holes)	 */	if (PageMappedToDisk(page))		goto mapped;	/* page is wholly or partially inside EOF */	if (((page->index + 1) << PAGE_CACHE_SHIFT) > i_size_read(inode)) {		unsigned offset;		offset = i_size_read(inode) & ~PAGE_CACHE_MASK;		zero_user_segment(page, offset, PAGE_CACHE_SIZE);	}	set_page_dirty(page);	SetPageUptodate(page);	trace_f2fs_vm_page_mkwrite(page, DATA);mapped:	/* fill the page */	f2fs_wait_on_page_writeback(page, DATA);	/* if gced page is attached, don't write to cold segment */	clear_cold_data(page);out:	return block_page_mkwrite_return(err);}

/* * NOTE: ipage is grabbed by caller, but if any error occurs, we should * release ipage in this function. */static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,				struct f2fs_inline_dentry *inline_dentry){	struct page *page;	struct dnode_of_data dn;	struct f2fs_dentry_block *dentry_blk;	int err;	page = grab_cache_page(dir->i_mapping, 0);	if (!page) {		f2fs_put_page(ipage, 1);		return -ENOMEM;	}	set_new_dnode(&dn, dir, ipage, NULL, 0);	err = f2fs_reserve_block(&dn, 0);	if (err)		goto out;	f2fs_wait_on_page_writeback(page, DATA);	zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);	dentry_blk = kmap_atomic(page);	/* copy data from inline dentry block to new dentry block */	memcpy(dentry_blk->dentry_bitmap, inline_dentry->dentry_bitmap,					INLINE_DENTRY_BITMAP_SIZE);	memset(dentry_blk->dentry_bitmap + INLINE_DENTRY_BITMAP_SIZE, 0,			SIZE_OF_DENTRY_BITMAP - INLINE_DENTRY_BITMAP_SIZE);	/*	 * we do not need to zero out remainder part of dentry and filename	 * field, since we have used bitmap for marking the usage status of	 * them, besides, we can also ignore copying/zeroing reserved space	 * of dentry block, because them haven't been used so far.	 */	memcpy(dentry_blk->dentry, inline_dentry->dentry,			sizeof(struct f2fs_dir_entry) * NR_INLINE_DENTRY);	memcpy(dentry_blk->filename, inline_dentry->filename,					NR_INLINE_DENTRY * F2FS_SLOT_LEN);	kunmap_atomic(dentry_blk);	SetPageUptodate(page);	set_page_dirty(page);	/* clear inline dir and flag after data writeback */	truncate_inline_inode(ipage, 0);	stat_dec_inline_dir(dir);	clear_inode_flag(F2FS_I(dir), FI_INLINE_DENTRY);	if (i_size_read(dir) < PAGE_CACHE_SIZE) {		i_size_write(dir, PAGE_CACHE_SIZE);		set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);	}	sync_inode_page(&dn);out:	f2fs_put_page(page, 1);	return err;}

static int nfs_write_end(struct file *file, struct address_space *mapping,			loff_t pos, unsigned len, unsigned copied,			struct page *page, void *fsdata){	unsigned offset = pos & (PAGE_CACHE_SIZE - 1);	int status;	dfprintk(PAGECACHE, "NFS: write_end(%s/%s(%ld), %[email
C++ zero_v3函数代码示例
C++ zephir_update_property_zval函数代码示例