linux-sg2042/fs/ocfs2/alloc.c

2041 lines
52 KiB
C
Raw Normal View History

/* -*- mode: c; c-basic-offset: 8; -*-
* vim: noexpandtab sw=8 ts=8 sts=0:
*
* alloc.c
*
* Extent allocs and frees
*
* Copyright (C) 2002, 2004 Oracle. All rights reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 021110-1307, USA.
*/
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/highmem.h>
#define MLOG_MASK_PREFIX ML_DISK_ALLOC
#include <cluster/masklog.h>
#include "ocfs2.h"
#include "alloc.h"
#include "dlmglue.h"
#include "extent_map.h"
#include "inode.h"
#include "journal.h"
#include "localalloc.h"
#include "suballoc.h"
#include "sysfile.h"
#include "file.h"
#include "super.h"
#include "uptodate.h"
#include "buffer_head_io.h"
static int ocfs2_extent_contig(struct inode *inode,
struct ocfs2_extent_rec *ext,
u64 blkno);
static int ocfs2_create_new_meta_bhs(struct ocfs2_super *osb,
struct ocfs2_journal_handle *handle,
struct inode *inode,
int wanted,
struct ocfs2_alloc_context *meta_ac,
struct buffer_head *bhs[]);
static int ocfs2_add_branch(struct ocfs2_super *osb,
struct ocfs2_journal_handle *handle,
struct inode *inode,
struct buffer_head *fe_bh,
struct buffer_head *eb_bh,
struct buffer_head *last_eb_bh,
struct ocfs2_alloc_context *meta_ac);
static int ocfs2_shift_tree_depth(struct ocfs2_super *osb,
struct ocfs2_journal_handle *handle,
struct inode *inode,
struct buffer_head *fe_bh,
struct ocfs2_alloc_context *meta_ac,
struct buffer_head **ret_new_eb_bh);
static int ocfs2_do_insert_extent(struct ocfs2_super *osb,
struct ocfs2_journal_handle *handle,
struct inode *inode,
struct buffer_head *fe_bh,
u64 blkno,
u32 new_clusters);
static int ocfs2_find_branch_target(struct ocfs2_super *osb,
struct inode *inode,
struct buffer_head *fe_bh,
struct buffer_head **target_bh);
static int ocfs2_find_new_last_ext_blk(struct ocfs2_super *osb,
struct inode *inode,
struct ocfs2_dinode *fe,
unsigned int new_i_clusters,
struct buffer_head *old_last_eb,
struct buffer_head **new_last_eb);
static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc);
static int ocfs2_extent_contig(struct inode *inode,
struct ocfs2_extent_rec *ext,
u64 blkno)
{
return blkno == (le64_to_cpu(ext->e_blkno) +
ocfs2_clusters_to_blocks(inode->i_sb,
le32_to_cpu(ext->e_clusters)));
}
/*
* How many free extents have we got before we need more meta data?
*/
int ocfs2_num_free_extents(struct ocfs2_super *osb,
struct inode *inode,
struct ocfs2_dinode *fe)
{
int retval;
struct ocfs2_extent_list *el;
struct ocfs2_extent_block *eb;
struct buffer_head *eb_bh = NULL;
mlog_entry_void();
if (!OCFS2_IS_VALID_DINODE(fe)) {
OCFS2_RO_ON_INVALID_DINODE(inode->i_sb, fe);
retval = -EIO;
goto bail;
}
if (fe->i_last_eb_blk) {
retval = ocfs2_read_block(osb, le64_to_cpu(fe->i_last_eb_blk),
&eb_bh, OCFS2_BH_CACHED, inode);
if (retval < 0) {
mlog_errno(retval);
goto bail;
}
eb = (struct ocfs2_extent_block *) eb_bh->b_data;
el = &eb->h_list;
} else
el = &fe->id2.i_list;
BUG_ON(el->l_tree_depth != 0);
retval = le16_to_cpu(el->l_count) - le16_to_cpu(el->l_next_free_rec);
bail:
if (eb_bh)
brelse(eb_bh);
mlog_exit(retval);
return retval;
}
/* expects array to already be allocated
*
* sets h_signature, h_blkno, h_suballoc_bit, h_suballoc_slot, and
* l_count for you
*/
static int ocfs2_create_new_meta_bhs(struct ocfs2_super *osb,
struct ocfs2_journal_handle *handle,
struct inode *inode,
int wanted,
struct ocfs2_alloc_context *meta_ac,
struct buffer_head *bhs[])
{
int count, status, i;
u16 suballoc_bit_start;
u32 num_got;
u64 first_blkno;
struct ocfs2_extent_block *eb;
mlog_entry_void();
count = 0;
while (count < wanted) {
status = ocfs2_claim_metadata(osb,
handle,
meta_ac,
wanted - count,
&suballoc_bit_start,
&num_got,
&first_blkno);
if (status < 0) {
mlog_errno(status);
goto bail;
}
for(i = count; i < (num_got + count); i++) {
bhs[i] = sb_getblk(osb->sb, first_blkno);
if (bhs[i] == NULL) {
status = -EIO;
mlog_errno(status);
goto bail;
}
ocfs2_set_new_buffer_uptodate(inode, bhs[i]);
status = ocfs2_journal_access(handle, inode, bhs[i],
OCFS2_JOURNAL_ACCESS_CREATE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
memset(bhs[i]->b_data, 0, osb->sb->s_blocksize);
eb = (struct ocfs2_extent_block *) bhs[i]->b_data;
/* Ok, setup the minimal stuff here. */
strcpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE);
eb->h_blkno = cpu_to_le64(first_blkno);
eb->h_fs_generation = cpu_to_le32(osb->fs_generation);
#ifndef OCFS2_USE_ALL_METADATA_SUBALLOCATORS
/* we always use slot zero's suballocator */
eb->h_suballoc_slot = 0;
#else
eb->h_suballoc_slot = cpu_to_le16(osb->slot_num);
#endif
eb->h_suballoc_bit = cpu_to_le16(suballoc_bit_start);
eb->h_list.l_count =
cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb));
suballoc_bit_start++;
first_blkno++;
/* We'll also be dirtied by the caller, so
* this isn't absolutely necessary. */
status = ocfs2_journal_dirty(handle, bhs[i]);
if (status < 0) {
mlog_errno(status);
goto bail;
}
}
count += num_got;
}
status = 0;
bail:
if (status < 0) {
for(i = 0; i < wanted; i++) {
if (bhs[i])
brelse(bhs[i]);
bhs[i] = NULL;
}
}
mlog_exit(status);
return status;
}
/*
* Add an entire tree branch to our inode. eb_bh is the extent block
* to start at, if we don't want to start the branch at the dinode
* structure.
*
* last_eb_bh is required as we have to update it's next_leaf pointer
* for the new last extent block.
*
* the new branch will be 'empty' in the sense that every block will
* contain a single record with e_clusters == 0.
*/
static int ocfs2_add_branch(struct ocfs2_super *osb,
struct ocfs2_journal_handle *handle,
struct inode *inode,
struct buffer_head *fe_bh,
struct buffer_head *eb_bh,
struct buffer_head *last_eb_bh,
struct ocfs2_alloc_context *meta_ac)
{
int status, new_blocks, i;
u64 next_blkno, new_last_eb_blk;
struct buffer_head *bh;
struct buffer_head **new_eb_bhs = NULL;
struct ocfs2_dinode *fe;
struct ocfs2_extent_block *eb;
struct ocfs2_extent_list *eb_el;
struct ocfs2_extent_list *el;
mlog_entry_void();
BUG_ON(!last_eb_bh);
fe = (struct ocfs2_dinode *) fe_bh->b_data;
if (eb_bh) {
eb = (struct ocfs2_extent_block *) eb_bh->b_data;
el = &eb->h_list;
} else
el = &fe->id2.i_list;
/* we never add a branch to a leaf. */
BUG_ON(!el->l_tree_depth);
new_blocks = le16_to_cpu(el->l_tree_depth);
/* allocate the number of new eb blocks we need */
new_eb_bhs = kcalloc(new_blocks, sizeof(struct buffer_head *),
GFP_KERNEL);
if (!new_eb_bhs) {
status = -ENOMEM;
mlog_errno(status);
goto bail;
}
status = ocfs2_create_new_meta_bhs(osb, handle, inode, new_blocks,
meta_ac, new_eb_bhs);
if (status < 0) {
mlog_errno(status);
goto bail;
}
/* Note: new_eb_bhs[new_blocks - 1] is the guy which will be
* linked with the rest of the tree.
* conversly, new_eb_bhs[0] is the new bottommost leaf.
*
* when we leave the loop, new_last_eb_blk will point to the
* newest leaf, and next_blkno will point to the topmost extent
* block. */
next_blkno = new_last_eb_blk = 0;
for(i = 0; i < new_blocks; i++) {
bh = new_eb_bhs[i];
eb = (struct ocfs2_extent_block *) bh->b_data;
if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
status = -EIO;
goto bail;
}
eb_el = &eb->h_list;
status = ocfs2_journal_access(handle, inode, bh,
OCFS2_JOURNAL_ACCESS_CREATE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
eb->h_next_leaf_blk = 0;
eb_el->l_tree_depth = cpu_to_le16(i);
eb_el->l_next_free_rec = cpu_to_le16(1);
eb_el->l_recs[0].e_cpos = fe->i_clusters;
eb_el->l_recs[0].e_blkno = cpu_to_le64(next_blkno);
eb_el->l_recs[0].e_clusters = cpu_to_le32(0);
if (!eb_el->l_tree_depth)
new_last_eb_blk = le64_to_cpu(eb->h_blkno);
status = ocfs2_journal_dirty(handle, bh);
if (status < 0) {
mlog_errno(status);
goto bail;
}
next_blkno = le64_to_cpu(eb->h_blkno);
}
/* This is a bit hairy. We want to update up to three blocks
* here without leaving any of them in an inconsistent state
* in case of error. We don't have to worry about
* journal_dirty erroring as it won't unless we've aborted the
* handle (in which case we would never be here) so reserving
* the write with journal_access is all we need to do. */
status = ocfs2_journal_access(handle, inode, last_eb_bh,
OCFS2_JOURNAL_ACCESS_WRITE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
status = ocfs2_journal_access(handle, inode, fe_bh,
OCFS2_JOURNAL_ACCESS_WRITE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
if (eb_bh) {
status = ocfs2_journal_access(handle, inode, eb_bh,
OCFS2_JOURNAL_ACCESS_WRITE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
}
/* Link the new branch into the rest of the tree (el will
* either be on the fe, or the extent block passed in. */
i = le16_to_cpu(el->l_next_free_rec);
el->l_recs[i].e_blkno = cpu_to_le64(next_blkno);
el->l_recs[i].e_cpos = fe->i_clusters;
el->l_recs[i].e_clusters = 0;
le16_add_cpu(&el->l_next_free_rec, 1);
/* fe needs a new last extent block pointer, as does the
* next_leaf on the previously last-extent-block. */
fe->i_last_eb_blk = cpu_to_le64(new_last_eb_blk);
eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
eb->h_next_leaf_blk = cpu_to_le64(new_last_eb_blk);
status = ocfs2_journal_dirty(handle, last_eb_bh);
if (status < 0)
mlog_errno(status);
status = ocfs2_journal_dirty(handle, fe_bh);
if (status < 0)
mlog_errno(status);
if (eb_bh) {
status = ocfs2_journal_dirty(handle, eb_bh);
if (status < 0)
mlog_errno(status);
}
status = 0;
bail:
if (new_eb_bhs) {
for (i = 0; i < new_blocks; i++)
if (new_eb_bhs[i])
brelse(new_eb_bhs[i]);
kfree(new_eb_bhs);
}
mlog_exit(status);
return status;
}
/*
* adds another level to the allocation tree.
* returns back the new extent block so you can add a branch to it
* after this call.
*/
static int ocfs2_shift_tree_depth(struct ocfs2_super *osb,
struct ocfs2_journal_handle *handle,
struct inode *inode,
struct buffer_head *fe_bh,
struct ocfs2_alloc_context *meta_ac,
struct buffer_head **ret_new_eb_bh)
{
int status, i;
struct buffer_head *new_eb_bh = NULL;
struct ocfs2_dinode *fe;
struct ocfs2_extent_block *eb;
struct ocfs2_extent_list *fe_el;
struct ocfs2_extent_list *eb_el;
mlog_entry_void();
status = ocfs2_create_new_meta_bhs(osb, handle, inode, 1, meta_ac,
&new_eb_bh);
if (status < 0) {
mlog_errno(status);
goto bail;
}
eb = (struct ocfs2_extent_block *) new_eb_bh->b_data;
if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
status = -EIO;
goto bail;
}
eb_el = &eb->h_list;
fe = (struct ocfs2_dinode *) fe_bh->b_data;
fe_el = &fe->id2.i_list;
status = ocfs2_journal_access(handle, inode, new_eb_bh,
OCFS2_JOURNAL_ACCESS_CREATE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
/* copy the fe data into the new extent block */
eb_el->l_tree_depth = fe_el->l_tree_depth;
eb_el->l_next_free_rec = fe_el->l_next_free_rec;
for(i = 0; i < le16_to_cpu(fe_el->l_next_free_rec); i++) {
eb_el->l_recs[i].e_cpos = fe_el->l_recs[i].e_cpos;
eb_el->l_recs[i].e_clusters = fe_el->l_recs[i].e_clusters;
eb_el->l_recs[i].e_blkno = fe_el->l_recs[i].e_blkno;
}
status = ocfs2_journal_dirty(handle, new_eb_bh);
if (status < 0) {
mlog_errno(status);
goto bail;
}
status = ocfs2_journal_access(handle, inode, fe_bh,
OCFS2_JOURNAL_ACCESS_WRITE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
/* update fe now */
le16_add_cpu(&fe_el->l_tree_depth, 1);
fe_el->l_recs[0].e_cpos = 0;
fe_el->l_recs[0].e_blkno = eb->h_blkno;
fe_el->l_recs[0].e_clusters = fe->i_clusters;
for(i = 1; i < le16_to_cpu(fe_el->l_next_free_rec); i++) {
fe_el->l_recs[i].e_cpos = 0;
fe_el->l_recs[i].e_clusters = 0;
fe_el->l_recs[i].e_blkno = 0;
}
fe_el->l_next_free_rec = cpu_to_le16(1);
/* If this is our 1st tree depth shift, then last_eb_blk
* becomes the allocated extent block */
if (fe_el->l_tree_depth == cpu_to_le16(1))
fe->i_last_eb_blk = eb->h_blkno;
status = ocfs2_journal_dirty(handle, fe_bh);
if (status < 0) {
mlog_errno(status);
goto bail;
}
*ret_new_eb_bh = new_eb_bh;
new_eb_bh = NULL;
status = 0;
bail:
if (new_eb_bh)
brelse(new_eb_bh);
mlog_exit(status);
return status;
}
/*
* Expects the tree to already have room in the rightmost leaf for the
* extent. Updates all the extent blocks (and the dinode) on the way
* down.
*/
static int ocfs2_do_insert_extent(struct ocfs2_super *osb,
struct ocfs2_journal_handle *handle,
struct inode *inode,
struct buffer_head *fe_bh,
u64 start_blk,
u32 new_clusters)
{
int status, i, num_bhs = 0;
u64 next_blkno;
u16 next_free;
struct buffer_head **eb_bhs = NULL;
struct ocfs2_dinode *fe;
struct ocfs2_extent_block *eb;
struct ocfs2_extent_list *el;
mlog_entry_void();
status = ocfs2_journal_access(handle, inode, fe_bh,
OCFS2_JOURNAL_ACCESS_WRITE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
fe = (struct ocfs2_dinode *) fe_bh->b_data;
el = &fe->id2.i_list;
if (el->l_tree_depth) {
/* This is another operation where we want to be
* careful about our tree updates. An error here means
* none of the previous changes we made should roll
* forward. As a result, we have to record the buffers
* for this part of the tree in an array and reserve a
* journal write to them before making any changes. */
num_bhs = le16_to_cpu(fe->id2.i_list.l_tree_depth);
eb_bhs = kcalloc(num_bhs, sizeof(struct buffer_head *),
GFP_KERNEL);
if (!eb_bhs) {
status = -ENOMEM;
mlog_errno(status);
goto bail;
}
i = 0;
while(el->l_tree_depth) {
next_free = le16_to_cpu(el->l_next_free_rec);
if (next_free == 0) {
ocfs2_error(inode->i_sb,
"Dinode %"MLFu64" has a bad "
"extent list",
OCFS2_I(inode)->ip_blkno);
status = -EIO;
goto bail;
}
next_blkno = le64_to_cpu(el->l_recs[next_free - 1].e_blkno);
BUG_ON(i >= num_bhs);
status = ocfs2_read_block(osb, next_blkno, &eb_bhs[i],
OCFS2_BH_CACHED, inode);
if (status < 0) {
mlog_errno(status);
goto bail;
}
eb = (struct ocfs2_extent_block *) eb_bhs[i]->b_data;
if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb,
eb);
status = -EIO;
goto bail;
}
status = ocfs2_journal_access(handle, inode, eb_bhs[i],
OCFS2_JOURNAL_ACCESS_WRITE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
el = &eb->h_list;
i++;
/* When we leave this loop, eb_bhs[num_bhs - 1] will
* hold the bottom-most leaf extent block. */
}
BUG_ON(el->l_tree_depth);
el = &fe->id2.i_list;
/* If we have tree depth, then the fe update is
* trivial, and we want to switch el out for the
* bottom-most leaf in order to update it with the
* actual extent data below. */
next_free = le16_to_cpu(el->l_next_free_rec);
if (next_free == 0) {
ocfs2_error(inode->i_sb,
"Dinode %"MLFu64" has a bad "
"extent list",
OCFS2_I(inode)->ip_blkno);
status = -EIO;
goto bail;
}
le32_add_cpu(&el->l_recs[next_free - 1].e_clusters,
new_clusters);
/* (num_bhs - 1) to avoid the leaf */
for(i = 0; i < (num_bhs - 1); i++) {
eb = (struct ocfs2_extent_block *) eb_bhs[i]->b_data;
el = &eb->h_list;
/* finally, make our actual change to the
* intermediate extent blocks. */
next_free = le16_to_cpu(el->l_next_free_rec);
le32_add_cpu(&el->l_recs[next_free - 1].e_clusters,
new_clusters);
status = ocfs2_journal_dirty(handle, eb_bhs[i]);
if (status < 0)
mlog_errno(status);
}
BUG_ON(i != (num_bhs - 1));
/* note that the leaf block wasn't touched in
* the loop above */
eb = (struct ocfs2_extent_block *) eb_bhs[num_bhs - 1]->b_data;
el = &eb->h_list;
BUG_ON(el->l_tree_depth);
}
/* yay, we can finally add the actual extent now! */
i = le16_to_cpu(el->l_next_free_rec) - 1;
if (le16_to_cpu(el->l_next_free_rec) &&
ocfs2_extent_contig(inode, &el->l_recs[i], start_blk)) {
le32_add_cpu(&el->l_recs[i].e_clusters, new_clusters);
} else if (le16_to_cpu(el->l_next_free_rec) &&
(le32_to_cpu(el->l_recs[i].e_clusters) == 0)) {
/* having an empty extent at eof is legal. */
if (el->l_recs[i].e_cpos != fe->i_clusters) {
ocfs2_error(inode->i_sb,
"Dinode %"MLFu64" trailing extent is bad: "
"cpos (%u) != number of clusters (%u)",
le32_to_cpu(el->l_recs[i].e_cpos),
le32_to_cpu(fe->i_clusters));
status = -EIO;
goto bail;
}
el->l_recs[i].e_blkno = cpu_to_le64(start_blk);
el->l_recs[i].e_clusters = cpu_to_le32(new_clusters);
} else {
/* No contiguous record, or no empty record at eof, so
* we add a new one. */
BUG_ON(le16_to_cpu(el->l_next_free_rec) >=
le16_to_cpu(el->l_count));
i = le16_to_cpu(el->l_next_free_rec);
el->l_recs[i].e_blkno = cpu_to_le64(start_blk);
el->l_recs[i].e_clusters = cpu_to_le32(new_clusters);
el->l_recs[i].e_cpos = fe->i_clusters;
le16_add_cpu(&el->l_next_free_rec, 1);
}
/*
* extent_map errors are not fatal, so they are ignored outside
* of flushing the thing.
*/
status = ocfs2_extent_map_append(inode, &el->l_recs[i],
new_clusters);
if (status) {
mlog_errno(status);
ocfs2_extent_map_drop(inode, le32_to_cpu(fe->i_clusters));
}
status = ocfs2_journal_dirty(handle, fe_bh);
if (status < 0)
mlog_errno(status);
if (fe->id2.i_list.l_tree_depth) {
status = ocfs2_journal_dirty(handle, eb_bhs[num_bhs - 1]);
if (status < 0)
mlog_errno(status);
}
status = 0;
bail:
if (eb_bhs) {
for (i = 0; i < num_bhs; i++)
if (eb_bhs[i])
brelse(eb_bhs[i]);
kfree(eb_bhs);
}
mlog_exit(status);
return status;
}
/*
* Should only be called when there is no space left in any of the
* leaf nodes. What we want to do is find the lowest tree depth
* non-leaf extent block with room for new records. There are three
* valid results of this search:
*
* 1) a lowest extent block is found, then we pass it back in
* *lowest_eb_bh and return '0'
*
* 2) the search fails to find anything, but the dinode has room. We
* pass NULL back in *lowest_eb_bh, but still return '0'
*
* 3) the search fails to find anything AND the dinode is full, in
* which case we return > 0
*
* return status < 0 indicates an error.
*/
static int ocfs2_find_branch_target(struct ocfs2_super *osb,
struct inode *inode,
struct buffer_head *fe_bh,
struct buffer_head **target_bh)
{
int status = 0, i;
u64 blkno;
struct ocfs2_dinode *fe;
struct ocfs2_extent_block *eb;
struct ocfs2_extent_list *el;
struct buffer_head *bh = NULL;
struct buffer_head *lowest_bh = NULL;
mlog_entry_void();
*target_bh = NULL;
fe = (struct ocfs2_dinode *) fe_bh->b_data;
el = &fe->id2.i_list;
while(le16_to_cpu(el->l_tree_depth) > 1) {
if (le16_to_cpu(el->l_next_free_rec) == 0) {
ocfs2_error(inode->i_sb, "Dinode %"MLFu64" has empty "
"extent list (next_free_rec == 0)",
OCFS2_I(inode)->ip_blkno);
status = -EIO;
goto bail;
}
i = le16_to_cpu(el->l_next_free_rec) - 1;
blkno = le64_to_cpu(el->l_recs[i].e_blkno);
if (!blkno) {
ocfs2_error(inode->i_sb, "Dinode %"MLFu64" has extent "
"list where extent # %d has no physical "
"block start",
OCFS2_I(inode)->ip_blkno, i);
status = -EIO;
goto bail;
}
if (bh) {
brelse(bh);
bh = NULL;
}
status = ocfs2_read_block(osb, blkno, &bh, OCFS2_BH_CACHED,
inode);
if (status < 0) {
mlog_errno(status);
goto bail;
}
eb = (struct ocfs2_extent_block *) bh->b_data;
if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
status = -EIO;
goto bail;
}
el = &eb->h_list;
if (le16_to_cpu(el->l_next_free_rec) <
le16_to_cpu(el->l_count)) {
if (lowest_bh)
brelse(lowest_bh);
lowest_bh = bh;
get_bh(lowest_bh);
}
}
/* If we didn't find one and the fe doesn't have any room,
* then return '1' */
if (!lowest_bh
&& (fe->id2.i_list.l_next_free_rec == fe->id2.i_list.l_count))
status = 1;
*target_bh = lowest_bh;
bail:
if (bh)
brelse(bh);
mlog_exit(status);
return status;
}
/* the caller needs to update fe->i_clusters */
int ocfs2_insert_extent(struct ocfs2_super *osb,
struct ocfs2_journal_handle *handle,
struct inode *inode,
struct buffer_head *fe_bh,
u64 start_blk,
u32 new_clusters,
struct ocfs2_alloc_context *meta_ac)
{
int status, i, shift;
struct buffer_head *last_eb_bh = NULL;
struct buffer_head *bh = NULL;
struct ocfs2_dinode *fe;
struct ocfs2_extent_block *eb;
struct ocfs2_extent_list *el;
mlog_entry_void();
mlog(0, "add %u clusters starting at block %"MLFu64" to "
"inode %"MLFu64"\n",
new_clusters, start_blk, OCFS2_I(inode)->ip_blkno);
fe = (struct ocfs2_dinode *) fe_bh->b_data;
el = &fe->id2.i_list;
if (el->l_tree_depth) {
/* jump to end of tree */
status = ocfs2_read_block(osb, le64_to_cpu(fe->i_last_eb_blk),
&last_eb_bh, OCFS2_BH_CACHED, inode);
if (status < 0) {
mlog_exit(status);
goto bail;
}
eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
el = &eb->h_list;
}
/* Can we allocate without adding/shifting tree bits? */
i = le16_to_cpu(el->l_next_free_rec) - 1;
if (le16_to_cpu(el->l_next_free_rec) == 0
|| (le16_to_cpu(el->l_next_free_rec) < le16_to_cpu(el->l_count))
|| le32_to_cpu(el->l_recs[i].e_clusters) == 0
|| ocfs2_extent_contig(inode, &el->l_recs[i], start_blk))
goto out_add;
mlog(0, "ocfs2_allocate_extent: couldn't do a simple add, traversing "
"tree now.\n");
shift = ocfs2_find_branch_target(osb, inode, fe_bh, &bh);
if (shift < 0) {
status = shift;
mlog_errno(status);
goto bail;
}
/* We traveled all the way to the bottom of the allocation tree
* and didn't find room for any more extents - we need to add
* another tree level */
if (shift) {
/* if we hit a leaf, we'd better be empty :) */
BUG_ON(le16_to_cpu(el->l_next_free_rec) !=
le16_to_cpu(el->l_count));
BUG_ON(bh);
mlog(0, "ocfs2_allocate_extent: need to shift tree depth "
"(current = %u)\n",
le16_to_cpu(fe->id2.i_list.l_tree_depth));
/* ocfs2_shift_tree_depth will return us a buffer with
* the new extent block (so we can pass that to
* ocfs2_add_branch). */
status = ocfs2_shift_tree_depth(osb, handle, inode, fe_bh,
meta_ac, &bh);
if (status < 0) {
mlog_errno(status);
goto bail;
}
/* Special case: we have room now if we shifted from
* tree_depth 0 */
if (fe->id2.i_list.l_tree_depth == cpu_to_le16(1))
goto out_add;
}
/* call ocfs2_add_branch to add the final part of the tree with
* the new data. */
mlog(0, "ocfs2_allocate_extent: add branch. bh = %p\n", bh);
status = ocfs2_add_branch(osb, handle, inode, fe_bh, bh, last_eb_bh,
meta_ac);
if (status < 0) {
mlog_errno(status);
goto bail;
}
out_add:
/* Finally, we can add clusters. */
status = ocfs2_do_insert_extent(osb, handle, inode, fe_bh,
start_blk, new_clusters);
if (status < 0)
mlog_errno(status);
bail:
if (bh)
brelse(bh);
if (last_eb_bh)
brelse(last_eb_bh);
mlog_exit(status);
return status;
}
static inline int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb)
{
struct buffer_head *tl_bh = osb->osb_tl_bh;
struct ocfs2_dinode *di;
struct ocfs2_truncate_log *tl;
di = (struct ocfs2_dinode *) tl_bh->b_data;
tl = &di->id2.i_dealloc;
mlog_bug_on_msg(le16_to_cpu(tl->tl_used) > le16_to_cpu(tl->tl_count),
"slot %d, invalid truncate log parameters: used = "
"%u, count = %u\n", osb->slot_num,
le16_to_cpu(tl->tl_used), le16_to_cpu(tl->tl_count));
return le16_to_cpu(tl->tl_used) == le16_to_cpu(tl->tl_count);
}
static int ocfs2_truncate_log_can_coalesce(struct ocfs2_truncate_log *tl,
unsigned int new_start)
{
unsigned int tail_index;
unsigned int current_tail;
/* No records, nothing to coalesce */
if (!le16_to_cpu(tl->tl_used))
return 0;
tail_index = le16_to_cpu(tl->tl_used) - 1;
current_tail = le32_to_cpu(tl->tl_recs[tail_index].t_start);
current_tail += le32_to_cpu(tl->tl_recs[tail_index].t_clusters);
return current_tail == new_start;
}
static int ocfs2_truncate_log_append(struct ocfs2_super *osb,
struct ocfs2_journal_handle *handle,
u64 start_blk,
unsigned int num_clusters)
{
int status, index;
unsigned int start_cluster, tl_count;
struct inode *tl_inode = osb->osb_tl_inode;
struct buffer_head *tl_bh = osb->osb_tl_bh;
struct ocfs2_dinode *di;
struct ocfs2_truncate_log *tl;
mlog_entry("start_blk = %"MLFu64", num_clusters = %u\n", start_blk,
num_clusters);
BUG_ON(mutex_trylock(&tl_inode->i_mutex));
start_cluster = ocfs2_blocks_to_clusters(osb->sb, start_blk);
di = (struct ocfs2_dinode *) tl_bh->b_data;
tl = &di->id2.i_dealloc;
if (!OCFS2_IS_VALID_DINODE(di)) {
OCFS2_RO_ON_INVALID_DINODE(osb->sb, di);
status = -EIO;
goto bail;
}
tl_count = le16_to_cpu(tl->tl_count);
mlog_bug_on_msg(tl_count > ocfs2_truncate_recs_per_inode(osb->sb) ||
tl_count == 0,
"Truncate record count on #%"MLFu64" invalid ("
"wanted %u, actual %u\n", OCFS2_I(tl_inode)->ip_blkno,
ocfs2_truncate_recs_per_inode(osb->sb),
le16_to_cpu(tl->tl_count));
/* Caller should have known to flush before calling us. */
index = le16_to_cpu(tl->tl_used);
if (index >= tl_count) {
status = -ENOSPC;
mlog_errno(status);
goto bail;
}
status = ocfs2_journal_access(handle, tl_inode, tl_bh,
OCFS2_JOURNAL_ACCESS_WRITE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
mlog(0, "Log truncate of %u clusters starting at cluster %u to "
"%"MLFu64" (index = %d)\n", num_clusters, start_cluster,
OCFS2_I(tl_inode)->ip_blkno, index);
if (ocfs2_truncate_log_can_coalesce(tl, start_cluster)) {
/*
* Move index back to the record we are coalescing with.
* ocfs2_truncate_log_can_coalesce() guarantees nonzero
*/
index--;
num_clusters += le32_to_cpu(tl->tl_recs[index].t_clusters);
mlog(0, "Coalesce with index %u (start = %u, clusters = %u)\n",
index, le32_to_cpu(tl->tl_recs[index].t_start),
num_clusters);
} else {
tl->tl_recs[index].t_start = cpu_to_le32(start_cluster);
tl->tl_used = cpu_to_le16(index + 1);
}
tl->tl_recs[index].t_clusters = cpu_to_le32(num_clusters);
status = ocfs2_journal_dirty(handle, tl_bh);
if (status < 0) {
mlog_errno(status);
goto bail;
}
bail:
mlog_exit(status);
return status;
}
static int ocfs2_replay_truncate_records(struct ocfs2_super *osb,
struct ocfs2_journal_handle *handle,
struct inode *data_alloc_inode,
struct buffer_head *data_alloc_bh)
{
int status = 0;
int i;
unsigned int num_clusters;
u64 start_blk;
struct ocfs2_truncate_rec rec;
struct ocfs2_dinode *di;
struct ocfs2_truncate_log *tl;
struct inode *tl_inode = osb->osb_tl_inode;
struct buffer_head *tl_bh = osb->osb_tl_bh;
mlog_entry_void();
di = (struct ocfs2_dinode *) tl_bh->b_data;
tl = &di->id2.i_dealloc;
i = le16_to_cpu(tl->tl_used) - 1;
while (i >= 0) {
/* Caller has given us at least enough credits to
* update the truncate log dinode */
status = ocfs2_journal_access(handle, tl_inode, tl_bh,
OCFS2_JOURNAL_ACCESS_WRITE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
tl->tl_used = cpu_to_le16(i);
status = ocfs2_journal_dirty(handle, tl_bh);
if (status < 0) {
mlog_errno(status);
goto bail;
}
/* TODO: Perhaps we can calculate the bulk of the
* credits up front rather than extending like
* this. */
status = ocfs2_extend_trans(handle,
OCFS2_TRUNCATE_LOG_FLUSH_ONE_REC);
if (status < 0) {
mlog_errno(status);
goto bail;
}
rec = tl->tl_recs[i];
start_blk = ocfs2_clusters_to_blocks(data_alloc_inode->i_sb,
le32_to_cpu(rec.t_start));
num_clusters = le32_to_cpu(rec.t_clusters);
/* if start_blk is not set, we ignore the record as
* invalid. */
if (start_blk) {
mlog(0, "free record %d, start = %u, clusters = %u\n",
i, le32_to_cpu(rec.t_start), num_clusters);
status = ocfs2_free_clusters(handle, data_alloc_inode,
data_alloc_bh, start_blk,
num_clusters);
if (status < 0) {
mlog_errno(status);
goto bail;
}
}
i--;
}
bail:
mlog_exit(status);
return status;
}
/* Expects you to already be holding tl_inode->i_mutex */
static int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
{
int status;
unsigned int num_to_flush;
struct ocfs2_journal_handle *handle = NULL;
struct inode *tl_inode = osb->osb_tl_inode;
struct inode *data_alloc_inode = NULL;
struct buffer_head *tl_bh = osb->osb_tl_bh;
struct buffer_head *data_alloc_bh = NULL;
struct ocfs2_dinode *di;
struct ocfs2_truncate_log *tl;
mlog_entry_void();
BUG_ON(mutex_trylock(&tl_inode->i_mutex));
di = (struct ocfs2_dinode *) tl_bh->b_data;
tl = &di->id2.i_dealloc;
if (!OCFS2_IS_VALID_DINODE(di)) {
OCFS2_RO_ON_INVALID_DINODE(osb->sb, di);
status = -EIO;
goto bail;
}
num_to_flush = le16_to_cpu(tl->tl_used);
mlog(0, "Flush %u records from truncate log #%"MLFu64"\n",
num_to_flush, OCFS2_I(tl_inode)->ip_blkno);
if (!num_to_flush) {
status = 0;
goto bail;
}
handle = ocfs2_alloc_handle(osb);
if (!handle) {
status = -ENOMEM;
mlog_errno(status);
goto bail;
}
data_alloc_inode = ocfs2_get_system_file_inode(osb,
GLOBAL_BITMAP_SYSTEM_INODE,
OCFS2_INVALID_SLOT);
if (!data_alloc_inode) {
status = -EINVAL;
mlog(ML_ERROR, "Could not get bitmap inode!\n");
goto bail;
}
ocfs2_handle_add_inode(handle, data_alloc_inode);
status = ocfs2_meta_lock(data_alloc_inode, handle, &data_alloc_bh, 1);
if (status < 0) {
mlog_errno(status);
goto bail;
}
handle = ocfs2_start_trans(osb, handle, OCFS2_TRUNCATE_LOG_UPDATE);
if (IS_ERR(handle)) {
status = PTR_ERR(handle);
handle = NULL;
mlog_errno(status);
goto bail;
}
status = ocfs2_replay_truncate_records(osb, handle, data_alloc_inode,
data_alloc_bh);
if (status < 0) {
mlog_errno(status);
goto bail;
}
bail:
if (handle)
ocfs2_commit_trans(handle);
if (data_alloc_inode)
iput(data_alloc_inode);
if (data_alloc_bh)
brelse(data_alloc_bh);
mlog_exit(status);
return status;
}
int ocfs2_flush_truncate_log(struct ocfs2_super *osb)
{
int status;
struct inode *tl_inode = osb->osb_tl_inode;
mutex_lock(&tl_inode->i_mutex);
status = __ocfs2_flush_truncate_log(osb);
mutex_unlock(&tl_inode->i_mutex);
return status;
}
static void ocfs2_truncate_log_worker(void *data)
{
int status;
struct ocfs2_super *osb = data;
mlog_entry_void();
status = ocfs2_flush_truncate_log(osb);
if (status < 0)
mlog_errno(status);
mlog_exit(status);
}
#define OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL (2 * HZ)
void ocfs2_schedule_truncate_log_flush(struct ocfs2_super *osb,
int cancel)
{
if (osb->osb_tl_inode) {
/* We want to push off log flushes while truncates are
* still running. */
if (cancel)
cancel_delayed_work(&osb->osb_truncate_log_wq);
queue_delayed_work(ocfs2_wq, &osb->osb_truncate_log_wq,
OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL);
}
}
static int ocfs2_get_truncate_log_info(struct ocfs2_super *osb,
int slot_num,
struct inode **tl_inode,
struct buffer_head **tl_bh)
{
int status;
struct inode *inode = NULL;
struct buffer_head *bh = NULL;
inode = ocfs2_get_system_file_inode(osb,
TRUNCATE_LOG_SYSTEM_INODE,
slot_num);
if (!inode) {
status = -EINVAL;
mlog(ML_ERROR, "Could not get load truncate log inode!\n");
goto bail;
}
status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, &bh,
OCFS2_BH_CACHED, inode);
if (status < 0) {
iput(inode);
mlog_errno(status);
goto bail;
}
*tl_inode = inode;
*tl_bh = bh;
bail:
mlog_exit(status);
return status;
}
/* called during the 1st stage of node recovery. we stamp a clean
* truncate log and pass back a copy for processing later. if the
* truncate log does not require processing, a *tl_copy is set to
* NULL. */
int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb,
int slot_num,
struct ocfs2_dinode **tl_copy)
{
int status;
struct inode *tl_inode = NULL;
struct buffer_head *tl_bh = NULL;
struct ocfs2_dinode *di;
struct ocfs2_truncate_log *tl;
*tl_copy = NULL;
mlog(0, "recover truncate log from slot %d\n", slot_num);
status = ocfs2_get_truncate_log_info(osb, slot_num, &tl_inode, &tl_bh);
if (status < 0) {
mlog_errno(status);
goto bail;
}
di = (struct ocfs2_dinode *) tl_bh->b_data;
tl = &di->id2.i_dealloc;
if (!OCFS2_IS_VALID_DINODE(di)) {
OCFS2_RO_ON_INVALID_DINODE(tl_inode->i_sb, di);
status = -EIO;
goto bail;
}
if (le16_to_cpu(tl->tl_used)) {
mlog(0, "We'll have %u logs to recover\n",
le16_to_cpu(tl->tl_used));
*tl_copy = kmalloc(tl_bh->b_size, GFP_KERNEL);
if (!(*tl_copy)) {
status = -ENOMEM;
mlog_errno(status);
goto bail;
}
/* Assuming the write-out below goes well, this copy
* will be passed back to recovery for processing. */
memcpy(*tl_copy, tl_bh->b_data, tl_bh->b_size);
/* All we need to do to clear the truncate log is set
* tl_used. */
tl->tl_used = 0;
status = ocfs2_write_block(osb, tl_bh, tl_inode);
if (status < 0) {
mlog_errno(status);
goto bail;
}
}
bail:
if (tl_inode)
iput(tl_inode);
if (tl_bh)
brelse(tl_bh);
if (status < 0 && (*tl_copy)) {
kfree(*tl_copy);
*tl_copy = NULL;
}
mlog_exit(status);
return status;
}
int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
struct ocfs2_dinode *tl_copy)
{
int status = 0;
int i;
unsigned int clusters, num_recs, start_cluster;
u64 start_blk;
struct ocfs2_journal_handle *handle;
struct inode *tl_inode = osb->osb_tl_inode;
struct ocfs2_truncate_log *tl;
mlog_entry_void();
if (OCFS2_I(tl_inode)->ip_blkno == le64_to_cpu(tl_copy->i_blkno)) {
mlog(ML_ERROR, "Asked to recover my own truncate log!\n");
return -EINVAL;
}
tl = &tl_copy->id2.i_dealloc;
num_recs = le16_to_cpu(tl->tl_used);
mlog(0, "cleanup %u records from %"MLFu64"\n", num_recs,
tl_copy->i_blkno);
mutex_lock(&tl_inode->i_mutex);
for(i = 0; i < num_recs; i++) {
if (ocfs2_truncate_log_needs_flush(osb)) {
status = __ocfs2_flush_truncate_log(osb);
if (status < 0) {
mlog_errno(status);
goto bail_up;
}
}
handle = ocfs2_start_trans(osb, NULL,
OCFS2_TRUNCATE_LOG_UPDATE);
if (IS_ERR(handle)) {
status = PTR_ERR(handle);
mlog_errno(status);
goto bail_up;
}
clusters = le32_to_cpu(tl->tl_recs[i].t_clusters);
start_cluster = le32_to_cpu(tl->tl_recs[i].t_start);
start_blk = ocfs2_clusters_to_blocks(osb->sb, start_cluster);
status = ocfs2_truncate_log_append(osb, handle,
start_blk, clusters);
ocfs2_commit_trans(handle);
if (status < 0) {
mlog_errno(status);
goto bail_up;
}
}
bail_up:
mutex_unlock(&tl_inode->i_mutex);
mlog_exit(status);
return status;
}
void ocfs2_truncate_log_shutdown(struct ocfs2_super *osb)
{
int status;
struct inode *tl_inode = osb->osb_tl_inode;
mlog_entry_void();
if (tl_inode) {
cancel_delayed_work(&osb->osb_truncate_log_wq);
flush_workqueue(ocfs2_wq);
status = ocfs2_flush_truncate_log(osb);
if (status < 0)
mlog_errno(status);
brelse(osb->osb_tl_bh);
iput(osb->osb_tl_inode);
}
mlog_exit_void();
}
int ocfs2_truncate_log_init(struct ocfs2_super *osb)
{
int status;
struct inode *tl_inode = NULL;
struct buffer_head *tl_bh = NULL;
mlog_entry_void();
status = ocfs2_get_truncate_log_info(osb,
osb->slot_num,
&tl_inode,
&tl_bh);
if (status < 0)
mlog_errno(status);
/* ocfs2_truncate_log_shutdown keys on the existence of
* osb->osb_tl_inode so we don't set any of the osb variables
* until we're sure all is well. */
INIT_WORK(&osb->osb_truncate_log_wq, ocfs2_truncate_log_worker, osb);
osb->osb_tl_bh = tl_bh;
osb->osb_tl_inode = tl_inode;
mlog_exit(status);
return status;
}
/* This function will figure out whether the currently last extent
* block will be deleted, and if it will, what the new last extent
* block will be so we can update his h_next_leaf_blk field, as well
* as the dinodes i_last_eb_blk */
static int ocfs2_find_new_last_ext_blk(struct ocfs2_super *osb,
struct inode *inode,
struct ocfs2_dinode *fe,
u32 new_i_clusters,
struct buffer_head *old_last_eb,
struct buffer_head **new_last_eb)
{
int i, status = 0;
u64 block = 0;
struct ocfs2_extent_block *eb;
struct ocfs2_extent_list *el;
struct buffer_head *bh = NULL;
*new_last_eb = NULL;
if (!OCFS2_IS_VALID_DINODE(fe)) {
OCFS2_RO_ON_INVALID_DINODE(inode->i_sb, fe);
status = -EIO;
goto bail;
}
/* we have no tree, so of course, no last_eb. */
if (!fe->id2.i_list.l_tree_depth)
goto bail;
/* trunc to zero special case - this makes tree_depth = 0
* regardless of what it is. */
if (!new_i_clusters)
goto bail;
eb = (struct ocfs2_extent_block *) old_last_eb->b_data;
el = &(eb->h_list);
BUG_ON(!el->l_next_free_rec);
/* Make sure that this guy will actually be empty after we
* clear away the data. */
if (le32_to_cpu(el->l_recs[0].e_cpos) < new_i_clusters)
goto bail;
/* Ok, at this point, we know that last_eb will definitely
* change, so lets traverse the tree and find the second to
* last extent block. */
el = &(fe->id2.i_list);
/* go down the tree, */
do {
for(i = (le16_to_cpu(el->l_next_free_rec) - 1); i >= 0; i--) {
if (le32_to_cpu(el->l_recs[i].e_cpos) <
new_i_clusters) {
block = le64_to_cpu(el->l_recs[i].e_blkno);
break;
}
}
BUG_ON(i < 0);
if (bh) {
brelse(bh);
bh = NULL;
}
status = ocfs2_read_block(osb, block, &bh, OCFS2_BH_CACHED,
inode);
if (status < 0) {
mlog_errno(status);
goto bail;
}
eb = (struct ocfs2_extent_block *) bh->b_data;
el = &eb->h_list;
if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
status = -EIO;
goto bail;
}
} while (el->l_tree_depth);
*new_last_eb = bh;
get_bh(*new_last_eb);
mlog(0, "returning block %"MLFu64"\n", le64_to_cpu(eb->h_blkno));
bail:
if (bh)
brelse(bh);
return status;
}
static int ocfs2_do_truncate(struct ocfs2_super *osb,
unsigned int clusters_to_del,
struct inode *inode,
struct buffer_head *fe_bh,
struct buffer_head *old_last_eb_bh,
struct ocfs2_journal_handle *handle,
struct ocfs2_truncate_context *tc)
{
int status, i, depth;
struct ocfs2_dinode *fe;
struct ocfs2_extent_block *eb;
struct ocfs2_extent_block *last_eb = NULL;
struct ocfs2_extent_list *el;
struct buffer_head *eb_bh = NULL;
struct buffer_head *last_eb_bh = NULL;
u64 next_eb = 0;
u64 delete_blk = 0;
fe = (struct ocfs2_dinode *) fe_bh->b_data;
status = ocfs2_find_new_last_ext_blk(osb,
inode,
fe,
le32_to_cpu(fe->i_clusters) -
clusters_to_del,
old_last_eb_bh,
&last_eb_bh);
if (status < 0) {
mlog_errno(status);
goto bail;
}
if (last_eb_bh)
last_eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
status = ocfs2_journal_access(handle, inode, fe_bh,
OCFS2_JOURNAL_ACCESS_WRITE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
el = &(fe->id2.i_list);
spin_lock(&OCFS2_I(inode)->ip_lock);
OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters) -
clusters_to_del;
spin_unlock(&OCFS2_I(inode)->ip_lock);
le32_add_cpu(&fe->i_clusters, -clusters_to_del);
fe->i_mtime = cpu_to_le64(CURRENT_TIME.tv_sec);
fe->i_mtime_nsec = cpu_to_le32(CURRENT_TIME.tv_nsec);
i = le16_to_cpu(el->l_next_free_rec) - 1;
BUG_ON(le32_to_cpu(el->l_recs[i].e_clusters) < clusters_to_del);
le32_add_cpu(&el->l_recs[i].e_clusters, -clusters_to_del);
/* tree depth zero, we can just delete the clusters, otherwise
* we need to record the offset of the next level extent block
* as we may overwrite it. */
if (!el->l_tree_depth)
delete_blk = le64_to_cpu(el->l_recs[i].e_blkno)
+ ocfs2_clusters_to_blocks(osb->sb,
le32_to_cpu(el->l_recs[i].e_clusters));
else
next_eb = le64_to_cpu(el->l_recs[i].e_blkno);
if (!el->l_recs[i].e_clusters) {
/* if we deleted the whole extent record, then clear
* out the other fields and update the extent
* list. For depth > 0 trees, we've already recorded
* the extent block in 'next_eb' */
el->l_recs[i].e_cpos = 0;
el->l_recs[i].e_blkno = 0;
BUG_ON(!el->l_next_free_rec);
le16_add_cpu(&el->l_next_free_rec, -1);
}
depth = le16_to_cpu(el->l_tree_depth);
if (!fe->i_clusters) {
/* trunc to zero is a special case. */
el->l_tree_depth = 0;
fe->i_last_eb_blk = 0;
} else if (last_eb)
fe->i_last_eb_blk = last_eb->h_blkno;
status = ocfs2_journal_dirty(handle, fe_bh);
if (status < 0) {
mlog_errno(status);
goto bail;
}
if (last_eb) {
/* If there will be a new last extent block, then by
* definition, there cannot be any leaves to the right of
* him. */
status = ocfs2_journal_access(handle, inode, last_eb_bh,
OCFS2_JOURNAL_ACCESS_WRITE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
last_eb->h_next_leaf_blk = 0;
status = ocfs2_journal_dirty(handle, last_eb_bh);
if (status < 0) {
mlog_errno(status);
goto bail;
}
}
/* if our tree depth > 0, update all the tree blocks below us. */
while (depth) {
mlog(0, "traveling tree (depth = %d, next_eb = %"MLFu64")\n",
depth, next_eb);
status = ocfs2_read_block(osb, next_eb, &eb_bh,
OCFS2_BH_CACHED, inode);
if (status < 0) {
mlog_errno(status);
goto bail;
}
eb = (struct ocfs2_extent_block *)eb_bh->b_data;
if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
status = -EIO;
goto bail;
}
el = &(eb->h_list);
status = ocfs2_journal_access(handle, inode, eb_bh,
OCFS2_JOURNAL_ACCESS_WRITE);
if (status < 0) {
mlog_errno(status);
goto bail;
}
BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0);
BUG_ON(depth != (le16_to_cpu(el->l_tree_depth) + 1));
i = le16_to_cpu(el->l_next_free_rec) - 1;
mlog(0, "extent block %"MLFu64", before: record %d: "
"(%u, %u, %"MLFu64"), next = %u\n",
le64_to_cpu(eb->h_blkno), i,
le32_to_cpu(el->l_recs[i].e_cpos),
le32_to_cpu(el->l_recs[i].e_clusters),
le64_to_cpu(el->l_recs[i].e_blkno),
le16_to_cpu(el->l_next_free_rec));
BUG_ON(le32_to_cpu(el->l_recs[i].e_clusters) < clusters_to_del);
le32_add_cpu(&el->l_recs[i].e_clusters, -clusters_to_del);
next_eb = le64_to_cpu(el->l_recs[i].e_blkno);
/* bottom-most block requires us to delete data.*/
if (!el->l_tree_depth)
delete_blk = le64_to_cpu(el->l_recs[i].e_blkno)
+ ocfs2_clusters_to_blocks(osb->sb,
le32_to_cpu(el->l_recs[i].e_clusters));
if (!el->l_recs[i].e_clusters) {
el->l_recs[i].e_cpos = 0;
el->l_recs[i].e_blkno = 0;
BUG_ON(!el->l_next_free_rec);
le16_add_cpu(&el->l_next_free_rec, -1);
}
mlog(0, "extent block %"MLFu64", after: record %d: "
"(%u, %u, %"MLFu64"), next = %u\n",
le64_to_cpu(eb->h_blkno), i,
le32_to_cpu(el->l_recs[i].e_cpos),
le32_to_cpu(el->l_recs[i].e_clusters),
le64_to_cpu(el->l_recs[i].e_blkno),
le16_to_cpu(el->l_next_free_rec));
status = ocfs2_journal_dirty(handle, eb_bh);
if (status < 0) {
mlog_errno(status);
goto bail;
}
if (!el->l_next_free_rec) {
mlog(0, "deleting this extent block.\n");
ocfs2_remove_from_cache(inode, eb_bh);
BUG_ON(eb->h_suballoc_slot);
BUG_ON(el->l_recs[0].e_clusters);
BUG_ON(el->l_recs[0].e_cpos);
BUG_ON(el->l_recs[0].e_blkno);
status = ocfs2_free_extent_block(handle,
tc->tc_ext_alloc_inode,
tc->tc_ext_alloc_bh,
eb);
if (status < 0) {
mlog_errno(status);
goto bail;
}
}
brelse(eb_bh);
eb_bh = NULL;
depth--;
}
BUG_ON(!delete_blk);
status = ocfs2_truncate_log_append(osb, handle, delete_blk,
clusters_to_del);
if (status < 0) {
mlog_errno(status);
goto bail;
}
status = 0;
bail:
if (!status)
ocfs2_extent_map_trunc(inode, le32_to_cpu(fe->i_clusters));
else
ocfs2_extent_map_drop(inode, 0);
mlog_exit(status);
return status;
}
/*
* It is expected, that by the time you call this function,
* inode->i_size and fe->i_size have been adjusted.
*
* WARNING: This will kfree the truncate context
*/
int ocfs2_commit_truncate(struct ocfs2_super *osb,
struct inode *inode,
struct buffer_head *fe_bh,
struct ocfs2_truncate_context *tc)
{
int status, i, credits, tl_sem = 0;
u32 clusters_to_del, target_i_clusters;
u64 last_eb = 0;
struct ocfs2_dinode *fe;
struct ocfs2_extent_block *eb;
struct ocfs2_extent_list *el;
struct buffer_head *last_eb_bh;
struct ocfs2_journal_handle *handle = NULL;
struct inode *tl_inode = osb->osb_tl_inode;
mlog_entry_void();
down_write(&OCFS2_I(inode)->ip_alloc_sem);
target_i_clusters = ocfs2_clusters_for_bytes(osb->sb,
i_size_read(inode));
last_eb_bh = tc->tc_last_eb_bh;
tc->tc_last_eb_bh = NULL;
fe = (struct ocfs2_dinode *) fe_bh->b_data;
if (fe->id2.i_list.l_tree_depth) {
eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
el = &eb->h_list;
} else
el = &fe->id2.i_list;
last_eb = le64_to_cpu(fe->i_last_eb_blk);
start:
mlog(0, "ocfs2_commit_truncate: fe->i_clusters = %u, "
"last_eb = %"MLFu64", fe->i_last_eb_blk = %"MLFu64", "
"fe->id2.i_list.l_tree_depth = %u last_eb_bh = %p\n",
le32_to_cpu(fe->i_clusters), last_eb,
le64_to_cpu(fe->i_last_eb_blk),
le16_to_cpu(fe->id2.i_list.l_tree_depth), last_eb_bh);
if (last_eb != le64_to_cpu(fe->i_last_eb_blk)) {
mlog(0, "last_eb changed!\n");
BUG_ON(!fe->id2.i_list.l_tree_depth);
last_eb = le64_to_cpu(fe->i_last_eb_blk);
/* i_last_eb_blk may have changed, read it if
* necessary. We don't have to worry about the
* truncate to zero case here (where there becomes no
* last_eb) because we never loop back after our work
* is done. */
if (last_eb_bh) {
brelse(last_eb_bh);
last_eb_bh = NULL;
}
status = ocfs2_read_block(osb, last_eb,
&last_eb_bh, OCFS2_BH_CACHED,
inode);
if (status < 0) {
mlog_errno(status);
goto bail;
}
eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
status = -EIO;
goto bail;
}
el = &(eb->h_list);
}
/* by now, el will point to the extent list on the bottom most
* portion of this tree. */
i = le16_to_cpu(el->l_next_free_rec) - 1;
if (le32_to_cpu(el->l_recs[i].e_cpos) >= target_i_clusters)
clusters_to_del = le32_to_cpu(el->l_recs[i].e_clusters);
else
clusters_to_del = (le32_to_cpu(el->l_recs[i].e_clusters) +
le32_to_cpu(el->l_recs[i].e_cpos)) -
target_i_clusters;
mlog(0, "clusters_to_del = %u in this pass\n", clusters_to_del);
mutex_lock(&tl_inode->i_mutex);
tl_sem = 1;
/* ocfs2_truncate_log_needs_flush guarantees us at least one
* record is free for use. If there isn't any, we flush to get
* an empty truncate log. */
if (ocfs2_truncate_log_needs_flush(osb)) {
status = __ocfs2_flush_truncate_log(osb);
if (status < 0) {
mlog_errno(status);
goto bail;
}
}
credits = ocfs2_calc_tree_trunc_credits(osb->sb, clusters_to_del,
fe, el);
handle = ocfs2_start_trans(osb, NULL, credits);
if (IS_ERR(handle)) {
status = PTR_ERR(handle);
handle = NULL;
mlog_errno(status);
goto bail;
}
inode->i_ctime = inode->i_mtime = CURRENT_TIME;
status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
if (status < 0)
mlog_errno(status);
status = ocfs2_do_truncate(osb, clusters_to_del, inode, fe_bh,
last_eb_bh, handle, tc);
if (status < 0) {
mlog_errno(status);
goto bail;
}
mutex_unlock(&tl_inode->i_mutex);
tl_sem = 0;
ocfs2_commit_trans(handle);
handle = NULL;
BUG_ON(le32_to_cpu(fe->i_clusters) < target_i_clusters);
if (le32_to_cpu(fe->i_clusters) > target_i_clusters)
goto start;
bail:
up_write(&OCFS2_I(inode)->ip_alloc_sem);
ocfs2_schedule_truncate_log_flush(osb, 1);
if (tl_sem)
mutex_unlock(&tl_inode->i_mutex);
if (handle)
ocfs2_commit_trans(handle);
if (last_eb_bh)
brelse(last_eb_bh);
/* This will drop the ext_alloc cluster lock for us */
ocfs2_free_truncate_context(tc);
mlog_exit(status);
return status;
}
/*
* Expects the inode to already be locked. This will figure out which
* inodes need to be locked and will put them on the returned truncate
* context.
*/
int ocfs2_prepare_truncate(struct ocfs2_super *osb,
struct inode *inode,
struct buffer_head *fe_bh,
struct ocfs2_truncate_context **tc)
{
int status, metadata_delete;
unsigned int new_i_clusters;
struct ocfs2_dinode *fe;
struct ocfs2_extent_block *eb;
struct ocfs2_extent_list *el;
struct buffer_head *last_eb_bh = NULL;
struct inode *ext_alloc_inode = NULL;
struct buffer_head *ext_alloc_bh = NULL;
mlog_entry_void();
*tc = NULL;
new_i_clusters = ocfs2_clusters_for_bytes(osb->sb,
i_size_read(inode));
fe = (struct ocfs2_dinode *) fe_bh->b_data;
mlog(0, "fe->i_clusters = %u, new_i_clusters = %u, fe->i_size ="
"%"MLFu64"\n", fe->i_clusters, new_i_clusters, fe->i_size);
if (le32_to_cpu(fe->i_clusters) <= new_i_clusters) {
ocfs2_error(inode->i_sb, "Dinode %"MLFu64" has cluster count "
"%u and size %"MLFu64" whereas struct inode has "
"cluster count %u and size %llu which caused an "
"invalid truncate to %u clusters.",
le64_to_cpu(fe->i_blkno),
le32_to_cpu(fe->i_clusters),
le64_to_cpu(fe->i_size),
OCFS2_I(inode)->ip_clusters, i_size_read(inode),
new_i_clusters);
mlog_meta_lvb(ML_ERROR, &OCFS2_I(inode)->ip_meta_lockres);
status = -EIO;
goto bail;
}
*tc = kcalloc(1, sizeof(struct ocfs2_truncate_context), GFP_KERNEL);
if (!(*tc)) {
status = -ENOMEM;
mlog_errno(status);
goto bail;
}
metadata_delete = 0;
if (fe->id2.i_list.l_tree_depth) {
/* If we have a tree, then the truncate may result in
* metadata deletes. Figure this out from the
* rightmost leaf block.*/
status = ocfs2_read_block(osb, le64_to_cpu(fe->i_last_eb_blk),
&last_eb_bh, OCFS2_BH_CACHED, inode);
if (status < 0) {
mlog_errno(status);
goto bail;
}
eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
brelse(last_eb_bh);
status = -EIO;
goto bail;
}
el = &(eb->h_list);
if (le32_to_cpu(el->l_recs[0].e_cpos) >= new_i_clusters)
metadata_delete = 1;
}
(*tc)->tc_last_eb_bh = last_eb_bh;
if (metadata_delete) {
mlog(0, "Will have to delete metadata for this trunc. "
"locking allocator.\n");
ext_alloc_inode = ocfs2_get_system_file_inode(osb, EXTENT_ALLOC_SYSTEM_INODE, 0);
if (!ext_alloc_inode) {
status = -ENOMEM;
mlog_errno(status);
goto bail;
}
mutex_lock(&ext_alloc_inode->i_mutex);
(*tc)->tc_ext_alloc_inode = ext_alloc_inode;
status = ocfs2_meta_lock(ext_alloc_inode,
NULL,
&ext_alloc_bh,
1);
if (status < 0) {
mlog_errno(status);
goto bail;
}
(*tc)->tc_ext_alloc_bh = ext_alloc_bh;
(*tc)->tc_ext_alloc_locked = 1;
}
status = 0;
bail:
if (status < 0) {
if (*tc)
ocfs2_free_truncate_context(*tc);
*tc = NULL;
}
mlog_exit_void();
return status;
}
static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc)
{
if (tc->tc_ext_alloc_inode) {
if (tc->tc_ext_alloc_locked)
ocfs2_meta_unlock(tc->tc_ext_alloc_inode, 1);
mutex_unlock(&tc->tc_ext_alloc_inode->i_mutex);
iput(tc->tc_ext_alloc_inode);
}
if (tc->tc_ext_alloc_bh)
brelse(tc->tc_ext_alloc_bh);
if (tc->tc_last_eb_bh)
brelse(tc->tc_last_eb_bh);
kfree(tc);
}