2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2005-11-01 20:58:39 -07:00
|
|
|
* Copyright (c) 2000-2005 Silicon Graphics, Inc.
|
2013-04-24 02:58:55 -06:00
|
|
|
* Copyright (c) 2013 Red Hat, Inc.
|
2005-11-01 20:58:39 -07:00
|
|
|
* All Rights Reserved.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
2005-04-16 16:20:36 -06:00
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* This program is distributed in the hope that it would 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.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write the Free Software Foundation,
|
|
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_fs.h"
|
2013-10-29 05:11:58 -06:00
|
|
|
#include "xfs_shared.h"
|
2013-10-22 17:51:50 -06:00
|
|
|
#include "xfs_format.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_bit.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_sb.h"
|
|
|
|
#include "xfs_mount.h"
|
2013-10-14 16:17:51 -06:00
|
|
|
#include "xfs_da_format.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_da_btree.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_inode.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_trans.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_inode_item.h"
|
2013-10-22 17:51:50 -06:00
|
|
|
#include "xfs_bmap_btree.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_bmap.h"
|
2013-10-22 17:51:50 -06:00
|
|
|
#include "xfs_attr_sf.h"
|
|
|
|
#include "xfs_attr_remote.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_attr.h"
|
|
|
|
#include "xfs_attr_leaf.h"
|
|
|
|
#include "xfs_error.h"
|
2009-12-14 16:14:59 -07:00
|
|
|
#include "xfs_trace.h"
|
2013-04-24 02:58:55 -06:00
|
|
|
#include "xfs_buf_item.h"
|
|
|
|
#include "xfs_cksum.h"
|
2013-10-29 05:11:51 -06:00
|
|
|
#include "xfs_dir2.h"
|
2015-10-11 22:59:25 -06:00
|
|
|
#include "xfs_log.h"
|
2013-04-24 02:58:55 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* xfs_attr_leaf.c
|
|
|
|
*
|
|
|
|
* Routines to implement leaf blocks of attributes as Btrees of hashed names.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*========================================================================
|
|
|
|
* Function prototypes for the kernel.
|
|
|
|
*========================================================================*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Routines used for growing the Btree.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
STATIC int xfs_attr3_leaf_create(struct xfs_da_args *args,
|
|
|
|
xfs_dablk_t which_block, struct xfs_buf **bpp);
|
|
|
|
STATIC int xfs_attr3_leaf_add_work(struct xfs_buf *leaf_buffer,
|
|
|
|
struct xfs_attr3_icleaf_hdr *ichdr,
|
|
|
|
struct xfs_da_args *args, int freemap_index);
|
|
|
|
STATIC void xfs_attr3_leaf_compact(struct xfs_da_args *args,
|
|
|
|
struct xfs_attr3_icleaf_hdr *ichdr,
|
|
|
|
struct xfs_buf *leaf_buffer);
|
|
|
|
STATIC void xfs_attr3_leaf_rebalance(xfs_da_state_t *state,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_da_state_blk_t *blk1,
|
|
|
|
xfs_da_state_blk_t *blk2);
|
2013-04-24 02:58:55 -06:00
|
|
|
STATIC int xfs_attr3_leaf_figure_balance(xfs_da_state_t *state,
|
|
|
|
xfs_da_state_blk_t *leaf_blk_1,
|
|
|
|
struct xfs_attr3_icleaf_hdr *ichdr1,
|
|
|
|
xfs_da_state_blk_t *leaf_blk_2,
|
|
|
|
struct xfs_attr3_icleaf_hdr *ichdr2,
|
|
|
|
int *number_entries_in_blk1,
|
|
|
|
int *number_usedbytes_in_blk1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Utility routines.
|
|
|
|
*/
|
2014-06-05 23:21:45 -06:00
|
|
|
STATIC void xfs_attr3_leaf_moveents(struct xfs_da_args *args,
|
|
|
|
struct xfs_attr_leafblock *src_leaf,
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr3_icleaf_hdr *src_ichdr, int src_start,
|
|
|
|
struct xfs_attr_leafblock *dst_leaf,
|
|
|
|
struct xfs_attr3_icleaf_hdr *dst_ichdr, int dst_start,
|
2014-06-05 23:21:45 -06:00
|
|
|
int move_count);
|
2005-06-20 23:36:52 -06:00
|
|
|
STATIC int xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index);
|
2006-09-27 19:01:37 -06:00
|
|
|
|
2015-04-12 19:27:10 -06:00
|
|
|
/*
|
|
|
|
* attr3 block 'firstused' conversion helpers.
|
|
|
|
*
|
|
|
|
* firstused refers to the offset of the first used byte of the nameval region
|
|
|
|
* of an attr leaf block. The region starts at the tail of the block and expands
|
|
|
|
* backwards towards the middle. As such, firstused is initialized to the block
|
|
|
|
* size for an empty leaf block and is reduced from there.
|
|
|
|
*
|
|
|
|
* The attr3 block size is pegged to the fsb size and the maximum fsb is 64k.
|
|
|
|
* The in-core firstused field is 32-bit and thus supports the maximum fsb size.
|
|
|
|
* The on-disk field is only 16-bit, however, and overflows at 64k. Since this
|
|
|
|
* only occurs at exactly 64k, we use zero as a magic on-disk value to represent
|
|
|
|
* the attr block size. The following helpers manage the conversion between the
|
|
|
|
* in-core and on-disk formats.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
xfs_attr3_leaf_firstused_from_disk(
|
|
|
|
struct xfs_da_geometry *geo,
|
|
|
|
struct xfs_attr3_icleaf_hdr *to,
|
|
|
|
struct xfs_attr_leafblock *from)
|
|
|
|
{
|
|
|
|
struct xfs_attr3_leaf_hdr *hdr3;
|
|
|
|
|
|
|
|
if (from->hdr.info.magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC)) {
|
|
|
|
hdr3 = (struct xfs_attr3_leaf_hdr *) from;
|
|
|
|
to->firstused = be16_to_cpu(hdr3->firstused);
|
|
|
|
} else {
|
|
|
|
to->firstused = be16_to_cpu(from->hdr.firstused);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert from the magic fsb size value to actual blocksize. This
|
|
|
|
* should only occur for empty blocks when the block size overflows
|
|
|
|
* 16-bits.
|
|
|
|
*/
|
|
|
|
if (to->firstused == XFS_ATTR3_LEAF_NULLOFF) {
|
|
|
|
ASSERT(!to->count && !to->usedbytes);
|
|
|
|
ASSERT(geo->blksize > USHRT_MAX);
|
|
|
|
to->firstused = geo->blksize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xfs_attr3_leaf_firstused_to_disk(
|
|
|
|
struct xfs_da_geometry *geo,
|
|
|
|
struct xfs_attr_leafblock *to,
|
|
|
|
struct xfs_attr3_icleaf_hdr *from)
|
|
|
|
{
|
|
|
|
struct xfs_attr3_leaf_hdr *hdr3;
|
|
|
|
uint32_t firstused;
|
|
|
|
|
|
|
|
/* magic value should only be seen on disk */
|
|
|
|
ASSERT(from->firstused != XFS_ATTR3_LEAF_NULLOFF);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scale down the 32-bit in-core firstused value to the 16-bit on-disk
|
|
|
|
* value. This only overflows at the max supported value of 64k. Use the
|
|
|
|
* magic on-disk value to represent block size in this case.
|
|
|
|
*/
|
|
|
|
firstused = from->firstused;
|
|
|
|
if (firstused > USHRT_MAX) {
|
|
|
|
ASSERT(from->firstused == geo->blksize);
|
|
|
|
firstused = XFS_ATTR3_LEAF_NULLOFF;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (from->magic == XFS_ATTR3_LEAF_MAGIC) {
|
|
|
|
hdr3 = (struct xfs_attr3_leaf_hdr *) to;
|
|
|
|
hdr3->firstused = cpu_to_be16(firstused);
|
|
|
|
} else {
|
|
|
|
to->hdr.firstused = cpu_to_be16(firstused);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
void
|
|
|
|
xfs_attr3_leaf_hdr_from_disk(
|
2015-04-12 19:26:02 -06:00
|
|
|
struct xfs_da_geometry *geo,
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr3_icleaf_hdr *to,
|
|
|
|
struct xfs_attr_leafblock *from)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
ASSERT(from->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC) ||
|
|
|
|
from->hdr.info.magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC));
|
|
|
|
|
|
|
|
if (from->hdr.info.magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC)) {
|
|
|
|
struct xfs_attr3_leaf_hdr *hdr3 = (struct xfs_attr3_leaf_hdr *)from;
|
|
|
|
|
|
|
|
to->forw = be32_to_cpu(hdr3->info.hdr.forw);
|
|
|
|
to->back = be32_to_cpu(hdr3->info.hdr.back);
|
|
|
|
to->magic = be16_to_cpu(hdr3->info.hdr.magic);
|
|
|
|
to->count = be16_to_cpu(hdr3->count);
|
|
|
|
to->usedbytes = be16_to_cpu(hdr3->usedbytes);
|
2015-04-12 19:27:10 -06:00
|
|
|
xfs_attr3_leaf_firstused_from_disk(geo, to, from);
|
2013-04-24 02:58:55 -06:00
|
|
|
to->holes = hdr3->holes;
|
|
|
|
|
|
|
|
for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
|
|
|
|
to->freemap[i].base = be16_to_cpu(hdr3->freemap[i].base);
|
|
|
|
to->freemap[i].size = be16_to_cpu(hdr3->freemap[i].size);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
to->forw = be32_to_cpu(from->hdr.info.forw);
|
|
|
|
to->back = be32_to_cpu(from->hdr.info.back);
|
|
|
|
to->magic = be16_to_cpu(from->hdr.info.magic);
|
|
|
|
to->count = be16_to_cpu(from->hdr.count);
|
|
|
|
to->usedbytes = be16_to_cpu(from->hdr.usedbytes);
|
2015-04-12 19:27:10 -06:00
|
|
|
xfs_attr3_leaf_firstused_from_disk(geo, to, from);
|
2013-04-24 02:58:55 -06:00
|
|
|
to->holes = from->hdr.holes;
|
|
|
|
|
|
|
|
for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
|
|
|
|
to->freemap[i].base = be16_to_cpu(from->hdr.freemap[i].base);
|
|
|
|
to->freemap[i].size = be16_to_cpu(from->hdr.freemap[i].size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_attr3_leaf_hdr_to_disk(
|
2015-04-12 19:26:02 -06:00
|
|
|
struct xfs_da_geometry *geo,
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *to,
|
|
|
|
struct xfs_attr3_icleaf_hdr *from)
|
|
|
|
{
|
2015-04-12 19:27:10 -06:00
|
|
|
int i;
|
2013-04-24 02:58:55 -06:00
|
|
|
|
|
|
|
ASSERT(from->magic == XFS_ATTR_LEAF_MAGIC ||
|
|
|
|
from->magic == XFS_ATTR3_LEAF_MAGIC);
|
|
|
|
|
|
|
|
if (from->magic == XFS_ATTR3_LEAF_MAGIC) {
|
|
|
|
struct xfs_attr3_leaf_hdr *hdr3 = (struct xfs_attr3_leaf_hdr *)to;
|
|
|
|
|
|
|
|
hdr3->info.hdr.forw = cpu_to_be32(from->forw);
|
|
|
|
hdr3->info.hdr.back = cpu_to_be32(from->back);
|
|
|
|
hdr3->info.hdr.magic = cpu_to_be16(from->magic);
|
|
|
|
hdr3->count = cpu_to_be16(from->count);
|
|
|
|
hdr3->usedbytes = cpu_to_be16(from->usedbytes);
|
2015-04-12 19:27:10 -06:00
|
|
|
xfs_attr3_leaf_firstused_to_disk(geo, to, from);
|
2013-04-24 02:58:55 -06:00
|
|
|
hdr3->holes = from->holes;
|
|
|
|
hdr3->pad1 = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
|
|
|
|
hdr3->freemap[i].base = cpu_to_be16(from->freemap[i].base);
|
|
|
|
hdr3->freemap[i].size = cpu_to_be16(from->freemap[i].size);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
to->hdr.info.forw = cpu_to_be32(from->forw);
|
|
|
|
to->hdr.info.back = cpu_to_be32(from->back);
|
|
|
|
to->hdr.info.magic = cpu_to_be16(from->magic);
|
|
|
|
to->hdr.count = cpu_to_be16(from->count);
|
|
|
|
to->hdr.usedbytes = cpu_to_be16(from->usedbytes);
|
2015-04-12 19:27:10 -06:00
|
|
|
xfs_attr3_leaf_firstused_to_disk(geo, to, from);
|
2013-04-24 02:58:55 -06:00
|
|
|
to->hdr.holes = from->holes;
|
|
|
|
to->hdr.pad1 = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
|
|
|
|
to->hdr.freemap[i].base = cpu_to_be16(from->freemap[i].base);
|
|
|
|
to->hdr.freemap[i].size = cpu_to_be16(from->freemap[i].size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
xfs_attr3_leaf_verify(
|
2012-11-12 04:54:16 -07:00
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = bp->b_target->bt_mount;
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf = bp->b_addr;
|
2016-12-08 22:49:47 -07:00
|
|
|
struct xfs_perag *pag = bp->b_pag;
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr3_icleaf_hdr ichdr;
|
2012-11-12 04:54:16 -07:00
|
|
|
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, leaf);
|
2013-04-24 02:58:55 -06:00
|
|
|
|
|
|
|
if (xfs_sb_version_hascrc(&mp->m_sb)) {
|
|
|
|
struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
|
|
|
|
|
|
|
|
if (ichdr.magic != XFS_ATTR3_LEAF_MAGIC)
|
|
|
|
return false;
|
|
|
|
|
2015-07-28 19:53:31 -06:00
|
|
|
if (!uuid_equal(&hdr3->info.uuid, &mp->m_sb.sb_meta_uuid))
|
2013-04-24 02:58:55 -06:00
|
|
|
return false;
|
|
|
|
if (be64_to_cpu(hdr3->info.blkno) != bp->b_bn)
|
|
|
|
return false;
|
2015-10-11 22:59:25 -06:00
|
|
|
if (!xfs_log_check_lsn(mp, be64_to_cpu(hdr3->info.lsn)))
|
|
|
|
return false;
|
2013-04-24 02:58:55 -06:00
|
|
|
} else {
|
|
|
|
if (ichdr.magic != XFS_ATTR_LEAF_MAGIC)
|
|
|
|
return false;
|
2012-11-12 04:54:16 -07:00
|
|
|
}
|
2016-12-08 22:49:47 -07:00
|
|
|
/*
|
|
|
|
* In recovery there is a transient state where count == 0 is valid
|
|
|
|
* because we may have transitioned an empty shortform attr to a leaf
|
|
|
|
* if the attr didn't fit in shortform.
|
|
|
|
*/
|
|
|
|
if (pag && pag->pagf_init && ichdr.count == 0)
|
2013-04-24 02:58:55 -06:00
|
|
|
return false;
|
|
|
|
|
|
|
|
/* XXX: need to range check rest of attr header values */
|
|
|
|
/* XXX: hash order check? */
|
|
|
|
|
|
|
|
return true;
|
2012-11-13 23:52:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_write_verify(
|
2012-11-13 23:52:32 -07:00
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_mount *mp = bp->b_target->bt_mount;
|
|
|
|
struct xfs_buf_log_item *bip = bp->b_fspriv;
|
|
|
|
struct xfs_attr3_leaf_hdr *hdr3 = bp->b_addr;
|
|
|
|
|
|
|
|
if (!xfs_attr3_leaf_verify(bp)) {
|
2014-06-24 22:58:08 -06:00
|
|
|
xfs_buf_ioerror(bp, -EFSCORRUPTED);
|
2014-02-26 21:23:10 -07:00
|
|
|
xfs_verifier_error(bp);
|
2013-04-24 02:58:55 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!xfs_sb_version_hascrc(&mp->m_sb))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (bip)
|
|
|
|
hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn);
|
|
|
|
|
2014-02-26 21:18:23 -07:00
|
|
|
xfs_buf_update_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF);
|
2012-11-13 23:52:32 -07:00
|
|
|
}
|
2012-11-12 04:54:16 -07:00
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
/*
|
|
|
|
* leaf/node format detection on trees is sketchy, so a node read can be done on
|
|
|
|
* leaf level blocks when detection identifies the tree as a node format tree
|
|
|
|
* incorrectly. In this case, we need to swap the verifier to match the correct
|
|
|
|
* format of the block being read.
|
|
|
|
*/
|
2012-11-13 23:54:40 -07:00
|
|
|
static void
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_read_verify(
|
|
|
|
struct xfs_buf *bp)
|
2012-11-13 23:52:32 -07:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_mount *mp = bp->b_target->bt_mount;
|
|
|
|
|
2014-02-26 21:23:10 -07:00
|
|
|
if (xfs_sb_version_hascrc(&mp->m_sb) &&
|
|
|
|
!xfs_buf_verify_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF))
|
2014-06-24 22:58:08 -06:00
|
|
|
xfs_buf_ioerror(bp, -EFSBADCRC);
|
2014-02-26 21:23:10 -07:00
|
|
|
else if (!xfs_attr3_leaf_verify(bp))
|
2014-06-24 22:58:08 -06:00
|
|
|
xfs_buf_ioerror(bp, -EFSCORRUPTED);
|
2014-02-26 21:23:10 -07:00
|
|
|
|
|
|
|
if (bp->b_error)
|
|
|
|
xfs_verifier_error(bp);
|
2012-11-12 04:54:16 -07:00
|
|
|
}
|
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
const struct xfs_buf_ops xfs_attr3_leaf_buf_ops = {
|
2016-01-03 22:10:19 -07:00
|
|
|
.name = "xfs_attr3_leaf",
|
2013-04-24 02:58:55 -06:00
|
|
|
.verify_read = xfs_attr3_leaf_read_verify,
|
|
|
|
.verify_write = xfs_attr3_leaf_write_verify,
|
2012-11-13 23:54:40 -07:00
|
|
|
};
|
2012-11-13 23:52:32 -07:00
|
|
|
|
2012-11-12 04:54:16 -07:00
|
|
|
int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_read(
|
2012-11-12 04:54:16 -07:00
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_inode *dp,
|
|
|
|
xfs_dablk_t bno,
|
|
|
|
xfs_daddr_t mappedbno,
|
|
|
|
struct xfs_buf **bpp)
|
|
|
|
{
|
2013-04-02 23:11:29 -06:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = xfs_da_read_buf(tp, dp, bno, mappedbno, bpp,
|
2013-04-24 02:58:55 -06:00
|
|
|
XFS_ATTR_FORK, &xfs_attr3_leaf_buf_ops);
|
2017-07-07 19:55:17 -06:00
|
|
|
if (!err && tp && *bpp)
|
2013-04-02 23:11:30 -06:00
|
|
|
xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_ATTR_LEAF_BUF);
|
2013-04-02 23:11:29 -06:00
|
|
|
return err;
|
2012-11-12 04:54:16 -07:00
|
|
|
}
|
|
|
|
|
2006-09-27 19:01:37 -06:00
|
|
|
/*========================================================================
|
|
|
|
* Namespace helper routines
|
|
|
|
*========================================================================*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If namespace bits don't match return 0.
|
|
|
|
* If all match then return 1.
|
|
|
|
*/
|
2009-11-14 09:17:22 -07:00
|
|
|
STATIC int
|
2006-09-27 19:01:37 -06:00
|
|
|
xfs_attr_namesp_match(int arg_flags, int ondisk_flags)
|
|
|
|
{
|
|
|
|
return XFS_ATTR_NSP_ONDISK(ondisk_flags) == XFS_ATTR_NSP_ARGS_TO_ONDISK(arg_flags);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*========================================================================
|
2005-11-01 16:34:53 -07:00
|
|
|
* External routines when attribute fork size < XFS_LITINO(mp).
|
2005-04-16 16:20:36 -06:00
|
|
|
*========================================================================*/
|
|
|
|
|
|
|
|
/*
|
2005-11-01 16:34:53 -07:00
|
|
|
* Query whether the requested number of additional bytes of extended
|
|
|
|
* attribute space will be able to fit inline.
|
2011-11-19 10:44:30 -07:00
|
|
|
*
|
2005-11-01 16:34:53 -07:00
|
|
|
* Returns zero if not, else the di_forkoff fork offset to be used in the
|
|
|
|
* literal area for attribute data once the new bytes have been added.
|
|
|
|
*
|
|
|
|
* di_forkoff must be 8 byte aligned, hence is stored as a >>3 value;
|
|
|
|
* special case for dev/uuid inodes, they have fixed size data forks.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
int
|
2005-11-01 16:34:53 -07:00
|
|
|
xfs_attr_shortform_bytesfit(xfs_inode_t *dp, int bytes)
|
|
|
|
{
|
|
|
|
int offset;
|
|
|
|
int minforkoff; /* lower limit on valid forkoff locations */
|
|
|
|
int maxforkoff; /* upper limit on valid forkoff locations */
|
2011-11-19 10:44:30 -07:00
|
|
|
int dsize;
|
2005-11-01 16:34:53 -07:00
|
|
|
xfs_mount_t *mp = dp->i_mount;
|
|
|
|
|
2013-03-12 06:30:36 -06:00
|
|
|
/* rounded down */
|
|
|
|
offset = (XFS_LITINO(mp, dp->i_d.di_version) - bytes) >> 3;
|
2005-11-01 16:34:53 -07:00
|
|
|
|
|
|
|
switch (dp->i_d.di_format) {
|
|
|
|
case XFS_DINODE_FMT_DEV:
|
|
|
|
minforkoff = roundup(sizeof(xfs_dev_t), 8) >> 3;
|
|
|
|
return (offset >= minforkoff) ? minforkoff : 0;
|
|
|
|
case XFS_DINODE_FMT_UUID:
|
|
|
|
minforkoff = roundup(sizeof(uuid_t), 8) >> 3;
|
|
|
|
return (offset >= minforkoff) ? minforkoff : 0;
|
|
|
|
}
|
|
|
|
|
2011-11-19 10:44:30 -07:00
|
|
|
/*
|
|
|
|
* If the requested numbers of bytes is smaller or equal to the
|
|
|
|
* current attribute fork size we can always proceed.
|
|
|
|
*
|
|
|
|
* Note that if_bytes in the data fork might actually be larger than
|
|
|
|
* the current data fork size is due to delalloc extents. In that
|
|
|
|
* case either the extent count will go down when they are converted
|
|
|
|
* to real extents, or the delalloc conversion will take care of the
|
|
|
|
* literal area rebalancing.
|
|
|
|
*/
|
|
|
|
if (bytes <= XFS_IFORK_ASIZE(dp))
|
|
|
|
return dp->i_d.di_forkoff;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For attr2 we can try to move the forkoff if there is space in the
|
|
|
|
* literal area, but for the old format we are done if there is no
|
|
|
|
* space in the fixed attribute fork.
|
|
|
|
*/
|
|
|
|
if (!(mp->m_flags & XFS_MOUNT_ATTR2))
|
2005-11-01 21:00:20 -07:00
|
|
|
return 0;
|
|
|
|
|
2007-02-10 00:35:58 -07:00
|
|
|
dsize = dp->i_df.if_bytes;
|
2011-11-19 10:44:30 -07:00
|
|
|
|
2007-02-10 00:35:58 -07:00
|
|
|
switch (dp->i_d.di_format) {
|
|
|
|
case XFS_DINODE_FMT_EXTENTS:
|
2011-11-19 10:44:30 -07:00
|
|
|
/*
|
2007-02-10 00:35:58 -07:00
|
|
|
* If there is no attr fork and the data fork is extents,
|
2011-11-19 10:44:30 -07:00
|
|
|
* determine if creating the default attr fork will result
|
|
|
|
* in the extents form migrating to btree. If so, the
|
|
|
|
* minimum offset only needs to be the space required for
|
2007-02-10 00:35:58 -07:00
|
|
|
* the btree root.
|
2011-11-19 10:44:30 -07:00
|
|
|
*/
|
2009-03-29 11:26:46 -06:00
|
|
|
if (!dp->i_d.di_forkoff && dp->i_df.if_bytes >
|
|
|
|
xfs_default_attroffset(dp))
|
2007-02-10 00:35:58 -07:00
|
|
|
dsize = XFS_BMDR_SPACE_CALC(MINDBTPTRS);
|
|
|
|
break;
|
|
|
|
case XFS_DINODE_FMT_BTREE:
|
|
|
|
/*
|
2011-11-19 10:44:30 -07:00
|
|
|
* If we have a data btree then keep forkoff if we have one,
|
|
|
|
* otherwise we are adding a new attr, so then we set
|
|
|
|
* minforkoff to where the btree root can finish so we have
|
2007-02-10 00:35:58 -07:00
|
|
|
* plenty of room for attrs
|
|
|
|
*/
|
|
|
|
if (dp->i_d.di_forkoff) {
|
2011-11-19 10:44:30 -07:00
|
|
|
if (offset < dp->i_d.di_forkoff)
|
2007-02-10 00:35:58 -07:00
|
|
|
return 0;
|
2011-11-19 10:44:30 -07:00
|
|
|
return dp->i_d.di_forkoff;
|
|
|
|
}
|
2013-04-21 13:53:46 -06:00
|
|
|
dsize = XFS_BMAP_BROOT_SPACE(mp, dp->i_df.if_broot);
|
2007-02-10 00:35:58 -07:00
|
|
|
break;
|
|
|
|
}
|
2011-11-19 10:44:30 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* A data fork btree root must have space for at least
|
2007-02-10 00:35:58 -07:00
|
|
|
* MINDBTPTRS key/ptr pairs if the data fork is small or empty.
|
|
|
|
*/
|
|
|
|
minforkoff = MAX(dsize, XFS_BMDR_SPACE_CALC(MINDBTPTRS));
|
2005-11-01 16:34:53 -07:00
|
|
|
minforkoff = roundup(minforkoff, 8) >> 3;
|
|
|
|
|
|
|
|
/* attr fork btree root can have at least this many key/ptr pairs */
|
2013-03-12 06:30:36 -06:00
|
|
|
maxforkoff = XFS_LITINO(mp, dp->i_d.di_version) -
|
|
|
|
XFS_BMDR_SPACE_CALC(MINABTPTRS);
|
2005-11-01 16:34:53 -07:00
|
|
|
maxforkoff = maxforkoff >> 3; /* rounded down */
|
|
|
|
|
|
|
|
if (offset >= maxforkoff)
|
|
|
|
return maxforkoff;
|
2011-11-19 10:44:30 -07:00
|
|
|
if (offset >= minforkoff)
|
|
|
|
return offset;
|
2005-11-01 16:34:53 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Switch on the ATTR2 superblock bit (implies also FEATURES2)
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xfs_sbversion_add_attr2(xfs_mount_t *mp, xfs_trans_t *tp)
|
|
|
|
{
|
2006-01-10 21:32:01 -07:00
|
|
|
if ((mp->m_flags & XFS_MOUNT_ATTR2) &&
|
2008-03-05 19:44:28 -07:00
|
|
|
!(xfs_sb_version_hasattr2(&mp->m_sb))) {
|
2007-10-11 01:42:32 -06:00
|
|
|
spin_lock(&mp->m_sb_lock);
|
2008-03-05 19:44:28 -07:00
|
|
|
if (!xfs_sb_version_hasattr2(&mp->m_sb)) {
|
|
|
|
xfs_sb_version_addattr2(&mp->m_sb);
|
2007-10-11 01:42:32 -06:00
|
|
|
spin_unlock(&mp->m_sb_lock);
|
2015-01-21 15:10:31 -07:00
|
|
|
xfs_log_sb(tp);
|
2005-11-01 16:34:53 -07:00
|
|
|
} else
|
2007-10-11 01:42:32 -06:00
|
|
|
spin_unlock(&mp->m_sb_lock);
|
2005-11-01 16:34:53 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create the initial contents of a shortform attribute list.
|
|
|
|
*/
|
|
|
|
void
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_attr_shortform_create(xfs_da_args_t *args)
|
|
|
|
{
|
|
|
|
xfs_attr_sf_hdr_t *hdr;
|
|
|
|
xfs_inode_t *dp;
|
|
|
|
xfs_ifork_t *ifp;
|
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_sf_create(args);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
dp = args->dp;
|
|
|
|
ASSERT(dp != NULL);
|
|
|
|
ifp = dp->i_afp;
|
|
|
|
ASSERT(ifp != NULL);
|
|
|
|
ASSERT(ifp->if_bytes == 0);
|
|
|
|
if (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS) {
|
|
|
|
ifp->if_flags &= ~XFS_IFEXTENTS; /* just in case */
|
|
|
|
dp->i_d.di_aformat = XFS_DINODE_FMT_LOCAL;
|
|
|
|
ifp->if_flags |= XFS_IFINLINE;
|
|
|
|
} else {
|
|
|
|
ASSERT(ifp->if_flags & XFS_IFINLINE);
|
|
|
|
}
|
|
|
|
xfs_idata_realloc(dp, sizeof(*hdr), XFS_ATTR_FORK);
|
|
|
|
hdr = (xfs_attr_sf_hdr_t *)ifp->if_u1.if_data;
|
|
|
|
hdr->count = 0;
|
2006-03-16 23:29:25 -07:00
|
|
|
hdr->totsize = cpu_to_be16(sizeof(*hdr));
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a name/value pair to the shortform attribute list.
|
|
|
|
* Overflow from the inode has already been checked for.
|
|
|
|
*/
|
2005-11-01 16:34:53 -07:00
|
|
|
void
|
|
|
|
xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xfs_attr_shortform_t *sf;
|
|
|
|
xfs_attr_sf_entry_t *sfe;
|
|
|
|
int i, offset, size;
|
2005-11-01 16:34:53 -07:00
|
|
|
xfs_mount_t *mp;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_inode_t *dp;
|
|
|
|
xfs_ifork_t *ifp;
|
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_sf_add(args);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
dp = args->dp;
|
2005-11-01 16:34:53 -07:00
|
|
|
mp = dp->i_mount;
|
|
|
|
dp->i_d.di_forkoff = forkoff;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ifp = dp->i_afp;
|
|
|
|
ASSERT(ifp->if_flags & XFS_IFINLINE);
|
|
|
|
sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
|
|
|
|
sfe = &sf->list[0];
|
2006-03-16 23:29:25 -07:00
|
|
|
for (i = 0; i < sf->hdr.count; sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
|
2005-11-01 16:34:53 -07:00
|
|
|
#ifdef DEBUG
|
2005-04-16 16:20:36 -06:00
|
|
|
if (sfe->namelen != args->namelen)
|
|
|
|
continue;
|
|
|
|
if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
|
|
|
|
continue;
|
2006-09-27 19:01:37 -06:00
|
|
|
if (!xfs_attr_namesp_match(args->flags, sfe->flags))
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
2005-11-01 16:34:53 -07:00
|
|
|
ASSERT(0);
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
offset = (char *)sfe - (char *)sf;
|
|
|
|
size = XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen, args->valuelen);
|
|
|
|
xfs_idata_realloc(dp, size, XFS_ATTR_FORK);
|
|
|
|
sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
|
|
|
|
sfe = (xfs_attr_sf_entry_t *)((char *)sf + offset);
|
|
|
|
|
|
|
|
sfe->namelen = args->namelen;
|
2006-03-16 23:29:25 -07:00
|
|
|
sfe->valuelen = args->valuelen;
|
2006-09-27 19:01:37 -06:00
|
|
|
sfe->flags = XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
memcpy(sfe->nameval, args->name, args->namelen);
|
|
|
|
memcpy(&sfe->nameval[args->namelen], args->value, args->valuelen);
|
2006-03-16 23:29:25 -07:00
|
|
|
sf->hdr.count++;
|
2008-02-13 16:03:29 -07:00
|
|
|
be16_add_cpu(&sf->hdr.totsize, size);
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
|
|
|
|
|
2005-11-01 16:34:53 -07:00
|
|
|
xfs_sbversion_add_attr2(mp, args->trans);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-02-04 01:36:00 -07:00
|
|
|
/*
|
|
|
|
* After the last attribute is removed revert to original inode format,
|
|
|
|
* making all literal area available to the data fork once more.
|
|
|
|
*/
|
2015-05-28 15:40:08 -06:00
|
|
|
void
|
|
|
|
xfs_attr_fork_remove(
|
2009-02-04 01:36:00 -07:00
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct xfs_trans *tp)
|
|
|
|
{
|
|
|
|
xfs_idestroy_fork(ip, XFS_ATTR_FORK);
|
|
|
|
ip->i_d.di_forkoff = 0;
|
|
|
|
ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
|
|
|
|
|
|
|
|
ASSERT(ip->i_d.di_anextents == 0);
|
|
|
|
ASSERT(ip->i_afp == NULL);
|
|
|
|
|
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2005-11-01 16:34:53 -07:00
|
|
|
* Remove an attribute from the shortform attribute list structure.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_attr_shortform_remove(xfs_da_args_t *args)
|
|
|
|
{
|
|
|
|
xfs_attr_shortform_t *sf;
|
|
|
|
xfs_attr_sf_entry_t *sfe;
|
|
|
|
int base, size=0, end, totsize, i;
|
2005-11-01 16:34:53 -07:00
|
|
|
xfs_mount_t *mp;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_inode_t *dp;
|
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_sf_remove(args);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
dp = args->dp;
|
2005-11-01 16:34:53 -07:00
|
|
|
mp = dp->i_mount;
|
2005-04-16 16:20:36 -06:00
|
|
|
base = sizeof(xfs_attr_sf_hdr_t);
|
|
|
|
sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
|
|
|
|
sfe = &sf->list[0];
|
2006-03-16 23:29:25 -07:00
|
|
|
end = sf->hdr.count;
|
2005-11-01 16:34:53 -07:00
|
|
|
for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
|
2005-04-16 16:20:36 -06:00
|
|
|
base += size, i++) {
|
|
|
|
size = XFS_ATTR_SF_ENTSIZE(sfe);
|
|
|
|
if (sfe->namelen != args->namelen)
|
|
|
|
continue;
|
|
|
|
if (memcmp(sfe->nameval, args->name, args->namelen) != 0)
|
|
|
|
continue;
|
2006-09-27 19:01:37 -06:00
|
|
|
if (!xfs_attr_namesp_match(args->flags, sfe->flags))
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
|
|
|
break;
|
|
|
|
}
|
2005-11-01 16:34:53 -07:00
|
|
|
if (i == end)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOATTR;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-11-01 16:34:53 -07:00
|
|
|
/*
|
|
|
|
* Fix up the attribute fork data, covering the hole
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
end = base + size;
|
2006-03-16 23:29:25 -07:00
|
|
|
totsize = be16_to_cpu(sf->hdr.totsize);
|
2005-11-01 16:34:53 -07:00
|
|
|
if (end != totsize)
|
|
|
|
memmove(&((char *)sf)[base], &((char *)sf)[end], totsize - end);
|
2006-03-16 23:29:25 -07:00
|
|
|
sf->hdr.count--;
|
2008-02-13 16:03:29 -07:00
|
|
|
be16_add_cpu(&sf->hdr.totsize, -size);
|
2005-11-01 16:34:53 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Fix up the start offset of the attribute fork
|
|
|
|
*/
|
|
|
|
totsize -= size;
|
2008-05-21 00:42:05 -06:00
|
|
|
if (totsize == sizeof(xfs_attr_sf_hdr_t) &&
|
2009-02-04 01:36:00 -07:00
|
|
|
(mp->m_flags & XFS_MOUNT_ATTR2) &&
|
|
|
|
(dp->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
|
|
|
|
!(args->op_flags & XFS_DA_OP_ADDNAME)) {
|
2015-05-28 15:40:08 -06:00
|
|
|
xfs_attr_fork_remove(dp, args->trans);
|
2005-11-01 16:34:53 -07:00
|
|
|
} else {
|
|
|
|
xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
|
|
|
|
dp->i_d.di_forkoff = xfs_attr_shortform_bytesfit(dp, totsize);
|
|
|
|
ASSERT(dp->i_d.di_forkoff);
|
2008-05-21 00:42:05 -06:00
|
|
|
ASSERT(totsize > sizeof(xfs_attr_sf_hdr_t) ||
|
|
|
|
(args->op_flags & XFS_DA_OP_ADDNAME) ||
|
|
|
|
!(mp->m_flags & XFS_MOUNT_ATTR2) ||
|
|
|
|
dp->i_d.di_format == XFS_DINODE_FMT_BTREE);
|
2005-11-01 16:34:53 -07:00
|
|
|
xfs_trans_log_inode(args->trans, dp,
|
|
|
|
XFS_ILOG_CORE | XFS_ILOG_ADATA);
|
|
|
|
}
|
|
|
|
|
|
|
|
xfs_sbversion_add_attr2(mp, args->trans);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-06-21 23:03:54 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Look up a name in a shortform attribute list structure.
|
|
|
|
*/
|
|
|
|
/*ARGSUSED*/
|
|
|
|
int
|
|
|
|
xfs_attr_shortform_lookup(xfs_da_args_t *args)
|
|
|
|
{
|
|
|
|
xfs_attr_shortform_t *sf;
|
|
|
|
xfs_attr_sf_entry_t *sfe;
|
|
|
|
int i;
|
|
|
|
xfs_ifork_t *ifp;
|
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_sf_lookup(args);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ifp = args->dp->i_afp;
|
|
|
|
ASSERT(ifp->if_flags & XFS_IFINLINE);
|
|
|
|
sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
|
|
|
|
sfe = &sf->list[0];
|
2006-03-16 23:29:25 -07:00
|
|
|
for (i = 0; i < sf->hdr.count;
|
2005-04-16 16:20:36 -06:00
|
|
|
sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
|
|
|
|
if (sfe->namelen != args->namelen)
|
|
|
|
continue;
|
|
|
|
if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
|
|
|
|
continue;
|
2006-09-27 19:01:37 -06:00
|
|
|
if (!xfs_attr_namesp_match(args->flags, sfe->flags))
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EEXIST;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOATTR;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Look up a name in a shortform attribute list structure.
|
|
|
|
*/
|
|
|
|
/*ARGSUSED*/
|
|
|
|
int
|
|
|
|
xfs_attr_shortform_getvalue(xfs_da_args_t *args)
|
|
|
|
{
|
|
|
|
xfs_attr_shortform_t *sf;
|
|
|
|
xfs_attr_sf_entry_t *sfe;
|
|
|
|
int i;
|
|
|
|
|
2012-03-30 10:24:11 -06:00
|
|
|
ASSERT(args->dp->i_afp->if_flags == XFS_IFINLINE);
|
2005-04-16 16:20:36 -06:00
|
|
|
sf = (xfs_attr_shortform_t *)args->dp->i_afp->if_u1.if_data;
|
|
|
|
sfe = &sf->list[0];
|
2006-03-16 23:29:25 -07:00
|
|
|
for (i = 0; i < sf->hdr.count;
|
2005-04-16 16:20:36 -06:00
|
|
|
sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
|
|
|
|
if (sfe->namelen != args->namelen)
|
|
|
|
continue;
|
|
|
|
if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
|
|
|
|
continue;
|
2006-09-27 19:01:37 -06:00
|
|
|
if (!xfs_attr_namesp_match(args->flags, sfe->flags))
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
|
|
|
if (args->flags & ATTR_KERNOVAL) {
|
2006-03-16 23:29:25 -07:00
|
|
|
args->valuelen = sfe->valuelen;
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EEXIST;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-03-16 23:29:25 -07:00
|
|
|
if (args->valuelen < sfe->valuelen) {
|
|
|
|
args->valuelen = sfe->valuelen;
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ERANGE;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-03-16 23:29:25 -07:00
|
|
|
args->valuelen = sfe->valuelen;
|
2005-04-16 16:20:36 -06:00
|
|
|
memcpy(args->value, &sfe->nameval[args->namelen],
|
|
|
|
args->valuelen);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EEXIST;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOATTR;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert from using the shortform to the leaf.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
|
|
|
|
{
|
|
|
|
xfs_inode_t *dp;
|
|
|
|
xfs_attr_shortform_t *sf;
|
|
|
|
xfs_attr_sf_entry_t *sfe;
|
|
|
|
xfs_da_args_t nargs;
|
|
|
|
char *tmpbuffer;
|
|
|
|
int error, i, size;
|
|
|
|
xfs_dablk_t blkno;
|
2012-06-22 02:50:14 -06:00
|
|
|
struct xfs_buf *bp;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_ifork_t *ifp;
|
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_sf_to_leaf(args);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
dp = args->dp;
|
|
|
|
ifp = dp->i_afp;
|
|
|
|
sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
|
2006-03-16 23:29:25 -07:00
|
|
|
size = be16_to_cpu(sf->hdr.totsize);
|
2005-04-16 16:20:36 -06:00
|
|
|
tmpbuffer = kmem_alloc(size, KM_SLEEP);
|
|
|
|
ASSERT(tmpbuffer != NULL);
|
|
|
|
memcpy(tmpbuffer, ifp->if_u1.if_data, size);
|
|
|
|
sf = (xfs_attr_shortform_t *)tmpbuffer;
|
|
|
|
|
|
|
|
xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
|
2013-07-09 15:04:00 -06:00
|
|
|
xfs_bmap_local_to_extents_empty(dp, XFS_ATTR_FORK);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
bp = NULL;
|
|
|
|
error = xfs_da_grow_inode(args, &blkno);
|
|
|
|
if (error) {
|
|
|
|
/*
|
|
|
|
* If we hit an IO error middle of the transaction inside
|
|
|
|
* grow_inode(), we may have inconsistent data. Bail out.
|
|
|
|
*/
|
2014-06-24 22:58:08 -06:00
|
|
|
if (error == -EIO)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
xfs_idata_realloc(dp, size, XFS_ATTR_FORK); /* try to put */
|
|
|
|
memcpy(ifp->if_u1.if_data, tmpbuffer, size); /* it back */
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(blkno == 0);
|
2013-04-24 02:58:55 -06:00
|
|
|
error = xfs_attr3_leaf_create(args, blkno, &bp);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error) {
|
|
|
|
error = xfs_da_shrink_inode(args, 0, bp);
|
|
|
|
bp = NULL;
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
xfs_idata_realloc(dp, size, XFS_ATTR_FORK); /* try to put */
|
|
|
|
memcpy(ifp->if_u1.if_data, tmpbuffer, size); /* it back */
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset((char *)&nargs, 0, sizeof(nargs));
|
|
|
|
nargs.dp = dp;
|
2014-06-05 23:01:58 -06:00
|
|
|
nargs.geo = args->geo;
|
2005-04-16 16:20:36 -06:00
|
|
|
nargs.firstblock = args->firstblock;
|
2016-08-02 19:19:29 -06:00
|
|
|
nargs.dfops = args->dfops;
|
2005-04-16 16:20:36 -06:00
|
|
|
nargs.total = args->total;
|
|
|
|
nargs.whichfork = XFS_ATTR_FORK;
|
|
|
|
nargs.trans = args->trans;
|
2008-05-21 00:42:05 -06:00
|
|
|
nargs.op_flags = XFS_DA_OP_OKNOENT;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
sfe = &sf->list[0];
|
2006-03-16 23:29:25 -07:00
|
|
|
for (i = 0; i < sf->hdr.count; i++) {
|
2010-01-19 16:47:48 -07:00
|
|
|
nargs.name = sfe->nameval;
|
2005-04-16 16:20:36 -06:00
|
|
|
nargs.namelen = sfe->namelen;
|
2010-01-19 16:47:48 -07:00
|
|
|
nargs.value = &sfe->nameval[nargs.namelen];
|
2006-03-16 23:29:25 -07:00
|
|
|
nargs.valuelen = sfe->valuelen;
|
2010-01-19 16:47:48 -07:00
|
|
|
nargs.hashval = xfs_da_hashname(sfe->nameval,
|
2005-04-16 16:20:36 -06:00
|
|
|
sfe->namelen);
|
2006-09-27 19:01:37 -06:00
|
|
|
nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(sfe->flags);
|
2013-04-24 02:58:55 -06:00
|
|
|
error = xfs_attr3_leaf_lookup_int(bp, &nargs); /* set a->index */
|
2014-06-24 22:58:08 -06:00
|
|
|
ASSERT(error == -ENOATTR);
|
2013-04-24 02:58:55 -06:00
|
|
|
error = xfs_attr3_leaf_add(bp, &nargs);
|
2014-06-24 22:58:08 -06:00
|
|
|
ASSERT(error != -ENOSPC);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
|
|
|
|
}
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
out:
|
2008-05-19 00:31:57 -06:00
|
|
|
kmem_free(tmpbuffer);
|
2014-06-21 23:03:54 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check a leaf attribute block to see if all the entries would fit into
|
|
|
|
* a shortform attribute list.
|
|
|
|
*/
|
|
|
|
int
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_attr_shortform_allfit(
|
2013-05-19 17:51:14 -06:00
|
|
|
struct xfs_buf *bp,
|
|
|
|
struct xfs_inode *dp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-05-19 17:51:14 -06:00
|
|
|
struct xfs_attr_leafblock *leaf;
|
|
|
|
struct xfs_attr_leaf_entry *entry;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_attr_leaf_name_local_t *name_loc;
|
2013-05-19 17:51:14 -06:00
|
|
|
struct xfs_attr3_icleaf_hdr leafhdr;
|
|
|
|
int bytes;
|
|
|
|
int i;
|
2015-04-12 19:26:02 -06:00
|
|
|
struct xfs_mount *mp = bp->b_target->bt_mount;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf = bp->b_addr;
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &leafhdr, leaf);
|
2013-05-19 17:51:14 -06:00
|
|
|
entry = xfs_attr3_leaf_entryp(leaf);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
bytes = sizeof(struct xfs_attr_sf_hdr);
|
2013-05-19 17:51:14 -06:00
|
|
|
for (i = 0; i < leafhdr.count; entry++, i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (entry->flags & XFS_ATTR_INCOMPLETE)
|
|
|
|
continue; /* don't copy partial entries */
|
|
|
|
if (!(entry->flags & XFS_ATTR_LOCAL))
|
2014-06-21 23:03:54 -06:00
|
|
|
return 0;
|
2013-04-24 02:58:55 -06:00
|
|
|
name_loc = xfs_attr3_leaf_name_local(leaf, i);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (name_loc->namelen >= XFS_ATTR_SF_ENTSIZE_MAX)
|
2014-06-21 23:03:54 -06:00
|
|
|
return 0;
|
2006-03-16 23:29:09 -07:00
|
|
|
if (be16_to_cpu(name_loc->valuelen) >= XFS_ATTR_SF_ENTSIZE_MAX)
|
2014-06-21 23:03:54 -06:00
|
|
|
return 0;
|
2013-05-19 17:51:14 -06:00
|
|
|
bytes += sizeof(struct xfs_attr_sf_entry) - 1
|
2005-04-16 16:20:36 -06:00
|
|
|
+ name_loc->namelen
|
2006-03-16 23:29:09 -07:00
|
|
|
+ be16_to_cpu(name_loc->valuelen);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-01-10 21:32:01 -07:00
|
|
|
if ((dp->i_mount->m_flags & XFS_MOUNT_ATTR2) &&
|
2007-02-10 00:35:58 -07:00
|
|
|
(dp->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
|
2005-11-24 22:42:22 -07:00
|
|
|
(bytes == sizeof(struct xfs_attr_sf_hdr)))
|
2013-05-19 17:51:14 -06:00
|
|
|
return -1;
|
|
|
|
return xfs_attr_shortform_bytesfit(dp, bytes);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert a leaf attribute list to shortform attribute list
|
|
|
|
*/
|
|
|
|
int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_to_shortform(
|
|
|
|
struct xfs_buf *bp,
|
|
|
|
struct xfs_da_args *args,
|
|
|
|
int forkoff)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf;
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr;
|
|
|
|
struct xfs_attr_leaf_entry *entry;
|
|
|
|
struct xfs_attr_leaf_name_local *name_loc;
|
|
|
|
struct xfs_da_args nargs;
|
|
|
|
struct xfs_inode *dp = args->dp;
|
|
|
|
char *tmpbuffer;
|
|
|
|
int error;
|
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_leaf_to_sf(args);
|
|
|
|
|
2014-06-05 23:21:45 -06:00
|
|
|
tmpbuffer = kmem_alloc(args->geo->blksize, KM_SLEEP);
|
2013-04-24 02:58:55 -06:00
|
|
|
if (!tmpbuffer)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-06-05 23:21:45 -06:00
|
|
|
memcpy(tmpbuffer, bp->b_addr, args->geo->blksize);
|
2013-04-24 02:58:55 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
leaf = (xfs_attr_leafblock_t *)tmpbuffer;
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
|
2013-04-24 02:58:55 -06:00
|
|
|
entry = xfs_attr3_leaf_entryp(leaf);
|
|
|
|
|
|
|
|
/* XXX (dgc): buffer is about to be marked stale - why zero it? */
|
2014-06-05 23:21:45 -06:00
|
|
|
memset(bp->b_addr, 0, args->geo->blksize);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Clean out the prior contents of the attribute list.
|
|
|
|
*/
|
|
|
|
error = xfs_da_shrink_inode(args, 0, bp);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
2005-11-01 16:34:53 -07:00
|
|
|
|
|
|
|
if (forkoff == -1) {
|
2006-01-10 21:32:01 -07:00
|
|
|
ASSERT(dp->i_mount->m_flags & XFS_MOUNT_ATTR2);
|
2007-02-10 00:35:58 -07:00
|
|
|
ASSERT(dp->i_d.di_format != XFS_DINODE_FMT_BTREE);
|
2015-05-28 15:40:08 -06:00
|
|
|
xfs_attr_fork_remove(dp, args->trans);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
2005-11-01 16:34:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
xfs_attr_shortform_create(args);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy the attributes
|
|
|
|
*/
|
|
|
|
memset((char *)&nargs, 0, sizeof(nargs));
|
2014-06-05 23:01:58 -06:00
|
|
|
nargs.geo = args->geo;
|
2005-04-16 16:20:36 -06:00
|
|
|
nargs.dp = dp;
|
|
|
|
nargs.firstblock = args->firstblock;
|
2016-08-02 19:19:29 -06:00
|
|
|
nargs.dfops = args->dfops;
|
2005-04-16 16:20:36 -06:00
|
|
|
nargs.total = args->total;
|
|
|
|
nargs.whichfork = XFS_ATTR_FORK;
|
|
|
|
nargs.trans = args->trans;
|
2008-05-21 00:42:05 -06:00
|
|
|
nargs.op_flags = XFS_DA_OP_OKNOENT;
|
2013-04-24 02:58:55 -06:00
|
|
|
|
|
|
|
for (i = 0; i < ichdr.count; entry++, i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (entry->flags & XFS_ATTR_INCOMPLETE)
|
|
|
|
continue; /* don't copy partial entries */
|
|
|
|
if (!entry->nameidx)
|
|
|
|
continue;
|
|
|
|
ASSERT(entry->flags & XFS_ATTR_LOCAL);
|
2013-04-24 02:58:55 -06:00
|
|
|
name_loc = xfs_attr3_leaf_name_local(leaf, i);
|
2010-01-19 16:47:48 -07:00
|
|
|
nargs.name = name_loc->nameval;
|
2005-04-16 16:20:36 -06:00
|
|
|
nargs.namelen = name_loc->namelen;
|
2010-01-19 16:47:48 -07:00
|
|
|
nargs.value = &name_loc->nameval[nargs.namelen];
|
2006-03-16 23:29:09 -07:00
|
|
|
nargs.valuelen = be16_to_cpu(name_loc->valuelen);
|
2006-03-16 23:29:02 -07:00
|
|
|
nargs.hashval = be32_to_cpu(entry->hashval);
|
2006-09-27 19:01:37 -06:00
|
|
|
nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(entry->flags);
|
2005-11-01 16:34:53 -07:00
|
|
|
xfs_attr_shortform_add(&nargs, forkoff);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
out:
|
2008-05-19 00:31:57 -06:00
|
|
|
kmem_free(tmpbuffer);
|
2013-04-24 02:58:55 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert from using a single leaf to a root node and a leaf.
|
|
|
|
*/
|
|
|
|
int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_to_node(
|
|
|
|
struct xfs_da_args *args)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf;
|
|
|
|
struct xfs_attr3_icleaf_hdr icleafhdr;
|
|
|
|
struct xfs_attr_leaf_entry *entries;
|
2013-04-24 02:58:02 -06:00
|
|
|
struct xfs_da_node_entry *btree;
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_da3_icnode_hdr icnodehdr;
|
|
|
|
struct xfs_da_intnode *node;
|
|
|
|
struct xfs_inode *dp = args->dp;
|
|
|
|
struct xfs_mount *mp = dp->i_mount;
|
|
|
|
struct xfs_buf *bp1 = NULL;
|
|
|
|
struct xfs_buf *bp2 = NULL;
|
|
|
|
xfs_dablk_t blkno;
|
|
|
|
int error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_leaf_to_node(args);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
error = xfs_da_grow_inode(args, &blkno);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
2013-04-24 02:58:55 -06:00
|
|
|
error = xfs_attr3_leaf_read(args->trans, dp, 0, -1, &bp1);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error)
|
|
|
|
goto out;
|
2012-11-12 04:54:16 -07:00
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
error = xfs_da_get_buf(args->trans, dp, blkno, -1, &bp2, XFS_ATTR_FORK);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error)
|
|
|
|
goto out;
|
2013-04-24 02:58:55 -06:00
|
|
|
|
|
|
|
/* copy leaf to new buffer, update identifiers */
|
2013-04-02 23:11:30 -06:00
|
|
|
xfs_trans_buf_set_type(args->trans, bp2, XFS_BLFT_ATTR_LEAF_BUF);
|
2012-11-13 23:54:40 -07:00
|
|
|
bp2->b_ops = bp1->b_ops;
|
2014-06-05 23:21:45 -06:00
|
|
|
memcpy(bp2->b_addr, bp1->b_addr, args->geo->blksize);
|
2013-04-24 02:58:55 -06:00
|
|
|
if (xfs_sb_version_hascrc(&mp->m_sb)) {
|
|
|
|
struct xfs_da3_blkinfo *hdr3 = bp2->b_addr;
|
|
|
|
hdr3->blkno = cpu_to_be64(bp2->b_bn);
|
|
|
|
}
|
2014-06-05 23:21:45 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp2, 0, args->geo->blksize - 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up the new root node.
|
|
|
|
*/
|
2013-04-24 02:58:02 -06:00
|
|
|
error = xfs_da3_node_create(args, 0, 1, &bp1, XFS_ATTR_FORK);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error)
|
|
|
|
goto out;
|
2012-06-22 02:50:14 -06:00
|
|
|
node = bp1->b_addr;
|
2013-10-29 05:11:52 -06:00
|
|
|
dp->d_ops->node_hdr_from_disk(&icnodehdr, node);
|
2013-10-29 05:11:51 -06:00
|
|
|
btree = dp->d_ops->node_tree_p(node);
|
2013-04-24 02:58:55 -06:00
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf = bp2->b_addr;
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(args->geo, &icleafhdr, leaf);
|
2013-04-24 02:58:55 -06:00
|
|
|
entries = xfs_attr3_leaf_entryp(leaf);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* both on-disk, don't endian-flip twice */
|
2013-04-24 02:58:55 -06:00
|
|
|
btree[0].hashval = entries[icleafhdr.count - 1].hashval;
|
2013-04-24 02:58:02 -06:00
|
|
|
btree[0].before = cpu_to_be32(blkno);
|
2013-04-24 02:58:55 -06:00
|
|
|
icnodehdr.count = 1;
|
2013-10-29 05:11:52 -06:00
|
|
|
dp->d_ops->node_hdr_to_disk(node, &icnodehdr);
|
2014-06-05 23:21:45 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp1, 0, args->geo->blksize - 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
error = 0;
|
|
|
|
out:
|
2013-04-24 02:58:55 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*========================================================================
|
|
|
|
* Routines used for growing the Btree.
|
|
|
|
*========================================================================*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create the initial contents of a leaf attribute list
|
|
|
|
* or a leaf in a node attribute list.
|
|
|
|
*/
|
2005-06-20 23:36:52 -06:00
|
|
|
STATIC int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_create(
|
|
|
|
struct xfs_da_args *args,
|
|
|
|
xfs_dablk_t blkno,
|
|
|
|
struct xfs_buf **bpp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf;
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr;
|
|
|
|
struct xfs_inode *dp = args->dp;
|
|
|
|
struct xfs_mount *mp = dp->i_mount;
|
|
|
|
struct xfs_buf *bp;
|
|
|
|
int error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_leaf_create(args);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
error = xfs_da_get_buf(args->trans, args->dp, blkno, -1, &bp,
|
|
|
|
XFS_ATTR_FORK);
|
|
|
|
if (error)
|
2013-04-24 02:58:55 -06:00
|
|
|
return error;
|
|
|
|
bp->b_ops = &xfs_attr3_leaf_buf_ops;
|
2013-04-02 23:11:30 -06:00
|
|
|
xfs_trans_buf_set_type(args->trans, bp, XFS_BLFT_ATTR_LEAF_BUF);
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf = bp->b_addr;
|
2014-06-05 23:21:45 -06:00
|
|
|
memset(leaf, 0, args->geo->blksize);
|
2013-04-24 02:58:55 -06:00
|
|
|
|
|
|
|
memset(&ichdr, 0, sizeof(ichdr));
|
2014-06-05 23:21:45 -06:00
|
|
|
ichdr.firstused = args->geo->blksize;
|
2013-04-24 02:58:55 -06:00
|
|
|
|
|
|
|
if (xfs_sb_version_hascrc(&mp->m_sb)) {
|
|
|
|
struct xfs_da3_blkinfo *hdr3 = bp->b_addr;
|
|
|
|
|
|
|
|
ichdr.magic = XFS_ATTR3_LEAF_MAGIC;
|
|
|
|
|
|
|
|
hdr3->blkno = cpu_to_be64(bp->b_bn);
|
|
|
|
hdr3->owner = cpu_to_be64(dp->i_ino);
|
2015-07-28 19:53:31 -06:00
|
|
|
uuid_copy(&hdr3->uuid, &mp->m_sb.sb_meta_uuid);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
ichdr.freemap[0].base = sizeof(struct xfs_attr3_leaf_hdr);
|
|
|
|
} else {
|
|
|
|
ichdr.magic = XFS_ATTR_LEAF_MAGIC;
|
|
|
|
ichdr.freemap[0].base = sizeof(struct xfs_attr_leaf_hdr);
|
|
|
|
}
|
|
|
|
ichdr.freemap[0].size = ichdr.firstused - ichdr.freemap[0].base;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr);
|
2014-06-05 23:21:45 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp, 0, args->geo->blksize - 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
*bpp = bp;
|
2013-04-24 02:58:55 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Split the leaf node, rebalance, then add the new entry.
|
|
|
|
*/
|
|
|
|
int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_split(
|
|
|
|
struct xfs_da_state *state,
|
|
|
|
struct xfs_da_state_blk *oldblk,
|
|
|
|
struct xfs_da_state_blk *newblk)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xfs_dablk_t blkno;
|
|
|
|
int error;
|
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_leaf_split(state->args);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Allocate space for a new leaf node.
|
|
|
|
*/
|
|
|
|
ASSERT(oldblk->magic == XFS_ATTR_LEAF_MAGIC);
|
|
|
|
error = xfs_da_grow_inode(state->args, &blkno);
|
|
|
|
if (error)
|
2014-06-21 23:03:54 -06:00
|
|
|
return error;
|
2013-04-24 02:58:55 -06:00
|
|
|
error = xfs_attr3_leaf_create(state->args, blkno, &newblk->bp);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error)
|
2014-06-21 23:03:54 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
newblk->blkno = blkno;
|
|
|
|
newblk->magic = XFS_ATTR_LEAF_MAGIC;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Rebalance the entries across the two leaves.
|
|
|
|
* NOTE: rebalance() currently depends on the 2nd block being empty.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_rebalance(state, oldblk, newblk);
|
2013-04-24 02:58:02 -06:00
|
|
|
error = xfs_da3_blk_link(state, oldblk, newblk);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error)
|
2014-06-21 23:03:54 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Save info on "old" attribute for "atomic rename" ops, leaf_add()
|
|
|
|
* modifies the index/blkno/rmtblk/rmtblkcnt fields to show the
|
|
|
|
* "new" attrs info. Will need the "old" info to remove it later.
|
|
|
|
*
|
|
|
|
* Insert the "new" entry in the correct block.
|
|
|
|
*/
|
2012-03-21 23:15:13 -06:00
|
|
|
if (state->inleaf) {
|
|
|
|
trace_xfs_attr_leaf_add_old(state->args);
|
2013-04-24 02:58:55 -06:00
|
|
|
error = xfs_attr3_leaf_add(oldblk->bp, state->args);
|
2012-03-21 23:15:13 -06:00
|
|
|
} else {
|
|
|
|
trace_xfs_attr_leaf_add_new(state->args);
|
2013-04-24 02:58:55 -06:00
|
|
|
error = xfs_attr3_leaf_add(newblk->bp, state->args);
|
2012-03-21 23:15:13 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Update last hashval in each block since we added the name.
|
|
|
|
*/
|
|
|
|
oldblk->hashval = xfs_attr_leaf_lasthash(oldblk->bp, NULL);
|
|
|
|
newblk->hashval = xfs_attr_leaf_lasthash(newblk->bp, NULL);
|
2014-06-21 23:03:54 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a name to the leaf attribute list structure.
|
|
|
|
*/
|
|
|
|
int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_add(
|
2012-06-22 02:50:14 -06:00
|
|
|
struct xfs_buf *bp,
|
|
|
|
struct xfs_da_args *args)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf;
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr;
|
|
|
|
int tablesize;
|
|
|
|
int entsize;
|
|
|
|
int sum;
|
|
|
|
int tmp;
|
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_leaf_add(args);
|
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf = bp->b_addr;
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(args->index >= 0 && args->index <= ichdr.count);
|
2014-06-05 23:21:27 -06:00
|
|
|
entsize = xfs_attr_leaf_newentsize(args, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Search through freemap for first-fit on new name length.
|
|
|
|
* (may need to figure in size of entry struct too)
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
tablesize = (ichdr.count + 1) * sizeof(xfs_attr_leaf_entry_t)
|
|
|
|
+ xfs_attr3_leaf_hdr_size(leaf);
|
|
|
|
for (sum = 0, i = XFS_ATTR_LEAF_MAPSIZE - 1; i >= 0; i--) {
|
|
|
|
if (tablesize > ichdr.firstused) {
|
|
|
|
sum += ichdr.freemap[i].size;
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
|
|
|
}
|
2013-04-24 02:58:55 -06:00
|
|
|
if (!ichdr.freemap[i].size)
|
2005-04-16 16:20:36 -06:00
|
|
|
continue; /* no space in this map */
|
|
|
|
tmp = entsize;
|
2013-04-24 02:58:55 -06:00
|
|
|
if (ichdr.freemap[i].base < ichdr.firstused)
|
2005-04-16 16:20:36 -06:00
|
|
|
tmp += sizeof(xfs_attr_leaf_entry_t);
|
2013-04-24 02:58:55 -06:00
|
|
|
if (ichdr.freemap[i].size >= tmp) {
|
|
|
|
tmp = xfs_attr3_leaf_add_work(bp, &ichdr, args, i);
|
|
|
|
goto out_log_hdr;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2013-04-24 02:58:55 -06:00
|
|
|
sum += ichdr.freemap[i].size;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there are no holes in the address space of the block,
|
|
|
|
* and we don't have enough freespace, then compaction will do us
|
|
|
|
* no good and we should just give up.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
if (!ichdr.holes && sum < entsize)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOSPC;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Compact the entries to coalesce free space.
|
|
|
|
* This may change the hdr->count via dropping INCOMPLETE entries.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_compact(args, &ichdr, bp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* After compaction, the block is guaranteed to have only one
|
|
|
|
* free region, in freemap[0]. If it is not big enough, give up.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
if (ichdr.freemap[0].size < (entsize + sizeof(xfs_attr_leaf_entry_t))) {
|
2014-06-24 22:58:08 -06:00
|
|
|
tmp = -ENOSPC;
|
2013-04-24 02:58:55 -06:00
|
|
|
goto out_log_hdr;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = xfs_attr3_leaf_add_work(bp, &ichdr, args, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
out_log_hdr:
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr);
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp,
|
|
|
|
XFS_DA_LOGRANGE(leaf, &leaf->hdr,
|
|
|
|
xfs_attr3_leaf_hdr_size(leaf)));
|
|
|
|
return tmp;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a name to a leaf attribute list structure.
|
|
|
|
*/
|
|
|
|
STATIC int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_add_work(
|
|
|
|
struct xfs_buf *bp,
|
|
|
|
struct xfs_attr3_icleaf_hdr *ichdr,
|
|
|
|
struct xfs_da_args *args,
|
|
|
|
int mapindex)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf;
|
|
|
|
struct xfs_attr_leaf_entry *entry;
|
|
|
|
struct xfs_attr_leaf_name_local *name_loc;
|
|
|
|
struct xfs_attr_leaf_name_remote *name_rmt;
|
|
|
|
struct xfs_mount *mp;
|
|
|
|
int tmp;
|
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-11-12 04:53:53 -07:00
|
|
|
trace_xfs_attr_leaf_add_work(args);
|
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf = bp->b_addr;
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(mapindex >= 0 && mapindex < XFS_ATTR_LEAF_MAPSIZE);
|
|
|
|
ASSERT(args->index >= 0 && args->index <= ichdr->count);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Force open some space in the entry array and fill it in.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
entry = &xfs_attr3_leaf_entryp(leaf)[args->index];
|
|
|
|
if (args->index < ichdr->count) {
|
|
|
|
tmp = ichdr->count - args->index;
|
2005-04-16 16:20:36 -06:00
|
|
|
tmp *= sizeof(xfs_attr_leaf_entry_t);
|
2013-04-24 02:58:55 -06:00
|
|
|
memmove(entry + 1, entry, tmp);
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp,
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
|
|
|
|
}
|
2013-04-24 02:58:55 -06:00
|
|
|
ichdr->count++;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate space for the new string (at the end of the run).
|
|
|
|
*/
|
|
|
|
mp = args->trans->t_mountp;
|
2014-06-05 23:21:45 -06:00
|
|
|
ASSERT(ichdr->freemap[mapindex].base < args->geo->blksize);
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT((ichdr->freemap[mapindex].base & 0x3) == 0);
|
|
|
|
ASSERT(ichdr->freemap[mapindex].size >=
|
2014-06-05 23:21:27 -06:00
|
|
|
xfs_attr_leaf_newentsize(args, NULL));
|
2014-06-05 23:21:45 -06:00
|
|
|
ASSERT(ichdr->freemap[mapindex].size < args->geo->blksize);
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT((ichdr->freemap[mapindex].size & 0x3) == 0);
|
|
|
|
|
2014-06-05 23:21:27 -06:00
|
|
|
ichdr->freemap[mapindex].size -= xfs_attr_leaf_newentsize(args, &tmp);
|
2013-04-24 02:58:55 -06:00
|
|
|
|
|
|
|
entry->nameidx = cpu_to_be16(ichdr->freemap[mapindex].base +
|
|
|
|
ichdr->freemap[mapindex].size);
|
2006-03-16 23:29:02 -07:00
|
|
|
entry->hashval = cpu_to_be32(args->hashval);
|
2005-04-16 16:20:36 -06:00
|
|
|
entry->flags = tmp ? XFS_ATTR_LOCAL : 0;
|
2006-09-27 19:01:37 -06:00
|
|
|
entry->flags |= XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags);
|
2008-05-21 00:42:05 -06:00
|
|
|
if (args->op_flags & XFS_DA_OP_RENAME) {
|
2005-04-16 16:20:36 -06:00
|
|
|
entry->flags |= XFS_ATTR_INCOMPLETE;
|
|
|
|
if ((args->blkno2 == args->blkno) &&
|
|
|
|
(args->index2 <= args->index)) {
|
|
|
|
args->index2++;
|
|
|
|
}
|
|
|
|
}
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp,
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
|
2006-03-16 23:29:02 -07:00
|
|
|
ASSERT((args->index == 0) ||
|
|
|
|
(be32_to_cpu(entry->hashval) >= be32_to_cpu((entry-1)->hashval)));
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT((args->index == ichdr->count - 1) ||
|
2006-03-16 23:29:02 -07:00
|
|
|
(be32_to_cpu(entry->hashval) <= be32_to_cpu((entry+1)->hashval)));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For "remote" attribute values, simply note that we need to
|
|
|
|
* allocate space for the "remote" value. We can't actually
|
|
|
|
* allocate the extents in this transaction, and we can't decide
|
|
|
|
* which blocks they should be as we might allocate more blocks
|
|
|
|
* as part of this transaction (a split operation for example).
|
|
|
|
*/
|
|
|
|
if (entry->flags & XFS_ATTR_LOCAL) {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_loc = xfs_attr3_leaf_name_local(leaf, args->index);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_loc->namelen = args->namelen;
|
2006-03-16 23:29:09 -07:00
|
|
|
name_loc->valuelen = cpu_to_be16(args->valuelen);
|
2005-04-16 16:20:36 -06:00
|
|
|
memcpy((char *)name_loc->nameval, args->name, args->namelen);
|
|
|
|
memcpy((char *)&name_loc->nameval[args->namelen], args->value,
|
2006-03-16 23:29:09 -07:00
|
|
|
be16_to_cpu(name_loc->valuelen));
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_rmt->namelen = args->namelen;
|
|
|
|
memcpy((char *)name_rmt->name, args->name, args->namelen);
|
|
|
|
entry->flags |= XFS_ATTR_INCOMPLETE;
|
|
|
|
/* just in case */
|
|
|
|
name_rmt->valuelen = 0;
|
|
|
|
name_rmt->valueblk = 0;
|
|
|
|
args->rmtblkno = 1;
|
xfs: rework remote attr CRCs
Note: this changes the on-disk remote attribute format. I assert
that this is OK to do as CRCs are marked experimental and the first
kernel it is included in has not yet reached release yet. Further,
the userspace utilities are still evolving and so anyone using this
stuff right now is a developer or tester using volatile filesystems
for testing this feature. Hence changing the format right now to
save longer term pain is the right thing to do.
The fundamental change is to move from a header per extent in the
attribute to a header per filesytem block in the attribute. This
means there are more header blocks and the parsing of the attribute
data is slightly more complex, but it has the advantage that we
always know the size of the attribute on disk based on the length of
the data it contains.
This is where the header-per-extent method has problems. We don't
know the size of the attribute on disk without first knowing how
many extents are used to hold it. And we can't tell from a
mapping lookup, either, because remote attributes can be allocated
contiguously with other attribute blocks and so there is no obvious
way of determining the actual size of the atribute on disk short of
walking and mapping buffers.
The problem with this approach is that if we map a buffer
incorrectly (e.g. we make the last buffer for the attribute data too
long), we then get buffer cache lookup failure when we map it
correctly. i.e. we get a size mismatch on lookup. This is not
necessarily fatal, but it's a cache coherency problem that can lead
to returning the wrong data to userspace or writing the wrong data
to disk. And debug kernels will assert fail if this occurs.
I found lots of niggly little problems trying to fix this issue on a
4k block size filesystem, finally getting it to pass with lots of
fixes. The thing is, 1024 byte filesystems still failed, and it was
getting really complex handling all the corner cases that were
showing up. And there were clearly more that I hadn't found yet.
It is complex, fragile code, and if we don't fix it now, it will be
complex, fragile code forever more.
Hence the simple fix is to add a header to each filesystem block.
This gives us the same relationship between the attribute data
length and the number of blocks on disk as we have without CRCs -
it's a linear mapping and doesn't require us to guess anything. It
is simple to implement, too - the remote block count calculated at
lookup time can be used by the remote attribute set/get/remove code
without modification for both CRC and non-CRC filesystems. The world
becomes sane again.
Because the copy-in and copy-out now need to iterate over each
filesystem block, I moved them into helper functions so we separate
the block mapping and buffer manupulations from the attribute data
and CRC header manipulations. The code becomes much clearer as a
result, and it is a lot easier to understand and debug. It also
appears to be much more robust - once it worked on 4k block size
filesystems, it has worked without failure on 1k block size
filesystems, too.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-05-21 02:02:08 -06:00
|
|
|
args->rmtblkcnt = xfs_attr3_rmt_blocks(mp, args->valuelen);
|
xfs: remote attribute overwrite causes transaction overrun
Commit e461fcb ("xfs: remote attribute lookups require the value
length") passes the remote attribute length in the xfs_da_args
structure on lookup so that CRC calculations and validity checking
can be performed correctly by related code. This, unfortunately has
the side effect of changing the args->valuelen parameter in cases
where it shouldn't.
That is, when we replace a remote attribute, the incoming
replacement stores the value and length in args->value and
args->valuelen, but then the lookup which finds the existing remote
attribute overwrites args->valuelen with the length of the remote
attribute being replaced. Hence when we go to create the new
attribute, we create it of the size of the existing remote
attribute, not the size it is supposed to be. When the new attribute
is much smaller than the old attribute, this results in a
transaction overrun and an ASSERT() failure on a debug kernel:
XFS: Assertion failed: tp->t_blk_res_used <= tp->t_blk_res, file: fs/xfs/xfs_trans.c, line: 331
Fix this by keeping the remote attribute value length separate to
the attribute value length in the xfs_da_args structure. The enables
us to pass the length of the remote attribute to be removed without
overwriting the new attribute's length.
Also, ensure that when we save remote block contexts for a later
rename we zero the original state variables so that we don't confuse
the state of the attribute to be removes with the state of the new
attribute that we just added. [Spotted by Brain Foster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-05-05 15:37:31 -06:00
|
|
|
args->rmtvaluelen = args->valuelen;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp,
|
2013-04-24 02:58:55 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf, xfs_attr3_leaf_name(leaf, args->index),
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_attr_leaf_entsize(leaf, args->index)));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update the control info for this leaf node
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
if (be16_to_cpu(entry->nameidx) < ichdr->firstused)
|
|
|
|
ichdr->firstused = be16_to_cpu(entry->nameidx);
|
|
|
|
|
|
|
|
ASSERT(ichdr->firstused >= ichdr->count * sizeof(xfs_attr_leaf_entry_t)
|
|
|
|
+ xfs_attr3_leaf_hdr_size(leaf));
|
|
|
|
tmp = (ichdr->count - 1) * sizeof(xfs_attr_leaf_entry_t)
|
|
|
|
+ xfs_attr3_leaf_hdr_size(leaf);
|
|
|
|
|
|
|
|
for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
|
|
|
|
if (ichdr->freemap[i].base == tmp) {
|
|
|
|
ichdr->freemap[i].base += sizeof(xfs_attr_leaf_entry_t);
|
|
|
|
ichdr->freemap[i].size -= sizeof(xfs_attr_leaf_entry_t);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2013-04-24 02:58:55 -06:00
|
|
|
ichdr->usedbytes += xfs_attr_leaf_entsize(leaf, args->index);
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Garbage collect a leaf attribute list block by copying it to a new buffer.
|
|
|
|
*/
|
|
|
|
STATIC void
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_compact(
|
2012-11-12 04:53:53 -07:00
|
|
|
struct xfs_da_args *args,
|
2013-05-21 02:02:06 -06:00
|
|
|
struct xfs_attr3_icleaf_hdr *ichdr_dst,
|
2012-11-12 04:53:53 -07:00
|
|
|
struct xfs_buf *bp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-05-21 02:02:06 -06:00
|
|
|
struct xfs_attr_leafblock *leaf_src;
|
|
|
|
struct xfs_attr_leafblock *leaf_dst;
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr_src;
|
2012-11-12 04:53:53 -07:00
|
|
|
struct xfs_trans *trans = args->trans;
|
|
|
|
char *tmpbuffer;
|
|
|
|
|
|
|
|
trace_xfs_attr_leaf_compact(args);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-06-05 23:21:45 -06:00
|
|
|
tmpbuffer = kmem_alloc(args->geo->blksize, KM_SLEEP);
|
|
|
|
memcpy(tmpbuffer, bp->b_addr, args->geo->blksize);
|
|
|
|
memset(bp->b_addr, 0, args->geo->blksize);
|
2013-05-21 02:02:06 -06:00
|
|
|
leaf_src = (xfs_attr_leafblock_t *)tmpbuffer;
|
|
|
|
leaf_dst = bp->b_addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2013-05-21 02:02:06 -06:00
|
|
|
* Copy the on-disk header back into the destination buffer to ensure
|
|
|
|
* all the information in the header that is not part of the incore
|
|
|
|
* header structure is preserved.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2013-05-21 02:02:06 -06:00
|
|
|
memcpy(bp->b_addr, tmpbuffer, xfs_attr3_leaf_hdr_size(leaf_src));
|
|
|
|
|
|
|
|
/* Initialise the incore headers */
|
|
|
|
ichdr_src = *ichdr_dst; /* struct copy */
|
2014-06-05 23:21:45 -06:00
|
|
|
ichdr_dst->firstused = args->geo->blksize;
|
2013-05-21 02:02:06 -06:00
|
|
|
ichdr_dst->usedbytes = 0;
|
|
|
|
ichdr_dst->count = 0;
|
|
|
|
ichdr_dst->holes = 0;
|
|
|
|
ichdr_dst->freemap[0].base = xfs_attr3_leaf_hdr_size(leaf_src);
|
|
|
|
ichdr_dst->freemap[0].size = ichdr_dst->firstused -
|
|
|
|
ichdr_dst->freemap[0].base;
|
|
|
|
|
|
|
|
/* write the header back to initialise the underlying buffer */
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_to_disk(args->geo, leaf_dst, ichdr_dst);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy all entry's in the same (sorted) order,
|
|
|
|
* but allocate name/value pairs packed and in sequence.
|
|
|
|
*/
|
2014-06-05 23:21:45 -06:00
|
|
|
xfs_attr3_leaf_moveents(args, leaf_src, &ichdr_src, 0,
|
|
|
|
leaf_dst, ichdr_dst, 0, ichdr_src.count);
|
2013-04-24 02:58:55 -06:00
|
|
|
/*
|
|
|
|
* this logs the entire buffer, but the caller must write the header
|
|
|
|
* back to the buffer when it is finished modifying it.
|
|
|
|
*/
|
2014-06-05 23:21:45 -06:00
|
|
|
xfs_trans_log_buf(trans, bp, 0, args->geo->blksize - 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-05-19 00:31:57 -06:00
|
|
|
kmem_free(tmpbuffer);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
/*
|
|
|
|
* Compare two leaf blocks "order".
|
|
|
|
* Return 0 unless leaf2 should go before leaf1.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_attr3_leaf_order(
|
|
|
|
struct xfs_buf *leaf1_bp,
|
|
|
|
struct xfs_attr3_icleaf_hdr *leaf1hdr,
|
|
|
|
struct xfs_buf *leaf2_bp,
|
|
|
|
struct xfs_attr3_icleaf_hdr *leaf2hdr)
|
|
|
|
{
|
|
|
|
struct xfs_attr_leaf_entry *entries1;
|
|
|
|
struct xfs_attr_leaf_entry *entries2;
|
|
|
|
|
|
|
|
entries1 = xfs_attr3_leaf_entryp(leaf1_bp->b_addr);
|
|
|
|
entries2 = xfs_attr3_leaf_entryp(leaf2_bp->b_addr);
|
|
|
|
if (leaf1hdr->count > 0 && leaf2hdr->count > 0 &&
|
|
|
|
((be32_to_cpu(entries2[0].hashval) <
|
|
|
|
be32_to_cpu(entries1[0].hashval)) ||
|
|
|
|
(be32_to_cpu(entries2[leaf2hdr->count - 1].hashval) <
|
|
|
|
be32_to_cpu(entries1[leaf1hdr->count - 1].hashval)))) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
xfs_attr_leaf_order(
|
|
|
|
struct xfs_buf *leaf1_bp,
|
|
|
|
struct xfs_buf *leaf2_bp)
|
|
|
|
{
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr1;
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr2;
|
2015-04-12 19:26:02 -06:00
|
|
|
struct xfs_mount *mp = leaf1_bp->b_target->bt_mount;
|
2013-04-24 02:58:55 -06:00
|
|
|
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr1, leaf1_bp->b_addr);
|
|
|
|
xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr2, leaf2_bp->b_addr);
|
2013-04-24 02:58:55 -06:00
|
|
|
return xfs_attr3_leaf_order(leaf1_bp, &ichdr1, leaf2_bp, &ichdr2);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Redistribute the attribute list entries between two leaf nodes,
|
|
|
|
* taking into account the size of the new entry.
|
|
|
|
*
|
|
|
|
* NOTE: if new block is empty, then it will get the upper half of the
|
|
|
|
* old block. At present, all (one) callers pass in an empty second block.
|
|
|
|
*
|
|
|
|
* This code adjusts the args->index/blkno and args->index2/blkno2 fields
|
|
|
|
* to match what it is doing in splitting the attribute leaf block. Those
|
|
|
|
* values are used in "atomic rename" operations on attributes. Note that
|
|
|
|
* the "new" and "old" values can end up in different blocks.
|
|
|
|
*/
|
|
|
|
STATIC void
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_rebalance(
|
|
|
|
struct xfs_da_state *state,
|
|
|
|
struct xfs_da_state_blk *blk1,
|
|
|
|
struct xfs_da_state_blk *blk2)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_da_args *args;
|
|
|
|
struct xfs_attr_leafblock *leaf1;
|
|
|
|
struct xfs_attr_leafblock *leaf2;
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr1;
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr2;
|
|
|
|
struct xfs_attr_leaf_entry *entries1;
|
|
|
|
struct xfs_attr_leaf_entry *entries2;
|
|
|
|
int count;
|
|
|
|
int totallen;
|
|
|
|
int max;
|
|
|
|
int space;
|
|
|
|
int swap;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up environment.
|
|
|
|
*/
|
|
|
|
ASSERT(blk1->magic == XFS_ATTR_LEAF_MAGIC);
|
|
|
|
ASSERT(blk2->magic == XFS_ATTR_LEAF_MAGIC);
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf1 = blk1->bp->b_addr;
|
|
|
|
leaf2 = blk2->bp->b_addr;
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr1, leaf1);
|
|
|
|
xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr2, leaf2);
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(ichdr2.count == 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
args = state->args;
|
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_leaf_rebalance(args);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Check ordering of blocks, reverse if it makes things simpler.
|
|
|
|
*
|
|
|
|
* NOTE: Given that all (current) callers pass in an empty
|
|
|
|
* second block, this code should never set "swap".
|
|
|
|
*/
|
|
|
|
swap = 0;
|
2013-04-24 02:58:55 -06:00
|
|
|
if (xfs_attr3_leaf_order(blk1->bp, &ichdr1, blk2->bp, &ichdr2)) {
|
|
|
|
struct xfs_da_state_blk *tmp_blk;
|
|
|
|
struct xfs_attr3_icleaf_hdr tmp_ichdr;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
tmp_blk = blk1;
|
|
|
|
blk1 = blk2;
|
|
|
|
blk2 = tmp_blk;
|
2013-04-24 02:58:55 -06:00
|
|
|
|
|
|
|
/* struct copies to swap them rather than reconverting */
|
|
|
|
tmp_ichdr = ichdr1;
|
|
|
|
ichdr1 = ichdr2;
|
|
|
|
ichdr2 = tmp_ichdr;
|
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf1 = blk1->bp->b_addr;
|
|
|
|
leaf2 = blk2->bp->b_addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
swap = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Examine entries until we reduce the absolute difference in
|
|
|
|
* byte usage between the two blocks to a minimum. Then get
|
|
|
|
* the direction to copy and the number of elements to move.
|
|
|
|
*
|
|
|
|
* "inleaf" is true if the new entry should be inserted into blk1.
|
|
|
|
* If "swap" is also true, then reverse the sense of "inleaf".
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
state->inleaf = xfs_attr3_leaf_figure_balance(state, blk1, &ichdr1,
|
|
|
|
blk2, &ichdr2,
|
|
|
|
&count, &totallen);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (swap)
|
|
|
|
state->inleaf = !state->inleaf;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move any entries required from leaf to leaf:
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
if (count < ichdr1.count) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Figure the total bytes to be added to the destination leaf.
|
|
|
|
*/
|
|
|
|
/* number entries being moved */
|
2013-04-24 02:58:55 -06:00
|
|
|
count = ichdr1.count - count;
|
|
|
|
space = ichdr1.usedbytes - totallen;
|
2005-04-16 16:20:36 -06:00
|
|
|
space += count * sizeof(xfs_attr_leaf_entry_t);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* leaf2 is the destination, compact it if it looks tight.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
max = ichdr2.firstused - xfs_attr3_leaf_hdr_size(leaf1);
|
|
|
|
max -= ichdr2.count * sizeof(xfs_attr_leaf_entry_t);
|
2012-11-12 04:53:53 -07:00
|
|
|
if (space > max)
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_compact(args, &ichdr2, blk2->bp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Move high entries from leaf1 to low end of leaf2.
|
|
|
|
*/
|
2014-06-05 23:21:45 -06:00
|
|
|
xfs_attr3_leaf_moveents(args, leaf1, &ichdr1,
|
|
|
|
ichdr1.count - count, leaf2, &ichdr2, 0, count);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
} else if (count > ichdr1.count) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* I assert that since all callers pass in an empty
|
|
|
|
* second buffer, this code should never execute.
|
|
|
|
*/
|
xfs: fix attr tree double split corruption
In certain circumstances, a double split of an attribute tree is
needed to insert or replace an attribute. In rare situations, this
can go wrong, leaving the attribute tree corrupted. In this case,
the attr being replaced is the last attr in a leaf node, and the
replacement is larger so doesn't fit in the same leaf node.
When we have the initial condition of a node format attribute
btree with two leaves at index 1 and 2. Call them L1 and L2. The
leaf L1 is completely full, there is not a single byte of free space
in it. L2 is mostly empty. The attribute being replaced - call it X
- is the last attribute in L1.
The way an attribute replace is executed is that the replacement
attribute - call it Y - is first inserted into the tree, but has an
INCOMPLETE flag set on it so that list traversals ignore it. Once
this transaction is committed, a second transaction it run to
atomically mark Y as COMPLETE and X as INCOMPLETE, so that a
traversal will now find Y and skip X. Once that transaction is
committed, attribute X is then removed.
So, the initial condition is:
+--------+ +--------+
| L1 | | L2 |
| fwd: 2 |---->| fwd: 0 |
| bwd: 0 |<----| bwd: 1 |
| fsp: 0 | | fsp: N |
|--------| |--------|
| attr A | | attr 1 |
|--------| |--------|
| attr B | | attr 2 |
|--------| |--------|
.......... ..........
|--------| |--------|
| attr X | | attr n |
+--------+ +--------+
So now we go to replace X, and see that L1:fsp = 0 - it is full so
we can't insert Y in the same leaf. So we record the the location of
attribute X so we can track it for later use, then we split L1 into
L1 and L3 and reblance across the two leafs. We end with:
+--------+ +--------+ +--------+
| L1 | | L3 | | L2 |
| fwd: 3 |---->| fwd: 2 |---->| fwd: 0 |
| bwd: 0 |<----| bwd: 1 |<----| bwd: 3 |
| fsp: M | | fsp: J | | fsp: N |
|--------| |--------| |--------|
| attr A | | attr X | | attr 1 |
|--------| +--------+ |--------|
| attr B | | attr 2 |
|--------| |--------|
.......... ..........
|--------| |--------|
| attr W | | attr n |
+--------+ +--------+
And we track that the original attribute is now at L3:0.
We then try to insert Y into L1 again, and find that there isn't
enough room because the new attribute is larger than the old one.
Hence we have to split again to make room for Y. We end up with
this:
+--------+ +--------+ +--------+ +--------+
| L1 | | L4 | | L3 | | L2 |
| fwd: 4 |---->| fwd: 3 |---->| fwd: 2 |---->| fwd: 0 |
| bwd: 0 |<----| bwd: 1 |<----| bwd: 4 |<----| bwd: 3 |
| fsp: M | | fsp: J | | fsp: J | | fsp: N |
|--------| |--------| |--------| |--------|
| attr A | | attr Y | | attr X | | attr 1 |
|--------| + INCOMP + +--------+ |--------|
| attr B | +--------+ | attr 2 |
|--------| |--------|
.......... ..........
|--------| |--------|
| attr W | | attr n |
+--------+ +--------+
And now we have the new (incomplete) attribute @ L4:0, and the
original attribute at L3:0. At this point, the first transaction is
committed, and we move to the flipping of the flags.
This is where we are supposed to end up with this:
+--------+ +--------+ +--------+ +--------+
| L1 | | L4 | | L3 | | L2 |
| fwd: 4 |---->| fwd: 3 |---->| fwd: 2 |---->| fwd: 0 |
| bwd: 0 |<----| bwd: 1 |<----| bwd: 4 |<----| bwd: 3 |
| fsp: M | | fsp: J | | fsp: J | | fsp: N |
|--------| |--------| |--------| |--------|
| attr A | | attr Y | | attr X | | attr 1 |
|--------| +--------+ + INCOMP + |--------|
| attr B | +--------+ | attr 2 |
|--------| |--------|
.......... ..........
|--------| |--------|
| attr W | | attr n |
+--------+ +--------+
But that doesn't happen properly - the attribute tracking indexes
are not pointing to the right locations. What we end up with is both
the old attribute to be removed pointing at L4:0 and the new
attribute at L4:1. On a debug kernel, this assert fails like so:
XFS: Assertion failed: args->index2 < be16_to_cpu(leaf2->hdr.count), file: fs/xfs/xfs_attr_leaf.c, line: 2725
because the new attribute location does not exist. On a production
kernel, this goes unnoticed and the code proceeds ahead merrily and
removes L4 because it thinks that is the block that is no longer
needed. This leaves the hash index node pointing to entries
L1, L4 and L2, but only blocks L1, L3 and L2 to exist. Further, the
leaf level sibling list is L1 <-> L4 <-> L2, but L4 is now free
space, and so everything is busted. This corruption is caused by the
removal of the old attribute triggering a join - it joins everything
correctly but then frees the wrong block.
xfs_repair will report something like:
bad sibling back pointer for block 4 in attribute fork for inode 131
problem with attribute contents in inode 131
would clear attr fork
bad nblocks 8 for inode 131, would reset to 3
bad anextents 4 for inode 131, would reset to 0
The problem lies in the assignment of the old/new blocks for
tracking purposes when the double leaf split occurs. The first split
tries to place the new attribute inside the current leaf (i.e.
"inleaf == true") and moves the old attribute (X) to the new block.
This sets up the old block/index to L1:X, and newly allocated
block to L3:0. It then moves attr X to the new block and tries to
insert attr Y at the old index. That fails, so it splits again.
With the second split, the rebalance ends up placing the new attr in
the second new block - L4:0 - and this is where the code goes wrong.
What is does is it sets both the new and old block index to the
second new block. Hence it inserts attr Y at the right place (L4:0)
but overwrites the current location of the attr to replace that is
held in the new block index (currently L3:0). It over writes it with
L4:1 - the index we later assert fail on.
Hopefully this table will show this in a foramt that is a bit easier
to understand:
Split old attr index new attr index
vanilla patched vanilla patched
before 1st L1:26 L1:26 N/A N/A
after 1st L3:0 L3:0 L1:26 L1:26
after 2nd L4:0 L3:0 L4:1 L4:0
^^^^ ^^^^
wrong wrong
The fix is surprisingly simple, for all this analysis - just stop
the rebalance on the out-of leaf case from overwriting the new attr
index - it's already correct for the double split case.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-11-12 04:09:44 -07:00
|
|
|
ASSERT(0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Figure the total bytes to be added to the destination leaf.
|
|
|
|
*/
|
|
|
|
/* number entries being moved */
|
2013-04-24 02:58:55 -06:00
|
|
|
count -= ichdr1.count;
|
|
|
|
space = totallen - ichdr1.usedbytes;
|
2005-04-16 16:20:36 -06:00
|
|
|
space += count * sizeof(xfs_attr_leaf_entry_t);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* leaf1 is the destination, compact it if it looks tight.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
max = ichdr1.firstused - xfs_attr3_leaf_hdr_size(leaf1);
|
|
|
|
max -= ichdr1.count * sizeof(xfs_attr_leaf_entry_t);
|
2012-11-12 04:53:53 -07:00
|
|
|
if (space > max)
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_compact(args, &ichdr1, blk1->bp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Move low entries from leaf2 to high end of leaf1.
|
|
|
|
*/
|
2014-06-05 23:21:45 -06:00
|
|
|
xfs_attr3_leaf_moveents(args, leaf2, &ichdr2, 0, leaf1, &ichdr1,
|
|
|
|
ichdr1.count, count);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_to_disk(state->args->geo, leaf1, &ichdr1);
|
|
|
|
xfs_attr3_leaf_hdr_to_disk(state->args->geo, leaf2, &ichdr2);
|
2014-06-05 23:22:04 -06:00
|
|
|
xfs_trans_log_buf(args->trans, blk1->bp, 0, args->geo->blksize - 1);
|
|
|
|
xfs_trans_log_buf(args->trans, blk2->bp, 0, args->geo->blksize - 1);
|
2013-04-24 02:58:55 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Copy out last hashval in each block for B-tree code.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
entries1 = xfs_attr3_leaf_entryp(leaf1);
|
|
|
|
entries2 = xfs_attr3_leaf_entryp(leaf2);
|
|
|
|
blk1->hashval = be32_to_cpu(entries1[ichdr1.count - 1].hashval);
|
|
|
|
blk2->hashval = be32_to_cpu(entries2[ichdr2.count - 1].hashval);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Adjust the expected index for insertion.
|
|
|
|
* NOTE: this code depends on the (current) situation that the
|
|
|
|
* second block was originally empty.
|
|
|
|
*
|
|
|
|
* If the insertion point moved to the 2nd block, we must adjust
|
|
|
|
* the index. We must also track the entry just following the
|
|
|
|
* new entry for use in an "atomic rename" operation, that entry
|
|
|
|
* is always the "old" entry and the "new" entry is what we are
|
|
|
|
* inserting. The index/blkno fields refer to the "old" entry,
|
|
|
|
* while the index2/blkno2 fields refer to the "new" entry.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
if (blk1->index > ichdr1.count) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(state->inleaf == 0);
|
2013-04-24 02:58:55 -06:00
|
|
|
blk2->index = blk1->index - ichdr1.count;
|
2005-04-16 16:20:36 -06:00
|
|
|
args->index = args->index2 = blk2->index;
|
|
|
|
args->blkno = args->blkno2 = blk2->blkno;
|
2013-04-24 02:58:55 -06:00
|
|
|
} else if (blk1->index == ichdr1.count) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (state->inleaf) {
|
|
|
|
args->index = blk1->index;
|
|
|
|
args->blkno = blk1->blkno;
|
|
|
|
args->index2 = 0;
|
|
|
|
args->blkno2 = blk2->blkno;
|
|
|
|
} else {
|
xfs: fix attr tree double split corruption
In certain circumstances, a double split of an attribute tree is
needed to insert or replace an attribute. In rare situations, this
can go wrong, leaving the attribute tree corrupted. In this case,
the attr being replaced is the last attr in a leaf node, and the
replacement is larger so doesn't fit in the same leaf node.
When we have the initial condition of a node format attribute
btree with two leaves at index 1 and 2. Call them L1 and L2. The
leaf L1 is completely full, there is not a single byte of free space
in it. L2 is mostly empty. The attribute being replaced - call it X
- is the last attribute in L1.
The way an attribute replace is executed is that the replacement
attribute - call it Y - is first inserted into the tree, but has an
INCOMPLETE flag set on it so that list traversals ignore it. Once
this transaction is committed, a second transaction it run to
atomically mark Y as COMPLETE and X as INCOMPLETE, so that a
traversal will now find Y and skip X. Once that transaction is
committed, attribute X is then removed.
So, the initial condition is:
+--------+ +--------+
| L1 | | L2 |
| fwd: 2 |---->| fwd: 0 |
| bwd: 0 |<----| bwd: 1 |
| fsp: 0 | | fsp: N |
|--------| |--------|
| attr A | | attr 1 |
|--------| |--------|
| attr B | | attr 2 |
|--------| |--------|
.......... ..........
|--------| |--------|
| attr X | | attr n |
+--------+ +--------+
So now we go to replace X, and see that L1:fsp = 0 - it is full so
we can't insert Y in the same leaf. So we record the the location of
attribute X so we can track it for later use, then we split L1 into
L1 and L3 and reblance across the two leafs. We end with:
+--------+ +--------+ +--------+
| L1 | | L3 | | L2 |
| fwd: 3 |---->| fwd: 2 |---->| fwd: 0 |
| bwd: 0 |<----| bwd: 1 |<----| bwd: 3 |
| fsp: M | | fsp: J | | fsp: N |
|--------| |--------| |--------|
| attr A | | attr X | | attr 1 |
|--------| +--------+ |--------|
| attr B | | attr 2 |
|--------| |--------|
.......... ..........
|--------| |--------|
| attr W | | attr n |
+--------+ +--------+
And we track that the original attribute is now at L3:0.
We then try to insert Y into L1 again, and find that there isn't
enough room because the new attribute is larger than the old one.
Hence we have to split again to make room for Y. We end up with
this:
+--------+ +--------+ +--------+ +--------+
| L1 | | L4 | | L3 | | L2 |
| fwd: 4 |---->| fwd: 3 |---->| fwd: 2 |---->| fwd: 0 |
| bwd: 0 |<----| bwd: 1 |<----| bwd: 4 |<----| bwd: 3 |
| fsp: M | | fsp: J | | fsp: J | | fsp: N |
|--------| |--------| |--------| |--------|
| attr A | | attr Y | | attr X | | attr 1 |
|--------| + INCOMP + +--------+ |--------|
| attr B | +--------+ | attr 2 |
|--------| |--------|
.......... ..........
|--------| |--------|
| attr W | | attr n |
+--------+ +--------+
And now we have the new (incomplete) attribute @ L4:0, and the
original attribute at L3:0. At this point, the first transaction is
committed, and we move to the flipping of the flags.
This is where we are supposed to end up with this:
+--------+ +--------+ +--------+ +--------+
| L1 | | L4 | | L3 | | L2 |
| fwd: 4 |---->| fwd: 3 |---->| fwd: 2 |---->| fwd: 0 |
| bwd: 0 |<----| bwd: 1 |<----| bwd: 4 |<----| bwd: 3 |
| fsp: M | | fsp: J | | fsp: J | | fsp: N |
|--------| |--------| |--------| |--------|
| attr A | | attr Y | | attr X | | attr 1 |
|--------| +--------+ + INCOMP + |--------|
| attr B | +--------+ | attr 2 |
|--------| |--------|
.......... ..........
|--------| |--------|
| attr W | | attr n |
+--------+ +--------+
But that doesn't happen properly - the attribute tracking indexes
are not pointing to the right locations. What we end up with is both
the old attribute to be removed pointing at L4:0 and the new
attribute at L4:1. On a debug kernel, this assert fails like so:
XFS: Assertion failed: args->index2 < be16_to_cpu(leaf2->hdr.count), file: fs/xfs/xfs_attr_leaf.c, line: 2725
because the new attribute location does not exist. On a production
kernel, this goes unnoticed and the code proceeds ahead merrily and
removes L4 because it thinks that is the block that is no longer
needed. This leaves the hash index node pointing to entries
L1, L4 and L2, but only blocks L1, L3 and L2 to exist. Further, the
leaf level sibling list is L1 <-> L4 <-> L2, but L4 is now free
space, and so everything is busted. This corruption is caused by the
removal of the old attribute triggering a join - it joins everything
correctly but then frees the wrong block.
xfs_repair will report something like:
bad sibling back pointer for block 4 in attribute fork for inode 131
problem with attribute contents in inode 131
would clear attr fork
bad nblocks 8 for inode 131, would reset to 3
bad anextents 4 for inode 131, would reset to 0
The problem lies in the assignment of the old/new blocks for
tracking purposes when the double leaf split occurs. The first split
tries to place the new attribute inside the current leaf (i.e.
"inleaf == true") and moves the old attribute (X) to the new block.
This sets up the old block/index to L1:X, and newly allocated
block to L3:0. It then moves attr X to the new block and tries to
insert attr Y at the old index. That fails, so it splits again.
With the second split, the rebalance ends up placing the new attr in
the second new block - L4:0 - and this is where the code goes wrong.
What is does is it sets both the new and old block index to the
second new block. Hence it inserts attr Y at the right place (L4:0)
but overwrites the current location of the attr to replace that is
held in the new block index (currently L3:0). It over writes it with
L4:1 - the index we later assert fail on.
Hopefully this table will show this in a foramt that is a bit easier
to understand:
Split old attr index new attr index
vanilla patched vanilla patched
before 1st L1:26 L1:26 N/A N/A
after 1st L3:0 L3:0 L1:26 L1:26
after 2nd L4:0 L3:0 L4:1 L4:0
^^^^ ^^^^
wrong wrong
The fix is surprisingly simple, for all this analysis - just stop
the rebalance on the out-of leaf case from overwriting the new attr
index - it's already correct for the double split case.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-11-12 04:09:44 -07:00
|
|
|
/*
|
|
|
|
* On a double leaf split, the original attr location
|
|
|
|
* is already stored in blkno2/index2, so don't
|
|
|
|
* overwrite it overwise we corrupt the tree.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
blk2->index = blk1->index - ichdr1.count;
|
xfs: fix attr tree double split corruption
In certain circumstances, a double split of an attribute tree is
needed to insert or replace an attribute. In rare situations, this
can go wrong, leaving the attribute tree corrupted. In this case,
the attr being replaced is the last attr in a leaf node, and the
replacement is larger so doesn't fit in the same leaf node.
When we have the initial condition of a node format attribute
btree with two leaves at index 1 and 2. Call them L1 and L2. The
leaf L1 is completely full, there is not a single byte of free space
in it. L2 is mostly empty. The attribute being replaced - call it X
- is the last attribute in L1.
The way an attribute replace is executed is that the replacement
attribute - call it Y - is first inserted into the tree, but has an
INCOMPLETE flag set on it so that list traversals ignore it. Once
this transaction is committed, a second transaction it run to
atomically mark Y as COMPLETE and X as INCOMPLETE, so that a
traversal will now find Y and skip X. Once that transaction is
committed, attribute X is then removed.
So, the initial condition is:
+--------+ +--------+
| L1 | | L2 |
| fwd: 2 |---->| fwd: 0 |
| bwd: 0 |<----| bwd: 1 |
| fsp: 0 | | fsp: N |
|--------| |--------|
| attr A | | attr 1 |
|--------| |--------|
| attr B | | attr 2 |
|--------| |--------|
.......... ..........
|--------| |--------|
| attr X | | attr n |
+--------+ +--------+
So now we go to replace X, and see that L1:fsp = 0 - it is full so
we can't insert Y in the same leaf. So we record the the location of
attribute X so we can track it for later use, then we split L1 into
L1 and L3 and reblance across the two leafs. We end with:
+--------+ +--------+ +--------+
| L1 | | L3 | | L2 |
| fwd: 3 |---->| fwd: 2 |---->| fwd: 0 |
| bwd: 0 |<----| bwd: 1 |<----| bwd: 3 |
| fsp: M | | fsp: J | | fsp: N |
|--------| |--------| |--------|
| attr A | | attr X | | attr 1 |
|--------| +--------+ |--------|
| attr B | | attr 2 |
|--------| |--------|
.......... ..........
|--------| |--------|
| attr W | | attr n |
+--------+ +--------+
And we track that the original attribute is now at L3:0.
We then try to insert Y into L1 again, and find that there isn't
enough room because the new attribute is larger than the old one.
Hence we have to split again to make room for Y. We end up with
this:
+--------+ +--------+ +--------+ +--------+
| L1 | | L4 | | L3 | | L2 |
| fwd: 4 |---->| fwd: 3 |---->| fwd: 2 |---->| fwd: 0 |
| bwd: 0 |<----| bwd: 1 |<----| bwd: 4 |<----| bwd: 3 |
| fsp: M | | fsp: J | | fsp: J | | fsp: N |
|--------| |--------| |--------| |--------|
| attr A | | attr Y | | attr X | | attr 1 |
|--------| + INCOMP + +--------+ |--------|
| attr B | +--------+ | attr 2 |
|--------| |--------|
.......... ..........
|--------| |--------|
| attr W | | attr n |
+--------+ +--------+
And now we have the new (incomplete) attribute @ L4:0, and the
original attribute at L3:0. At this point, the first transaction is
committed, and we move to the flipping of the flags.
This is where we are supposed to end up with this:
+--------+ +--------+ +--------+ +--------+
| L1 | | L4 | | L3 | | L2 |
| fwd: 4 |---->| fwd: 3 |---->| fwd: 2 |---->| fwd: 0 |
| bwd: 0 |<----| bwd: 1 |<----| bwd: 4 |<----| bwd: 3 |
| fsp: M | | fsp: J | | fsp: J | | fsp: N |
|--------| |--------| |--------| |--------|
| attr A | | attr Y | | attr X | | attr 1 |
|--------| +--------+ + INCOMP + |--------|
| attr B | +--------+ | attr 2 |
|--------| |--------|
.......... ..........
|--------| |--------|
| attr W | | attr n |
+--------+ +--------+
But that doesn't happen properly - the attribute tracking indexes
are not pointing to the right locations. What we end up with is both
the old attribute to be removed pointing at L4:0 and the new
attribute at L4:1. On a debug kernel, this assert fails like so:
XFS: Assertion failed: args->index2 < be16_to_cpu(leaf2->hdr.count), file: fs/xfs/xfs_attr_leaf.c, line: 2725
because the new attribute location does not exist. On a production
kernel, this goes unnoticed and the code proceeds ahead merrily and
removes L4 because it thinks that is the block that is no longer
needed. This leaves the hash index node pointing to entries
L1, L4 and L2, but only blocks L1, L3 and L2 to exist. Further, the
leaf level sibling list is L1 <-> L4 <-> L2, but L4 is now free
space, and so everything is busted. This corruption is caused by the
removal of the old attribute triggering a join - it joins everything
correctly but then frees the wrong block.
xfs_repair will report something like:
bad sibling back pointer for block 4 in attribute fork for inode 131
problem with attribute contents in inode 131
would clear attr fork
bad nblocks 8 for inode 131, would reset to 3
bad anextents 4 for inode 131, would reset to 0
The problem lies in the assignment of the old/new blocks for
tracking purposes when the double leaf split occurs. The first split
tries to place the new attribute inside the current leaf (i.e.
"inleaf == true") and moves the old attribute (X) to the new block.
This sets up the old block/index to L1:X, and newly allocated
block to L3:0. It then moves attr X to the new block and tries to
insert attr Y at the old index. That fails, so it splits again.
With the second split, the rebalance ends up placing the new attr in
the second new block - L4:0 - and this is where the code goes wrong.
What is does is it sets both the new and old block index to the
second new block. Hence it inserts attr Y at the right place (L4:0)
but overwrites the current location of the attr to replace that is
held in the new block index (currently L3:0). It over writes it with
L4:1 - the index we later assert fail on.
Hopefully this table will show this in a foramt that is a bit easier
to understand:
Split old attr index new attr index
vanilla patched vanilla patched
before 1st L1:26 L1:26 N/A N/A
after 1st L3:0 L3:0 L1:26 L1:26
after 2nd L4:0 L3:0 L4:1 L4:0
^^^^ ^^^^
wrong wrong
The fix is surprisingly simple, for all this analysis - just stop
the rebalance on the out-of leaf case from overwriting the new attr
index - it's already correct for the double split case.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-11-12 04:09:44 -07:00
|
|
|
args->index = blk2->index;
|
|
|
|
args->blkno = blk2->blkno;
|
|
|
|
if (!state->extravalid) {
|
|
|
|
/*
|
|
|
|
* set the new attr location to match the old
|
|
|
|
* one and let the higher level split code
|
|
|
|
* decide where in the leaf to place it.
|
|
|
|
*/
|
|
|
|
args->index2 = blk2->index;
|
|
|
|
args->blkno2 = blk2->blkno;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ASSERT(state->inleaf == 1);
|
|
|
|
args->index = args->index2 = blk1->index;
|
|
|
|
args->blkno = args->blkno2 = blk1->blkno;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Examine entries until we reduce the absolute difference in
|
|
|
|
* byte usage between the two blocks to a minimum.
|
|
|
|
* GROT: Is this really necessary? With other than a 512 byte blocksize,
|
|
|
|
* GROT: there will always be enough room in either block for a new entry.
|
|
|
|
* GROT: Do a double-split for this case?
|
|
|
|
*/
|
|
|
|
STATIC int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_figure_balance(
|
|
|
|
struct xfs_da_state *state,
|
|
|
|
struct xfs_da_state_blk *blk1,
|
|
|
|
struct xfs_attr3_icleaf_hdr *ichdr1,
|
|
|
|
struct xfs_da_state_blk *blk2,
|
|
|
|
struct xfs_attr3_icleaf_hdr *ichdr2,
|
|
|
|
int *countarg,
|
|
|
|
int *usedbytesarg)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf1 = blk1->bp->b_addr;
|
|
|
|
struct xfs_attr_leafblock *leaf2 = blk2->bp->b_addr;
|
|
|
|
struct xfs_attr_leaf_entry *entry;
|
|
|
|
int count;
|
|
|
|
int max;
|
|
|
|
int index;
|
|
|
|
int totallen = 0;
|
|
|
|
int half;
|
|
|
|
int lastdelta;
|
|
|
|
int foundit = 0;
|
|
|
|
int tmp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Examine entries until we reduce the absolute difference in
|
|
|
|
* byte usage between the two blocks to a minimum.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
max = ichdr1->count + ichdr2->count;
|
|
|
|
half = (max + 1) * sizeof(*entry);
|
|
|
|
half += ichdr1->usedbytes + ichdr2->usedbytes +
|
2014-06-05 23:21:27 -06:00
|
|
|
xfs_attr_leaf_newentsize(state->args, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
half /= 2;
|
2014-06-05 23:22:04 -06:00
|
|
|
lastdelta = state->args->geo->blksize;
|
2013-04-24 02:58:55 -06:00
|
|
|
entry = xfs_attr3_leaf_entryp(leaf1);
|
2005-04-16 16:20:36 -06:00
|
|
|
for (count = index = 0; count < max; entry++, index++, count++) {
|
|
|
|
|
|
|
|
#define XFS_ATTR_ABS(A) (((A) < 0) ? -(A) : (A))
|
|
|
|
/*
|
|
|
|
* The new entry is in the first block, account for it.
|
|
|
|
*/
|
|
|
|
if (count == blk1->index) {
|
|
|
|
tmp = totallen + sizeof(*entry) +
|
2014-06-05 23:21:27 -06:00
|
|
|
xfs_attr_leaf_newentsize(state->args, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (XFS_ATTR_ABS(half - tmp) > lastdelta)
|
|
|
|
break;
|
|
|
|
lastdelta = XFS_ATTR_ABS(half - tmp);
|
|
|
|
totallen = tmp;
|
|
|
|
foundit = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wrap around into the second block if necessary.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
if (count == ichdr1->count) {
|
2005-04-16 16:20:36 -06:00
|
|
|
leaf1 = leaf2;
|
2013-04-24 02:58:55 -06:00
|
|
|
entry = xfs_attr3_leaf_entryp(leaf1);
|
2005-04-16 16:20:36 -06:00
|
|
|
index = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Figure out if next leaf entry would be too much.
|
|
|
|
*/
|
|
|
|
tmp = totallen + sizeof(*entry) + xfs_attr_leaf_entsize(leaf1,
|
|
|
|
index);
|
|
|
|
if (XFS_ATTR_ABS(half - tmp) > lastdelta)
|
|
|
|
break;
|
|
|
|
lastdelta = XFS_ATTR_ABS(half - tmp);
|
|
|
|
totallen = tmp;
|
|
|
|
#undef XFS_ATTR_ABS
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate the number of usedbytes that will end up in lower block.
|
|
|
|
* If new entry not in lower block, fix up the count.
|
|
|
|
*/
|
|
|
|
totallen -= count * sizeof(*entry);
|
|
|
|
if (foundit) {
|
|
|
|
totallen -= sizeof(*entry) +
|
2014-06-05 23:21:27 -06:00
|
|
|
xfs_attr_leaf_newentsize(state->args, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
*countarg = count;
|
|
|
|
*usedbytesarg = totallen;
|
2013-04-24 02:58:55 -06:00
|
|
|
return foundit;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*========================================================================
|
|
|
|
* Routines used for shrinking the Btree.
|
|
|
|
*========================================================================*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check a leaf block and its neighbors to see if the block should be
|
|
|
|
* collapsed into one or the other neighbor. Always keep the block
|
|
|
|
* with the smaller block number.
|
|
|
|
* If the current block is over 50% full, don't try to join it, return 0.
|
|
|
|
* If the block is empty, fill in the state structure and return 2.
|
|
|
|
* If it can be collapsed, fill in the state structure and return 1.
|
|
|
|
* If nothing can be done, return 0.
|
|
|
|
*
|
|
|
|
* GROT: allow for INCOMPLETE entries in calculation.
|
|
|
|
*/
|
|
|
|
int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_toosmall(
|
|
|
|
struct xfs_da_state *state,
|
|
|
|
int *action)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf;
|
|
|
|
struct xfs_da_state_blk *blk;
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr;
|
|
|
|
struct xfs_buf *bp;
|
|
|
|
xfs_dablk_t blkno;
|
|
|
|
int bytes;
|
|
|
|
int forward;
|
|
|
|
int error;
|
|
|
|
int retval;
|
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-11-12 04:53:53 -07:00
|
|
|
trace_xfs_attr_leaf_toosmall(state->args);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Check for the degenerate case of the block being over 50% full.
|
|
|
|
* If so, it's not worth even looking to see if we might be able
|
|
|
|
* to coalesce with a sibling.
|
|
|
|
*/
|
|
|
|
blk = &state->path.blk[ state->path.active-1 ];
|
2013-04-24 02:58:55 -06:00
|
|
|
leaf = blk->bp->b_addr;
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr, leaf);
|
2013-04-24 02:58:55 -06:00
|
|
|
bytes = xfs_attr3_leaf_hdr_size(leaf) +
|
|
|
|
ichdr.count * sizeof(xfs_attr_leaf_entry_t) +
|
|
|
|
ichdr.usedbytes;
|
2014-06-05 23:22:04 -06:00
|
|
|
if (bytes > (state->args->geo->blksize >> 1)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
*action = 0; /* blk over 50%, don't try to join */
|
2014-06-21 23:03:54 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for the degenerate case of the block being empty.
|
|
|
|
* If the block is empty, we'll simply delete it, no need to
|
2006-03-28 15:55:14 -07:00
|
|
|
* coalesce it with a sibling block. We choose (arbitrarily)
|
2005-04-16 16:20:36 -06:00
|
|
|
* to merge with the forward block unless it is NULL.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
if (ichdr.count == 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Make altpath point to the block we want to keep and
|
|
|
|
* path point to the block we want to drop (this one).
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
forward = (ichdr.forw != 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
memcpy(&state->altpath, &state->path, sizeof(state->path));
|
2013-04-24 02:58:02 -06:00
|
|
|
error = xfs_da3_path_shift(state, &state->altpath, forward,
|
2005-04-16 16:20:36 -06:00
|
|
|
0, &retval);
|
|
|
|
if (error)
|
2014-06-21 23:03:54 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (retval) {
|
|
|
|
*action = 0;
|
|
|
|
} else {
|
|
|
|
*action = 2;
|
|
|
|
}
|
2013-04-24 02:58:55 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Examine each sibling block to see if we can coalesce with
|
|
|
|
* at least 25% free space to spare. We need to figure out
|
|
|
|
* whether to merge with the forward or the backward block.
|
|
|
|
* We prefer coalescing with the lower numbered sibling so as
|
|
|
|
* to shrink an attribute list over time.
|
|
|
|
*/
|
|
|
|
/* start with smaller blk num */
|
2013-04-24 02:58:55 -06:00
|
|
|
forward = ichdr.forw < ichdr.back;
|
2005-04-16 16:20:36 -06:00
|
|
|
for (i = 0; i < 2; forward = !forward, i++) {
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr3_icleaf_hdr ichdr2;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (forward)
|
2013-04-24 02:58:55 -06:00
|
|
|
blkno = ichdr.forw;
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2013-04-24 02:58:55 -06:00
|
|
|
blkno = ichdr.back;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (blkno == 0)
|
|
|
|
continue;
|
2013-04-24 02:58:55 -06:00
|
|
|
error = xfs_attr3_leaf_read(state->args->trans, state->args->dp,
|
2012-11-12 04:54:16 -07:00
|
|
|
blkno, -1, &bp);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error)
|
2014-06-21 23:03:54 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr2, bp->b_addr);
|
2013-04-24 02:58:55 -06:00
|
|
|
|
2014-06-05 23:22:04 -06:00
|
|
|
bytes = state->args->geo->blksize -
|
|
|
|
(state->args->geo->blksize >> 2) -
|
2013-04-24 02:58:55 -06:00
|
|
|
ichdr.usedbytes - ichdr2.usedbytes -
|
|
|
|
((ichdr.count + ichdr2.count) *
|
|
|
|
sizeof(xfs_attr_leaf_entry_t)) -
|
|
|
|
xfs_attr3_leaf_hdr_size(leaf);
|
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_brelse(state->args->trans, bp);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (bytes >= 0)
|
|
|
|
break; /* fits with at least 25% to spare */
|
|
|
|
}
|
|
|
|
if (i >= 2) {
|
|
|
|
*action = 0;
|
2014-06-21 23:03:54 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make altpath point to the block we want to keep (the lower
|
|
|
|
* numbered block) and path point to the block we want to drop.
|
|
|
|
*/
|
|
|
|
memcpy(&state->altpath, &state->path, sizeof(state->path));
|
|
|
|
if (blkno < blk->blkno) {
|
2013-04-24 02:58:02 -06:00
|
|
|
error = xfs_da3_path_shift(state, &state->altpath, forward,
|
2005-04-16 16:20:36 -06:00
|
|
|
0, &retval);
|
|
|
|
} else {
|
2013-04-24 02:58:02 -06:00
|
|
|
error = xfs_da3_path_shift(state, &state->path, forward,
|
2005-04-16 16:20:36 -06:00
|
|
|
0, &retval);
|
|
|
|
}
|
|
|
|
if (error)
|
2014-06-21 23:03:54 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (retval) {
|
|
|
|
*action = 0;
|
|
|
|
} else {
|
|
|
|
*action = 1;
|
|
|
|
}
|
2014-06-21 23:03:54 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove a name from the leaf attribute list structure.
|
|
|
|
*
|
|
|
|
* Return 1 if leaf is less than 37% full, 0 if >= 37% full.
|
|
|
|
* If two leaves are 37% full, when combined they will leave 25% free.
|
|
|
|
*/
|
|
|
|
int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_remove(
|
|
|
|
struct xfs_buf *bp,
|
|
|
|
struct xfs_da_args *args)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf;
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr;
|
|
|
|
struct xfs_attr_leaf_entry *entry;
|
|
|
|
int before;
|
|
|
|
int after;
|
|
|
|
int smallest;
|
|
|
|
int entsize;
|
|
|
|
int tablesize;
|
|
|
|
int tmp;
|
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-11-12 04:53:53 -07:00
|
|
|
trace_xfs_attr_leaf_remove(args);
|
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf = bp->b_addr;
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
|
2013-04-24 02:58:55 -06:00
|
|
|
|
2014-06-05 23:21:45 -06:00
|
|
|
ASSERT(ichdr.count > 0 && ichdr.count < args->geo->blksize / 8);
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(args->index >= 0 && args->index < ichdr.count);
|
|
|
|
ASSERT(ichdr.firstused >= ichdr.count * sizeof(*entry) +
|
|
|
|
xfs_attr3_leaf_hdr_size(leaf));
|
|
|
|
|
|
|
|
entry = &xfs_attr3_leaf_entryp(leaf)[args->index];
|
|
|
|
|
|
|
|
ASSERT(be16_to_cpu(entry->nameidx) >= ichdr.firstused);
|
2014-06-05 23:21:45 -06:00
|
|
|
ASSERT(be16_to_cpu(entry->nameidx) < args->geo->blksize);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Scan through free region table:
|
|
|
|
* check for adjacency of free'd entry with an existing one,
|
|
|
|
* find smallest free region in case we need to replace it,
|
|
|
|
* adjust any map that borders the entry table,
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
tablesize = ichdr.count * sizeof(xfs_attr_leaf_entry_t)
|
|
|
|
+ xfs_attr3_leaf_hdr_size(leaf);
|
|
|
|
tmp = ichdr.freemap[0].size;
|
2005-04-16 16:20:36 -06:00
|
|
|
before = after = -1;
|
|
|
|
smallest = XFS_ATTR_LEAF_MAPSIZE - 1;
|
|
|
|
entsize = xfs_attr_leaf_entsize(leaf, args->index);
|
2013-04-24 02:58:55 -06:00
|
|
|
for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
|
2014-06-05 23:21:45 -06:00
|
|
|
ASSERT(ichdr.freemap[i].base < args->geo->blksize);
|
|
|
|
ASSERT(ichdr.freemap[i].size < args->geo->blksize);
|
2013-04-24 02:58:55 -06:00
|
|
|
if (ichdr.freemap[i].base == tablesize) {
|
|
|
|
ichdr.freemap[i].base -= sizeof(xfs_attr_leaf_entry_t);
|
|
|
|
ichdr.freemap[i].size += sizeof(xfs_attr_leaf_entry_t);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
if (ichdr.freemap[i].base + ichdr.freemap[i].size ==
|
|
|
|
be16_to_cpu(entry->nameidx)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
before = i;
|
2013-04-24 02:58:55 -06:00
|
|
|
} else if (ichdr.freemap[i].base ==
|
|
|
|
(be16_to_cpu(entry->nameidx) + entsize)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
after = i;
|
2013-04-24 02:58:55 -06:00
|
|
|
} else if (ichdr.freemap[i].size < tmp) {
|
|
|
|
tmp = ichdr.freemap[i].size;
|
2005-04-16 16:20:36 -06:00
|
|
|
smallest = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Coalesce adjacent freemap regions,
|
|
|
|
* or replace the smallest region.
|
|
|
|
*/
|
|
|
|
if ((before >= 0) || (after >= 0)) {
|
|
|
|
if ((before >= 0) && (after >= 0)) {
|
2013-04-24 02:58:55 -06:00
|
|
|
ichdr.freemap[before].size += entsize;
|
|
|
|
ichdr.freemap[before].size += ichdr.freemap[after].size;
|
|
|
|
ichdr.freemap[after].base = 0;
|
|
|
|
ichdr.freemap[after].size = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else if (before >= 0) {
|
2013-04-24 02:58:55 -06:00
|
|
|
ichdr.freemap[before].size += entsize;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2013-04-24 02:58:55 -06:00
|
|
|
ichdr.freemap[after].base = be16_to_cpu(entry->nameidx);
|
|
|
|
ichdr.freemap[after].size += entsize;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Replace smallest region (if it is smaller than free'd entry)
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
if (ichdr.freemap[smallest].size < entsize) {
|
|
|
|
ichdr.freemap[smallest].base = be16_to_cpu(entry->nameidx);
|
|
|
|
ichdr.freemap[smallest].size = entsize;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Did we remove the first entry?
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
if (be16_to_cpu(entry->nameidx) == ichdr.firstused)
|
2005-04-16 16:20:36 -06:00
|
|
|
smallest = 1;
|
|
|
|
else
|
|
|
|
smallest = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compress the remaining entries and zero out the removed stuff.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
memset(xfs_attr3_leaf_name(leaf, args->index), 0, entsize);
|
|
|
|
ichdr.usedbytes -= entsize;
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp,
|
2013-04-24 02:58:55 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf, xfs_attr3_leaf_name(leaf, args->index),
|
2005-04-16 16:20:36 -06:00
|
|
|
entsize));
|
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
tmp = (ichdr.count - args->index) * sizeof(xfs_attr_leaf_entry_t);
|
|
|
|
memmove(entry, entry + 1, tmp);
|
|
|
|
ichdr.count--;
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp,
|
2013-04-24 02:58:55 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(xfs_attr_leaf_entry_t)));
|
|
|
|
|
|
|
|
entry = &xfs_attr3_leaf_entryp(leaf)[ichdr.count];
|
|
|
|
memset(entry, 0, sizeof(xfs_attr_leaf_entry_t));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we removed the first entry, re-find the first used byte
|
|
|
|
* in the name area. Note that if the entry was the "firstused",
|
|
|
|
* then we don't have a "hole" in our block resulting from
|
|
|
|
* removing the name.
|
|
|
|
*/
|
|
|
|
if (smallest) {
|
2014-06-05 23:21:45 -06:00
|
|
|
tmp = args->geo->blksize;
|
2013-04-24 02:58:55 -06:00
|
|
|
entry = xfs_attr3_leaf_entryp(leaf);
|
|
|
|
for (i = ichdr.count - 1; i >= 0; entry++, i--) {
|
|
|
|
ASSERT(be16_to_cpu(entry->nameidx) >= ichdr.firstused);
|
2014-06-05 23:21:45 -06:00
|
|
|
ASSERT(be16_to_cpu(entry->nameidx) < args->geo->blksize);
|
2006-03-16 23:29:02 -07:00
|
|
|
|
|
|
|
if (be16_to_cpu(entry->nameidx) < tmp)
|
|
|
|
tmp = be16_to_cpu(entry->nameidx);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2013-04-24 02:58:55 -06:00
|
|
|
ichdr.firstused = tmp;
|
2015-04-12 19:27:59 -06:00
|
|
|
ASSERT(ichdr.firstused != 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2013-04-24 02:58:55 -06:00
|
|
|
ichdr.holes = 1; /* mark as needing compaction */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr);
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp,
|
2013-04-24 02:58:55 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf, &leaf->hdr,
|
|
|
|
xfs_attr3_leaf_hdr_size(leaf)));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if leaf is less than 50% full, caller may want to
|
|
|
|
* "join" the leaf with a sibling if so.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
tmp = ichdr.usedbytes + xfs_attr3_leaf_hdr_size(leaf) +
|
|
|
|
ichdr.count * sizeof(xfs_attr_leaf_entry_t);
|
|
|
|
|
2014-06-05 23:18:10 -06:00
|
|
|
return tmp < args->geo->magicpct; /* leaf is < 37% full */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move all the attribute list entries from drop_leaf into save_leaf.
|
|
|
|
*/
|
|
|
|
void
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_unbalance(
|
|
|
|
struct xfs_da_state *state,
|
|
|
|
struct xfs_da_state_blk *drop_blk,
|
|
|
|
struct xfs_da_state_blk *save_blk)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *drop_leaf = drop_blk->bp->b_addr;
|
|
|
|
struct xfs_attr_leafblock *save_leaf = save_blk->bp->b_addr;
|
|
|
|
struct xfs_attr3_icleaf_hdr drophdr;
|
|
|
|
struct xfs_attr3_icleaf_hdr savehdr;
|
|
|
|
struct xfs_attr_leaf_entry *entry;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_leaf_unbalance(state->args);
|
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
drop_leaf = drop_blk->bp->b_addr;
|
|
|
|
save_leaf = save_blk->bp->b_addr;
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(state->args->geo, &drophdr, drop_leaf);
|
|
|
|
xfs_attr3_leaf_hdr_from_disk(state->args->geo, &savehdr, save_leaf);
|
2013-04-24 02:58:55 -06:00
|
|
|
entry = xfs_attr3_leaf_entryp(drop_leaf);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Save last hashval from dying block for later Btree fixup.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
drop_blk->hashval = be32_to_cpu(entry[drophdr.count - 1].hashval);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if we need a temp buffer, or can we do it in place.
|
|
|
|
* Note that we don't check "leaf" for holes because we will
|
|
|
|
* always be dropping it, toosmall() decided that for us already.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
if (savehdr.holes == 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* dest leaf has no holes, so we add there. May need
|
|
|
|
* to make some room in the entry array.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
if (xfs_attr3_leaf_order(save_blk->bp, &savehdr,
|
|
|
|
drop_blk->bp, &drophdr)) {
|
2014-06-05 23:21:45 -06:00
|
|
|
xfs_attr3_leaf_moveents(state->args,
|
|
|
|
drop_leaf, &drophdr, 0,
|
2013-04-24 02:58:55 -06:00
|
|
|
save_leaf, &savehdr, 0,
|
2014-06-05 23:21:45 -06:00
|
|
|
drophdr.count);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2014-06-05 23:21:45 -06:00
|
|
|
xfs_attr3_leaf_moveents(state->args,
|
|
|
|
drop_leaf, &drophdr, 0,
|
2013-04-24 02:58:55 -06:00
|
|
|
save_leaf, &savehdr,
|
2014-06-05 23:21:45 -06:00
|
|
|
savehdr.count, drophdr.count);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Destination has holes, so we make a temporary copy
|
|
|
|
* of the leaf and add them both to that.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *tmp_leaf;
|
|
|
|
struct xfs_attr3_icleaf_hdr tmphdr;
|
|
|
|
|
2014-06-05 23:22:04 -06:00
|
|
|
tmp_leaf = kmem_zalloc(state->args->geo->blksize, KM_SLEEP);
|
2013-05-21 02:02:05 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy the header into the temp leaf so that all the stuff
|
|
|
|
* not in the incore header is present and gets copied back in
|
|
|
|
* once we've moved all the entries.
|
|
|
|
*/
|
|
|
|
memcpy(tmp_leaf, save_leaf, xfs_attr3_leaf_hdr_size(save_leaf));
|
2013-04-24 02:58:55 -06:00
|
|
|
|
2013-05-21 02:02:05 -06:00
|
|
|
memset(&tmphdr, 0, sizeof(tmphdr));
|
2013-04-24 02:58:55 -06:00
|
|
|
tmphdr.magic = savehdr.magic;
|
|
|
|
tmphdr.forw = savehdr.forw;
|
|
|
|
tmphdr.back = savehdr.back;
|
2014-06-05 23:22:04 -06:00
|
|
|
tmphdr.firstused = state->args->geo->blksize;
|
2013-05-21 02:02:05 -06:00
|
|
|
|
|
|
|
/* write the header to the temp buffer to initialise it */
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_to_disk(state->args->geo, tmp_leaf, &tmphdr);
|
2013-05-21 02:02:05 -06:00
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
if (xfs_attr3_leaf_order(save_blk->bp, &savehdr,
|
|
|
|
drop_blk->bp, &drophdr)) {
|
2014-06-05 23:21:45 -06:00
|
|
|
xfs_attr3_leaf_moveents(state->args,
|
|
|
|
drop_leaf, &drophdr, 0,
|
2013-04-24 02:58:55 -06:00
|
|
|
tmp_leaf, &tmphdr, 0,
|
2014-06-05 23:21:45 -06:00
|
|
|
drophdr.count);
|
|
|
|
xfs_attr3_leaf_moveents(state->args,
|
|
|
|
save_leaf, &savehdr, 0,
|
2013-04-24 02:58:55 -06:00
|
|
|
tmp_leaf, &tmphdr, tmphdr.count,
|
2014-06-05 23:21:45 -06:00
|
|
|
savehdr.count);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2014-06-05 23:21:45 -06:00
|
|
|
xfs_attr3_leaf_moveents(state->args,
|
|
|
|
save_leaf, &savehdr, 0,
|
2013-04-24 02:58:55 -06:00
|
|
|
tmp_leaf, &tmphdr, 0,
|
2014-06-05 23:21:45 -06:00
|
|
|
savehdr.count);
|
|
|
|
xfs_attr3_leaf_moveents(state->args,
|
|
|
|
drop_leaf, &drophdr, 0,
|
2013-04-24 02:58:55 -06:00
|
|
|
tmp_leaf, &tmphdr, tmphdr.count,
|
2014-06-05 23:21:45 -06:00
|
|
|
drophdr.count);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2014-06-05 23:22:04 -06:00
|
|
|
memcpy(save_leaf, tmp_leaf, state->args->geo->blksize);
|
2013-04-24 02:58:55 -06:00
|
|
|
savehdr = tmphdr; /* struct copy */
|
|
|
|
kmem_free(tmp_leaf);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_to_disk(state->args->geo, save_leaf, &savehdr);
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(state->args->trans, save_blk->bp, 0,
|
2014-06-05 23:22:04 -06:00
|
|
|
state->args->geo->blksize - 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy out last hashval in each block for B-tree code.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
entry = xfs_attr3_leaf_entryp(save_leaf);
|
|
|
|
save_blk->hashval = be32_to_cpu(entry[savehdr.count - 1].hashval);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*========================================================================
|
|
|
|
* Routines used for finding things in the Btree.
|
|
|
|
*========================================================================*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Look up a name in a leaf attribute list structure.
|
|
|
|
* This is the internal routine, it uses the caller's buffer.
|
|
|
|
*
|
|
|
|
* Note that duplicate keys are allowed, but only check within the
|
|
|
|
* current leaf node. The Btree code must check in adjacent leaf nodes.
|
|
|
|
*
|
|
|
|
* Return in args->index the index into the entry[] array of either
|
|
|
|
* the found entry, or where the entry should have been (insert before
|
|
|
|
* that entry).
|
|
|
|
*
|
|
|
|
* Don't change the args->value unless we find the attribute.
|
|
|
|
*/
|
|
|
|
int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_lookup_int(
|
|
|
|
struct xfs_buf *bp,
|
|
|
|
struct xfs_da_args *args)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf;
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr;
|
|
|
|
struct xfs_attr_leaf_entry *entry;
|
|
|
|
struct xfs_attr_leaf_entry *entries;
|
|
|
|
struct xfs_attr_leaf_name_local *name_loc;
|
|
|
|
struct xfs_attr_leaf_name_remote *name_rmt;
|
|
|
|
xfs_dahash_t hashval;
|
|
|
|
int probe;
|
|
|
|
int span;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_leaf_lookup(args);
|
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf = bp->b_addr;
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
|
2013-04-24 02:58:55 -06:00
|
|
|
entries = xfs_attr3_leaf_entryp(leaf);
|
2014-06-05 23:21:45 -06:00
|
|
|
ASSERT(ichdr.count < args->geo->blksize / 8);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Binary search. (note: small blocks will skip this loop)
|
|
|
|
*/
|
|
|
|
hashval = args->hashval;
|
2013-04-24 02:58:55 -06:00
|
|
|
probe = span = ichdr.count / 2;
|
|
|
|
for (entry = &entries[probe]; span > 4; entry = &entries[probe]) {
|
2005-04-16 16:20:36 -06:00
|
|
|
span /= 2;
|
2006-03-16 23:29:02 -07:00
|
|
|
if (be32_to_cpu(entry->hashval) < hashval)
|
2005-04-16 16:20:36 -06:00
|
|
|
probe += span;
|
2006-03-16 23:29:02 -07:00
|
|
|
else if (be32_to_cpu(entry->hashval) > hashval)
|
2005-04-16 16:20:36 -06:00
|
|
|
probe -= span;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(probe >= 0 && (!ichdr.count || probe < ichdr.count));
|
|
|
|
ASSERT(span <= 4 || be32_to_cpu(entry->hashval) == hashval);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Since we may have duplicate hashval's, find the first matching
|
|
|
|
* hashval in the leaf.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
while (probe > 0 && be32_to_cpu(entry->hashval) >= hashval) {
|
2005-04-16 16:20:36 -06:00
|
|
|
entry--;
|
|
|
|
probe--;
|
|
|
|
}
|
2013-04-24 02:58:55 -06:00
|
|
|
while (probe < ichdr.count &&
|
|
|
|
be32_to_cpu(entry->hashval) < hashval) {
|
2005-04-16 16:20:36 -06:00
|
|
|
entry++;
|
|
|
|
probe++;
|
|
|
|
}
|
2013-04-24 02:58:55 -06:00
|
|
|
if (probe == ichdr.count || be32_to_cpu(entry->hashval) != hashval) {
|
2005-04-16 16:20:36 -06:00
|
|
|
args->index = probe;
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOATTR;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Duplicate keys may be present, so search all of them for a match.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
for (; probe < ichdr.count && (be32_to_cpu(entry->hashval) == hashval);
|
2005-04-16 16:20:36 -06:00
|
|
|
entry++, probe++) {
|
|
|
|
/*
|
|
|
|
* GROT: Add code to remove incomplete entries.
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* If we are looking for INCOMPLETE entries, show only those.
|
|
|
|
* If we are looking for complete entries, show only those.
|
|
|
|
*/
|
|
|
|
if ((args->flags & XFS_ATTR_INCOMPLETE) !=
|
|
|
|
(entry->flags & XFS_ATTR_INCOMPLETE)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (entry->flags & XFS_ATTR_LOCAL) {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_loc = xfs_attr3_leaf_name_local(leaf, probe);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (name_loc->namelen != args->namelen)
|
|
|
|
continue;
|
2013-04-24 02:58:55 -06:00
|
|
|
if (memcmp(args->name, name_loc->nameval,
|
|
|
|
args->namelen) != 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
2006-09-27 19:01:37 -06:00
|
|
|
if (!xfs_attr_namesp_match(args->flags, entry->flags))
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
|
|
|
args->index = probe;
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EEXIST;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_rmt = xfs_attr3_leaf_name_remote(leaf, probe);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (name_rmt->namelen != args->namelen)
|
|
|
|
continue;
|
2013-04-24 02:58:55 -06:00
|
|
|
if (memcmp(args->name, name_rmt->name,
|
|
|
|
args->namelen) != 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
2006-09-27 19:01:37 -06:00
|
|
|
if (!xfs_attr_namesp_match(args->flags, entry->flags))
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
|
|
|
args->index = probe;
|
xfs: remote attribute overwrite causes transaction overrun
Commit e461fcb ("xfs: remote attribute lookups require the value
length") passes the remote attribute length in the xfs_da_args
structure on lookup so that CRC calculations and validity checking
can be performed correctly by related code. This, unfortunately has
the side effect of changing the args->valuelen parameter in cases
where it shouldn't.
That is, when we replace a remote attribute, the incoming
replacement stores the value and length in args->value and
args->valuelen, but then the lookup which finds the existing remote
attribute overwrites args->valuelen with the length of the remote
attribute being replaced. Hence when we go to create the new
attribute, we create it of the size of the existing remote
attribute, not the size it is supposed to be. When the new attribute
is much smaller than the old attribute, this results in a
transaction overrun and an ASSERT() failure on a debug kernel:
XFS: Assertion failed: tp->t_blk_res_used <= tp->t_blk_res, file: fs/xfs/xfs_trans.c, line: 331
Fix this by keeping the remote attribute value length separate to
the attribute value length in the xfs_da_args structure. The enables
us to pass the length of the remote attribute to be removed without
overwriting the new attribute's length.
Also, ensure that when we save remote block contexts for a later
rename we zero the original state variables so that we don't confuse
the state of the attribute to be removes with the state of the new
attribute that we just added. [Spotted by Brain Foster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-05-05 15:37:31 -06:00
|
|
|
args->rmtvaluelen = be32_to_cpu(name_rmt->valuelen);
|
2006-03-16 23:29:18 -07:00
|
|
|
args->rmtblkno = be32_to_cpu(name_rmt->valueblk);
|
xfs: rework remote attr CRCs
Note: this changes the on-disk remote attribute format. I assert
that this is OK to do as CRCs are marked experimental and the first
kernel it is included in has not yet reached release yet. Further,
the userspace utilities are still evolving and so anyone using this
stuff right now is a developer or tester using volatile filesystems
for testing this feature. Hence changing the format right now to
save longer term pain is the right thing to do.
The fundamental change is to move from a header per extent in the
attribute to a header per filesytem block in the attribute. This
means there are more header blocks and the parsing of the attribute
data is slightly more complex, but it has the advantage that we
always know the size of the attribute on disk based on the length of
the data it contains.
This is where the header-per-extent method has problems. We don't
know the size of the attribute on disk without first knowing how
many extents are used to hold it. And we can't tell from a
mapping lookup, either, because remote attributes can be allocated
contiguously with other attribute blocks and so there is no obvious
way of determining the actual size of the atribute on disk short of
walking and mapping buffers.
The problem with this approach is that if we map a buffer
incorrectly (e.g. we make the last buffer for the attribute data too
long), we then get buffer cache lookup failure when we map it
correctly. i.e. we get a size mismatch on lookup. This is not
necessarily fatal, but it's a cache coherency problem that can lead
to returning the wrong data to userspace or writing the wrong data
to disk. And debug kernels will assert fail if this occurs.
I found lots of niggly little problems trying to fix this issue on a
4k block size filesystem, finally getting it to pass with lots of
fixes. The thing is, 1024 byte filesystems still failed, and it was
getting really complex handling all the corner cases that were
showing up. And there were clearly more that I hadn't found yet.
It is complex, fragile code, and if we don't fix it now, it will be
complex, fragile code forever more.
Hence the simple fix is to add a header to each filesystem block.
This gives us the same relationship between the attribute data
length and the number of blocks on disk as we have without CRCs -
it's a linear mapping and doesn't require us to guess anything. It
is simple to implement, too - the remote block count calculated at
lookup time can be used by the remote attribute set/get/remove code
without modification for both CRC and non-CRC filesystems. The world
becomes sane again.
Because the copy-in and copy-out now need to iterate over each
filesystem block, I moved them into helper functions so we separate
the block mapping and buffer manupulations from the attribute data
and CRC header manipulations. The code becomes much clearer as a
result, and it is a lot easier to understand and debug. It also
appears to be much more robust - once it worked on 4k block size
filesystems, it has worked without failure on 1k block size
filesystems, too.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-05-21 02:02:08 -06:00
|
|
|
args->rmtblkcnt = xfs_attr3_rmt_blocks(
|
|
|
|
args->dp->i_mount,
|
xfs: remote attribute overwrite causes transaction overrun
Commit e461fcb ("xfs: remote attribute lookups require the value
length") passes the remote attribute length in the xfs_da_args
structure on lookup so that CRC calculations and validity checking
can be performed correctly by related code. This, unfortunately has
the side effect of changing the args->valuelen parameter in cases
where it shouldn't.
That is, when we replace a remote attribute, the incoming
replacement stores the value and length in args->value and
args->valuelen, but then the lookup which finds the existing remote
attribute overwrites args->valuelen with the length of the remote
attribute being replaced. Hence when we go to create the new
attribute, we create it of the size of the existing remote
attribute, not the size it is supposed to be. When the new attribute
is much smaller than the old attribute, this results in a
transaction overrun and an ASSERT() failure on a debug kernel:
XFS: Assertion failed: tp->t_blk_res_used <= tp->t_blk_res, file: fs/xfs/xfs_trans.c, line: 331
Fix this by keeping the remote attribute value length separate to
the attribute value length in the xfs_da_args structure. The enables
us to pass the length of the remote attribute to be removed without
overwriting the new attribute's length.
Also, ensure that when we save remote block contexts for a later
rename we zero the original state variables so that we don't confuse
the state of the attribute to be removes with the state of the new
attribute that we just added. [Spotted by Brain Foster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-05-05 15:37:31 -06:00
|
|
|
args->rmtvaluelen);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EEXIST;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
args->index = probe;
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOATTR;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the value associated with an attribute name from a leaf attribute
|
|
|
|
* list structure.
|
|
|
|
*/
|
|
|
|
int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_getvalue(
|
|
|
|
struct xfs_buf *bp,
|
|
|
|
struct xfs_da_args *args)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf;
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr;
|
|
|
|
struct xfs_attr_leaf_entry *entry;
|
|
|
|
struct xfs_attr_leaf_name_local *name_loc;
|
|
|
|
struct xfs_attr_leaf_name_remote *name_rmt;
|
|
|
|
int valuelen;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf = bp->b_addr;
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
|
2014-06-05 23:21:45 -06:00
|
|
|
ASSERT(ichdr.count < args->geo->blksize / 8);
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(args->index < ichdr.count);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
entry = &xfs_attr3_leaf_entryp(leaf)[args->index];
|
2005-04-16 16:20:36 -06:00
|
|
|
if (entry->flags & XFS_ATTR_LOCAL) {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_loc = xfs_attr3_leaf_name_local(leaf, args->index);
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(name_loc->namelen == args->namelen);
|
|
|
|
ASSERT(memcmp(args->name, name_loc->nameval, args->namelen) == 0);
|
2006-03-16 23:29:09 -07:00
|
|
|
valuelen = be16_to_cpu(name_loc->valuelen);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (args->flags & ATTR_KERNOVAL) {
|
|
|
|
args->valuelen = valuelen;
|
2013-04-24 02:58:55 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (args->valuelen < valuelen) {
|
|
|
|
args->valuelen = valuelen;
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ERANGE;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
args->valuelen = valuelen;
|
|
|
|
memcpy(args->value, &name_loc->nameval[args->namelen], valuelen);
|
|
|
|
} else {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(name_rmt->namelen == args->namelen);
|
|
|
|
ASSERT(memcmp(args->name, name_rmt->name, args->namelen) == 0);
|
xfs: remote attribute overwrite causes transaction overrun
Commit e461fcb ("xfs: remote attribute lookups require the value
length") passes the remote attribute length in the xfs_da_args
structure on lookup so that CRC calculations and validity checking
can be performed correctly by related code. This, unfortunately has
the side effect of changing the args->valuelen parameter in cases
where it shouldn't.
That is, when we replace a remote attribute, the incoming
replacement stores the value and length in args->value and
args->valuelen, but then the lookup which finds the existing remote
attribute overwrites args->valuelen with the length of the remote
attribute being replaced. Hence when we go to create the new
attribute, we create it of the size of the existing remote
attribute, not the size it is supposed to be. When the new attribute
is much smaller than the old attribute, this results in a
transaction overrun and an ASSERT() failure on a debug kernel:
XFS: Assertion failed: tp->t_blk_res_used <= tp->t_blk_res, file: fs/xfs/xfs_trans.c, line: 331
Fix this by keeping the remote attribute value length separate to
the attribute value length in the xfs_da_args structure. The enables
us to pass the length of the remote attribute to be removed without
overwriting the new attribute's length.
Also, ensure that when we save remote block contexts for a later
rename we zero the original state variables so that we don't confuse
the state of the attribute to be removes with the state of the new
attribute that we just added. [Spotted by Brain Foster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-05-05 15:37:31 -06:00
|
|
|
args->rmtvaluelen = be32_to_cpu(name_rmt->valuelen);
|
2006-03-16 23:29:18 -07:00
|
|
|
args->rmtblkno = be32_to_cpu(name_rmt->valueblk);
|
xfs: rework remote attr CRCs
Note: this changes the on-disk remote attribute format. I assert
that this is OK to do as CRCs are marked experimental and the first
kernel it is included in has not yet reached release yet. Further,
the userspace utilities are still evolving and so anyone using this
stuff right now is a developer or tester using volatile filesystems
for testing this feature. Hence changing the format right now to
save longer term pain is the right thing to do.
The fundamental change is to move from a header per extent in the
attribute to a header per filesytem block in the attribute. This
means there are more header blocks and the parsing of the attribute
data is slightly more complex, but it has the advantage that we
always know the size of the attribute on disk based on the length of
the data it contains.
This is where the header-per-extent method has problems. We don't
know the size of the attribute on disk without first knowing how
many extents are used to hold it. And we can't tell from a
mapping lookup, either, because remote attributes can be allocated
contiguously with other attribute blocks and so there is no obvious
way of determining the actual size of the atribute on disk short of
walking and mapping buffers.
The problem with this approach is that if we map a buffer
incorrectly (e.g. we make the last buffer for the attribute data too
long), we then get buffer cache lookup failure when we map it
correctly. i.e. we get a size mismatch on lookup. This is not
necessarily fatal, but it's a cache coherency problem that can lead
to returning the wrong data to userspace or writing the wrong data
to disk. And debug kernels will assert fail if this occurs.
I found lots of niggly little problems trying to fix this issue on a
4k block size filesystem, finally getting it to pass with lots of
fixes. The thing is, 1024 byte filesystems still failed, and it was
getting really complex handling all the corner cases that were
showing up. And there were clearly more that I hadn't found yet.
It is complex, fragile code, and if we don't fix it now, it will be
complex, fragile code forever more.
Hence the simple fix is to add a header to each filesystem block.
This gives us the same relationship between the attribute data
length and the number of blocks on disk as we have without CRCs -
it's a linear mapping and doesn't require us to guess anything. It
is simple to implement, too - the remote block count calculated at
lookup time can be used by the remote attribute set/get/remove code
without modification for both CRC and non-CRC filesystems. The world
becomes sane again.
Because the copy-in and copy-out now need to iterate over each
filesystem block, I moved them into helper functions so we separate
the block mapping and buffer manupulations from the attribute data
and CRC header manipulations. The code becomes much clearer as a
result, and it is a lot easier to understand and debug. It also
appears to be much more robust - once it worked on 4k block size
filesystems, it has worked without failure on 1k block size
filesystems, too.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-05-21 02:02:08 -06:00
|
|
|
args->rmtblkcnt = xfs_attr3_rmt_blocks(args->dp->i_mount,
|
xfs: remote attribute overwrite causes transaction overrun
Commit e461fcb ("xfs: remote attribute lookups require the value
length") passes the remote attribute length in the xfs_da_args
structure on lookup so that CRC calculations and validity checking
can be performed correctly by related code. This, unfortunately has
the side effect of changing the args->valuelen parameter in cases
where it shouldn't.
That is, when we replace a remote attribute, the incoming
replacement stores the value and length in args->value and
args->valuelen, but then the lookup which finds the existing remote
attribute overwrites args->valuelen with the length of the remote
attribute being replaced. Hence when we go to create the new
attribute, we create it of the size of the existing remote
attribute, not the size it is supposed to be. When the new attribute
is much smaller than the old attribute, this results in a
transaction overrun and an ASSERT() failure on a debug kernel:
XFS: Assertion failed: tp->t_blk_res_used <= tp->t_blk_res, file: fs/xfs/xfs_trans.c, line: 331
Fix this by keeping the remote attribute value length separate to
the attribute value length in the xfs_da_args structure. The enables
us to pass the length of the remote attribute to be removed without
overwriting the new attribute's length.
Also, ensure that when we save remote block contexts for a later
rename we zero the original state variables so that we don't confuse
the state of the attribute to be removes with the state of the new
attribute that we just added. [Spotted by Brain Foster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-05-05 15:37:31 -06:00
|
|
|
args->rmtvaluelen);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (args->flags & ATTR_KERNOVAL) {
|
xfs: remote attribute overwrite causes transaction overrun
Commit e461fcb ("xfs: remote attribute lookups require the value
length") passes the remote attribute length in the xfs_da_args
structure on lookup so that CRC calculations and validity checking
can be performed correctly by related code. This, unfortunately has
the side effect of changing the args->valuelen parameter in cases
where it shouldn't.
That is, when we replace a remote attribute, the incoming
replacement stores the value and length in args->value and
args->valuelen, but then the lookup which finds the existing remote
attribute overwrites args->valuelen with the length of the remote
attribute being replaced. Hence when we go to create the new
attribute, we create it of the size of the existing remote
attribute, not the size it is supposed to be. When the new attribute
is much smaller than the old attribute, this results in a
transaction overrun and an ASSERT() failure on a debug kernel:
XFS: Assertion failed: tp->t_blk_res_used <= tp->t_blk_res, file: fs/xfs/xfs_trans.c, line: 331
Fix this by keeping the remote attribute value length separate to
the attribute value length in the xfs_da_args structure. The enables
us to pass the length of the remote attribute to be removed without
overwriting the new attribute's length.
Also, ensure that when we save remote block contexts for a later
rename we zero the original state variables so that we don't confuse
the state of the attribute to be removes with the state of the new
attribute that we just added. [Spotted by Brain Foster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-05-05 15:37:31 -06:00
|
|
|
args->valuelen = args->rmtvaluelen;
|
2013-04-24 02:58:55 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
xfs: remote attribute overwrite causes transaction overrun
Commit e461fcb ("xfs: remote attribute lookups require the value
length") passes the remote attribute length in the xfs_da_args
structure on lookup so that CRC calculations and validity checking
can be performed correctly by related code. This, unfortunately has
the side effect of changing the args->valuelen parameter in cases
where it shouldn't.
That is, when we replace a remote attribute, the incoming
replacement stores the value and length in args->value and
args->valuelen, but then the lookup which finds the existing remote
attribute overwrites args->valuelen with the length of the remote
attribute being replaced. Hence when we go to create the new
attribute, we create it of the size of the existing remote
attribute, not the size it is supposed to be. When the new attribute
is much smaller than the old attribute, this results in a
transaction overrun and an ASSERT() failure on a debug kernel:
XFS: Assertion failed: tp->t_blk_res_used <= tp->t_blk_res, file: fs/xfs/xfs_trans.c, line: 331
Fix this by keeping the remote attribute value length separate to
the attribute value length in the xfs_da_args structure. The enables
us to pass the length of the remote attribute to be removed without
overwriting the new attribute's length.
Also, ensure that when we save remote block contexts for a later
rename we zero the original state variables so that we don't confuse
the state of the attribute to be removes with the state of the new
attribute that we just added. [Spotted by Brain Foster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-05-05 15:37:31 -06:00
|
|
|
if (args->valuelen < args->rmtvaluelen) {
|
|
|
|
args->valuelen = args->rmtvaluelen;
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ERANGE;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
xfs: remote attribute overwrite causes transaction overrun
Commit e461fcb ("xfs: remote attribute lookups require the value
length") passes the remote attribute length in the xfs_da_args
structure on lookup so that CRC calculations and validity checking
can be performed correctly by related code. This, unfortunately has
the side effect of changing the args->valuelen parameter in cases
where it shouldn't.
That is, when we replace a remote attribute, the incoming
replacement stores the value and length in args->value and
args->valuelen, but then the lookup which finds the existing remote
attribute overwrites args->valuelen with the length of the remote
attribute being replaced. Hence when we go to create the new
attribute, we create it of the size of the existing remote
attribute, not the size it is supposed to be. When the new attribute
is much smaller than the old attribute, this results in a
transaction overrun and an ASSERT() failure on a debug kernel:
XFS: Assertion failed: tp->t_blk_res_used <= tp->t_blk_res, file: fs/xfs/xfs_trans.c, line: 331
Fix this by keeping the remote attribute value length separate to
the attribute value length in the xfs_da_args structure. The enables
us to pass the length of the remote attribute to be removed without
overwriting the new attribute's length.
Also, ensure that when we save remote block contexts for a later
rename we zero the original state variables so that we don't confuse
the state of the attribute to be removes with the state of the new
attribute that we just added. [Spotted by Brain Foster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-05-05 15:37:31 -06:00
|
|
|
args->valuelen = args->rmtvaluelen;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2013-04-24 02:58:55 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*========================================================================
|
|
|
|
* Utility routines.
|
|
|
|
*========================================================================*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move the indicated entries from one leaf to another.
|
|
|
|
* NOTE: this routine modifies both source and destination leaves.
|
|
|
|
*/
|
|
|
|
/*ARGSUSED*/
|
|
|
|
STATIC void
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_moveents(
|
2014-06-05 23:21:45 -06:00
|
|
|
struct xfs_da_args *args,
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf_s,
|
|
|
|
struct xfs_attr3_icleaf_hdr *ichdr_s,
|
|
|
|
int start_s,
|
|
|
|
struct xfs_attr_leafblock *leaf_d,
|
|
|
|
struct xfs_attr3_icleaf_hdr *ichdr_d,
|
|
|
|
int start_d,
|
2014-06-05 23:21:45 -06:00
|
|
|
int count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leaf_entry *entry_s;
|
|
|
|
struct xfs_attr_leaf_entry *entry_d;
|
|
|
|
int desti;
|
|
|
|
int tmp;
|
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for nothing to do.
|
|
|
|
*/
|
|
|
|
if (count == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up environment.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(ichdr_s->magic == XFS_ATTR_LEAF_MAGIC ||
|
|
|
|
ichdr_s->magic == XFS_ATTR3_LEAF_MAGIC);
|
|
|
|
ASSERT(ichdr_s->magic == ichdr_d->magic);
|
2014-06-05 23:21:45 -06:00
|
|
|
ASSERT(ichdr_s->count > 0 && ichdr_s->count < args->geo->blksize / 8);
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(ichdr_s->firstused >= (ichdr_s->count * sizeof(*entry_s))
|
|
|
|
+ xfs_attr3_leaf_hdr_size(leaf_s));
|
2014-06-05 23:21:45 -06:00
|
|
|
ASSERT(ichdr_d->count < args->geo->blksize / 8);
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(ichdr_d->firstused >= (ichdr_d->count * sizeof(*entry_d))
|
|
|
|
+ xfs_attr3_leaf_hdr_size(leaf_d));
|
|
|
|
|
|
|
|
ASSERT(start_s < ichdr_s->count);
|
|
|
|
ASSERT(start_d <= ichdr_d->count);
|
|
|
|
ASSERT(count <= ichdr_s->count);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Move the entries in the destination leaf up to make a hole?
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
if (start_d < ichdr_d->count) {
|
|
|
|
tmp = ichdr_d->count - start_d;
|
2005-04-16 16:20:36 -06:00
|
|
|
tmp *= sizeof(xfs_attr_leaf_entry_t);
|
2013-04-24 02:58:55 -06:00
|
|
|
entry_s = &xfs_attr3_leaf_entryp(leaf_d)[start_d];
|
|
|
|
entry_d = &xfs_attr3_leaf_entryp(leaf_d)[start_d + count];
|
|
|
|
memmove(entry_d, entry_s, tmp);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy all entry's in the same (sorted) order,
|
|
|
|
* but allocate attribute info packed and in sequence.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
entry_s = &xfs_attr3_leaf_entryp(leaf_s)[start_s];
|
|
|
|
entry_d = &xfs_attr3_leaf_entryp(leaf_d)[start_d];
|
2005-04-16 16:20:36 -06:00
|
|
|
desti = start_d;
|
|
|
|
for (i = 0; i < count; entry_s++, entry_d++, desti++, i++) {
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(be16_to_cpu(entry_s->nameidx) >= ichdr_s->firstused);
|
2005-04-16 16:20:36 -06:00
|
|
|
tmp = xfs_attr_leaf_entsize(leaf_s, start_s + i);
|
|
|
|
#ifdef GROT
|
|
|
|
/*
|
|
|
|
* Code to drop INCOMPLETE entries. Difficult to use as we
|
|
|
|
* may also need to change the insertion index. Code turned
|
|
|
|
* off for 6.2, should be revisited later.
|
|
|
|
*/
|
|
|
|
if (entry_s->flags & XFS_ATTR_INCOMPLETE) { /* skip partials? */
|
2013-04-24 02:58:55 -06:00
|
|
|
memset(xfs_attr3_leaf_name(leaf_s, start_s + i), 0, tmp);
|
|
|
|
ichdr_s->usedbytes -= tmp;
|
|
|
|
ichdr_s->count -= 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
entry_d--; /* to compensate for ++ in loop hdr */
|
|
|
|
desti--;
|
|
|
|
if ((start_s + i) < offset)
|
|
|
|
result++; /* insertion index adjustment */
|
|
|
|
} else {
|
|
|
|
#endif /* GROT */
|
2013-04-24 02:58:55 -06:00
|
|
|
ichdr_d->firstused -= tmp;
|
2005-04-16 16:20:36 -06:00
|
|
|
/* both on-disk, don't endian flip twice */
|
|
|
|
entry_d->hashval = entry_s->hashval;
|
2013-04-24 02:58:55 -06:00
|
|
|
entry_d->nameidx = cpu_to_be16(ichdr_d->firstused);
|
2005-04-16 16:20:36 -06:00
|
|
|
entry_d->flags = entry_s->flags;
|
2006-03-16 23:29:02 -07:00
|
|
|
ASSERT(be16_to_cpu(entry_d->nameidx) + tmp
|
2014-06-05 23:21:45 -06:00
|
|
|
<= args->geo->blksize);
|
2013-04-24 02:58:55 -06:00
|
|
|
memmove(xfs_attr3_leaf_name(leaf_d, desti),
|
|
|
|
xfs_attr3_leaf_name(leaf_s, start_s + i), tmp);
|
2006-03-16 23:29:02 -07:00
|
|
|
ASSERT(be16_to_cpu(entry_s->nameidx) + tmp
|
2014-06-05 23:21:45 -06:00
|
|
|
<= args->geo->blksize);
|
2013-04-24 02:58:55 -06:00
|
|
|
memset(xfs_attr3_leaf_name(leaf_s, start_s + i), 0, tmp);
|
|
|
|
ichdr_s->usedbytes -= tmp;
|
|
|
|
ichdr_d->usedbytes += tmp;
|
|
|
|
ichdr_s->count -= 1;
|
|
|
|
ichdr_d->count += 1;
|
|
|
|
tmp = ichdr_d->count * sizeof(xfs_attr_leaf_entry_t)
|
|
|
|
+ xfs_attr3_leaf_hdr_size(leaf_d);
|
|
|
|
ASSERT(ichdr_d->firstused >= tmp);
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef GROT
|
|
|
|
}
|
|
|
|
#endif /* GROT */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Zero out the entries we just copied.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
if (start_s == ichdr_s->count) {
|
2005-04-16 16:20:36 -06:00
|
|
|
tmp = count * sizeof(xfs_attr_leaf_entry_t);
|
2013-04-24 02:58:55 -06:00
|
|
|
entry_s = &xfs_attr3_leaf_entryp(leaf_s)[start_s];
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(((char *)entry_s + tmp) <=
|
2014-06-05 23:21:45 -06:00
|
|
|
((char *)leaf_s + args->geo->blksize));
|
2013-04-24 02:58:55 -06:00
|
|
|
memset(entry_s, 0, tmp);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Move the remaining entries down to fill the hole,
|
|
|
|
* then zero the entries at the top.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
tmp = (ichdr_s->count - count) * sizeof(xfs_attr_leaf_entry_t);
|
|
|
|
entry_s = &xfs_attr3_leaf_entryp(leaf_s)[start_s + count];
|
|
|
|
entry_d = &xfs_attr3_leaf_entryp(leaf_s)[start_s];
|
|
|
|
memmove(entry_d, entry_s, tmp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
tmp = count * sizeof(xfs_attr_leaf_entry_t);
|
2013-04-24 02:58:55 -06:00
|
|
|
entry_s = &xfs_attr3_leaf_entryp(leaf_s)[ichdr_s->count];
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(((char *)entry_s + tmp) <=
|
2014-06-05 23:21:45 -06:00
|
|
|
((char *)leaf_s + args->geo->blksize));
|
2013-04-24 02:58:55 -06:00
|
|
|
memset(entry_s, 0, tmp);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill in the freemap information
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
ichdr_d->freemap[0].base = xfs_attr3_leaf_hdr_size(leaf_d);
|
|
|
|
ichdr_d->freemap[0].base += ichdr_d->count * sizeof(xfs_attr_leaf_entry_t);
|
|
|
|
ichdr_d->freemap[0].size = ichdr_d->firstused - ichdr_d->freemap[0].base;
|
|
|
|
ichdr_d->freemap[1].base = 0;
|
|
|
|
ichdr_d->freemap[2].base = 0;
|
|
|
|
ichdr_d->freemap[1].size = 0;
|
|
|
|
ichdr_d->freemap[2].size = 0;
|
|
|
|
ichdr_s->holes = 1; /* leaf may not be compact */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Pick up the last hashvalue from a leaf block.
|
|
|
|
*/
|
|
|
|
xfs_dahash_t
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_attr_leaf_lasthash(
|
|
|
|
struct xfs_buf *bp,
|
|
|
|
int *count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr3_icleaf_hdr ichdr;
|
|
|
|
struct xfs_attr_leaf_entry *entries;
|
2015-04-12 19:26:02 -06:00
|
|
|
struct xfs_mount *mp = bp->b_target->bt_mount;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, bp->b_addr);
|
2013-04-24 02:58:55 -06:00
|
|
|
entries = xfs_attr3_leaf_entryp(bp->b_addr);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (count)
|
2013-04-24 02:58:55 -06:00
|
|
|
*count = ichdr.count;
|
|
|
|
if (!ichdr.count)
|
|
|
|
return 0;
|
|
|
|
return be32_to_cpu(entries[ichdr.count - 1].hashval);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate the number of bytes used to store the indicated attribute
|
|
|
|
* (whether local or remote only calculate bytes in this block).
|
|
|
|
*/
|
2005-06-20 23:36:52 -06:00
|
|
|
STATIC int
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index)
|
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leaf_entry *entries;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_attr_leaf_name_local_t *name_loc;
|
|
|
|
xfs_attr_leaf_name_remote_t *name_rmt;
|
|
|
|
int size;
|
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
entries = xfs_attr3_leaf_entryp(leaf);
|
|
|
|
if (entries[index].flags & XFS_ATTR_LOCAL) {
|
|
|
|
name_loc = xfs_attr3_leaf_name_local(leaf, index);
|
2009-01-01 15:40:11 -07:00
|
|
|
size = xfs_attr_leaf_entsize_local(name_loc->namelen,
|
2006-03-16 23:29:09 -07:00
|
|
|
be16_to_cpu(name_loc->valuelen));
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_rmt = xfs_attr3_leaf_name_remote(leaf, index);
|
2009-01-01 15:40:11 -07:00
|
|
|
size = xfs_attr_leaf_entsize_remote(name_rmt->namelen);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2013-04-24 02:58:55 -06:00
|
|
|
return size;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate the number of bytes that would be required to store the new
|
|
|
|
* attribute (whether local or remote only calculate bytes in this block).
|
|
|
|
* This routine decides as a side effect whether the attribute will be
|
|
|
|
* a "local" or a "remote" attribute.
|
|
|
|
*/
|
|
|
|
int
|
2014-06-05 23:21:27 -06:00
|
|
|
xfs_attr_leaf_newentsize(
|
|
|
|
struct xfs_da_args *args,
|
|
|
|
int *local)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-06-05 23:21:27 -06:00
|
|
|
int size;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-06-05 23:21:27 -06:00
|
|
|
size = xfs_attr_leaf_entsize_local(args->namelen, args->valuelen);
|
|
|
|
if (size < xfs_attr_leaf_entsize_local_max(args->geo->blksize)) {
|
|
|
|
if (local)
|
2005-04-16 16:20:36 -06:00
|
|
|
*local = 1;
|
2014-06-05 23:21:27 -06:00
|
|
|
return size;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2014-06-05 23:21:27 -06:00
|
|
|
if (local)
|
|
|
|
*local = 0;
|
|
|
|
return xfs_attr_leaf_entsize_remote(args->namelen);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*========================================================================
|
|
|
|
* Manage the INCOMPLETE flag in a leaf entry
|
|
|
|
*========================================================================*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear the INCOMPLETE flag on an entry in a leaf block.
|
|
|
|
*/
|
|
|
|
int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_clearflag(
|
|
|
|
struct xfs_da_args *args)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf;
|
|
|
|
struct xfs_attr_leaf_entry *entry;
|
|
|
|
struct xfs_attr_leaf_name_remote *name_rmt;
|
|
|
|
struct xfs_buf *bp;
|
|
|
|
int error;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef DEBUG
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr3_icleaf_hdr ichdr;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_attr_leaf_name_local_t *name_loc;
|
|
|
|
int namelen;
|
|
|
|
char *name;
|
|
|
|
#endif /* DEBUG */
|
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_leaf_clearflag(args);
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Set up the operation.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, -1, &bp);
|
2012-11-12 04:54:16 -07:00
|
|
|
if (error)
|
2014-06-21 23:03:54 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf = bp->b_addr;
|
2013-04-24 02:58:55 -06:00
|
|
|
entry = &xfs_attr3_leaf_entryp(leaf)[args->index];
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(entry->flags & XFS_ATTR_INCOMPLETE);
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(args->index < ichdr.count);
|
|
|
|
ASSERT(args->index >= 0);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (entry->flags & XFS_ATTR_LOCAL) {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_loc = xfs_attr3_leaf_name_local(leaf, args->index);
|
2005-04-16 16:20:36 -06:00
|
|
|
namelen = name_loc->namelen;
|
|
|
|
name = (char *)name_loc->nameval;
|
|
|
|
} else {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);
|
2005-04-16 16:20:36 -06:00
|
|
|
namelen = name_rmt->namelen;
|
|
|
|
name = (char *)name_rmt->name;
|
|
|
|
}
|
2006-03-16 23:29:02 -07:00
|
|
|
ASSERT(be32_to_cpu(entry->hashval) == args->hashval);
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(namelen == args->namelen);
|
|
|
|
ASSERT(memcmp(name, args->name, namelen) == 0);
|
|
|
|
#endif /* DEBUG */
|
|
|
|
|
|
|
|
entry->flags &= ~XFS_ATTR_INCOMPLETE;
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp,
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
|
|
|
|
|
|
|
|
if (args->rmtblkno) {
|
|
|
|
ASSERT((entry->flags & XFS_ATTR_LOCAL) == 0);
|
2013-04-24 02:58:55 -06:00
|
|
|
name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);
|
2006-03-16 23:29:18 -07:00
|
|
|
name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
|
xfs: remote attribute overwrite causes transaction overrun
Commit e461fcb ("xfs: remote attribute lookups require the value
length") passes the remote attribute length in the xfs_da_args
structure on lookup so that CRC calculations and validity checking
can be performed correctly by related code. This, unfortunately has
the side effect of changing the args->valuelen parameter in cases
where it shouldn't.
That is, when we replace a remote attribute, the incoming
replacement stores the value and length in args->value and
args->valuelen, but then the lookup which finds the existing remote
attribute overwrites args->valuelen with the length of the remote
attribute being replaced. Hence when we go to create the new
attribute, we create it of the size of the existing remote
attribute, not the size it is supposed to be. When the new attribute
is much smaller than the old attribute, this results in a
transaction overrun and an ASSERT() failure on a debug kernel:
XFS: Assertion failed: tp->t_blk_res_used <= tp->t_blk_res, file: fs/xfs/xfs_trans.c, line: 331
Fix this by keeping the remote attribute value length separate to
the attribute value length in the xfs_da_args structure. The enables
us to pass the length of the remote attribute to be removed without
overwriting the new attribute's length.
Also, ensure that when we save remote block contexts for a later
rename we zero the original state variables so that we don't confuse
the state of the attribute to be removes with the state of the new
attribute that we just added. [Spotted by Brain Foster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-05-05 15:37:31 -06:00
|
|
|
name_rmt->valuelen = cpu_to_be32(args->rmtvaluelen);
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp,
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Commit the flag value change and start the next trans in series.
|
|
|
|
*/
|
2017-08-28 11:21:03 -06:00
|
|
|
return xfs_trans_roll_inode(&args->trans, args->dp);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the INCOMPLETE flag on an entry in a leaf block.
|
|
|
|
*/
|
|
|
|
int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_setflag(
|
|
|
|
struct xfs_da_args *args)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf;
|
|
|
|
struct xfs_attr_leaf_entry *entry;
|
|
|
|
struct xfs_attr_leaf_name_remote *name_rmt;
|
|
|
|
struct xfs_buf *bp;
|
2005-04-16 16:20:36 -06:00
|
|
|
int error;
|
2013-04-24 02:58:55 -06:00
|
|
|
#ifdef DEBUG
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr;
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_leaf_setflag(args);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Set up the operation.
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, -1, &bp);
|
2012-11-12 04:54:16 -07:00
|
|
|
if (error)
|
2014-06-21 23:03:54 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf = bp->b_addr;
|
2013-04-24 02:58:55 -06:00
|
|
|
#ifdef DEBUG
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(args->index < ichdr.count);
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(args->index >= 0);
|
2013-04-24 02:58:55 -06:00
|
|
|
#endif
|
|
|
|
entry = &xfs_attr3_leaf_entryp(leaf)[args->index];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT((entry->flags & XFS_ATTR_INCOMPLETE) == 0);
|
|
|
|
entry->flags |= XFS_ATTR_INCOMPLETE;
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp,
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
|
|
|
|
if ((entry->flags & XFS_ATTR_LOCAL) == 0) {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_rmt->valueblk = 0;
|
|
|
|
name_rmt->valuelen = 0;
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp,
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Commit the flag value change and start the next trans in series.
|
|
|
|
*/
|
2017-08-28 11:21:03 -06:00
|
|
|
return xfs_trans_roll_inode(&args->trans, args->dp);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In a single transaction, clear the INCOMPLETE flag on the leaf entry
|
|
|
|
* given by args->blkno/index and set the INCOMPLETE flag on the leaf
|
|
|
|
* entry given by args->blkno2/index2.
|
|
|
|
*
|
|
|
|
* Note that they could be in different blocks, or in the same block.
|
|
|
|
*/
|
|
|
|
int
|
2013-04-24 02:58:55 -06:00
|
|
|
xfs_attr3_leaf_flipflags(
|
|
|
|
struct xfs_da_args *args)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr_leafblock *leaf1;
|
|
|
|
struct xfs_attr_leafblock *leaf2;
|
|
|
|
struct xfs_attr_leaf_entry *entry1;
|
|
|
|
struct xfs_attr_leaf_entry *entry2;
|
|
|
|
struct xfs_attr_leaf_name_remote *name_rmt;
|
|
|
|
struct xfs_buf *bp1;
|
|
|
|
struct xfs_buf *bp2;
|
2005-04-16 16:20:36 -06:00
|
|
|
int error;
|
|
|
|
#ifdef DEBUG
|
2013-04-24 02:58:55 -06:00
|
|
|
struct xfs_attr3_icleaf_hdr ichdr1;
|
|
|
|
struct xfs_attr3_icleaf_hdr ichdr2;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_attr_leaf_name_local_t *name_loc;
|
|
|
|
int namelen1, namelen2;
|
|
|
|
char *name1, *name2;
|
|
|
|
#endif /* DEBUG */
|
|
|
|
|
2012-03-21 23:15:13 -06:00
|
|
|
trace_xfs_attr_leaf_flipflags(args);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Read the block containing the "old" attr
|
|
|
|
*/
|
2013-04-24 02:58:55 -06:00
|
|
|
error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, -1, &bp1);
|
2012-11-12 04:54:16 -07:00
|
|
|
if (error)
|
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Read the block containing the "new" attr, if it is different
|
|
|
|
*/
|
|
|
|
if (args->blkno2 != args->blkno) {
|
2013-04-24 02:58:55 -06:00
|
|
|
error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno2,
|
2012-11-12 04:54:16 -07:00
|
|
|
-1, &bp2);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
bp2 = bp1;
|
|
|
|
}
|
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf1 = bp1->b_addr;
|
2013-04-24 02:58:55 -06:00
|
|
|
entry1 = &xfs_attr3_leaf_entryp(leaf1)[args->index];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-06-22 02:50:14 -06:00
|
|
|
leaf2 = bp2->b_addr;
|
2013-04-24 02:58:55 -06:00
|
|
|
entry2 = &xfs_attr3_leaf_entryp(leaf2)[args->index2];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr1, leaf1);
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(args->index < ichdr1.count);
|
|
|
|
ASSERT(args->index >= 0);
|
|
|
|
|
2015-04-12 19:26:02 -06:00
|
|
|
xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr2, leaf2);
|
2013-04-24 02:58:55 -06:00
|
|
|
ASSERT(args->index2 < ichdr2.count);
|
|
|
|
ASSERT(args->index2 >= 0);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (entry1->flags & XFS_ATTR_LOCAL) {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_loc = xfs_attr3_leaf_name_local(leaf1, args->index);
|
2005-04-16 16:20:36 -06:00
|
|
|
namelen1 = name_loc->namelen;
|
|
|
|
name1 = (char *)name_loc->nameval;
|
|
|
|
} else {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_rmt = xfs_attr3_leaf_name_remote(leaf1, args->index);
|
2005-04-16 16:20:36 -06:00
|
|
|
namelen1 = name_rmt->namelen;
|
|
|
|
name1 = (char *)name_rmt->name;
|
|
|
|
}
|
|
|
|
if (entry2->flags & XFS_ATTR_LOCAL) {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_loc = xfs_attr3_leaf_name_local(leaf2, args->index2);
|
2005-04-16 16:20:36 -06:00
|
|
|
namelen2 = name_loc->namelen;
|
|
|
|
name2 = (char *)name_loc->nameval;
|
|
|
|
} else {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_rmt = xfs_attr3_leaf_name_remote(leaf2, args->index2);
|
2005-04-16 16:20:36 -06:00
|
|
|
namelen2 = name_rmt->namelen;
|
|
|
|
name2 = (char *)name_rmt->name;
|
|
|
|
}
|
2006-03-16 23:29:02 -07:00
|
|
|
ASSERT(be32_to_cpu(entry1->hashval) == be32_to_cpu(entry2->hashval));
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(namelen1 == namelen2);
|
|
|
|
ASSERT(memcmp(name1, name2, namelen1) == 0);
|
|
|
|
#endif /* DEBUG */
|
|
|
|
|
|
|
|
ASSERT(entry1->flags & XFS_ATTR_INCOMPLETE);
|
|
|
|
ASSERT((entry2->flags & XFS_ATTR_INCOMPLETE) == 0);
|
|
|
|
|
|
|
|
entry1->flags &= ~XFS_ATTR_INCOMPLETE;
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp1,
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf1, entry1, sizeof(*entry1)));
|
|
|
|
if (args->rmtblkno) {
|
|
|
|
ASSERT((entry1->flags & XFS_ATTR_LOCAL) == 0);
|
2013-04-24 02:58:55 -06:00
|
|
|
name_rmt = xfs_attr3_leaf_name_remote(leaf1, args->index);
|
2006-03-16 23:29:18 -07:00
|
|
|
name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
|
xfs: remote attribute overwrite causes transaction overrun
Commit e461fcb ("xfs: remote attribute lookups require the value
length") passes the remote attribute length in the xfs_da_args
structure on lookup so that CRC calculations and validity checking
can be performed correctly by related code. This, unfortunately has
the side effect of changing the args->valuelen parameter in cases
where it shouldn't.
That is, when we replace a remote attribute, the incoming
replacement stores the value and length in args->value and
args->valuelen, but then the lookup which finds the existing remote
attribute overwrites args->valuelen with the length of the remote
attribute being replaced. Hence when we go to create the new
attribute, we create it of the size of the existing remote
attribute, not the size it is supposed to be. When the new attribute
is much smaller than the old attribute, this results in a
transaction overrun and an ASSERT() failure on a debug kernel:
XFS: Assertion failed: tp->t_blk_res_used <= tp->t_blk_res, file: fs/xfs/xfs_trans.c, line: 331
Fix this by keeping the remote attribute value length separate to
the attribute value length in the xfs_da_args structure. The enables
us to pass the length of the remote attribute to be removed without
overwriting the new attribute's length.
Also, ensure that when we save remote block contexts for a later
rename we zero the original state variables so that we don't confuse
the state of the attribute to be removes with the state of the new
attribute that we just added. [Spotted by Brain Foster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-05-05 15:37:31 -06:00
|
|
|
name_rmt->valuelen = cpu_to_be32(args->rmtvaluelen);
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp1,
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf1, name_rmt, sizeof(*name_rmt)));
|
|
|
|
}
|
|
|
|
|
|
|
|
entry2->flags |= XFS_ATTR_INCOMPLETE;
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp2,
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf2, entry2, sizeof(*entry2)));
|
|
|
|
if ((entry2->flags & XFS_ATTR_LOCAL) == 0) {
|
2013-04-24 02:58:55 -06:00
|
|
|
name_rmt = xfs_attr3_leaf_name_remote(leaf2, args->index2);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_rmt->valueblk = 0;
|
|
|
|
name_rmt->valuelen = 0;
|
2012-06-22 02:50:14 -06:00
|
|
|
xfs_trans_log_buf(args->trans, bp2,
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_DA_LOGRANGE(leaf2, name_rmt, sizeof(*name_rmt)));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Commit the flag value change and start the next trans in series.
|
|
|
|
*/
|
2017-08-28 11:21:03 -06:00
|
|
|
error = xfs_trans_roll_inode(&args->trans, args->dp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-04-24 02:58:55 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|