2006-01-16 16:50:04 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2006-05-18 19:09:15 +00:00
|
|
|
* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
|
2006-01-16 16:50:04 +00:00
|
|
|
*
|
|
|
|
* This copyrighted material is made available to anyone wishing to use,
|
|
|
|
* modify, copy, or redistribute it subject to the terms and conditions
|
2006-09-01 15:05:15 +00:00
|
|
|
* of the GNU General Public License version 2.
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2006-04-24 14:07:13 +00:00
|
|
|
* Implements Extendible Hashing as described in:
|
|
|
|
* "Extendible Hashing" by Fagin, et al in
|
|
|
|
* __ACM Trans. on Database Systems__, Sept 1979.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Here's the layout of dirents which is essentially the same as that of ext2
|
|
|
|
* within a single block. The field de_name_len is the number of bytes
|
|
|
|
* actually required for the name (no null terminator). The field de_rec_len
|
|
|
|
* is the number of bytes allocated to the dirent. The offset of the next
|
|
|
|
* dirent in the block is (dirent + dirent->de_rec_len). When a dirent is
|
|
|
|
* deleted, the preceding dirent inherits its allocated space, ie
|
|
|
|
* prev->de_rec_len += deleted->de_rec_len. Since the next dirent is obtained
|
|
|
|
* by adding de_rec_len to the current dirent, this essentially causes the
|
|
|
|
* deleted dirent to get jumped over when iterating through all the dirents.
|
|
|
|
*
|
|
|
|
* When deleting the first dirent in a block, there is no previous dirent so
|
|
|
|
* the field de_ino is set to zero to designate it as deleted. When allocating
|
|
|
|
* a dirent, gfs2_dirent_alloc iterates through the dirents in a block. If the
|
|
|
|
* first dirent has (de_ino == 0) and de_rec_len is large enough, this first
|
|
|
|
* dirent is allocated. Otherwise it must go through all the 'used' dirents
|
|
|
|
* searching for one in which the amount of total space minus the amount of
|
|
|
|
* used space will provide enough space for the new dirent.
|
|
|
|
*
|
|
|
|
* There are two types of blocks in which dirents reside. In a stuffed dinode,
|
|
|
|
* the dirents begin at offset sizeof(struct gfs2_dinode) from the beginning of
|
|
|
|
* the block. In leaves, they begin at offset sizeof(struct gfs2_leaf) from the
|
|
|
|
* beginning of the leaf block. The dirents reside in leaves when
|
|
|
|
*
|
2008-11-04 10:05:22 +00:00
|
|
|
* dip->i_diskflags & GFS2_DIF_EXHASH is true
|
2006-04-24 14:07:13 +00:00
|
|
|
*
|
|
|
|
* Otherwise, the dirents are "linear", within a single stuffed dinode block.
|
|
|
|
*
|
|
|
|
* When the dirents are in leaves, the actual contents of the directory file are
|
|
|
|
* used as an array of 64-bit block pointers pointing to the leaf blocks. The
|
|
|
|
* dirents are NOT in the directory file itself. There can be more than one
|
|
|
|
* block pointer in the array that points to the same leaf. In fact, when a
|
|
|
|
* directory is first converted from linear to exhash, all of the pointers
|
|
|
|
* point to the same leaf.
|
|
|
|
*
|
|
|
|
* When a leaf is completely full, the size of the hash table can be
|
|
|
|
* doubled unless it is already at the maximum size which is hard coded into
|
|
|
|
* GFS2_DIR_MAX_DEPTH. After that, leaves are chained together in a linked list,
|
|
|
|
* but never before the maximum hash table size has been reached.
|
|
|
|
*/
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2014-03-06 20:10:45 +00:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/sort.h>
|
2006-02-27 22:23:27 +00:00
|
|
|
#include <linux/gfs2_ondisk.h>
|
2006-03-28 19:14:04 +00:00
|
|
|
#include <linux/crc32.h>
|
2006-04-18 14:09:15 +00:00
|
|
|
#include <linux/vmalloc.h>
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
#include "gfs2.h"
|
2006-02-27 22:23:27 +00:00
|
|
|
#include "incore.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
#include "dir.h"
|
|
|
|
#include "glock.h"
|
|
|
|
#include "inode.h"
|
|
|
|
#include "meta_io.h"
|
|
|
|
#include "quota.h"
|
|
|
|
#include "rgrp.h"
|
|
|
|
#include "trans.h"
|
2006-01-30 13:31:50 +00:00
|
|
|
#include "bmap.h"
|
2006-02-27 22:23:27 +00:00
|
|
|
#include "util.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
#define IS_LEAF 1 /* Hashed (leaf) directory */
|
|
|
|
#define IS_DINODE 2 /* Linear (stuffed dinode block) directory */
|
|
|
|
|
2011-10-27 16:16:06 +00:00
|
|
|
#define MAX_RA_BLOCKS 32 /* max read-ahead blocks */
|
|
|
|
|
2006-09-04 16:49:07 +00:00
|
|
|
#define gfs2_disk_hash2offset(h) (((u64)(h)) >> 1)
|
|
|
|
#define gfs2_dir_offset2hash(p) ((u32)(((u64)(p)) << 1))
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2010-09-17 11:30:23 +00:00
|
|
|
struct qstr gfs2_qdot __read_mostly;
|
|
|
|
struct qstr gfs2_qdotdot __read_mostly;
|
|
|
|
|
2006-09-05 13:34:20 +00:00
|
|
|
typedef int (*gfs2_dscan_t)(const struct gfs2_dirent *dent,
|
|
|
|
const struct qstr *name, void *opaque);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-09-04 16:49:07 +00:00
|
|
|
int gfs2_dir_get_new_buffer(struct gfs2_inode *ip, u64 block,
|
2006-04-24 14:07:13 +00:00
|
|
|
struct buffer_head **bhp)
|
2006-01-30 13:31:50 +00:00
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
|
|
|
|
2006-04-24 14:07:13 +00:00
|
|
|
bh = gfs2_meta_new(ip->i_gl, block);
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(ip->i_gl, bh);
|
2006-04-24 14:07:13 +00:00
|
|
|
gfs2_metatype_set(bh, GFS2_METATYPE_JD, GFS2_FORMAT_JD);
|
|
|
|
gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
|
2006-01-30 13:31:50 +00:00
|
|
|
*bhp = bh;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-04 16:49:07 +00:00
|
|
|
static int gfs2_dir_get_existing_buffer(struct gfs2_inode *ip, u64 block,
|
2006-04-24 14:07:13 +00:00
|
|
|
struct buffer_head **bhp)
|
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
|
|
|
int error;
|
2006-01-30 13:31:50 +00:00
|
|
|
|
2006-09-21 21:05:23 +00:00
|
|
|
error = gfs2_meta_read(ip->i_gl, block, DIO_WAIT, &bh);
|
2006-04-24 14:07:13 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
2006-06-14 19:32:57 +00:00
|
|
|
if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_JD)) {
|
2006-04-24 14:07:13 +00:00
|
|
|
brelse(bh);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
*bhp = bh;
|
|
|
|
return 0;
|
|
|
|
}
|
2006-01-30 13:31:50 +00:00
|
|
|
|
|
|
|
static int gfs2_dir_write_stuffed(struct gfs2_inode *ip, const char *buf,
|
|
|
|
unsigned int offset, unsigned int size)
|
|
|
|
{
|
|
|
|
struct buffer_head *dibh;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(ip, &dibh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(ip->i_gl, dibh);
|
2006-03-20 17:30:04 +00:00
|
|
|
memcpy(dibh->b_data + offset + sizeof(struct gfs2_dinode), buf, size);
|
2010-08-11 08:53:11 +00:00
|
|
|
if (ip->i_inode.i_size < offset + size)
|
|
|
|
i_size_write(&ip->i_inode, offset + size);
|
2007-06-05 08:39:18 +00:00
|
|
|
ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
|
2006-10-31 20:07:05 +00:00
|
|
|
gfs2_dinode_out(ip, dibh->b_data);
|
2006-01-30 13:31:50 +00:00
|
|
|
|
|
|
|
brelse(dibh);
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_dir_write_data - Write directory information to the inode
|
|
|
|
* @ip: The GFS2 inode
|
|
|
|
* @buf: The buffer containing information to be written
|
|
|
|
* @offset: The file offset to start writing at
|
|
|
|
* @size: The amount of data to write
|
|
|
|
*
|
|
|
|
* Returns: The number of bytes correctly written or error code
|
|
|
|
*/
|
|
|
|
static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf,
|
2006-09-04 16:49:07 +00:00
|
|
|
u64 offset, unsigned int size)
|
2006-01-30 13:31:50 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2006-01-30 13:31:50 +00:00
|
|
|
struct buffer_head *dibh;
|
2006-09-04 16:49:07 +00:00
|
|
|
u64 lblock, dblock;
|
|
|
|
u32 extlen = 0;
|
2006-01-30 13:31:50 +00:00
|
|
|
unsigned int o;
|
|
|
|
int copied = 0;
|
|
|
|
int error = 0;
|
2008-02-22 16:09:31 +00:00
|
|
|
int new = 0;
|
2006-01-30 13:31:50 +00:00
|
|
|
|
|
|
|
if (!size)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (gfs2_is_stuffed(ip) &&
|
|
|
|
offset + size <= sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode))
|
2006-02-27 17:00:42 +00:00
|
|
|
return gfs2_dir_write_stuffed(ip, buf, (unsigned int)offset,
|
|
|
|
size);
|
2006-01-30 13:31:50 +00:00
|
|
|
|
|
|
|
if (gfs2_assert_warn(sdp, gfs2_is_jdata(ip)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (gfs2_is_stuffed(ip)) {
|
2006-07-26 14:51:20 +00:00
|
|
|
error = gfs2_unstuff_dinode(ip, NULL);
|
2006-01-30 13:31:50 +00:00
|
|
|
if (error)
|
2006-03-20 17:30:04 +00:00
|
|
|
return error;
|
2006-01-30 13:31:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
lblock = offset;
|
|
|
|
o = do_div(lblock, sdp->sd_jbsize) + sizeof(struct gfs2_meta_header);
|
|
|
|
|
|
|
|
while (copied < size) {
|
|
|
|
unsigned int amount;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
|
|
|
|
amount = size - copied;
|
|
|
|
if (amount > sdp->sd_sb.sb_bsize - o)
|
|
|
|
amount = sdp->sd_sb.sb_bsize - o;
|
|
|
|
|
|
|
|
if (!extlen) {
|
|
|
|
new = 1;
|
2006-06-14 19:32:57 +00:00
|
|
|
error = gfs2_extent_map(&ip->i_inode, lblock, &new,
|
2006-05-05 20:59:11 +00:00
|
|
|
&dblock, &extlen);
|
2006-01-30 13:31:50 +00:00
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
error = -EIO;
|
|
|
|
if (gfs2_assert_withdraw(sdp, dblock))
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2006-04-24 14:07:13 +00:00
|
|
|
if (amount == sdp->sd_jbsize || new)
|
|
|
|
error = gfs2_dir_get_new_buffer(ip, dblock, &bh);
|
|
|
|
else
|
|
|
|
error = gfs2_dir_get_existing_buffer(ip, dblock, &bh);
|
|
|
|
|
2006-01-30 13:31:50 +00:00
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(ip->i_gl, bh);
|
2006-01-30 13:31:50 +00:00
|
|
|
memcpy(bh->b_data + o, buf, amount);
|
|
|
|
brelse(bh);
|
|
|
|
|
2006-08-01 19:28:57 +00:00
|
|
|
buf += amount;
|
2006-01-30 13:31:50 +00:00
|
|
|
copied += amount;
|
|
|
|
lblock++;
|
|
|
|
dblock++;
|
|
|
|
extlen--;
|
|
|
|
|
|
|
|
o = sizeof(struct gfs2_meta_header);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
error = gfs2_meta_inode_buffer(ip, &dibh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2010-08-11 08:53:11 +00:00
|
|
|
if (ip->i_inode.i_size < offset + copied)
|
|
|
|
i_size_write(&ip->i_inode, offset + copied);
|
2007-06-05 08:39:18 +00:00
|
|
|
ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
|
2006-01-30 13:31:50 +00:00
|
|
|
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(ip->i_gl, dibh);
|
2006-10-31 20:07:05 +00:00
|
|
|
gfs2_dinode_out(ip, dibh->b_data);
|
2006-01-30 13:31:50 +00:00
|
|
|
brelse(dibh);
|
|
|
|
|
|
|
|
return copied;
|
|
|
|
fail:
|
|
|
|
if (copied)
|
|
|
|
goto out;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2011-07-26 08:17:28 +00:00
|
|
|
static int gfs2_dir_read_stuffed(struct gfs2_inode *ip, __be64 *buf,
|
|
|
|
unsigned int size)
|
2006-01-30 13:31:50 +00:00
|
|
|
{
|
|
|
|
struct buffer_head *dibh;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(ip, &dibh);
|
|
|
|
if (!error) {
|
2011-07-26 08:17:28 +00:00
|
|
|
memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
|
2006-01-30 13:31:50 +00:00
|
|
|
brelse(dibh);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (error) ? error : size;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_dir_read_data - Read a data from a directory inode
|
|
|
|
* @ip: The GFS2 Inode
|
|
|
|
* @buf: The buffer to place result into
|
|
|
|
* @size: Amount of data to transfer
|
|
|
|
*
|
|
|
|
* Returns: The amount of data actually copied or the error
|
|
|
|
*/
|
2011-07-26 08:17:28 +00:00
|
|
|
static int gfs2_dir_read_data(struct gfs2_inode *ip, __be64 *buf,
|
|
|
|
unsigned int size)
|
2006-01-30 13:31:50 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2006-09-04 16:49:07 +00:00
|
|
|
u64 lblock, dblock;
|
|
|
|
u32 extlen = 0;
|
2006-01-30 13:31:50 +00:00
|
|
|
unsigned int o;
|
|
|
|
int copied = 0;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (gfs2_is_stuffed(ip))
|
2011-07-26 08:17:28 +00:00
|
|
|
return gfs2_dir_read_stuffed(ip, buf, size);
|
2006-01-30 13:31:50 +00:00
|
|
|
|
|
|
|
if (gfs2_assert_warn(sdp, gfs2_is_jdata(ip)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-07-26 08:17:28 +00:00
|
|
|
lblock = 0;
|
2006-01-30 13:31:50 +00:00
|
|
|
o = do_div(lblock, sdp->sd_jbsize) + sizeof(struct gfs2_meta_header);
|
|
|
|
|
|
|
|
while (copied < size) {
|
|
|
|
unsigned int amount;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
int new;
|
|
|
|
|
|
|
|
amount = size - copied;
|
|
|
|
if (amount > sdp->sd_sb.sb_bsize - o)
|
|
|
|
amount = sdp->sd_sb.sb_bsize - o;
|
|
|
|
|
|
|
|
if (!extlen) {
|
|
|
|
new = 0;
|
2006-06-14 19:32:57 +00:00
|
|
|
error = gfs2_extent_map(&ip->i_inode, lblock, &new,
|
2006-05-05 20:59:11 +00:00
|
|
|
&dblock, &extlen);
|
2006-09-21 21:05:23 +00:00
|
|
|
if (error || !dblock)
|
2006-01-30 13:31:50 +00:00
|
|
|
goto fail;
|
2006-09-21 21:05:23 +00:00
|
|
|
BUG_ON(extlen < 1);
|
|
|
|
bh = gfs2_meta_ra(ip->i_gl, dblock, extlen);
|
2006-10-19 14:02:07 +00:00
|
|
|
} else {
|
2006-09-21 21:05:23 +00:00
|
|
|
error = gfs2_meta_read(ip->i_gl, dblock, DIO_WAIT, &bh);
|
2006-01-30 13:31:50 +00:00
|
|
|
if (error)
|
|
|
|
goto fail;
|
2006-09-21 21:05:23 +00:00
|
|
|
}
|
|
|
|
error = gfs2_metatype_check(sdp, bh, GFS2_METATYPE_JD);
|
|
|
|
if (error) {
|
|
|
|
brelse(bh);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
dblock++;
|
|
|
|
extlen--;
|
2006-01-30 13:31:50 +00:00
|
|
|
memcpy(buf, bh->b_data + o, amount);
|
|
|
|
brelse(bh);
|
2011-07-26 08:17:28 +00:00
|
|
|
buf += (amount/sizeof(__be64));
|
2006-01-30 13:31:50 +00:00
|
|
|
copied += amount;
|
|
|
|
lblock++;
|
|
|
|
o = sizeof(struct gfs2_meta_header);
|
|
|
|
}
|
|
|
|
|
|
|
|
return copied;
|
|
|
|
fail:
|
|
|
|
return (copied) ? copied : error;
|
|
|
|
}
|
|
|
|
|
2011-06-15 09:29:37 +00:00
|
|
|
/**
|
|
|
|
* gfs2_dir_get_hash_table - Get pointer to the dir hash table
|
|
|
|
* @ip: The inode in question
|
|
|
|
*
|
|
|
|
* Returns: The hash table or an error
|
|
|
|
*/
|
|
|
|
|
|
|
|
static __be64 *gfs2_dir_get_hash_table(struct gfs2_inode *ip)
|
|
|
|
{
|
|
|
|
struct inode *inode = &ip->i_inode;
|
|
|
|
int ret;
|
|
|
|
u32 hsize;
|
|
|
|
__be64 *hc;
|
|
|
|
|
|
|
|
BUG_ON(!(ip->i_diskflags & GFS2_DIF_EXHASH));
|
|
|
|
|
|
|
|
hc = ip->i_hash_cache;
|
|
|
|
if (hc)
|
|
|
|
return hc;
|
|
|
|
|
|
|
|
hsize = 1 << ip->i_depth;
|
|
|
|
hsize *= sizeof(__be64);
|
|
|
|
if (hsize != i_size_read(&ip->i_inode)) {
|
|
|
|
gfs2_consist_inode(ip);
|
|
|
|
return ERR_PTR(-EIO);
|
|
|
|
}
|
|
|
|
|
2013-05-30 13:48:56 +00:00
|
|
|
hc = kmalloc(hsize, GFP_NOFS | __GFP_NOWARN);
|
|
|
|
if (hc == NULL)
|
|
|
|
hc = __vmalloc(hsize, GFP_NOFS, PAGE_KERNEL);
|
|
|
|
|
2011-06-15 09:29:37 +00:00
|
|
|
if (hc == NULL)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
2011-07-26 08:17:28 +00:00
|
|
|
ret = gfs2_dir_read_data(ip, hc, hsize);
|
2011-06-15 09:29:37 +00:00
|
|
|
if (ret < 0) {
|
2014-11-20 05:18:38 +00:00
|
|
|
kvfree(hc);
|
2011-06-15 09:29:37 +00:00
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock(&inode->i_lock);
|
2014-11-20 05:19:47 +00:00
|
|
|
if (likely(!ip->i_hash_cache)) {
|
2011-06-15 09:29:37 +00:00
|
|
|
ip->i_hash_cache = hc;
|
2014-11-20 05:19:47 +00:00
|
|
|
hc = NULL;
|
|
|
|
}
|
2011-06-15 09:29:37 +00:00
|
|
|
spin_unlock(&inode->i_lock);
|
2014-11-20 05:19:47 +00:00
|
|
|
kvfree(hc);
|
2011-06-15 09:29:37 +00:00
|
|
|
|
|
|
|
return ip->i_hash_cache;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_dir_hash_inval - Invalidate dir hash
|
|
|
|
* @ip: The directory inode
|
|
|
|
*
|
|
|
|
* Must be called with an exclusive glock, or during glock invalidation.
|
|
|
|
*/
|
|
|
|
void gfs2_dir_hash_inval(struct gfs2_inode *ip)
|
|
|
|
{
|
|
|
|
__be64 *hc = ip->i_hash_cache;
|
|
|
|
ip->i_hash_cache = NULL;
|
2014-11-20 05:18:38 +00:00
|
|
|
kvfree(hc);
|
2011-06-15 09:29:37 +00:00
|
|
|
}
|
|
|
|
|
2006-11-17 17:27:44 +00:00
|
|
|
static inline int gfs2_dirent_sentinel(const struct gfs2_dirent *dent)
|
|
|
|
{
|
|
|
|
return dent->de_inum.no_addr == 0 || dent->de_inum.no_formal_ino == 0;
|
|
|
|
}
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
static inline int __gfs2_dirent_find(const struct gfs2_dirent *dent,
|
|
|
|
const struct qstr *name, int ret)
|
|
|
|
{
|
2006-11-17 17:27:44 +00:00
|
|
|
if (!gfs2_dirent_sentinel(dent) &&
|
2006-03-20 17:30:04 +00:00
|
|
|
be32_to_cpu(dent->de_hash) == name->hash &&
|
|
|
|
be16_to_cpu(dent->de_name_len) == name->len &&
|
2006-09-05 13:34:20 +00:00
|
|
|
memcmp(dent+1, name->name, name->len) == 0)
|
2006-03-20 17:30:04 +00:00
|
|
|
return ret;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gfs2_dirent_find(const struct gfs2_dirent *dent,
|
2006-03-28 19:14:04 +00:00
|
|
|
const struct qstr *name,
|
|
|
|
void *opaque)
|
2006-03-20 17:30:04 +00:00
|
|
|
{
|
|
|
|
return __gfs2_dirent_find(dent, name, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gfs2_dirent_prev(const struct gfs2_dirent *dent,
|
2006-03-28 19:14:04 +00:00
|
|
|
const struct qstr *name,
|
|
|
|
void *opaque)
|
2006-03-20 17:30:04 +00:00
|
|
|
{
|
|
|
|
return __gfs2_dirent_find(dent, name, 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* name->name holds ptr to start of block.
|
|
|
|
* name->len holds size of block.
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
2006-03-20 17:30:04 +00:00
|
|
|
static int gfs2_dirent_last(const struct gfs2_dirent *dent,
|
2006-03-28 19:14:04 +00:00
|
|
|
const struct qstr *name,
|
|
|
|
void *opaque)
|
2006-03-20 17:30:04 +00:00
|
|
|
{
|
|
|
|
const char *start = name->name;
|
|
|
|
const char *end = (const char *)dent + be16_to_cpu(dent->de_rec_len);
|
|
|
|
if (name->len == (end - start))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
static int gfs2_dirent_find_space(const struct gfs2_dirent *dent,
|
2006-03-28 19:14:04 +00:00
|
|
|
const struct qstr *name,
|
|
|
|
void *opaque)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-03-20 17:30:04 +00:00
|
|
|
unsigned required = GFS2_DIRENT_SIZE(name->len);
|
|
|
|
unsigned actual = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
|
|
|
|
unsigned totlen = be16_to_cpu(dent->de_rec_len);
|
|
|
|
|
2006-11-17 17:27:44 +00:00
|
|
|
if (gfs2_dirent_sentinel(dent))
|
GFS2: rename causes kernel Oops
This patch fixes a kernel Oops in the GFS2 rename code.
The problem was in the way the gfs2 directory code was trying
to re-use sentinel directory entries.
In the failing case, gfs2's rename function was renaming a
file to another name that had the same non-trivial length.
The file being renamed happened to be the first directory
entry on the leaf block.
First, the rename code (gfs2_rename in ops_inode.c) found the
original directory entry and decided it could do its job by
simply replacing the directory entry with another. Therefore
it determined correctly that no block allocations were needed.
Next, the rename code deleted the old directory entry prior to
replacing it with the new name. Therefore, the soon-to-be
replaced directory entry was temporarily made into a directory
entry "sentinel" or a place holder at the start of a leaf block.
Lastly, it went to re-add the replacement directory entry in
that leaf block. However, when gfs2_dirent_find_space was
looking for space in the leaf block, it used the wrong value
for the sentinel. That threw off its calculations so later
it decides it can't really re-use the sentinel and therefore
must allocate a new leaf block. But because it previously decided
to re-use the directory entry, it didn't waste the time to
grab a new block allocation for the inode. Therefore, the
inode's i_alloc pointer was still NULL and it crashes trying to
reference it.
In the case of sentinel directory entries, the entire dirent is
reused, not just the "free space" portion of it, and therefore
the function gfs2_dirent_find_space should use the value 0
rather than GFS2_DIRENT_SIZE(0) for the actual dirent size.
Fixing this calculation enables the reproducer programs to work
properly.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2010-07-14 22:12:26 +00:00
|
|
|
actual = 0;
|
2006-09-05 12:30:40 +00:00
|
|
|
if (totlen - actual >= required)
|
2006-03-20 17:30:04 +00:00
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-03-28 19:14:04 +00:00
|
|
|
struct dirent_gather {
|
|
|
|
const struct gfs2_dirent **pdent;
|
|
|
|
unsigned offset;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int gfs2_dirent_gather(const struct gfs2_dirent *dent,
|
|
|
|
const struct qstr *name,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
struct dirent_gather *g = opaque;
|
2006-11-17 17:27:44 +00:00
|
|
|
if (!gfs2_dirent_sentinel(dent)) {
|
2006-03-28 19:14:04 +00:00
|
|
|
g->pdent[g->offset++] = dent;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
/*
|
|
|
|
* Other possible things to check:
|
|
|
|
* - Inode located within filesystem size (and on valid block)
|
|
|
|
* - Valid directory entry type
|
|
|
|
* Not sure how heavy-weight we want to make this... could also check
|
|
|
|
* hash is correct for example, but that would take a lot of extra time.
|
|
|
|
* For now the most important thing is to check that the various sizes
|
|
|
|
* are correct.
|
|
|
|
*/
|
|
|
|
static int gfs2_check_dirent(struct gfs2_dirent *dent, unsigned int offset,
|
|
|
|
unsigned int size, unsigned int len, int first)
|
|
|
|
{
|
|
|
|
const char *msg = "gfs2_dirent too small";
|
|
|
|
if (unlikely(size < sizeof(struct gfs2_dirent)))
|
|
|
|
goto error;
|
|
|
|
msg = "gfs2_dirent misaligned";
|
|
|
|
if (unlikely(offset & 0x7))
|
|
|
|
goto error;
|
|
|
|
msg = "gfs2_dirent points beyond end of block";
|
|
|
|
if (unlikely(offset + size > len))
|
|
|
|
goto error;
|
|
|
|
msg = "zero inode number";
|
2006-11-17 17:27:44 +00:00
|
|
|
if (unlikely(!first && gfs2_dirent_sentinel(dent)))
|
2006-03-20 17:30:04 +00:00
|
|
|
goto error;
|
|
|
|
msg = "name length is greater than space in dirent";
|
2006-11-17 17:27:44 +00:00
|
|
|
if (!gfs2_dirent_sentinel(dent) &&
|
2006-03-20 17:30:04 +00:00
|
|
|
unlikely(sizeof(struct gfs2_dirent)+be16_to_cpu(dent->de_name_len) >
|
|
|
|
size))
|
|
|
|
goto error;
|
|
|
|
return 0;
|
|
|
|
error:
|
2014-03-06 20:10:45 +00:00
|
|
|
pr_warn("%s: %s (%s)\n",
|
|
|
|
__func__, msg, first ? "first in block" : "not first in block");
|
2006-03-20 17:30:04 +00:00
|
|
|
return -EIO;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2006-03-28 19:14:04 +00:00
|
|
|
static int gfs2_dirent_offset(const void *buf)
|
2006-03-20 17:30:04 +00:00
|
|
|
{
|
2006-03-28 19:14:04 +00:00
|
|
|
const struct gfs2_meta_header *h = buf;
|
|
|
|
int offset;
|
2006-03-20 17:30:04 +00:00
|
|
|
|
|
|
|
BUG_ON(buf == NULL);
|
|
|
|
|
2006-03-30 20:46:23 +00:00
|
|
|
switch(be32_to_cpu(h->mh_type)) {
|
2006-03-20 17:30:04 +00:00
|
|
|
case GFS2_METATYPE_LF:
|
|
|
|
offset = sizeof(struct gfs2_leaf);
|
|
|
|
break;
|
|
|
|
case GFS2_METATYPE_DI:
|
|
|
|
offset = sizeof(struct gfs2_dinode);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto wrong_type;
|
|
|
|
}
|
2006-03-28 19:14:04 +00:00
|
|
|
return offset;
|
|
|
|
wrong_type:
|
2014-03-06 20:10:45 +00:00
|
|
|
pr_warn("%s: wrong block type %u\n", __func__, be32_to_cpu(h->mh_type));
|
2006-03-28 19:14:04 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2006-09-05 13:34:20 +00:00
|
|
|
static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode, void *buf,
|
2006-03-28 19:14:04 +00:00
|
|
|
unsigned int len, gfs2_dscan_t scan,
|
|
|
|
const struct qstr *name,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
struct gfs2_dirent *dent, *prev;
|
|
|
|
unsigned offset;
|
|
|
|
unsigned size;
|
|
|
|
int ret = 0;
|
2006-03-20 17:30:04 +00:00
|
|
|
|
2006-03-28 19:14:04 +00:00
|
|
|
ret = gfs2_dirent_offset(buf);
|
|
|
|
if (ret < 0)
|
|
|
|
goto consist_inode;
|
|
|
|
|
|
|
|
offset = ret;
|
2006-03-20 17:30:04 +00:00
|
|
|
prev = NULL;
|
2006-09-05 13:34:20 +00:00
|
|
|
dent = buf + offset;
|
2006-03-20 17:30:04 +00:00
|
|
|
size = be16_to_cpu(dent->de_rec_len);
|
|
|
|
if (gfs2_check_dirent(dent, offset, size, len, 1))
|
|
|
|
goto consist_inode;
|
|
|
|
do {
|
2006-03-28 19:14:04 +00:00
|
|
|
ret = scan(dent, name, opaque);
|
2006-03-20 17:30:04 +00:00
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
offset += size;
|
|
|
|
if (offset == len)
|
|
|
|
break;
|
|
|
|
prev = dent;
|
2006-09-05 13:34:20 +00:00
|
|
|
dent = buf + offset;
|
2006-03-20 17:30:04 +00:00
|
|
|
size = be16_to_cpu(dent->de_rec_len);
|
|
|
|
if (gfs2_check_dirent(dent, offset, size, len, 0))
|
|
|
|
goto consist_inode;
|
|
|
|
} while(1);
|
|
|
|
|
|
|
|
switch(ret) {
|
|
|
|
case 0:
|
|
|
|
return NULL;
|
|
|
|
case 1:
|
|
|
|
return dent;
|
|
|
|
case 2:
|
|
|
|
return prev ? prev : dent;
|
|
|
|
default:
|
|
|
|
BUG_ON(ret > 0);
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
consist_inode:
|
2006-06-14 19:32:57 +00:00
|
|
|
gfs2_consist_inode(GFS2_I(inode));
|
2006-03-20 17:30:04 +00:00
|
|
|
return ERR_PTR(-EIO);
|
|
|
|
}
|
|
|
|
|
2006-09-05 13:34:20 +00:00
|
|
|
static int dirent_check_reclen(struct gfs2_inode *dip,
|
|
|
|
const struct gfs2_dirent *d, const void *end_p)
|
|
|
|
{
|
|
|
|
const void *ptr = d;
|
|
|
|
u16 rec_len = be16_to_cpu(d->de_rec_len);
|
|
|
|
|
|
|
|
if (unlikely(rec_len < sizeof(struct gfs2_dirent)))
|
|
|
|
goto broken;
|
|
|
|
ptr += rec_len;
|
|
|
|
if (ptr < end_p)
|
|
|
|
return rec_len;
|
|
|
|
if (ptr == end_p)
|
|
|
|
return -ENOENT;
|
|
|
|
broken:
|
|
|
|
gfs2_consist_inode(dip);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/**
|
|
|
|
* dirent_next - Next dirent
|
|
|
|
* @dip: the directory
|
|
|
|
* @bh: The buffer
|
|
|
|
* @dent: Pointer to list of dirents
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, error code otherwise
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int dirent_next(struct gfs2_inode *dip, struct buffer_head *bh,
|
|
|
|
struct gfs2_dirent **dent)
|
|
|
|
{
|
2006-09-05 13:34:20 +00:00
|
|
|
struct gfs2_dirent *cur = *dent, *tmp;
|
|
|
|
char *bh_end = bh->b_data + bh->b_size;
|
|
|
|
int ret;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-09-05 13:34:20 +00:00
|
|
|
ret = dirent_check_reclen(dip, cur, bh_end);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2006-02-14 15:56:44 +00:00
|
|
|
|
2006-09-05 13:34:20 +00:00
|
|
|
tmp = (void *)cur + ret;
|
|
|
|
ret = dirent_check_reclen(dip, tmp, bh_end);
|
|
|
|
if (ret == -EIO)
|
|
|
|
return ret;
|
2006-02-14 15:56:44 +00:00
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/* Only the first dent could ever have de_inum.no_addr == 0 */
|
2006-11-17 17:27:44 +00:00
|
|
|
if (gfs2_dirent_sentinel(tmp)) {
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_consist_inode(dip);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
*dent = tmp;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dirent_del - Delete a dirent
|
|
|
|
* @dip: The GFS2 inode
|
|
|
|
* @bh: The buffer
|
|
|
|
* @prev: The previous dirent
|
|
|
|
* @cur: The current dirent
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void dirent_del(struct gfs2_inode *dip, struct buffer_head *bh,
|
|
|
|
struct gfs2_dirent *prev, struct gfs2_dirent *cur)
|
|
|
|
{
|
2006-09-04 16:49:07 +00:00
|
|
|
u16 cur_rec_len, prev_rec_len;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-11-17 17:27:44 +00:00
|
|
|
if (gfs2_dirent_sentinel(cur)) {
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_consist_inode(dip);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(dip->i_gl, bh);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
/* If there is no prev entry, this is the first entry in the block.
|
|
|
|
The de_rec_len is already as big as it needs to be. Just zero
|
|
|
|
out the inode number and return. */
|
|
|
|
|
|
|
|
if (!prev) {
|
2006-11-17 17:27:44 +00:00
|
|
|
cur->de_inum.no_addr = 0;
|
|
|
|
cur->de_inum.no_formal_ino = 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Combine this dentry with the previous one. */
|
|
|
|
|
2006-02-13 16:21:47 +00:00
|
|
|
prev_rec_len = be16_to_cpu(prev->de_rec_len);
|
|
|
|
cur_rec_len = be16_to_cpu(cur->de_rec_len);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if ((char *)prev + prev_rec_len != (char *)cur)
|
|
|
|
gfs2_consist_inode(dip);
|
|
|
|
if ((char *)cur + cur_rec_len > bh->b_data + bh->b_size)
|
|
|
|
gfs2_consist_inode(dip);
|
|
|
|
|
|
|
|
prev_rec_len += cur_rec_len;
|
2006-02-13 16:21:47 +00:00
|
|
|
prev->de_rec_len = cpu_to_be16(prev_rec_len);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
/*
|
|
|
|
* Takes a dent from which to grab space as an argument. Returns the
|
|
|
|
* newly created dent.
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
2006-04-28 14:59:12 +00:00
|
|
|
static struct gfs2_dirent *gfs2_init_dirent(struct inode *inode,
|
|
|
|
struct gfs2_dirent *dent,
|
|
|
|
const struct qstr *name,
|
|
|
|
struct buffer_head *bh)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2006-03-20 17:30:04 +00:00
|
|
|
struct gfs2_dirent *ndent;
|
|
|
|
unsigned offset = 0, totlen;
|
|
|
|
|
2006-11-17 17:27:44 +00:00
|
|
|
if (!gfs2_dirent_sentinel(dent))
|
2006-03-20 17:30:04 +00:00
|
|
|
offset = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
|
|
|
|
totlen = be16_to_cpu(dent->de_rec_len);
|
|
|
|
BUG_ON(offset + name->len > totlen);
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(ip->i_gl, bh);
|
2006-03-20 17:30:04 +00:00
|
|
|
ndent = (struct gfs2_dirent *)((char *)dent + offset);
|
|
|
|
dent->de_rec_len = cpu_to_be16(offset);
|
|
|
|
gfs2_qstr2dirent(name, totlen - offset, ndent);
|
|
|
|
return ndent;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
static struct gfs2_dirent *gfs2_dirent_alloc(struct inode *inode,
|
|
|
|
struct buffer_head *bh,
|
|
|
|
const struct qstr *name)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
|
|
|
struct gfs2_dirent *dent;
|
2006-09-25 13:26:04 +00:00
|
|
|
dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
|
2006-03-28 19:14:04 +00:00
|
|
|
gfs2_dirent_find_space, name, NULL);
|
2006-03-20 17:30:04 +00:00
|
|
|
if (!dent || IS_ERR(dent))
|
|
|
|
return dent;
|
|
|
|
return gfs2_init_dirent(inode, dent, name, bh);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2006-09-04 16:49:07 +00:00
|
|
|
static int get_leaf(struct gfs2_inode *dip, u64 leaf_no,
|
2006-01-16 16:50:04 +00:00
|
|
|
struct buffer_head **bhp)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2006-09-21 21:05:23 +00:00
|
|
|
error = gfs2_meta_read(dip->i_gl, leaf_no, DIO_WAIT, bhp);
|
2006-06-14 19:32:57 +00:00
|
|
|
if (!error && gfs2_metatype_check(GFS2_SB(&dip->i_inode), *bhp, GFS2_METATYPE_LF)) {
|
2014-03-06 20:10:45 +00:00
|
|
|
/* pr_info("block num=%llu\n", leaf_no); */
|
2006-01-16 16:50:04 +00:00
|
|
|
error = -EIO;
|
2006-06-14 19:32:57 +00:00
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get_leaf_nr - Get a leaf number associated with the index
|
|
|
|
* @dip: The GFS2 inode
|
|
|
|
* @index:
|
|
|
|
* @leaf_out:
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, error code otherwise
|
|
|
|
*/
|
|
|
|
|
2006-09-04 16:49:07 +00:00
|
|
|
static int get_leaf_nr(struct gfs2_inode *dip, u32 index,
|
|
|
|
u64 *leaf_out)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2011-06-15 09:29:37 +00:00
|
|
|
__be64 *hash;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2011-06-15 09:29:37 +00:00
|
|
|
hash = gfs2_dir_get_hash_table(dip);
|
|
|
|
if (IS_ERR(hash))
|
|
|
|
return PTR_ERR(hash);
|
|
|
|
*leaf_out = be64_to_cpu(*(hash + index));
|
2006-01-16 16:50:04 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-04 16:49:07 +00:00
|
|
|
static int get_first_leaf(struct gfs2_inode *dip, u32 index,
|
2006-01-16 16:50:04 +00:00
|
|
|
struct buffer_head **bh_out)
|
|
|
|
{
|
2006-09-04 16:49:07 +00:00
|
|
|
u64 leaf_no;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
error = get_leaf_nr(dip, index, &leaf_no);
|
|
|
|
if (!error)
|
|
|
|
error = get_leaf(dip, leaf_no, bh_out);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
static struct gfs2_dirent *gfs2_dirent_search(struct inode *inode,
|
|
|
|
const struct qstr *name,
|
|
|
|
gfs2_dscan_t scan,
|
|
|
|
struct buffer_head **pbh)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-03-20 17:30:04 +00:00
|
|
|
struct buffer_head *bh;
|
|
|
|
struct gfs2_dirent *dent;
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
|
|
|
|
2008-11-04 10:05:22 +00:00
|
|
|
if (ip->i_diskflags & GFS2_DIF_EXHASH) {
|
2006-03-20 17:30:04 +00:00
|
|
|
struct gfs2_leaf *leaf;
|
2008-02-01 09:23:44 +00:00
|
|
|
unsigned hsize = 1 << ip->i_depth;
|
2006-03-20 17:30:04 +00:00
|
|
|
unsigned index;
|
|
|
|
u64 ln;
|
2010-08-11 08:53:11 +00:00
|
|
|
if (hsize * sizeof(u64) != i_size_read(inode)) {
|
2006-03-20 17:30:04 +00:00
|
|
|
gfs2_consist_inode(ip);
|
|
|
|
return ERR_PTR(-EIO);
|
|
|
|
}
|
2006-09-25 13:26:04 +00:00
|
|
|
|
2008-02-01 09:23:44 +00:00
|
|
|
index = name->hash >> (32 - ip->i_depth);
|
2006-03-20 17:30:04 +00:00
|
|
|
error = get_first_leaf(ip, index, &bh);
|
|
|
|
if (error)
|
|
|
|
return ERR_PTR(error);
|
|
|
|
do {
|
|
|
|
dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
|
2006-03-28 19:14:04 +00:00
|
|
|
scan, name, NULL);
|
2006-03-20 17:30:04 +00:00
|
|
|
if (dent)
|
|
|
|
goto got_dent;
|
|
|
|
leaf = (struct gfs2_leaf *)bh->b_data;
|
|
|
|
ln = be64_to_cpu(leaf->lf_next);
|
2006-04-11 18:49:06 +00:00
|
|
|
brelse(bh);
|
2006-03-20 17:30:04 +00:00
|
|
|
if (!ln)
|
|
|
|
break;
|
2006-09-25 13:26:04 +00:00
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
error = get_leaf(ip, ln, &bh);
|
|
|
|
} while(!error);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
return error ? ERR_PTR(error) : NULL;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2006-09-25 13:26:04 +00:00
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
error = gfs2_meta_inode_buffer(ip, &bh);
|
|
|
|
if (error)
|
|
|
|
return ERR_PTR(error);
|
2006-03-28 19:14:04 +00:00
|
|
|
dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size, scan, name, NULL);
|
2006-03-20 17:30:04 +00:00
|
|
|
got_dent:
|
2006-04-11 18:49:06 +00:00
|
|
|
if (unlikely(dent == NULL || IS_ERR(dent))) {
|
2006-04-07 20:28:07 +00:00
|
|
|
brelse(bh);
|
|
|
|
bh = NULL;
|
|
|
|
}
|
2006-03-20 17:30:04 +00:00
|
|
|
*pbh = bh;
|
|
|
|
return dent;
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh, u16 depth)
|
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2008-02-06 10:11:15 +00:00
|
|
|
unsigned int n = 1;
|
2009-05-20 09:48:47 +00:00
|
|
|
u64 bn;
|
|
|
|
int error;
|
|
|
|
struct buffer_head *bh;
|
2006-03-20 17:30:04 +00:00
|
|
|
struct gfs2_leaf *leaf;
|
|
|
|
struct gfs2_dirent *dent;
|
2012-05-10 20:14:12 +00:00
|
|
|
struct qstr name = { .name = "" };
|
2014-01-08 12:14:57 +00:00
|
|
|
struct timespec tv = CURRENT_TIME;
|
2009-05-20 09:48:47 +00:00
|
|
|
|
2011-11-18 15:58:32 +00:00
|
|
|
error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
|
2009-05-20 09:48:47 +00:00
|
|
|
if (error)
|
|
|
|
return NULL;
|
|
|
|
bh = gfs2_meta_new(ip->i_gl, bn);
|
2006-03-20 17:30:04 +00:00
|
|
|
if (!bh)
|
|
|
|
return NULL;
|
2009-05-20 09:48:47 +00:00
|
|
|
|
2008-02-01 13:16:55 +00:00
|
|
|
gfs2_trans_add_unrevoke(GFS2_SB(inode), bn, 1);
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(ip->i_gl, bh);
|
2006-03-20 17:30:04 +00:00
|
|
|
gfs2_metatype_set(bh, GFS2_METATYPE_LF, GFS2_FORMAT_LF);
|
|
|
|
leaf = (struct gfs2_leaf *)bh->b_data;
|
|
|
|
leaf->lf_depth = cpu_to_be16(depth);
|
2006-09-05 13:34:20 +00:00
|
|
|
leaf->lf_entries = 0;
|
2006-10-14 15:49:30 +00:00
|
|
|
leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
|
2006-09-05 13:34:20 +00:00
|
|
|
leaf->lf_next = 0;
|
2014-01-08 12:14:57 +00:00
|
|
|
leaf->lf_inode = cpu_to_be64(ip->i_no_addr);
|
|
|
|
leaf->lf_dist = cpu_to_be32(1);
|
|
|
|
leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
|
|
|
|
leaf->lf_sec = cpu_to_be64(tv.tv_sec);
|
|
|
|
memset(leaf->lf_reserved2, 0, sizeof(leaf->lf_reserved2));
|
2006-03-20 17:30:04 +00:00
|
|
|
dent = (struct gfs2_dirent *)(leaf+1);
|
2006-03-28 19:14:04 +00:00
|
|
|
gfs2_qstr2dirent(&name, bh->b_size - sizeof(struct gfs2_leaf), dent);
|
2006-03-20 17:30:04 +00:00
|
|
|
*pbh = bh;
|
|
|
|
return leaf;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dir_make_exhash - Convert a stuffed directory into an ExHash directory
|
|
|
|
* @dip: The GFS2 inode
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, error code otherwise
|
|
|
|
*/
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
static int dir_make_exhash(struct inode *inode)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *dip = GFS2_I(inode);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_dirent *dent;
|
2006-03-20 17:30:04 +00:00
|
|
|
struct qstr args;
|
2006-01-16 16:50:04 +00:00
|
|
|
struct buffer_head *bh, *dibh;
|
|
|
|
struct gfs2_leaf *leaf;
|
|
|
|
int y;
|
2006-09-04 16:49:07 +00:00
|
|
|
u32 x;
|
2006-10-14 14:46:30 +00:00
|
|
|
__be64 *lp;
|
|
|
|
u64 bn;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(dip, &dibh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/* Turn over a new leaf */
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
leaf = new_leaf(inode, &bh, 0);
|
|
|
|
if (!leaf)
|
|
|
|
return -ENOSPC;
|
|
|
|
bn = bh->b_blocknr;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2008-11-03 13:59:19 +00:00
|
|
|
gfs2_assert(sdp, dip->i_entries < (1 << 16));
|
|
|
|
leaf->lf_entries = cpu_to_be16(dip->i_entries);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
/* Copy dirents */
|
|
|
|
|
|
|
|
gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_leaf), dibh,
|
|
|
|
sizeof(struct gfs2_dinode));
|
|
|
|
|
|
|
|
/* Find last entry */
|
|
|
|
|
|
|
|
x = 0;
|
2006-03-20 17:30:04 +00:00
|
|
|
args.len = bh->b_size - sizeof(struct gfs2_dinode) +
|
|
|
|
sizeof(struct gfs2_leaf);
|
|
|
|
args.name = bh->b_data;
|
2006-06-14 19:32:57 +00:00
|
|
|
dent = gfs2_dirent_scan(&dip->i_inode, bh->b_data, bh->b_size,
|
2006-03-28 19:14:04 +00:00
|
|
|
gfs2_dirent_last, &args, NULL);
|
2006-03-20 17:30:04 +00:00
|
|
|
if (!dent) {
|
|
|
|
brelse(bh);
|
|
|
|
brelse(dibh);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
if (IS_ERR(dent)) {
|
|
|
|
brelse(bh);
|
|
|
|
brelse(dibh);
|
|
|
|
return PTR_ERR(dent);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Adjust the last dirent's record length
|
|
|
|
(Remember that dent still points to the last entry.) */
|
|
|
|
|
2006-02-14 15:56:44 +00:00
|
|
|
dent->de_rec_len = cpu_to_be16(be16_to_cpu(dent->de_rec_len) +
|
2006-01-16 16:50:04 +00:00
|
|
|
sizeof(struct gfs2_dinode) -
|
2006-02-14 15:56:44 +00:00
|
|
|
sizeof(struct gfs2_leaf));
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
brelse(bh);
|
|
|
|
|
|
|
|
/* We're done with the new leaf block, now setup the new
|
|
|
|
hash table. */
|
|
|
|
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(dip->i_gl, dibh);
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
|
|
|
|
|
2006-10-14 14:46:30 +00:00
|
|
|
lp = (__be64 *)(dibh->b_data + sizeof(struct gfs2_dinode));
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
for (x = sdp->sd_hash_ptrs; x--; lp++)
|
|
|
|
*lp = cpu_to_be64(bn);
|
|
|
|
|
2010-08-11 08:53:11 +00:00
|
|
|
i_size_write(inode, sdp->sd_sb.sb_bsize / 2);
|
2008-02-12 14:17:27 +00:00
|
|
|
gfs2_add_inode_blocks(&dip->i_inode, 1);
|
2008-11-04 10:05:22 +00:00
|
|
|
dip->i_diskflags |= GFS2_DIF_EXHASH;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
for (x = sdp->sd_hash_ptrs, y = -1; x; x >>= 1, y++) ;
|
2008-02-01 09:23:44 +00:00
|
|
|
dip->i_depth = y;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-10-31 20:07:05 +00:00
|
|
|
gfs2_dinode_out(dip, dibh->b_data);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
brelse(dibh);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dir_split_leaf - Split a leaf block into two
|
|
|
|
* @dip: The GFS2 inode
|
|
|
|
* @index:
|
|
|
|
* @leaf_no:
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, error code on failure
|
|
|
|
*/
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
static int dir_split_leaf(struct inode *inode, const struct qstr *name)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *dip = GFS2_I(inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
struct buffer_head *nbh, *obh, *dibh;
|
|
|
|
struct gfs2_leaf *nleaf, *oleaf;
|
2006-07-11 17:19:13 +00:00
|
|
|
struct gfs2_dirent *dent = NULL, *prev = NULL, *next = NULL, *new;
|
2006-09-04 16:49:07 +00:00
|
|
|
u32 start, len, half_len, divider;
|
2006-10-14 14:46:30 +00:00
|
|
|
u64 bn, leaf_no;
|
|
|
|
__be64 *lp;
|
2006-09-04 16:49:07 +00:00
|
|
|
u32 index;
|
2006-01-16 16:50:04 +00:00
|
|
|
int x, moved = 0;
|
|
|
|
int error;
|
|
|
|
|
2008-02-01 09:23:44 +00:00
|
|
|
index = name->hash >> (32 - dip->i_depth);
|
2006-03-20 17:30:04 +00:00
|
|
|
error = get_leaf_nr(dip, index, &leaf_no);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
/* Get the old leaf block */
|
|
|
|
error = get_leaf(dip, leaf_no, &obh);
|
|
|
|
if (error)
|
2006-03-30 00:02:15 +00:00
|
|
|
return error;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
oleaf = (struct gfs2_leaf *)obh->b_data;
|
2008-02-01 09:23:44 +00:00
|
|
|
if (dip->i_depth == be16_to_cpu(oleaf->lf_depth)) {
|
2006-03-30 00:02:15 +00:00
|
|
|
brelse(obh);
|
|
|
|
return 1; /* can't split */
|
|
|
|
}
|
|
|
|
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(dip->i_gl, obh);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
nleaf = new_leaf(inode, &nbh, be16_to_cpu(oleaf->lf_depth) + 1);
|
|
|
|
if (!nleaf) {
|
|
|
|
brelse(obh);
|
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
bn = nbh->b_blocknr;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
/* Compute the start and len of leaf pointers in the hash table. */
|
2008-02-01 09:23:44 +00:00
|
|
|
len = 1 << (dip->i_depth - be16_to_cpu(oleaf->lf_depth));
|
2006-01-16 16:50:04 +00:00
|
|
|
half_len = len >> 1;
|
|
|
|
if (!half_len) {
|
2014-03-06 20:10:45 +00:00
|
|
|
pr_warn("i_depth %u lf_depth %u index %u\n",
|
|
|
|
dip->i_depth, be16_to_cpu(oleaf->lf_depth), index);
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_consist_inode(dip);
|
|
|
|
error = -EIO;
|
|
|
|
goto fail_brelse;
|
|
|
|
}
|
|
|
|
|
|
|
|
start = (index & ~(len - 1));
|
|
|
|
|
|
|
|
/* Change the pointers.
|
|
|
|
Don't bother distinguishing stuffed from non-stuffed.
|
|
|
|
This code is complicated enough already. */
|
2010-07-21 02:45:03 +00:00
|
|
|
lp = kmalloc(half_len * sizeof(__be64), GFP_NOFS);
|
|
|
|
if (!lp) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto fail_brelse;
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/* Change the pointers */
|
|
|
|
for (x = 0; x < half_len; x++)
|
|
|
|
lp[x] = cpu_to_be64(bn);
|
|
|
|
|
2011-06-15 09:29:37 +00:00
|
|
|
gfs2_dir_hash_inval(dip);
|
|
|
|
|
2006-09-04 16:49:07 +00:00
|
|
|
error = gfs2_dir_write_data(dip, (char *)lp, start * sizeof(u64),
|
|
|
|
half_len * sizeof(u64));
|
|
|
|
if (error != half_len * sizeof(u64)) {
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error >= 0)
|
|
|
|
error = -EIO;
|
|
|
|
goto fail_lpfree;
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(lp);
|
|
|
|
|
|
|
|
/* Compute the divider */
|
2008-02-01 09:23:44 +00:00
|
|
|
divider = (start + half_len) << (32 - dip->i_depth);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
/* Copy the entries */
|
2009-11-06 11:06:37 +00:00
|
|
|
dent = (struct gfs2_dirent *)(obh->b_data + sizeof(struct gfs2_leaf));
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
do {
|
|
|
|
next = dent;
|
|
|
|
if (dirent_next(dip, obh, &next))
|
|
|
|
next = NULL;
|
|
|
|
|
2006-11-17 17:27:44 +00:00
|
|
|
if (!gfs2_dirent_sentinel(dent) &&
|
2006-01-16 16:50:04 +00:00
|
|
|
be32_to_cpu(dent->de_hash) < divider) {
|
2006-03-20 17:30:04 +00:00
|
|
|
struct qstr str;
|
|
|
|
str.name = (char*)(dent+1);
|
|
|
|
str.len = be16_to_cpu(dent->de_name_len);
|
|
|
|
str.hash = be32_to_cpu(dent->de_hash);
|
2006-03-28 19:14:04 +00:00
|
|
|
new = gfs2_dirent_alloc(inode, nbh, &str);
|
2006-03-20 17:30:04 +00:00
|
|
|
if (IS_ERR(new)) {
|
|
|
|
error = PTR_ERR(new);
|
|
|
|
break;
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
new->de_inum = dent->de_inum; /* No endian worries */
|
|
|
|
new->de_type = dent->de_type; /* No endian worries */
|
2008-02-12 23:06:10 +00:00
|
|
|
be16_add_cpu(&nleaf->lf_entries, 1);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
dirent_del(dip, obh, prev, dent);
|
|
|
|
|
|
|
|
if (!oleaf->lf_entries)
|
|
|
|
gfs2_consist_inode(dip);
|
2008-02-12 23:06:10 +00:00
|
|
|
be16_add_cpu(&oleaf->lf_entries, -1);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (!prev)
|
|
|
|
prev = dent;
|
|
|
|
|
|
|
|
moved = 1;
|
2006-03-20 17:30:04 +00:00
|
|
|
} else {
|
2006-01-16 16:50:04 +00:00
|
|
|
prev = dent;
|
2006-03-20 17:30:04 +00:00
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
dent = next;
|
2006-03-20 17:30:04 +00:00
|
|
|
} while (dent);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
oleaf->lf_depth = nleaf->lf_depth;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(dip, &dibh);
|
2006-06-14 19:32:57 +00:00
|
|
|
if (!gfs2_assert_withdraw(GFS2_SB(&dip->i_inode), !error)) {
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(dip->i_gl, dibh);
|
2008-02-12 14:17:27 +00:00
|
|
|
gfs2_add_inode_blocks(&dip->i_inode, 1);
|
2006-10-31 20:07:05 +00:00
|
|
|
gfs2_dinode_out(dip, dibh->b_data);
|
2006-01-16 16:50:04 +00:00
|
|
|
brelse(dibh);
|
|
|
|
}
|
|
|
|
|
|
|
|
brelse(obh);
|
|
|
|
brelse(nbh);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
|
2006-03-30 00:02:15 +00:00
|
|
|
fail_lpfree:
|
2006-01-16 16:50:04 +00:00
|
|
|
kfree(lp);
|
|
|
|
|
2006-03-30 00:02:15 +00:00
|
|
|
fail_brelse:
|
2006-01-16 16:50:04 +00:00
|
|
|
brelse(obh);
|
|
|
|
brelse(nbh);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dir_double_exhash - Double size of ExHash table
|
|
|
|
* @dip: The GFS2 dinode
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, error code on failure
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int dir_double_exhash(struct gfs2_inode *dip)
|
|
|
|
{
|
|
|
|
struct buffer_head *dibh;
|
2006-09-04 16:49:07 +00:00
|
|
|
u32 hsize;
|
2011-06-15 09:29:37 +00:00
|
|
|
u32 hsize_bytes;
|
|
|
|
__be64 *hc;
|
|
|
|
__be64 *hc2, *h;
|
2006-01-16 16:50:04 +00:00
|
|
|
int x;
|
|
|
|
int error = 0;
|
|
|
|
|
2008-02-01 09:23:44 +00:00
|
|
|
hsize = 1 << dip->i_depth;
|
2011-06-15 09:29:37 +00:00
|
|
|
hsize_bytes = hsize * sizeof(__be64);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2011-06-15 09:29:37 +00:00
|
|
|
hc = gfs2_dir_get_hash_table(dip);
|
|
|
|
if (IS_ERR(hc))
|
|
|
|
return PTR_ERR(hc);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-06-14 12:39:18 +00:00
|
|
|
hc2 = kmalloc(hsize_bytes * 2, GFP_NOFS | __GFP_NOWARN);
|
2013-05-30 13:48:56 +00:00
|
|
|
if (hc2 == NULL)
|
|
|
|
hc2 = __vmalloc(hsize_bytes * 2, GFP_NOFS, PAGE_KERNEL);
|
|
|
|
|
2011-06-15 09:29:37 +00:00
|
|
|
if (!hc2)
|
2010-07-21 02:45:03 +00:00
|
|
|
return -ENOMEM;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-06-14 12:39:18 +00:00
|
|
|
h = hc2;
|
2011-06-15 09:29:37 +00:00
|
|
|
error = gfs2_meta_inode_buffer(dip, &dibh);
|
|
|
|
if (error)
|
|
|
|
goto out_kfree;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2011-06-15 09:29:37 +00:00
|
|
|
for (x = 0; x < hsize; x++) {
|
|
|
|
*h++ = *hc;
|
|
|
|
*h++ = *hc;
|
|
|
|
hc++;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2011-06-15 09:29:37 +00:00
|
|
|
error = gfs2_dir_write_data(dip, (char *)hc2, 0, hsize_bytes * 2);
|
|
|
|
if (error != (hsize_bytes * 2))
|
|
|
|
goto fail;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2011-06-15 09:29:37 +00:00
|
|
|
gfs2_dir_hash_inval(dip);
|
|
|
|
dip->i_hash_cache = hc2;
|
|
|
|
dip->i_depth++;
|
|
|
|
gfs2_dinode_out(dip, dibh->b_data);
|
|
|
|
brelse(dibh);
|
|
|
|
return 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-09-04 16:04:26 +00:00
|
|
|
fail:
|
2011-06-15 09:29:37 +00:00
|
|
|
/* Replace original hash table & size */
|
|
|
|
gfs2_dir_write_data(dip, (char *)hc, 0, hsize_bytes);
|
|
|
|
i_size_write(&dip->i_inode, hsize_bytes);
|
|
|
|
gfs2_dinode_out(dip, dibh->b_data);
|
|
|
|
brelse(dibh);
|
|
|
|
out_kfree:
|
2014-11-20 05:18:38 +00:00
|
|
|
kvfree(hc2);
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* compare_dents - compare directory entries by hash value
|
|
|
|
* @a: first dent
|
|
|
|
* @b: second dent
|
|
|
|
*
|
|
|
|
* When comparing the hash entries of @a to @b:
|
|
|
|
* gt: returns 1
|
|
|
|
* lt: returns -1
|
|
|
|
* eq: returns 0
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int compare_dents(const void *a, const void *b)
|
|
|
|
{
|
2006-09-05 13:34:20 +00:00
|
|
|
const struct gfs2_dirent *dent_a, *dent_b;
|
2006-09-04 16:49:07 +00:00
|
|
|
u32 hash_a, hash_b;
|
2006-01-16 16:50:04 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
2006-09-05 13:34:20 +00:00
|
|
|
dent_a = *(const struct gfs2_dirent **)a;
|
2006-03-20 17:30:04 +00:00
|
|
|
hash_a = be32_to_cpu(dent_a->de_hash);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-09-05 13:34:20 +00:00
|
|
|
dent_b = *(const struct gfs2_dirent **)b;
|
2006-03-20 17:30:04 +00:00
|
|
|
hash_b = be32_to_cpu(dent_b->de_hash);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (hash_a > hash_b)
|
|
|
|
ret = 1;
|
|
|
|
else if (hash_a < hash_b)
|
|
|
|
ret = -1;
|
|
|
|
else {
|
2006-02-14 15:56:44 +00:00
|
|
|
unsigned int len_a = be16_to_cpu(dent_a->de_name_len);
|
|
|
|
unsigned int len_b = be16_to_cpu(dent_b->de_name_len);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (len_a > len_b)
|
|
|
|
ret = 1;
|
|
|
|
else if (len_a < len_b)
|
|
|
|
ret = -1;
|
|
|
|
else
|
2006-09-05 13:34:20 +00:00
|
|
|
ret = memcmp(dent_a + 1, dent_b + 1, len_a);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* do_filldir_main - read out directory entries
|
|
|
|
* @dip: The GFS2 inode
|
2013-05-16 18:14:48 +00:00
|
|
|
* @ctx: what to feed the entries to
|
2006-01-16 16:50:04 +00:00
|
|
|
* @darr: an array of struct gfs2_dirent pointers to read
|
|
|
|
* @entries: the number of entries in darr
|
|
|
|
* @copied: pointer to int that's non-zero if a entry has been copied out
|
|
|
|
*
|
|
|
|
* Jump through some hoops to make sure that if there are hash collsions,
|
|
|
|
* they are read out at the beginning of a buffer. We want to minimize
|
|
|
|
* the possibility that they will fall into different readdir buffers or
|
|
|
|
* that someone will want to seek to that location.
|
|
|
|
*
|
2013-05-16 18:14:48 +00:00
|
|
|
* Returns: errno, >0 if the actor tells you to stop
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
|
|
|
|
2013-05-16 18:14:48 +00:00
|
|
|
static int do_filldir_main(struct gfs2_inode *dip, struct dir_context *ctx,
|
2006-09-04 16:49:07 +00:00
|
|
|
const struct gfs2_dirent **darr, u32 entries,
|
2006-01-16 16:50:04 +00:00
|
|
|
int *copied)
|
|
|
|
{
|
2006-03-28 19:14:04 +00:00
|
|
|
const struct gfs2_dirent *dent, *dent_next;
|
2006-09-04 16:49:07 +00:00
|
|
|
u64 off, off_next;
|
2006-01-16 16:50:04 +00:00
|
|
|
unsigned int x, y;
|
|
|
|
int run = 0;
|
|
|
|
|
|
|
|
sort(darr, entries, sizeof(struct gfs2_dirent *), compare_dents, NULL);
|
|
|
|
|
|
|
|
dent_next = darr[0];
|
|
|
|
off_next = be32_to_cpu(dent_next->de_hash);
|
|
|
|
off_next = gfs2_disk_hash2offset(off_next);
|
|
|
|
|
|
|
|
for (x = 0, y = 1; x < entries; x++, y++) {
|
|
|
|
dent = dent_next;
|
|
|
|
off = off_next;
|
|
|
|
|
|
|
|
if (y < entries) {
|
|
|
|
dent_next = darr[y];
|
|
|
|
off_next = be32_to_cpu(dent_next->de_hash);
|
|
|
|
off_next = gfs2_disk_hash2offset(off_next);
|
|
|
|
|
2013-05-16 18:14:48 +00:00
|
|
|
if (off < ctx->pos)
|
2006-01-16 16:50:04 +00:00
|
|
|
continue;
|
2013-05-16 18:14:48 +00:00
|
|
|
ctx->pos = off;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (off_next == off) {
|
|
|
|
if (*copied && !run)
|
|
|
|
return 1;
|
|
|
|
run = 1;
|
|
|
|
} else
|
|
|
|
run = 0;
|
|
|
|
} else {
|
2013-05-16 18:14:48 +00:00
|
|
|
if (off < ctx->pos)
|
2006-01-16 16:50:04 +00:00
|
|
|
continue;
|
2013-05-16 18:14:48 +00:00
|
|
|
ctx->pos = off;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2013-05-16 18:14:48 +00:00
|
|
|
if (!dir_emit(ctx, (const char *)(dent + 1),
|
2006-02-14 15:56:44 +00:00
|
|
|
be16_to_cpu(dent->de_name_len),
|
2013-05-16 18:14:48 +00:00
|
|
|
be64_to_cpu(dent->de_inum.no_addr),
|
|
|
|
be16_to_cpu(dent->de_type)))
|
2006-01-16 16:50:04 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
*copied = 1;
|
|
|
|
}
|
|
|
|
|
2013-05-16 18:14:48 +00:00
|
|
|
/* Increment the ctx->pos by one, so the next time we come into the
|
2006-01-16 16:50:04 +00:00
|
|
|
do_filldir fxn, we get the next entry instead of the last one in the
|
|
|
|
current leaf */
|
|
|
|
|
2013-05-16 18:14:48 +00:00
|
|
|
ctx->pos++;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-07-28 16:56:23 +00:00
|
|
|
static void *gfs2_alloc_sort_buffer(unsigned size)
|
|
|
|
{
|
|
|
|
void *ptr = NULL;
|
|
|
|
|
|
|
|
if (size < KMALLOC_MAX_SIZE)
|
|
|
|
ptr = kmalloc(size, GFP_NOFS | __GFP_NOWARN);
|
|
|
|
if (!ptr)
|
|
|
|
ptr = __vmalloc(size, GFP_NOFS, PAGE_KERNEL);
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
2013-05-16 18:14:48 +00:00
|
|
|
static int gfs2_dir_read_leaf(struct inode *inode, struct dir_context *ctx,
|
|
|
|
int *copied, unsigned *depth,
|
2007-01-17 15:09:20 +00:00
|
|
|
u64 leaf_no)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2007-04-18 08:38:42 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2006-03-28 19:14:04 +00:00
|
|
|
struct buffer_head *bh;
|
|
|
|
struct gfs2_leaf *lf;
|
2007-04-18 08:38:42 +00:00
|
|
|
unsigned entries = 0, entries2 = 0;
|
2006-03-28 19:14:04 +00:00
|
|
|
unsigned leaves = 0;
|
|
|
|
const struct gfs2_dirent **darr, *dent;
|
|
|
|
struct dirent_gather g;
|
|
|
|
struct buffer_head **larr;
|
|
|
|
int leaf = 0;
|
|
|
|
int error, i;
|
|
|
|
u64 lfn = leaf_no;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
do {
|
2006-03-28 19:14:04 +00:00
|
|
|
error = get_leaf(ip, lfn, &bh);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
2006-03-28 19:14:04 +00:00
|
|
|
goto out;
|
|
|
|
lf = (struct gfs2_leaf *)bh->b_data;
|
|
|
|
if (leaves == 0)
|
|
|
|
*depth = be16_to_cpu(lf->lf_depth);
|
|
|
|
entries += be16_to_cpu(lf->lf_entries);
|
|
|
|
leaves++;
|
|
|
|
lfn = be64_to_cpu(lf->lf_next);
|
|
|
|
brelse(bh);
|
|
|
|
} while(lfn);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (!entries)
|
|
|
|
return 0;
|
|
|
|
|
2006-03-28 19:14:04 +00:00
|
|
|
error = -ENOMEM;
|
2007-04-18 08:38:42 +00:00
|
|
|
/*
|
|
|
|
* The extra 99 entries are not normally used, but are a buffer
|
|
|
|
* zone in case the number of entries in the leaf is corrupt.
|
|
|
|
* 99 is the maximum number of entries that can fit in a single
|
|
|
|
* leaf block.
|
|
|
|
*/
|
2010-07-28 16:56:23 +00:00
|
|
|
larr = gfs2_alloc_sort_buffer((leaves + entries + 99) * sizeof(void *));
|
2006-03-28 19:14:04 +00:00
|
|
|
if (!larr)
|
|
|
|
goto out;
|
|
|
|
darr = (const struct gfs2_dirent **)(larr + leaves);
|
|
|
|
g.pdent = darr;
|
|
|
|
g.offset = 0;
|
|
|
|
lfn = leaf_no;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-03-28 19:14:04 +00:00
|
|
|
do {
|
|
|
|
error = get_leaf(ip, lfn, &bh);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
2010-07-28 16:56:23 +00:00
|
|
|
goto out_free;
|
2006-03-28 19:14:04 +00:00
|
|
|
lf = (struct gfs2_leaf *)bh->b_data;
|
|
|
|
lfn = be64_to_cpu(lf->lf_next);
|
|
|
|
if (lf->lf_entries) {
|
2007-04-18 08:38:42 +00:00
|
|
|
entries2 += be16_to_cpu(lf->lf_entries);
|
2006-03-28 19:14:04 +00:00
|
|
|
dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
|
|
|
|
gfs2_dirent_gather, NULL, &g);
|
|
|
|
error = PTR_ERR(dent);
|
2007-04-18 08:38:42 +00:00
|
|
|
if (IS_ERR(dent))
|
2010-07-28 16:56:23 +00:00
|
|
|
goto out_free;
|
2007-04-18 08:38:42 +00:00
|
|
|
if (entries2 != g.offset) {
|
2007-04-26 04:08:02 +00:00
|
|
|
fs_warn(sdp, "Number of entries corrupt in dir "
|
|
|
|
"leaf %llu, entries2 (%u) != "
|
|
|
|
"g.offset (%u)\n",
|
|
|
|
(unsigned long long)bh->b_blocknr,
|
|
|
|
entries2, g.offset);
|
2007-04-18 08:38:42 +00:00
|
|
|
|
|
|
|
error = -EIO;
|
2010-07-28 16:56:23 +00:00
|
|
|
goto out_free;
|
2006-03-28 19:14:04 +00:00
|
|
|
}
|
|
|
|
error = 0;
|
|
|
|
larr[leaf++] = bh;
|
2006-01-16 16:50:04 +00:00
|
|
|
} else {
|
2006-03-28 19:14:04 +00:00
|
|
|
brelse(bh);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
2006-03-28 19:14:04 +00:00
|
|
|
} while(lfn);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2007-04-18 08:38:42 +00:00
|
|
|
BUG_ON(entries2 != entries);
|
2013-05-16 18:14:48 +00:00
|
|
|
error = do_filldir_main(ip, ctx, darr, entries, copied);
|
2010-07-28 16:56:23 +00:00
|
|
|
out_free:
|
2006-03-28 19:14:04 +00:00
|
|
|
for(i = 0; i < leaf; i++)
|
|
|
|
brelse(larr[i]);
|
2014-11-20 05:18:38 +00:00
|
|
|
kvfree(larr);
|
2006-03-28 19:14:04 +00:00
|
|
|
out:
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2011-11-09 13:46:06 +00:00
|
|
|
/**
|
|
|
|
* gfs2_dir_readahead - Issue read-ahead requests for leaf blocks.
|
2011-10-27 16:16:06 +00:00
|
|
|
*
|
|
|
|
* Note: we can't calculate each index like dir_e_read can because we don't
|
|
|
|
* have the leaf, and therefore we don't have the depth, and therefore we
|
|
|
|
* don't have the length. So we have to just read enough ahead to make up
|
2011-11-09 13:46:06 +00:00
|
|
|
* for the loss of information.
|
|
|
|
*/
|
2011-10-27 16:16:06 +00:00
|
|
|
static void gfs2_dir_readahead(struct inode *inode, unsigned hsize, u32 index,
|
|
|
|
struct file_ra_state *f_ra)
|
|
|
|
{
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_glock *gl = ip->i_gl;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
u64 blocknr = 0, last;
|
|
|
|
unsigned count;
|
|
|
|
|
|
|
|
/* First check if we've already read-ahead for the whole range. */
|
2011-11-09 13:46:06 +00:00
|
|
|
if (index + MAX_RA_BLOCKS < f_ra->start)
|
2011-10-27 16:16:06 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
f_ra->start = max((pgoff_t)index, f_ra->start);
|
|
|
|
for (count = 0; count < MAX_RA_BLOCKS; count++) {
|
|
|
|
if (f_ra->start >= hsize) /* if exceeded the hash table */
|
|
|
|
break;
|
|
|
|
|
|
|
|
last = blocknr;
|
|
|
|
blocknr = be64_to_cpu(ip->i_hash_cache[f_ra->start]);
|
|
|
|
f_ra->start++;
|
|
|
|
if (blocknr == last)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
bh = gfs2_getbuf(gl, blocknr, 1);
|
|
|
|
if (trylock_buffer(bh)) {
|
|
|
|
if (buffer_uptodate(bh)) {
|
|
|
|
unlock_buffer(bh);
|
|
|
|
brelse(bh);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
bh->b_end_io = end_buffer_read_sync;
|
|
|
|
submit_bh(READA | REQ_META, bh);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
brelse(bh);
|
|
|
|
}
|
|
|
|
}
|
2011-06-15 09:29:37 +00:00
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/**
|
2006-03-20 17:30:04 +00:00
|
|
|
* dir_e_read - Reads the entries from a directory into a filldir buffer
|
|
|
|
* @dip: dinode pointer
|
2013-05-16 18:14:48 +00:00
|
|
|
* @ctx: actor to feed the entries to
|
2006-01-16 16:50:04 +00:00
|
|
|
*
|
2006-03-20 17:30:04 +00:00
|
|
|
* Returns: errno
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
|
|
|
|
2013-05-16 18:14:48 +00:00
|
|
|
static int dir_e_read(struct inode *inode, struct dir_context *ctx,
|
|
|
|
struct file_ra_state *f_ra)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *dip = GFS2_I(inode);
|
2006-09-04 16:49:07 +00:00
|
|
|
u32 hsize, len = 0;
|
|
|
|
u32 hash, index;
|
2006-10-14 14:46:30 +00:00
|
|
|
__be64 *lp;
|
2006-03-20 17:30:04 +00:00
|
|
|
int copied = 0;
|
|
|
|
int error = 0;
|
2006-07-11 17:19:13 +00:00
|
|
|
unsigned depth = 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2008-02-01 09:23:44 +00:00
|
|
|
hsize = 1 << dip->i_depth;
|
2013-05-16 18:14:48 +00:00
|
|
|
hash = gfs2_dir_offset2hash(ctx->pos);
|
2008-02-01 09:23:44 +00:00
|
|
|
index = hash >> (32 - dip->i_depth);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2011-11-09 13:46:06 +00:00
|
|
|
if (dip->i_hash_cache == NULL)
|
2011-10-27 16:16:06 +00:00
|
|
|
f_ra->start = 0;
|
2011-06-15 09:29:37 +00:00
|
|
|
lp = gfs2_dir_get_hash_table(dip);
|
|
|
|
if (IS_ERR(lp))
|
|
|
|
return PTR_ERR(lp);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2011-10-27 16:16:06 +00:00
|
|
|
gfs2_dir_readahead(inode, hsize, index, f_ra);
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
while (index < hsize) {
|
2013-05-16 18:14:48 +00:00
|
|
|
error = gfs2_dir_read_leaf(inode, ctx,
|
2006-03-28 19:14:04 +00:00
|
|
|
&copied, &depth,
|
2011-06-15 09:29:37 +00:00
|
|
|
be64_to_cpu(lp[index]));
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
2006-03-28 19:14:04 +00:00
|
|
|
break;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2008-02-01 09:23:44 +00:00
|
|
|
len = 1 << (dip->i_depth - depth);
|
2006-01-16 16:50:04 +00:00
|
|
|
index = (index & ~(len - 1)) + len;
|
|
|
|
}
|
|
|
|
|
2006-03-28 19:14:04 +00:00
|
|
|
if (error > 0)
|
|
|
|
error = 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2013-05-16 18:14:48 +00:00
|
|
|
int gfs2_dir_read(struct inode *inode, struct dir_context *ctx,
|
|
|
|
struct file_ra_state *f_ra)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *dip = GFS2_I(inode);
|
2007-04-18 08:38:42 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2006-03-28 19:14:04 +00:00
|
|
|
struct dirent_gather g;
|
|
|
|
const struct gfs2_dirent **darr, *dent;
|
2006-01-16 16:50:04 +00:00
|
|
|
struct buffer_head *dibh;
|
|
|
|
int copied = 0;
|
|
|
|
int error;
|
|
|
|
|
2008-11-03 13:59:19 +00:00
|
|
|
if (!dip->i_entries)
|
2006-03-28 19:14:04 +00:00
|
|
|
return 0;
|
|
|
|
|
2008-11-04 10:05:22 +00:00
|
|
|
if (dip->i_diskflags & GFS2_DIF_EXHASH)
|
2013-05-16 18:14:48 +00:00
|
|
|
return dir_e_read(inode, ctx, f_ra);
|
2006-03-28 19:14:04 +00:00
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
if (!gfs2_is_stuffed(dip)) {
|
|
|
|
gfs2_consist_inode(dip);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(dip, &dibh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2006-03-28 19:14:04 +00:00
|
|
|
error = -ENOMEM;
|
2007-04-18 08:38:42 +00:00
|
|
|
/* 96 is max number of dirents which can be stuffed into an inode */
|
2008-04-09 13:33:41 +00:00
|
|
|
darr = kmalloc(96 * sizeof(struct gfs2_dirent *), GFP_NOFS);
|
2006-03-28 19:14:04 +00:00
|
|
|
if (darr) {
|
|
|
|
g.pdent = darr;
|
|
|
|
g.offset = 0;
|
|
|
|
dent = gfs2_dirent_scan(inode, dibh->b_data, dibh->b_size,
|
|
|
|
gfs2_dirent_gather, NULL, &g);
|
|
|
|
if (IS_ERR(dent)) {
|
|
|
|
error = PTR_ERR(dent);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-11-03 13:59:19 +00:00
|
|
|
if (dip->i_entries != g.offset) {
|
2007-04-18 08:38:42 +00:00
|
|
|
fs_warn(sdp, "Number of entries corrupt in dir %llu, "
|
2008-11-03 13:59:19 +00:00
|
|
|
"ip->i_entries (%u) != g.offset (%u)\n",
|
2007-05-15 14:37:50 +00:00
|
|
|
(unsigned long long)dip->i_no_addr,
|
2008-11-03 13:59:19 +00:00
|
|
|
dip->i_entries,
|
2007-04-18 08:38:42 +00:00
|
|
|
g.offset);
|
|
|
|
error = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
2013-05-16 18:14:48 +00:00
|
|
|
error = do_filldir_main(dip, ctx, darr,
|
2008-11-03 13:59:19 +00:00
|
|
|
dip->i_entries, &copied);
|
2006-03-28 19:14:04 +00:00
|
|
|
out:
|
|
|
|
kfree(darr);
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error > 0)
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
brelse(dibh);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_dir_search - Search a directory
|
2013-06-11 12:45:29 +00:00
|
|
|
* @dip: The GFS2 dir inode
|
|
|
|
* @name: The name we are looking up
|
|
|
|
* @fail_on_exist: Fail if the name exists rather than looking it up
|
2006-01-16 16:50:04 +00:00
|
|
|
*
|
|
|
|
* This routine searches a directory for a file or another directory.
|
|
|
|
* Assumes a glock is held on dip.
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
2013-06-11 12:45:29 +00:00
|
|
|
struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name,
|
|
|
|
bool fail_on_exist)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-03-20 17:30:04 +00:00
|
|
|
struct buffer_head *bh;
|
|
|
|
struct gfs2_dirent *dent;
|
2013-06-11 12:45:29 +00:00
|
|
|
u64 addr, formal_ino;
|
|
|
|
u16 dtype;
|
2007-05-15 14:37:50 +00:00
|
|
|
|
|
|
|
dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
|
|
|
|
if (dent) {
|
|
|
|
if (IS_ERR(dent))
|
2008-02-07 08:15:26 +00:00
|
|
|
return ERR_CAST(dent);
|
2013-06-11 12:45:29 +00:00
|
|
|
dtype = be16_to_cpu(dent->de_type);
|
|
|
|
addr = be64_to_cpu(dent->de_inum.no_addr);
|
|
|
|
formal_ino = be64_to_cpu(dent->de_inum.no_formal_ino);
|
2007-05-15 14:37:50 +00:00
|
|
|
brelse(bh);
|
2013-06-11 12:45:29 +00:00
|
|
|
if (fail_on_exist)
|
|
|
|
return ERR_PTR(-EEXIST);
|
|
|
|
return gfs2_inode_lookup(dir->i_sb, dtype, addr, formal_ino, 0);
|
2007-05-15 14:37:50 +00:00
|
|
|
}
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
}
|
|
|
|
|
|
|
|
int gfs2_dir_check(struct inode *dir, const struct qstr *name,
|
|
|
|
const struct gfs2_inode *ip)
|
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct gfs2_dirent *dent;
|
|
|
|
int ret = -ENOENT;
|
2006-03-20 17:30:04 +00:00
|
|
|
|
|
|
|
dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
|
|
|
|
if (dent) {
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
return PTR_ERR(dent);
|
2007-05-15 14:37:50 +00:00
|
|
|
if (ip) {
|
|
|
|
if (be64_to_cpu(dent->de_inum.no_addr) != ip->i_no_addr)
|
|
|
|
goto out;
|
|
|
|
if (be64_to_cpu(dent->de_inum.no_formal_ino) !=
|
|
|
|
ip->i_no_formal_ino)
|
|
|
|
goto out;
|
|
|
|
if (unlikely(IF2DT(ip->i_inode.i_mode) !=
|
|
|
|
be16_to_cpu(dent->de_type))) {
|
|
|
|
gfs2_consist_inode(GFS2_I(dir));
|
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
out:
|
2006-03-20 17:30:04 +00:00
|
|
|
brelse(bh);
|
|
|
|
}
|
2007-05-15 14:37:50 +00:00
|
|
|
return ret;
|
2006-03-20 17:30:04 +00:00
|
|
|
}
|
|
|
|
|
2014-01-08 12:14:57 +00:00
|
|
|
/**
|
|
|
|
* dir_new_leaf - Add a new leaf onto hash chain
|
|
|
|
* @inode: The directory
|
|
|
|
* @name: The name we are adding
|
|
|
|
*
|
|
|
|
* This adds a new dir leaf onto an existing leaf when there is not
|
|
|
|
* enough space to add a new dir entry. This is a last resort after
|
|
|
|
* we've expanded the hash table to max size and also split existing
|
|
|
|
* leaf blocks, so it will only occur for very large directories.
|
|
|
|
*
|
|
|
|
* The dist parameter is set to 1 for leaf blocks directly attached
|
|
|
|
* to the hash table, 2 for one layer of indirection, 3 for two layers
|
|
|
|
* etc. We are thus able to tell the difference between an old leaf
|
|
|
|
* with dist set to zero (i.e. "don't know") and a new one where we
|
|
|
|
* set this information for debug/fsck purposes.
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, or -ve on error
|
|
|
|
*/
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
static int dir_new_leaf(struct inode *inode, const struct qstr *name)
|
|
|
|
{
|
|
|
|
struct buffer_head *bh, *obh;
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2006-03-20 17:30:04 +00:00
|
|
|
struct gfs2_leaf *leaf, *oleaf;
|
2014-01-08 12:14:57 +00:00
|
|
|
u32 dist = 1;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
2006-03-20 17:30:04 +00:00
|
|
|
u32 index;
|
|
|
|
u64 bn;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2008-02-01 09:23:44 +00:00
|
|
|
index = name->hash >> (32 - ip->i_depth);
|
2006-03-20 17:30:04 +00:00
|
|
|
error = get_first_leaf(ip, index, &obh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
do {
|
2014-01-08 12:14:57 +00:00
|
|
|
dist++;
|
2006-03-20 17:30:04 +00:00
|
|
|
oleaf = (struct gfs2_leaf *)obh->b_data;
|
|
|
|
bn = be64_to_cpu(oleaf->lf_next);
|
|
|
|
if (!bn)
|
|
|
|
break;
|
|
|
|
brelse(obh);
|
|
|
|
error = get_leaf(ip, bn, &obh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
} while(1);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(ip->i_gl, obh);
|
2006-03-20 17:30:04 +00:00
|
|
|
|
|
|
|
leaf = new_leaf(inode, &bh, be16_to_cpu(oleaf->lf_depth));
|
|
|
|
if (!leaf) {
|
|
|
|
brelse(obh);
|
|
|
|
return -ENOSPC;
|
|
|
|
}
|
2014-01-08 12:14:57 +00:00
|
|
|
leaf->lf_dist = cpu_to_be32(dist);
|
2006-04-12 21:39:45 +00:00
|
|
|
oleaf->lf_next = cpu_to_be64(bh->b_blocknr);
|
2006-03-20 17:30:04 +00:00
|
|
|
brelse(bh);
|
|
|
|
brelse(obh);
|
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(ip, &bh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(ip->i_gl, bh);
|
2008-02-12 14:17:27 +00:00
|
|
|
gfs2_add_inode_blocks(&ip->i_inode, 1);
|
2006-10-31 20:07:05 +00:00
|
|
|
gfs2_dinode_out(ip, bh->b_data);
|
2006-03-20 17:30:04 +00:00
|
|
|
brelse(bh);
|
|
|
|
return 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
GFS2: Add meta readahead field in directory entries
The intent of this new field in the directory entry is to
allow a subsequent lookup to know how many blocks, which
are contiguous with the inode, contain metadata which relates
to the inode. This will then allow the issuing of a single
read to read these blocks, rather than reading the inode
first, and then issuing a second read for the metadata.
This only works under some fairly strict conditions, since
we do not have back pointers from inodes to directory entries
we must ensure that the blocks referenced in this way will
always belong to the inode.
This rules out being able to use this system for indirect
blocks, as these can change as a result of truncate/rewrite.
So the idea here is to restrict this to xattr blocks only
for the time being. For most inodes, that means only a
single block. Also, when using ACLs and/or SELinux or
other LSMs, these will be added at inode creation time
so that they will be contiguous with the inode on disk and
also will almost always be needed when we read the inode in
for permissions checks.
Once an xattr block for an inode is allocated, it will never
change until the inode is deallocated.
This patch adds the new field, a further patch will add the
readahead in due course.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2014-02-07 11:23:22 +00:00
|
|
|
static u16 gfs2_inode_ra_len(const struct gfs2_inode *ip)
|
|
|
|
{
|
|
|
|
u64 where = ip->i_no_addr + 1;
|
|
|
|
if (ip->i_eattr == where)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/**
|
|
|
|
* gfs2_dir_add - Add new filename into directory
|
2014-01-06 12:49:43 +00:00
|
|
|
* @inode: The directory inode
|
|
|
|
* @name: The new name
|
|
|
|
* @nip: The GFS2 inode to be linked in to the directory
|
|
|
|
* @da: The directory addition info
|
|
|
|
*
|
|
|
|
* If the call to gfs2_diradd_alloc_required resulted in there being
|
|
|
|
* no need to allocate any new directory blocks, then it will contain
|
|
|
|
* a pointer to the directory entry and the bh in which it resides. We
|
|
|
|
* can use that without having to repeat the search. If there was no
|
|
|
|
* free space, then we must now create more space.
|
2006-01-16 16:50:04 +00:00
|
|
|
*
|
|
|
|
* Returns: 0 on success, error code on failure
|
|
|
|
*/
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
int gfs2_dir_add(struct inode *inode, const struct qstr *name,
|
2014-01-06 12:49:43 +00:00
|
|
|
const struct gfs2_inode *nip, struct gfs2_diradd *da)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2014-01-06 12:49:43 +00:00
|
|
|
struct buffer_head *bh = da->bh;
|
|
|
|
struct gfs2_dirent *dent = da->dent;
|
2014-01-08 12:14:57 +00:00
|
|
|
struct timespec tv;
|
2006-03-20 17:30:04 +00:00
|
|
|
struct gfs2_leaf *leaf;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
while(1) {
|
2014-01-06 12:49:43 +00:00
|
|
|
if (da->bh == NULL) {
|
|
|
|
dent = gfs2_dirent_search(inode, name,
|
|
|
|
gfs2_dirent_find_space, &bh);
|
|
|
|
}
|
2006-03-20 17:30:04 +00:00
|
|
|
if (dent) {
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
return PTR_ERR(dent);
|
|
|
|
dent = gfs2_init_dirent(inode, dent, name, bh);
|
2007-05-15 14:37:50 +00:00
|
|
|
gfs2_inum_out(nip, dent);
|
2011-05-09 12:30:08 +00:00
|
|
|
dent->de_type = cpu_to_be16(IF2DT(nip->i_inode.i_mode));
|
GFS2: Add meta readahead field in directory entries
The intent of this new field in the directory entry is to
allow a subsequent lookup to know how many blocks, which
are contiguous with the inode, contain metadata which relates
to the inode. This will then allow the issuing of a single
read to read these blocks, rather than reading the inode
first, and then issuing a second read for the metadata.
This only works under some fairly strict conditions, since
we do not have back pointers from inodes to directory entries
we must ensure that the blocks referenced in this way will
always belong to the inode.
This rules out being able to use this system for indirect
blocks, as these can change as a result of truncate/rewrite.
So the idea here is to restrict this to xattr blocks only
for the time being. For most inodes, that means only a
single block. Also, when using ACLs and/or SELinux or
other LSMs, these will be added at inode creation time
so that they will be contiguous with the inode on disk and
also will almost always be needed when we read the inode in
for permissions checks.
Once an xattr block for an inode is allocated, it will never
change until the inode is deallocated.
This patch adds the new field, a further patch will add the
readahead in due course.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2014-02-07 11:23:22 +00:00
|
|
|
dent->de_rahead = cpu_to_be16(gfs2_inode_ra_len(nip));
|
2014-01-08 12:14:57 +00:00
|
|
|
tv = CURRENT_TIME;
|
2008-11-04 10:05:22 +00:00
|
|
|
if (ip->i_diskflags & GFS2_DIF_EXHASH) {
|
2006-03-20 17:30:04 +00:00
|
|
|
leaf = (struct gfs2_leaf *)bh->b_data;
|
2008-02-12 23:06:10 +00:00
|
|
|
be16_add_cpu(&leaf->lf_entries, 1);
|
2014-01-08 12:14:57 +00:00
|
|
|
leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
|
|
|
|
leaf->lf_sec = cpu_to_be64(tv.tv_sec);
|
2006-03-20 17:30:04 +00:00
|
|
|
}
|
2014-01-06 12:49:43 +00:00
|
|
|
da->dent = NULL;
|
|
|
|
da->bh = NULL;
|
2006-03-20 17:30:04 +00:00
|
|
|
brelse(bh);
|
2008-11-03 13:59:19 +00:00
|
|
|
ip->i_entries++;
|
2014-01-08 12:14:57 +00:00
|
|
|
ip->i_inode.i_mtime = ip->i_inode.i_ctime = tv;
|
2011-05-09 12:30:08 +00:00
|
|
|
if (S_ISDIR(nip->i_inode.i_mode))
|
|
|
|
inc_nlink(&ip->i_inode);
|
2012-11-12 18:04:54 +00:00
|
|
|
mark_inode_dirty(inode);
|
2006-03-20 17:30:04 +00:00
|
|
|
error = 0;
|
|
|
|
break;
|
|
|
|
}
|
2008-11-04 10:05:22 +00:00
|
|
|
if (!(ip->i_diskflags & GFS2_DIF_EXHASH)) {
|
2006-03-20 17:30:04 +00:00
|
|
|
error = dir_make_exhash(inode);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
error = dir_split_leaf(inode, name);
|
|
|
|
if (error == 0)
|
|
|
|
continue;
|
2006-03-30 00:02:15 +00:00
|
|
|
if (error < 0)
|
2006-03-20 17:30:04 +00:00
|
|
|
break;
|
2008-02-01 09:23:44 +00:00
|
|
|
if (ip->i_depth < GFS2_DIR_MAX_DEPTH) {
|
2006-03-20 17:30:04 +00:00
|
|
|
error = dir_double_exhash(ip);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
error = dir_split_leaf(inode, name);
|
2006-03-30 00:02:15 +00:00
|
|
|
if (error < 0)
|
2006-03-20 17:30:04 +00:00
|
|
|
break;
|
2006-03-30 00:02:15 +00:00
|
|
|
if (error == 0)
|
|
|
|
continue;
|
2006-03-20 17:30:04 +00:00
|
|
|
}
|
|
|
|
error = dir_new_leaf(inode, name);
|
|
|
|
if (!error)
|
|
|
|
continue;
|
|
|
|
error = -ENOSPC;
|
|
|
|
break;
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/**
|
|
|
|
* gfs2_dir_del - Delete a directory entry
|
|
|
|
* @dip: The GFS2 inode
|
|
|
|
* @filename: The filename
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, error code on failure
|
|
|
|
*/
|
|
|
|
|
2011-05-09 15:42:37 +00:00
|
|
|
int gfs2_dir_del(struct gfs2_inode *dip, const struct dentry *dentry)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2011-05-09 15:42:37 +00:00
|
|
|
const struct qstr *name = &dentry->d_name;
|
2006-03-20 17:30:04 +00:00
|
|
|
struct gfs2_dirent *dent, *prev = NULL;
|
|
|
|
struct buffer_head *bh;
|
2014-01-08 12:14:57 +00:00
|
|
|
struct timespec tv = CURRENT_TIME;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
/* Returns _either_ the entry (if its first in block) or the
|
|
|
|
previous entry otherwise */
|
2006-06-14 19:32:57 +00:00
|
|
|
dent = gfs2_dirent_search(&dip->i_inode, name, gfs2_dirent_prev, &bh);
|
2006-03-20 17:30:04 +00:00
|
|
|
if (!dent) {
|
|
|
|
gfs2_consist_inode(dip);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
if (IS_ERR(dent)) {
|
|
|
|
gfs2_consist_inode(dip);
|
|
|
|
return PTR_ERR(dent);
|
|
|
|
}
|
|
|
|
/* If not first in block, adjust pointers accordingly */
|
2006-03-28 19:14:04 +00:00
|
|
|
if (gfs2_dirent_find(dent, name, NULL) == 0) {
|
2006-03-20 17:30:04 +00:00
|
|
|
prev = dent;
|
|
|
|
dent = (struct gfs2_dirent *)((char *)dent + be16_to_cpu(prev->de_rec_len));
|
|
|
|
}
|
|
|
|
|
|
|
|
dirent_del(dip, bh, prev, dent);
|
2008-11-04 10:05:22 +00:00
|
|
|
if (dip->i_diskflags & GFS2_DIF_EXHASH) {
|
2006-03-20 17:30:04 +00:00
|
|
|
struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;
|
|
|
|
u16 entries = be16_to_cpu(leaf->lf_entries);
|
|
|
|
if (!entries)
|
|
|
|
gfs2_consist_inode(dip);
|
|
|
|
leaf->lf_entries = cpu_to_be16(--entries);
|
2014-01-08 12:14:57 +00:00
|
|
|
leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
|
|
|
|
leaf->lf_sec = cpu_to_be64(tv.tv_sec);
|
2006-03-20 17:30:04 +00:00
|
|
|
}
|
2006-04-07 20:28:07 +00:00
|
|
|
brelse(bh);
|
2006-03-20 17:30:04 +00:00
|
|
|
|
2008-11-03 13:59:19 +00:00
|
|
|
if (!dip->i_entries)
|
2006-03-20 17:30:04 +00:00
|
|
|
gfs2_consist_inode(dip);
|
2008-11-03 13:59:19 +00:00
|
|
|
dip->i_entries--;
|
2014-01-08 12:14:57 +00:00
|
|
|
dip->i_inode.i_mtime = dip->i_inode.i_ctime = tv;
|
VFS: (Scripted) Convert S_ISLNK/DIR/REG(dentry->d_inode) to d_is_*(dentry)
Convert the following where appropriate:
(1) S_ISLNK(dentry->d_inode) to d_is_symlink(dentry).
(2) S_ISREG(dentry->d_inode) to d_is_reg(dentry).
(3) S_ISDIR(dentry->d_inode) to d_is_dir(dentry). This is actually more
complicated than it appears as some calls should be converted to
d_can_lookup() instead. The difference is whether the directory in
question is a real dir with a ->lookup op or whether it's a fake dir with
a ->d_automount op.
In some circumstances, we can subsume checks for dentry->d_inode not being
NULL into this, provided we the code isn't in a filesystem that expects
d_inode to be NULL if the dirent really *is* negative (ie. if we're going to
use d_inode() rather than d_backing_inode() to get the inode pointer).
Note that the dentry type field may be set to something other than
DCACHE_MISS_TYPE when d_inode is NULL in the case of unionmount, where the VFS
manages the fall-through from a negative dentry to a lower layer. In such a
case, the dentry type of the negative union dentry is set to the same as the
type of the lower dentry.
However, if you know d_inode is not NULL at the call site, then you can use
the d_is_xxx() functions even in a filesystem.
There is one further complication: a 0,0 chardev dentry may be labelled
DCACHE_WHITEOUT_TYPE rather than DCACHE_SPECIAL_TYPE. Strictly, this was
intended for special directory entry types that don't have attached inodes.
The following perl+coccinelle script was used:
use strict;
my @callers;
open($fd, 'git grep -l \'S_IS[A-Z].*->d_inode\' |') ||
die "Can't grep for S_ISDIR and co. callers";
@callers = <$fd>;
close($fd);
unless (@callers) {
print "No matches\n";
exit(0);
}
my @cocci = (
'@@',
'expression E;',
'@@',
'',
'- S_ISLNK(E->d_inode->i_mode)',
'+ d_is_symlink(E)',
'',
'@@',
'expression E;',
'@@',
'',
'- S_ISDIR(E->d_inode->i_mode)',
'+ d_is_dir(E)',
'',
'@@',
'expression E;',
'@@',
'',
'- S_ISREG(E->d_inode->i_mode)',
'+ d_is_reg(E)' );
my $coccifile = "tmp.sp.cocci";
open($fd, ">$coccifile") || die $coccifile;
print($fd "$_\n") || die $coccifile foreach (@cocci);
close($fd);
foreach my $file (@callers) {
chomp $file;
print "Processing ", $file, "\n";
system("spatch", "--sp-file", $coccifile, $file, "--in-place", "--no-show-diff") == 0 ||
die "spatch failed";
}
[AV: overlayfs parts skipped]
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2015-01-29 12:02:35 +00:00
|
|
|
if (d_is_dir(dentry))
|
2011-05-09 15:42:37 +00:00
|
|
|
drop_nlink(&dip->i_inode);
|
2006-06-14 19:32:57 +00:00
|
|
|
mark_inode_dirty(&dip->i_inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2011-08-15 13:20:36 +00:00
|
|
|
return 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_dir_mvino - Change inode number of directory entry
|
|
|
|
* @dip: The GFS2 inode
|
|
|
|
* @filename:
|
|
|
|
* @new_inode:
|
|
|
|
*
|
|
|
|
* This routine changes the inode number of a directory entry. It's used
|
|
|
|
* by rename to change ".." when a directory is moved.
|
|
|
|
* Assumes a glock is held on dvp.
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
|
2007-05-15 14:37:50 +00:00
|
|
|
const struct gfs2_inode *nip, unsigned int new_type)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-03-20 17:30:04 +00:00
|
|
|
struct buffer_head *bh;
|
|
|
|
struct gfs2_dirent *dent;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
|
|
|
|
2006-06-14 19:32:57 +00:00
|
|
|
dent = gfs2_dirent_search(&dip->i_inode, filename, gfs2_dirent_find, &bh);
|
2006-03-20 17:30:04 +00:00
|
|
|
if (!dent) {
|
|
|
|
gfs2_consist_inode(dip);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
return PTR_ERR(dent);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(dip->i_gl, bh);
|
2007-05-15 14:37:50 +00:00
|
|
|
gfs2_inum_out(nip, dent);
|
2006-03-20 17:30:04 +00:00
|
|
|
dent->de_type = cpu_to_be16(new_type);
|
|
|
|
|
2008-11-04 10:05:22 +00:00
|
|
|
if (dip->i_diskflags & GFS2_DIF_EXHASH) {
|
2006-03-20 17:30:04 +00:00
|
|
|
brelse(bh);
|
|
|
|
error = gfs2_meta_inode_buffer(dip, &bh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(dip->i_gl, bh);
|
2006-03-20 17:30:04 +00:00
|
|
|
}
|
|
|
|
|
2007-06-05 08:39:18 +00:00
|
|
|
dip->i_inode.i_mtime = dip->i_inode.i_ctime = CURRENT_TIME;
|
2006-10-31 20:07:05 +00:00
|
|
|
gfs2_dinode_out(dip, bh->b_data);
|
2006-03-20 17:30:04 +00:00
|
|
|
brelse(bh);
|
|
|
|
return 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* leaf_dealloc - Deallocate a directory leaf
|
|
|
|
* @dip: the directory
|
|
|
|
* @index: the hash table offset in the directory
|
|
|
|
* @len: the number of pointers to this leaf
|
|
|
|
* @leaf_no: the leaf number
|
2011-03-22 17:55:23 +00:00
|
|
|
* @leaf_bh: buffer_head for the starting leaf
|
2011-03-22 17:54:03 +00:00
|
|
|
* last_dealloc: 1 if this is the final dealloc for the leaf, else 0
|
2006-01-16 16:50:04 +00:00
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
2006-09-04 16:49:07 +00:00
|
|
|
static int leaf_dealloc(struct gfs2_inode *dip, u32 index, u32 len,
|
2011-03-22 17:55:23 +00:00
|
|
|
u64 leaf_no, struct buffer_head *leaf_bh,
|
|
|
|
int last_dealloc)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
|
2006-03-20 17:30:04 +00:00
|
|
|
struct gfs2_leaf *tmp_leaf;
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_rgrp_list rlist;
|
|
|
|
struct buffer_head *bh, *dibh;
|
2006-09-04 16:49:07 +00:00
|
|
|
u64 blk, nblk;
|
2006-01-16 16:50:04 +00:00
|
|
|
unsigned int rg_blocks = 0, l_blocks = 0;
|
|
|
|
char *ht;
|
2006-09-04 16:49:07 +00:00
|
|
|
unsigned int x, size = len * sizeof(u64);
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
|
|
|
|
2012-04-05 02:11:16 +00:00
|
|
|
error = gfs2_rindex_update(sdp);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
|
|
|
|
|
2013-06-19 19:15:53 +00:00
|
|
|
ht = kzalloc(size, GFP_NOFS | __GFP_NOWARN);
|
2013-05-30 13:48:56 +00:00
|
|
|
if (ht == NULL)
|
2015-02-02 03:59:54 +00:00
|
|
|
ht = __vmalloc(size, GFP_NOFS | __GFP_NOWARN | __GFP_ZERO,
|
|
|
|
PAGE_KERNEL);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (!ht)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2013-02-01 01:49:26 +00:00
|
|
|
error = gfs2_quota_hold(dip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
2012-05-18 13:28:23 +00:00
|
|
|
goto out;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
/* Count the number of leaves */
|
2011-03-22 17:55:23 +00:00
|
|
|
bh = leaf_bh;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
for (blk = leaf_no; blk; blk = nblk) {
|
2011-03-22 17:55:23 +00:00
|
|
|
if (blk != leaf_no) {
|
|
|
|
error = get_leaf(dip, blk, &bh);
|
|
|
|
if (error)
|
|
|
|
goto out_rlist;
|
|
|
|
}
|
2006-03-20 17:30:04 +00:00
|
|
|
tmp_leaf = (struct gfs2_leaf *)bh->b_data;
|
|
|
|
nblk = be64_to_cpu(tmp_leaf->lf_next);
|
2011-03-22 17:55:23 +00:00
|
|
|
if (blk != leaf_no)
|
|
|
|
brelse(bh);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2011-09-02 15:08:09 +00:00
|
|
|
gfs2_rlist_add(dip, &rlist, blk);
|
2006-01-16 16:50:04 +00:00
|
|
|
l_blocks++;
|
|
|
|
}
|
|
|
|
|
2008-01-28 17:13:02 +00:00
|
|
|
gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
for (x = 0; x < rlist.rl_rgrps; x++) {
|
|
|
|
struct gfs2_rgrpd *rgd;
|
2006-02-27 22:23:27 +00:00
|
|
|
rgd = rlist.rl_ghs[x].gh_gl->gl_object;
|
2007-06-01 13:11:58 +00:00
|
|
|
rg_blocks += rgd->rd_length;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
|
|
|
|
if (error)
|
|
|
|
goto out_rlist;
|
|
|
|
|
|
|
|
error = gfs2_trans_begin(sdp,
|
2006-02-27 22:23:27 +00:00
|
|
|
rg_blocks + (DIV_ROUND_UP(size, sdp->sd_jbsize) + 1) +
|
2006-01-16 16:50:04 +00:00
|
|
|
RES_DINODE + RES_STATFS + RES_QUOTA, l_blocks);
|
|
|
|
if (error)
|
|
|
|
goto out_rg_gunlock;
|
|
|
|
|
2011-03-22 17:55:23 +00:00
|
|
|
bh = leaf_bh;
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
for (blk = leaf_no; blk; blk = nblk) {
|
2011-03-22 17:55:23 +00:00
|
|
|
if (blk != leaf_no) {
|
|
|
|
error = get_leaf(dip, blk, &bh);
|
|
|
|
if (error)
|
|
|
|
goto out_end_trans;
|
|
|
|
}
|
2006-03-20 17:30:04 +00:00
|
|
|
tmp_leaf = (struct gfs2_leaf *)bh->b_data;
|
|
|
|
nblk = be64_to_cpu(tmp_leaf->lf_next);
|
2011-03-22 17:55:23 +00:00
|
|
|
if (blk != leaf_no)
|
|
|
|
brelse(bh);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
gfs2_free_meta(dip, blk, 1);
|
2008-02-12 14:17:27 +00:00
|
|
|
gfs2_add_inode_blocks(&dip->i_inode, -1);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2006-09-04 16:49:07 +00:00
|
|
|
error = gfs2_dir_write_data(dip, ht, index * sizeof(u64), size);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error != size) {
|
|
|
|
if (error >= 0)
|
|
|
|
error = -EIO;
|
|
|
|
goto out_end_trans;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(dip, &dibh);
|
|
|
|
if (error)
|
|
|
|
goto out_end_trans;
|
|
|
|
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(dip->i_gl, dibh);
|
2011-03-22 17:54:03 +00:00
|
|
|
/* On the last dealloc, make this a regular file in case we crash.
|
|
|
|
(We don't want to free these blocks a second time.) */
|
|
|
|
if (last_dealloc)
|
|
|
|
dip->i_inode.i_mode = S_IFREG;
|
2006-10-31 20:07:05 +00:00
|
|
|
gfs2_dinode_out(dip, dibh->b_data);
|
2006-01-16 16:50:04 +00:00
|
|
|
brelse(dibh);
|
|
|
|
|
2006-09-04 16:04:26 +00:00
|
|
|
out_end_trans:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_trans_end(sdp);
|
2006-09-04 16:04:26 +00:00
|
|
|
out_rg_gunlock:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
|
2006-09-04 16:04:26 +00:00
|
|
|
out_rlist:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_rlist_free(&rlist);
|
|
|
|
gfs2_quota_unhold(dip);
|
2008-03-03 18:54:21 +00:00
|
|
|
out:
|
2014-11-20 05:18:38 +00:00
|
|
|
kvfree(ht);
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_dir_exhash_dealloc - free all the leaf blocks in a directory
|
|
|
|
* @dip: the directory
|
|
|
|
*
|
|
|
|
* Dealloc all on-disk directory leaves to FREEMETA state
|
|
|
|
* Change on-disk inode type to "regular file"
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
int gfs2_dir_exhash_dealloc(struct gfs2_inode *dip)
|
|
|
|
{
|
2011-03-22 17:56:37 +00:00
|
|
|
struct buffer_head *bh;
|
|
|
|
struct gfs2_leaf *leaf;
|
|
|
|
u32 hsize, len;
|
|
|
|
u32 index = 0, next_index;
|
|
|
|
__be64 *lp;
|
|
|
|
u64 leaf_no;
|
|
|
|
int error = 0, last;
|
|
|
|
|
|
|
|
hsize = 1 << dip->i_depth;
|
|
|
|
|
2011-06-15 09:29:37 +00:00
|
|
|
lp = gfs2_dir_get_hash_table(dip);
|
|
|
|
if (IS_ERR(lp))
|
|
|
|
return PTR_ERR(lp);
|
2011-03-22 17:56:37 +00:00
|
|
|
|
|
|
|
while (index < hsize) {
|
2011-06-15 09:29:37 +00:00
|
|
|
leaf_no = be64_to_cpu(lp[index]);
|
2011-03-22 17:56:37 +00:00
|
|
|
if (leaf_no) {
|
|
|
|
error = get_leaf(dip, leaf_no, &bh);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
leaf = (struct gfs2_leaf *)bh->b_data;
|
|
|
|
len = 1 << (dip->i_depth - be16_to_cpu(leaf->lf_depth));
|
|
|
|
|
|
|
|
next_index = (index & ~(len - 1)) + len;
|
|
|
|
last = ((next_index >= hsize) ? 1 : 0);
|
|
|
|
error = leaf_dealloc(dip, index, len, leaf_no, bh,
|
|
|
|
last);
|
|
|
|
brelse(bh);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
index = next_index;
|
|
|
|
} else
|
|
|
|
index++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (index != hsize) {
|
|
|
|
gfs2_consist_inode(dip);
|
|
|
|
error = -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
|
|
|
return error;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_diradd_alloc_required - find if adding entry will require an allocation
|
|
|
|
* @ip: the file being written to
|
|
|
|
* @filname: the filename that's going to be added
|
2014-01-06 11:28:41 +00:00
|
|
|
* @da: The structure to return dir alloc info
|
2006-01-16 16:50:04 +00:00
|
|
|
*
|
2014-01-06 11:28:41 +00:00
|
|
|
* Returns: 0 if ok, -ve on error
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
|
|
|
|
2014-01-06 11:28:41 +00:00
|
|
|
int gfs2_diradd_alloc_required(struct inode *inode, const struct qstr *name,
|
|
|
|
struct gfs2_diradd *da)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2014-01-08 11:05:29 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2014-01-06 11:28:41 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2014-01-08 11:05:29 +00:00
|
|
|
const unsigned int extra = sizeof(struct gfs2_dinode) - sizeof(struct gfs2_leaf);
|
2006-03-20 17:30:04 +00:00
|
|
|
struct gfs2_dirent *dent;
|
|
|
|
struct buffer_head *bh;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2014-01-06 11:28:41 +00:00
|
|
|
da->nr_blocks = 0;
|
2014-01-06 12:49:43 +00:00
|
|
|
da->bh = NULL;
|
|
|
|
da->dent = NULL;
|
2014-01-06 11:28:41 +00:00
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
dent = gfs2_dirent_search(inode, name, gfs2_dirent_find_space, &bh);
|
2006-04-07 20:28:07 +00:00
|
|
|
if (!dent) {
|
2014-01-06 11:28:41 +00:00
|
|
|
da->nr_blocks = sdp->sd_max_dirres;
|
2014-01-08 11:05:29 +00:00
|
|
|
if (!(ip->i_diskflags & GFS2_DIF_EXHASH) &&
|
|
|
|
(GFS2_DIRENT_SIZE(name->len) < extra))
|
|
|
|
da->nr_blocks = 1;
|
2014-01-06 11:28:41 +00:00
|
|
|
return 0;
|
2006-04-07 20:28:07 +00:00
|
|
|
}
|
2006-03-20 17:30:04 +00:00
|
|
|
if (IS_ERR(dent))
|
|
|
|
return PTR_ERR(dent);
|
2014-09-29 12:52:04 +00:00
|
|
|
|
|
|
|
if (da->save_loc) {
|
|
|
|
da->bh = bh;
|
|
|
|
da->dent = dent;
|
|
|
|
} else {
|
|
|
|
brelse(bh);
|
|
|
|
}
|
2006-03-20 17:30:04 +00:00
|
|
|
return 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|