As suggested by Pekka Enberg <penberg@cs.helsinki.fi>.
The DIV_RU macro is renamed DIV_ROUND_UP and and moved to kernel.h
The other macros are gone from gfs2.h as (although not requested
by Pekka Enberg) are a number of included header file which are now
included individually. The inode number comparison function is
now an inline function.
The DT2IF and IF2DT may be addressed in a future patch.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
#include <linux/posix_acl.h>
#include <linux/posix_acl_xattr.h>
#include <asm/semaphore.h>
+#include <linux/gfs2_ondisk.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "acl.h"
#include "eaops.h"
#include "eattr.h"
#include "inode.h"
#include "meta_io.h"
#include "trans.h"
+#include "util.h"
#define ACL_ACCESS 1
#define ACL_DEFAULT 0
struct posix_acl *acl = NULL;
int error;
- error = acl_get(get_v2ip(inode), ACL_ACCESS, &acl, NULL, NULL, NULL);
+ error = acl_get(inode->u.generic_ip, ACL_ACCESS, &acl, NULL, NULL, NULL);
if (error)
return error;
int gfs2_check_acl(struct inode *inode, int mask)
{
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_holder i_gh;
int error;
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bits.h"
+#include "util.h"
static const char valid_change[16] = {
/* current */
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bmap.h"
#include "glock.h"
#include "inode.h"
#include "rgrp.h"
#include "trans.h"
#include "dir.h"
+#include "util.h"
/* This doesn't need to be that large as max 64 bit pointers in a 4k
* block is 512, so __u16 is fine for that. It saves stack space to
for (x = 0; x < rlist.rl_rgrps; x++) {
struct gfs2_rgrpd *rgd;
- rgd = get_gl2rgd(rlist.rl_ghs[x].gh_gl);
+ rgd = rlist.rl_ghs[x].gh_gl->gl_object;
rg_blocks += rgd->rd_ri.ri_length;
}
unsigned int tmp;
if (gfs2_is_dir(ip)) {
- *data_blocks = DIV_RU(len, sdp->sd_jbsize) + 2;
+ *data_blocks = DIV_ROUND_UP(len, sdp->sd_jbsize) + 2;
*ind_blocks = 3 * (sdp->sd_max_jheight - 1);
} else {
*data_blocks = (len >> sdp->sd_sb.sb_bsize_shift) + 3;
}
for (tmp = *data_blocks; tmp > sdp->sd_diptrs;) {
- tmp = DIV_RU(tmp, sdp->sd_inptrs);
+ tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs);
*ind_blocks += tmp;
}
}
#include <linux/buffer_head.h>
#include <linux/kthread.h>
#include <linux/delay.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "daemon.h"
#include "glock.h"
#include "log.h"
#include "recovery.h"
#include "super.h"
#include "unlinked.h"
+#include "util.h"
/* This uses schedule_timeout() instead of msleep() because it's good for
the daemons to wake up more often than the timeout when unmounting so
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/sort.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "dir.h"
#include "glock.h"
#include "inode.h"
#include "rgrp.h"
#include "trans.h"
#include "bmap.h"
+#include "util.h"
#define IS_LEAF 1 /* Hashed (leaf) directory */
#define IS_DINODE 2 /* Linear (stuffed dinode block) directory */
for (x = 0; x < rlist.rl_rgrps; x++) {
struct gfs2_rgrpd *rgd;
- rgd = get_gl2rgd(rlist.rl_ghs[x].gh_gl);
+ rgd = rlist.rl_ghs[x].gh_gl->gl_object;
rg_blocks += rgd->rd_ri.ri_length;
}
goto out_rlist;
error = gfs2_trans_begin(sdp,
- rg_blocks + (DIV_RU(size, sdp->sd_jbsize) + 1) +
+ rg_blocks + (DIV_ROUND_UP(size, sdp->sd_jbsize) + 1) +
RES_DINODE + RES_STATFS + RES_QUOTA, l_blocks);
if (error)
goto out_rg_gunlock;
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/xattr.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include <asm/uaccess.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "acl.h"
#include "eaops.h"
#include "eattr.h"
+#include "util.h"
/**
* gfs2_ea_name2type - get the type of the ea, and truncate type from the name
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/xattr.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include <asm/uaccess.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "acl.h"
#include "eaops.h"
#include "eattr.h"
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
+#include "util.h"
/**
* ea_calc_size - returns the acutal number of bytes the request will take up
struct gfs2_sbd *sdp = ip->i_sbd;
struct buffer_head **bh;
unsigned int amount = GFS2_EA_DATA_LEN(ea);
- unsigned int nptrs = DIV_RU(amount, sdp->sd_jbsize);
+ unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);
uint64_t *dataptrs = GFS2_EA2DATAPTRS(ea);
unsigned int x;
int error = 0;
unsigned int copy;
unsigned int x;
- ea->ea_num_ptrs = DIV_RU(er->er_data_len, sdp->sd_jbsize);
+ ea->ea_num_ptrs = DIV_ROUND_UP(er->er_data_len, sdp->sd_jbsize);
for (x = 0; x < ea->ea_num_ptrs; x++) {
struct buffer_head *bh;
uint64_t block;
unsigned int blks = 1;
if (GFS2_EAREQ_SIZE_STUFFED(er) > jbsize)
- blks += DIV_RU(er->er_data_len, jbsize);
+ blks += DIV_ROUND_UP(er->er_data_len, jbsize);
return ea_alloc_skeleton(ip, er, blks, ea_init_i, NULL);
}
es->es_bh = bh;
es->es_ea = ea;
- blks = 2 + DIV_RU(es->es_er->er_data_len, ip->i_sbd->sd_jbsize);
+ blks = 2 + DIV_ROUND_UP(es->es_er->er_data_len,
+ ip->i_sbd->sd_jbsize);
error = ea_alloc_skeleton(ip, es->es_er, blks,
ea_set_simple_alloc, es);
if (!(ip->i_di.di_flags & GFS2_DIF_EA_INDIRECT))
blks++;
if (GFS2_EAREQ_SIZE_STUFFED(er) > ip->i_sbd->sd_jbsize)
- blks += DIV_RU(er->er_data_len, ip->i_sbd->sd_jbsize);
+ blks += DIV_ROUND_UP(er->er_data_len, ip->i_sbd->sd_jbsize);
return ea_alloc_skeleton(ip, er, blks, ea_set_block, el);
}
struct gfs2_sbd *sdp = ip->i_sbd;
struct buffer_head **bh;
unsigned int amount = GFS2_EA_DATA_LEN(ea);
- unsigned int nptrs = DIV_RU(amount, sdp->sd_jbsize);
+ unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);
uint64_t *dataptrs = GFS2_EA2DATAPTRS(ea);
unsigned int x;
int error;
for (x = 0; x < rlist.rl_rgrps; x++) {
struct gfs2_rgrpd *rgd;
- rgd = get_gl2rgd(rlist.rl_ghs[x].gh_gl);
+ rgd = rlist.rl_ghs[x].gh_gl->gl_object;
rg_blocks += rgd->rd_ri.ri_length;
}
#define GFS2_EAREQ_SIZE_UNSTUFFED(sdp, er) \
ALIGN(sizeof(struct gfs2_ea_header) + (er)->er_name_len + \
- sizeof(uint64_t) * DIV_RU((er)->er_data_len, (sdp)->sd_jbsize), 8)
+ sizeof(uint64_t) * DIV_ROUND_UP((er)->er_data_len, (sdp)->sd_jbsize), 8)
#define GFS2_EA2NAME(ea) ((char *)((struct gfs2_ea_header *)(ea) + 1))
#define GFS2_EA2DATA(ea) (GFS2_EA2NAME(ea) + (ea)->ea_name_len)
#ifndef __GFS2_DOT_H__
#define __GFS2_DOT_H__
-#include <linux/gfs2_ondisk.h>
-
-#include "lm_interface.h"
-#include "lvb.h"
-#include "incore.h"
-#include "util.h"
-
enum {
NO_CREATE = 0,
CREATE = 1,
FORCE = 1,
};
-/* Divide num by den. Round up if there is a remainder. */
-#define DIV_RU(num, den) (((num) + (den) - 1) / (den))
-
#define GFS2_FAST_NAME_SIZE 8
-#define get_v2sdp(sb) ((struct gfs2_sbd *)(sb)->s_fs_info)
-#define set_v2sdp(sb, sdp) (sb)->s_fs_info = (sdp)
-#define get_v2ip(inode) ((struct gfs2_inode *)(inode)->u.generic_ip)
-#define set_v2ip(inode, ip) (inode)->u.generic_ip = (ip)
-#define get_v2fp(file) ((struct gfs2_file *)(file)->private_data)
-#define set_v2fp(file, fp) (file)->private_data = (fp)
-#define get_v2bd(bh) ((struct gfs2_bufdata *)(bh)->b_private)
-#define set_v2bd(bh, bd) (bh)->b_private = (bd)
-
-#define get_transaction ((struct gfs2_trans *)(current->journal_info))
-#define set_transaction(tr) (current->journal_info) = (tr)
-
-#define get_gl2ip(gl) ((struct gfs2_inode *)(gl)->gl_object)
-#define set_gl2ip(gl, ip) (gl)->gl_object = (ip)
-#define get_gl2rgd(gl) ((struct gfs2_rgrpd *)(gl)->gl_object)
-#define set_gl2rgd(gl, rgd) (gl)->gl_object = (rgd)
-#define get_gl2gl(gl) ((struct gfs2_glock *)(gl)->gl_object)
-#define set_gl2gl(gl, gl2) (gl)->gl_object = (gl2)
-
#endif /* __GFS2_DOT_H__ */
#include <linux/sort.h>
#include <linux/jhash.h>
#include <linux/kref.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include <asm/uaccess.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "glock.h"
#include "glops.h"
#include "inode.h"
#include "meta_io.h"
#include "quota.h"
#include "super.h"
+#include "util.h"
/* Must be kept in sync with the beginning of struct gfs2_glock */
struct glock_plug {
if (!gfs2_glmutex_trylock(gl))
goto out;
- ip = get_gl2ip(gl);
+ ip = gl->gl_object;
if (!ip)
goto out_unlock;
return;
spin_lock(&io_gl->gl_spin);
- i_gl = get_gl2gl(io_gl);
+ i_gl = io_gl->gl_object;
if (i_gl) {
gfs2_glock_hold(i_gl);
spin_unlock(&io_gl->gl_spin);
}
if (gfs2_glmutex_trylock(i_gl)) {
- struct gfs2_inode *ip = get_gl2ip(i_gl);
+ struct gfs2_inode *ip = i_gl->gl_object;
if (ip) {
gfs2_try_toss_vnode(ip);
gfs2_glmutex_unlock(i_gl);
if (gfs2_glmutex_trylock(gl)) {
if (gl->gl_ops == &gfs2_inode_glops) {
- struct gfs2_inode *ip = get_gl2ip(gl);
+ struct gfs2_inode *ip = gl->gl_object;
if (ip && !atomic_read(&ip->i_count))
gfs2_inode_destroy(ip);
}
{
if (gfs2_glmutex_trylock(gl)) {
if (gl->gl_ops == &gfs2_inode_glops) {
- struct gfs2_inode *ip = get_gl2ip(gl);
+ struct gfs2_inode *ip = gl->gl_object;
if (ip && !atomic_read(&ip->i_count))
goto out_schedule;
}
if (gfs2_glmutex_trylock(gl)) {
if (gl->gl_ops == &gfs2_inode_glops) {
- struct gfs2_inode *ip = get_gl2ip(gl);
+ struct gfs2_inode *ip = gl->gl_object;
if (ip && !atomic_read(&ip->i_count))
gfs2_inode_destroy(ip);
}
if (error)
goto out;
}
- if (gl->gl_ops == &gfs2_inode_glops && get_gl2ip(gl)) {
+ if (gl->gl_ops == &gfs2_inode_glops && gl->gl_object) {
if (!test_bit(GLF_LOCK, &gl->gl_flags) &&
list_empty(&gl->gl_holders)) {
- error = dump_inode(get_gl2ip(gl));
+ error = dump_inode(gl->gl_object);
if (error)
goto out;
} else {
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bmap.h"
#include "glock.h"
#include "glops.h"
#include "page.h"
#include "recovery.h"
#include "rgrp.h"
+#include "util.h"
/**
* meta_go_sync - sync out the metadata for this glock
struct gfs2_sbd *sdp = gl->gl_sbd;
int demote = 0;
- if (!get_gl2ip(gl) && !gl->gl_aspace->i_mapping->nrpages)
+ if (!gl->gl_object && !gl->gl_aspace->i_mapping->nrpages)
demote = 1;
else if (!sdp->sd_args.ar_localcaching &&
time_after_eq(jiffies, gl->gl_stamp +
static int inode_go_lock(struct gfs2_holder *gh)
{
struct gfs2_glock *gl = gh->gh_gl;
- struct gfs2_inode *ip = get_gl2ip(gl);
+ struct gfs2_inode *ip = gl->gl_object;
int error = 0;
if (!ip)
static void inode_go_unlock(struct gfs2_holder *gh)
{
struct gfs2_glock *gl = gh->gh_gl;
- struct gfs2_inode *ip = get_gl2ip(gl);
+ struct gfs2_inode *ip = gl->gl_object;
if (ip && test_bit(GLF_DIRTY, &gl->gl_flags))
gfs2_inode_attr_in(ip);
static void inode_greedy(struct gfs2_glock *gl)
{
struct gfs2_sbd *sdp = gl->gl_sbd;
- struct gfs2_inode *ip = get_gl2ip(gl);
+ struct gfs2_inode *ip = gl->gl_object;
unsigned int quantum = gfs2_tune_get(sdp, gt_greedy_quantum);
unsigned int max = gfs2_tune_get(sdp, gt_greedy_max);
unsigned int new_time;
static int rgrp_go_lock(struct gfs2_holder *gh)
{
- return gfs2_rgrp_bh_get(get_gl2rgd(gh->gh_gl));
+ return gfs2_rgrp_bh_get(gh->gh_gl->gl_object);
}
/**
static void rgrp_go_unlock(struct gfs2_holder *gh)
{
- gfs2_rgrp_bh_put(get_gl2rgd(gh->gh_gl));
+ gfs2_rgrp_bh_put(gh->gh_gl->gl_object);
}
/**
static void trans_go_xmote_bh(struct gfs2_glock *gl)
{
struct gfs2_sbd *sdp = gl->gl_sbd;
- struct gfs2_glock *j_gl = get_v2ip(sdp->sd_jdesc->jd_inode)->i_gl;
+ struct gfs2_inode *ip = sdp->sd_jdesc->jd_inode->u.generic_ip;
+ struct gfs2_glock *j_gl = ip->i_gl;
struct gfs2_log_header head;
int error;
if (gl->gl_state != LM_ST_UNLOCKED &&
test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
- gfs2_meta_cache_flush(get_v2ip(sdp->sd_jdesc->jd_inode));
+ gfs2_meta_cache_flush(sdp->sd_jdesc->jd_inode->u.generic_ip);
j_gl->gl_ops->go_inval(j_gl, DIO_METADATA | DIO_DATA);
error = gfs2_find_jhead(sdp->sd_jdesc, &head);
QDF_LOCKED = 2,
};
+struct gfs2_quota_lvb {
+ uint32_t qb_magic;
+ uint32_t __pad;
+ uint64_t qb_limit; /* Hard limit of # blocks to alloc */
+ uint64_t qb_warn; /* Warn user when alloc is above this # */
+ int64_t qb_value; /* Current # blocks allocated */
+};
+
struct gfs2_quota_data {
struct list_head qd_list;
unsigned int qd_count;
#include <linux/buffer_head.h>
#include <linux/posix_acl.h>
#include <linux/sort.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "acl.h"
#include "bmap.h"
#include "dir.h"
#include "rgrp.h"
#include "trans.h"
#include "unlinked.h"
+#include "util.h"
/**
* inode_attr_in - Copy attributes from the dinode into the VFS inode
init_special_inode(tmp, tmp->i_mode, tmp->i_rdev);
}
- set_v2ip(tmp, NULL);
+ tmp->u.generic_ip = NULL;
for (;;) {
spin_lock(&ip->i_spin);
gfs2_inode_hold(ip);
ip->i_vnode = inode;
- set_v2ip(inode, ip);
+ inode->u.generic_ip = ip;
spin_unlock(&ip->i_spin);
static int iget_test(struct inode *inode, void *opaque)
{
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_inum *inum = (struct gfs2_inum *)opaque;
if (ip && ip->i_num.no_addr == inum->no_addr)
spin_lock(&io_gl->gl_spin);
gfs2_glock_hold(i_gl);
- set_gl2gl(io_gl, i_gl);
+ io_gl->gl_object = i_gl;
spin_unlock(&io_gl->gl_spin);
gfs2_glock_hold(i_gl);
- set_gl2ip(i_gl, ip);
+ i_gl->gl_object = ip;
atomic_inc(&sdp->sd_inode_count);
gfs2_glmutex_lock(i_gl);
- *ipp = get_gl2ip(i_gl);
+ *ipp = i_gl->gl_object;
if (*ipp) {
error = -ESTALE;
if ((*ipp)->i_num.no_formal_ino != inum->no_formal_ino)
struct gfs2_glock *i_gl = ip->i_gl;
gfs2_assert_warn(sdp, !atomic_read(&ip->i_count));
- gfs2_assert(sdp, get_gl2gl(io_gl) == i_gl);
+ gfs2_assert(sdp, io_gl->gl_object == i_gl);
spin_lock(&io_gl->gl_spin);
- set_gl2gl(io_gl, NULL);
+ io_gl->gl_object = NULL;
gfs2_glock_put(i_gl);
spin_unlock(&io_gl->gl_spin);
gfs2_meta_cache_flush(ip);
kmem_cache_free(gfs2_inode_cachep, ip);
- set_gl2ip(i_gl, NULL);
+ i_gl->gl_object = NULL;
gfs2_glock_put(i_gl);
atomic_dec(&sdp->sd_inode_count);
goto out;
}
- gfs2_assert_warn(sdp, !get_gl2ip(i_gh.gh_gl));
+ gfs2_assert_warn(sdp, !i_gh.gh_gl->gl_object);
error = inode_create(i_gh.gh_gl, &ul->ul_ut.ut_inum, io_gh->gh_gl,
LM_ST_EXCLUSIVE, &ip);
struct inode **inodep)
{
struct gfs2_inode *ipp;
- struct gfs2_inode *dip = get_v2ip(dir);
+ struct gfs2_inode *dip = dir->u.generic_ip;
struct gfs2_sbd *sdp = dip->i_sbd;
struct gfs2_holder d_gh;
struct gfs2_inum inum;
static int pick_formal_ino_1(struct gfs2_sbd *sdp, uint64_t *formal_ino)
{
- struct gfs2_inode *ip = get_v2ip(sdp->sd_ir_inode);
+ struct gfs2_inode *ip = sdp->sd_ir_inode->u.generic_ip;
struct buffer_head *bh;
struct gfs2_inum_range ir;
int error;
static int pick_formal_ino_2(struct gfs2_sbd *sdp, uint64_t *formal_ino)
{
- struct gfs2_inode *ip = get_v2ip(sdp->sd_ir_inode);
- struct gfs2_inode *m_ip = get_v2ip(sdp->sd_inum_inode);
+ struct gfs2_inode *ip = sdp->sd_ir_inode->u.generic_ip;
+ struct gfs2_inode *m_ip = sdp->sd_inum_inode->u.generic_ip;
struct gfs2_holder gh;
struct buffer_head *bh;
struct gfs2_inum_range ir;
unsigned int mode)
{
struct inode *inode;
- struct gfs2_inode *dip = get_gl2ip(ghs->gh_gl);
+ struct gfs2_inode *dip = ghs->gh_gl->gl_object;
struct gfs2_sbd *sdp = dip->i_sbd;
struct gfs2_unlinked *ul;
struct gfs2_inode *ip;
{
struct gfs2_glock *gl = gh->gh_gl;
struct gfs2_sbd *sdp = gl->gl_sbd;
- struct gfs2_inode *ip = get_gl2ip(gl);
+ struct gfs2_inode *ip = gl->gl_object;
int64_t curtime, quantum = gfs2_tune_get(sdp, gt_atime_quantum);
unsigned int state;
int flags;
{
int error;
- if (get_transaction)
+ if (current->journal_info)
return __gfs2_setattr_simple(ip, attr);
error = gfs2_trans_begin(ip->i_sbd, RES_DINODE, 0);
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/delay.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "glock.h"
#include "lm.h"
#include "super.h"
+#include "util.h"
+#include "lvb.h"
/**
* gfs2_lm_mount - mount a locking protocol
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bmap.h"
#include "glock.h"
#include "log.h"
#include "lops.h"
#include "meta_io.h"
+#include "util.h"
#define PULL 1
if (nstruct > first) {
second = (sdp->sd_sb.sb_bsize -
sizeof(struct gfs2_meta_header)) / ssize;
- blks += DIV_RU(nstruct - first, second);
+ blks += DIV_ROUND_UP(nstruct - first, second);
}
return blks;
uint64_t dbn;
int error;
- error = gfs2_block_map(get_v2ip(sdp->sd_jdesc->jd_inode),
+ error = gfs2_block_map(sdp->sd_jdesc->jd_inode->u.generic_ip,
lbn, &new, &dbn, NULL);
gfs2_assert_withdraw(sdp, !error && dbn);
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "glock.h"
#include "log.h"
#include "lops.h"
#include "recovery.h"
#include "rgrp.h"
#include "trans.h"
+#include "util.h"
static void glock_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le)
{
struct gfs2_glock *gl;
+ struct gfs2_trans *tr = current->journal_info;
- get_transaction->tr_touched = 1;
+ tr->tr_touched = 1;
if (!list_empty(&le->le_list))
return;
if (!list_empty(&bd->bd_list_tr))
return;
- tr = get_transaction;
+ tr = current->journal_info;
tr->tr_touched = 1;
tr->tr_num_buf++;
list_add(&bd->bd_list_tr, &tr->tr_list_buf);
static void buf_lo_before_scan(struct gfs2_jdesc *jd,
struct gfs2_log_header *head, int pass)
{
- struct gfs2_sbd *sdp = get_v2ip(jd->jd_inode)->i_sbd;
+ struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
+ struct gfs2_sbd *sdp = ip->i_sbd;
if (pass != 0)
return;
struct gfs2_log_descriptor *ld, __be64 *ptr,
int pass)
{
- struct gfs2_sbd *sdp = get_v2ip(jd->jd_inode)->i_sbd;
- struct gfs2_glock *gl = get_v2ip(jd->jd_inode)->i_gl;
+ struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
+ struct gfs2_sbd *sdp = ip->i_sbd;
+ struct gfs2_glock *gl = ip->i_gl;
unsigned int blks = be32_to_cpu(ld->ld_data1);
struct buffer_head *bh_log, *bh_ip;
uint64_t blkno;
static void buf_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
{
- struct gfs2_sbd *sdp = get_v2ip(jd->jd_inode)->i_sbd;
+ struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
+ struct gfs2_sbd *sdp = ip->i_sbd;
if (error) {
- gfs2_meta_sync(get_v2ip(jd->jd_inode)->i_gl,
+ gfs2_meta_sync(ip->i_gl,
DIO_START | DIO_WAIT);
return;
}
if (pass != 1)
return;
- gfs2_meta_sync(get_v2ip(jd->jd_inode)->i_gl, DIO_START | DIO_WAIT);
+ gfs2_meta_sync(ip->i_gl, DIO_START | DIO_WAIT);
fs_info(sdp, "jid=%u: Replayed %u of %u blocks\n",
jd->jd_jid, sdp->sd_replayed_blocks, sdp->sd_found_blocks);
{
struct gfs2_trans *tr;
- tr = get_transaction;
+ tr = current->journal_info;
tr->tr_touched = 1;
tr->tr_num_revoke++;
static void revoke_lo_before_scan(struct gfs2_jdesc *jd,
struct gfs2_log_header *head, int pass)
{
- struct gfs2_sbd *sdp = get_v2ip(jd->jd_inode)->i_sbd;
+ struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
+ struct gfs2_sbd *sdp = ip->i_sbd;
if (pass != 0)
return;
struct gfs2_log_descriptor *ld, __be64 *ptr,
int pass)
{
- struct gfs2_sbd *sdp = get_v2ip(jd->jd_inode)->i_sbd;
+ struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
+ struct gfs2_sbd *sdp = ip->i_sbd;
unsigned int blks = be32_to_cpu(ld->ld_length);
unsigned int revokes = be32_to_cpu(ld->ld_data1);
struct buffer_head *bh;
static void revoke_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
{
- struct gfs2_sbd *sdp = get_v2ip(jd->jd_inode)->i_sbd;
+ struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
+ struct gfs2_sbd *sdp = ip->i_sbd;
if (error) {
gfs2_revoke_clean(sdp);
static void rg_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le)
{
struct gfs2_rgrpd *rgd;
+ struct gfs2_trans *tr = current->journal_info;
- get_transaction->tr_touched = 1;
+ tr->tr_touched = 1;
if (!list_empty(&le->le_list))
return;
static void databuf_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le)
{
struct gfs2_bufdata *bd = container_of(le, struct gfs2_bufdata, bd_le);
- struct gfs2_trans *tr = get_transaction;
+ struct gfs2_trans *tr = current->journal_info;
struct address_space *mapping = bd->bd_bh->b_page->mapping;
- struct gfs2_inode *ip = get_v2ip(mapping->host);
+ struct gfs2_inode *ip = mapping->host->u.generic_ip;
tr->tr_touched = 1;
if (!list_empty(&bd->bd_list_tr) &&
bh = bd1->bd_bh;
if (bh) {
- set_v2bd(bh, NULL);
+ bh->b_private = NULL;
gfs2_log_unlock(sdp);
wait_on_buffer(bh);
brelse(bh);
struct gfs2_log_descriptor *ld,
__be64 *ptr, int pass)
{
- struct gfs2_sbd *sdp = get_v2ip(jd->jd_inode)->i_sbd;
- struct gfs2_glock *gl = get_v2ip(jd->jd_inode)->i_gl;
+ struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
+ struct gfs2_sbd *sdp = ip->i_sbd;
+ struct gfs2_glock *gl = ip->i_gl;
unsigned int blks = be32_to_cpu(ld->ld_data1);
struct buffer_head *bh_log, *bh_ip;
uint64_t blkno;
static void databuf_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
{
- struct gfs2_sbd *sdp = get_v2ip(jd->jd_inode)->i_sbd;
+ struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
+ struct gfs2_sbd *sdp = ip->i_sbd;
if (error) {
- gfs2_meta_sync(get_v2ip(jd->jd_inode)->i_gl,
+ gfs2_meta_sync(ip->i_gl,
DIO_START | DIO_WAIT);
return;
}
return;
/* data sync? */
- gfs2_meta_sync(get_v2ip(jd->jd_inode)->i_gl, DIO_START | DIO_WAIT);
+ gfs2_meta_sync(ip->i_gl, DIO_START | DIO_WAIT);
fs_info(sdp, "jid=%u: Replayed %u of %u data blocks\n",
jd->jd_jid, sdp->sd_replayed_blocks, sdp->sd_found_blocks);
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
+#include "lvb.h"
#define pv(struct, member, fmt) printk(KERN_INFO " "#member" = "fmt"\n", \
struct->member);
#define GFS2_MIN_LVB_SIZE 32
-struct gfs2_quota_lvb {
- uint32_t qb_magic;
- uint32_t __pad;
- uint64_t qb_limit; /* Hard limit of # blocks to alloc */
- uint64_t qb_warn; /* Warn user when alloc is above this # */
- int64_t qb_value; /* Current # blocks allocated */
-};
-
void gfs2_quota_lvb_in(struct gfs2_quota_lvb *qb, char *lvb);
void gfs2_quota_lvb_out(struct gfs2_quota_lvb *qb, char *lvb);
void gfs2_quota_lvb_print(struct gfs2_quota_lvb *qb);
#include <linux/buffer_head.h>
#include <linux/module.h>
#include <linux/init.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "ops_fstype.h"
#include "sys.h"
+#include "util.h"
/**
* init_gfs2_fs - Register GFS2 as a filesystem
#include <linux/writeback.h>
#include <linux/swap.h>
#include <linux/delay.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "glock.h"
#include "glops.h"
#include "inode.h"
#include "meta_io.h"
#include "rgrp.h"
#include "trans.h"
+#include "util.h"
#define buffer_busy(bh) \
((bh)->b_state & ((1ul << BH_Dirty) | (1ul << BH_Lock) | (1ul << BH_Pinned)))
static int aspace_get_block(struct inode *inode, sector_t lblock,
struct buffer_head *bh_result, int create)
{
- gfs2_assert_warn(get_v2sdp(inode->i_sb), 0);
+ gfs2_assert_warn(inode->i_sb->s_fs_info, 0);
return -EOPNOTSUPP;
}
static void stuck_releasepage(struct buffer_head *bh)
{
- struct gfs2_sbd *sdp = get_v2sdp(bh->b_page->mapping->host->i_sb);
- struct gfs2_bufdata *bd = get_v2bd(bh);
+ struct gfs2_sbd *sdp = bh->b_page->mapping->host->i_sb->s_fs_info;
+ struct gfs2_bufdata *bd = bh->b_private;
struct gfs2_glock *gl;
fs_warn(sdp, "stuck in gfs2_releasepage()\n");
fs_warn(sdp, "blkno = %llu, bh->b_count = %d\n",
(uint64_t)bh->b_blocknr, atomic_read(&bh->b_count));
fs_warn(sdp, "pinned = %u\n", buffer_pinned(bh));
- fs_warn(sdp, "get_v2bd(bh) = %s\n", (bd) ? "!NULL" : "NULL");
+ fs_warn(sdp, "bh->b_private = %s\n", (bd) ? "!NULL" : "NULL");
if (!bd)
return;
(list_empty(&bd->bd_le.le_list)) ? "no" : "yes");
if (gl->gl_ops == &gfs2_inode_glops) {
- struct gfs2_inode *ip = get_gl2ip(gl);
+ struct gfs2_inode *ip = gl->gl_object;
unsigned int x;
if (!ip)
static int gfs2_aspace_releasepage(struct page *page, gfp_t gfp_mask)
{
struct inode *aspace = page->mapping->host;
- struct gfs2_sbd *sdp = get_v2sdp(aspace->i_sb);
+ struct gfs2_sbd *sdp = aspace->i_sb->s_fs_info;
struct buffer_head *bh, *head;
struct gfs2_bufdata *bd;
unsigned long t;
gfs2_assert_warn(sdp, !buffer_pinned(bh));
- bd = get_v2bd(bh);
+ bd = bh->b_private;
if (bd) {
gfs2_assert_warn(sdp, bd->bd_bh == bh);
gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr));
gfs2_assert_warn(sdp, list_empty(&bd->bd_le.le_list));
gfs2_assert_warn(sdp, !bd->bd_ail);
kmem_cache_free(gfs2_bufdata_cachep, bd);
- set_v2bd(bh, NULL);
+ bh->b_private = NULL;
}
bh = bh->b_this_page;
mapping_set_gfp_mask(aspace->i_mapping, GFP_KERNEL);
aspace->i_mapping->a_ops = &aspace_aops;
aspace->i_size = ~0ULL;
- set_v2ip(aspace, NULL);
+ aspace->u.generic_ip = NULL;
insert_inode_hash(aspace);
}
wait_on_buffer(bh);
if (!buffer_uptodate(bh)) {
- struct gfs2_trans *tr = get_transaction;
+ struct gfs2_trans *tr = current->journal_info;
if (tr && tr->tr_touched)
gfs2_io_error_bh(sdp, bh);
return -EIO;
if (meta)
lock_page(bh->b_page);
- if (get_v2bd(bh)) {
+ if (bh->b_private) {
if (meta)
unlock_page(bh->b_page);
return;
lops_init_le(&bd->bd_le, &gfs2_databuf_lops);
get_bh(bh);
}
- set_v2bd(bh, bd);
+ bh->b_private = bd;
if (meta)
unlock_page(bh->b_page);
void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh)
{
- struct gfs2_bufdata *bd = get_v2bd(bh);
+ struct gfs2_bufdata *bd = bh->b_private;
gfs2_assert_withdraw(sdp, test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags));
void gfs2_unpin(struct gfs2_sbd *sdp, struct buffer_head *bh,
struct gfs2_ail *ai)
{
- struct gfs2_bufdata *bd = get_v2bd(bh);
+ struct gfs2_bufdata *bd = bh->b_private;
gfs2_assert_withdraw(sdp, buffer_uptodate(bh));
while (blen) {
bh = getbuf(sdp, aspace, bstart, NO_CREATE);
if (bh) {
- struct gfs2_bufdata *bd = get_v2bd(bh);
+ struct gfs2_bufdata *bd = bh->b_private;
if (test_clear_buffer_pinned(bh)) {
+ struct gfs2_trans *tr = current->journal_info;
gfs2_log_lock(sdp);
list_del_init(&bd->bd_le.le_list);
gfs2_assert_warn(sdp, sdp->sd_log_num_buf);
sdp->sd_log_num_buf--;
gfs2_log_unlock(sdp);
- get_transaction->tr_num_buf_rm++;
+ tr->tr_num_buf_rm++;
brelse(bh);
}
if (bd) {
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "mount.h"
#include "sys.h"
+#include "util.h"
/**
* gfs2_mount_args - Parse mount options
#include <linux/pagemap.h>
#include <linux/mpage.h>
#include <linux/fs.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bmap.h"
#include "glock.h"
#include "inode.h"
#include "trans.h"
#include "rgrp.h"
#include "ops_file.h"
+#include "util.h"
/**
* gfs2_get_block - Fills in a buffer head with details about a block
int gfs2_get_block(struct inode *inode, sector_t lblock,
struct buffer_head *bh_result, int create)
{
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
int new = create;
uint64_t dblock;
int error;
static int get_block_noalloc(struct inode *inode, sector_t lblock,
struct buffer_head *bh_result, int create)
{
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
int new = 0;
uint64_t dblock;
int error;
unsigned long max_blocks, struct buffer_head *bh_result,
int create)
{
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
int new = create;
uint64_t dblock;
uint32_t extlen;
unsigned long max_blocks,
struct buffer_head *bh_result, int create)
{
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
int new = 0;
uint64_t dblock;
uint32_t extlen;
static int gfs2_writepage(struct page *page, struct writeback_control *wbc)
{
struct inode *inode = page->mapping->host;
- struct gfs2_inode *ip = get_v2ip(page->mapping->host);
+ struct gfs2_inode *ip = page->mapping->host->u.generic_ip;
struct gfs2_sbd *sdp = ip->i_sbd;
loff_t i_size = i_size_read(inode);
pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
unlock_page(page);
return -EIO;
}
- if (get_transaction)
+ if (current->journal_info)
goto out_ignore;
/* Is the page fully outside i_size? (truncate in progress) */
static int gfs2_readpage(struct file *file, struct page *page)
{
- struct gfs2_inode *ip = get_v2ip(page->mapping->host);
+ struct gfs2_inode *ip = page->mapping->host->u.generic_ip;
struct gfs2_sbd *sdp = ip->i_sbd;
struct gfs2_holder gh;
int error;
static int gfs2_prepare_write(struct file *file, struct page *page,
unsigned from, unsigned to)
{
- struct gfs2_inode *ip = get_v2ip(page->mapping->host);
+ struct gfs2_inode *ip = page->mapping->host->u.generic_ip;
struct gfs2_sbd *sdp = ip->i_sbd;
unsigned int data_blocks, ind_blocks, rblocks;
int alloc_required;
unsigned from, unsigned to)
{
struct inode *inode = page->mapping->host;
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_sbd *sdp = ip->i_sbd;
int error = -EOPNOTSUPP;
struct buffer_head *dibh;
static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock)
{
- struct gfs2_inode *ip = get_v2ip(mapping->host);
+ struct gfs2_inode *ip = mapping->host->u.generic_ip;
struct gfs2_holder i_gh;
sector_t dblock = 0;
int error;
struct gfs2_bufdata *bd;
gfs2_log_lock(sdp);
- bd = get_v2bd(bh);
+ bd = bh->b_private;
if (bd) {
bd->bd_bh = NULL;
- set_v2bd(bh, NULL);
+ bh->b_private = NULL;
gfs2_log_unlock(sdp);
brelse(bh);
} else
static int gfs2_invalidatepage(struct page *page, unsigned long offset)
{
- struct gfs2_sbd *sdp = get_v2sdp(page->mapping->host->i_sb);
+ struct gfs2_sbd *sdp = page->mapping->host->i_sb->s_fs_info;
struct buffer_head *head, *bh, *next;
unsigned int curr_off = 0;
int ret = 1;
{
struct file *file = iocb->ki_filp;
struct inode *inode = file->f_mapping->host;
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_holder gh;
int rv;
{
struct file *file = iocb->ki_filp;
struct inode *inode = file->f_mapping->host;
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_sbd *sdp = ip->i_sbd;
if (rw == WRITE)
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/smp_lock.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "dir.h"
#include "glock.h"
#include "ops_dentry.h"
+#include "util.h"
/**
* gfs2_drevalidate - Check directory lookup consistency
static int gfs2_drevalidate(struct dentry *dentry, struct nameidata *nd)
{
struct dentry *parent = dget_parent(dentry);
- struct gfs2_inode *dip = get_v2ip(parent->d_inode);
+ struct gfs2_inode *dip = parent->d_inode->u.generic_ip;
struct inode *inode;
struct gfs2_holder d_gh;
struct gfs2_inode *ip;
goto fail_gunlock;
}
- ip = get_v2ip(inode);
+ ip = inode->u.generic_ip;
if (!gfs2_inum_equal(&ip->i_num, &inum))
goto invalid_gunlock;
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "dir.h"
#include "glock.h"
#include "glops.h"
int connectable)
{
struct inode *inode = dentry->d_inode;
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_sbd *sdp = ip->i_sbd;
if (*len < 4 || (connectable && *len < 8))
fh[3] = cpu_to_be32(fh[3]);
*len = 4;
- if (!connectable || ip == get_v2ip(sdp->sd_root_dir))
+ if (!connectable || ip == sdp->sd_root_dir->u.generic_ip)
return *len;
spin_lock(&dentry->d_lock);
inode = dentry->d_parent->d_inode;
- ip = get_v2ip(inode);
+ ip = inode->u.generic_ip;
gfs2_inode_hold(ip);
spin_unlock(&dentry->d_lock);
if (!S_ISDIR(dir->i_mode) || !inode)
return -EINVAL;
- dip = get_v2ip(dir);
- ip = get_v2ip(inode);
+ dip = dir->u.generic_ip;
+ ip = inode->u.generic_ip;
*name = 0;
gnfd.inum = ip->i_num;
static struct dentry *gfs2_get_dentry(struct super_block *sb, void *inum_p)
{
- struct gfs2_sbd *sdp = get_v2sdp(sb);
+ struct gfs2_sbd *sdp = sb->s_fs_info;
struct gfs2_inum *inum = (struct gfs2_inum *)inum_p;
struct gfs2_holder i_gh, ri_gh, rgd_gh;
struct gfs2_rgrpd *rgd;
inode = gfs2_iget(sb, inum);
if (inode) {
- ip = get_v2ip(inode);
+ ip = inode->u.generic_ip;
if (ip->i_num.no_formal_ino != inum->no_formal_ino) {
iput(inode);
return ERR_PTR(-ESTALE);
#include <linux/smp_lock.h>
#include <linux/gfs2_ioctl.h>
#include <linux/fs.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include <asm/uaccess.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bmap.h"
#include "dir.h"
#include "glock.h"
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
+#include "util.h"
/* "bad" is for NFS support */
struct filldir_bad_entry {
static loff_t gfs2_llseek(struct file *file, loff_t offset, int origin)
{
- struct gfs2_inode *ip = get_v2ip(file->f_mapping->host);
+ struct gfs2_inode *ip = file->f_mapping->host->u.generic_ip;
struct gfs2_holder i_gh;
loff_t error;
unsigned long nr_segs, loff_t *ppos)
{
struct file *filp = iocb->ki_filp;
- struct gfs2_inode *ip = get_v2ip(filp->f_mapping->host);
+ struct gfs2_inode *ip = filp->f_mapping->host->u.generic_ip;
struct gfs2_holder gh;
ssize_t retval;
unsigned long seg;
static int readdir_reg(struct file *file, void *dirent, filldir_t filldir)
{
- struct gfs2_inode *dip = get_v2ip(file->f_mapping->host);
+ struct gfs2_inode *dip = file->f_mapping->host->u.generic_ip;
struct filldir_reg fdr;
struct gfs2_holder d_gh;
uint64_t offset = file->f_pos;
static int readdir_bad(struct file *file, void *dirent, filldir_t filldir)
{
- struct gfs2_inode *dip = get_v2ip(file->f_mapping->host);
+ struct gfs2_inode *dip = file->f_mapping->host->u.generic_ip;
struct gfs2_sbd *sdp = dip->i_sbd;
struct filldir_reg fdr;
unsigned int entries, size;
static int gfs2_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
unsigned long arg)
{
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
switch (cmd) {
case GFS2_IOCTL_SETFLAGS:
static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
{
- struct gfs2_inode *ip = get_v2ip(file->f_mapping->host);
+ struct gfs2_inode *ip = file->f_mapping->host->u.generic_ip;
struct gfs2_holder i_gh;
int error;
static int gfs2_open(struct inode *inode, struct file *file)
{
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_holder i_gh;
struct gfs2_file *fp;
int error;
fp->f_inode = ip;
fp->f_vfile = file;
- gfs2_assert_warn(ip->i_sbd, !get_v2fp(file));
- set_v2fp(file, fp);
+ gfs2_assert_warn(ip->i_sbd, !file->private_data);
+ file->private_data = fp;
if (S_ISREG(ip->i_di.di_mode)) {
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
gfs2_glock_dq_uninit(&i_gh);
fail:
- set_v2fp(file, NULL);
+ file->private_data = NULL;
kfree(fp);
return error;
static int gfs2_close(struct inode *inode, struct file *file)
{
- struct gfs2_sbd *sdp = get_v2sdp(inode->i_sb);
+ struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
struct gfs2_file *fp;
- fp = get_v2fp(file);
- set_v2fp(file, NULL);
+ fp = file->private_data;
+ file->private_data = NULL;
if (gfs2_assert_warn(sdp, fp))
return -EIO;
static int gfs2_fsync(struct file *file, struct dentry *dentry, int datasync)
{
- struct gfs2_inode *ip = get_v2ip(dentry->d_inode);
+ struct gfs2_inode *ip = dentry->d_inode->u.generic_ip;
gfs2_log_flush_glock(ip->i_gl);
static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl)
{
- struct gfs2_inode *ip = get_v2ip(file->f_mapping->host);
+ struct gfs2_inode *ip = file->f_mapping->host->u.generic_ip;
struct gfs2_sbd *sdp = ip->i_sbd;
struct lm_lockname name =
{ .ln_number = ip->i_num.no_addr,
static int do_flock(struct file *file, int cmd, struct file_lock *fl)
{
- struct gfs2_file *fp = get_v2fp(file);
+ struct gfs2_file *fp = file->private_data;
struct gfs2_holder *fl_gh = &fp->f_fl_gh;
struct gfs2_inode *ip = fp->f_inode;
struct gfs2_glock *gl;
static void do_unflock(struct file *file, struct file_lock *fl)
{
- struct gfs2_file *fp = get_v2fp(file);
+ struct gfs2_file *fp = file->private_data;
struct gfs2_holder *fl_gh = &fp->f_fl_gh;
mutex_lock(&fp->f_fl_mutex);
static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)
{
- struct gfs2_inode *ip = get_v2ip(file->f_mapping->host);
+ struct gfs2_inode *ip = file->f_mapping->host->u.generic_ip;
struct gfs2_sbd *sdp = ip->i_sbd;
if (!(fl->fl_flags & FL_FLOCK))
#include <linux/vmalloc.h>
#include <linux/blkdev.h>
#include <linux/kthread.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "daemon.h"
#include "glock.h"
#include "glops.h"
#include "super.h"
#include "unlinked.h"
#include "sys.h"
+#include "util.h"
#define DO 0
#define UNDO 1
memset(sdp, 0, sizeof(struct gfs2_sbd));
- set_v2sdp(sb, sdp);
+ sb->s_fs_info = sdp;
sdp->sd_vfs = sb;
gfs2_tune_init(&sdp->sd_tune);
{
struct gfs2_holder ji_gh;
struct task_struct *p;
+ struct gfs2_inode *ip;
int jindex = 1;
int error = 0;
fs_err(sdp, "can't lookup journal index: %d\n", error);
return error;
}
- set_bit(GLF_STICKY, &get_v2ip(sdp->sd_jindex)->i_gl->gl_flags);
+ ip = sdp->sd_jindex->u.generic_ip;
+ set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
/* Load in the journal index special file */
goto fail_jindex;
}
- error = gfs2_glock_nq_init(
- get_v2ip(sdp->sd_jdesc->jd_inode)->i_gl,
+ ip = sdp->sd_jdesc->jd_inode->u.generic_ip;
+ error = gfs2_glock_nq_init(ip->i_gl,
LM_ST_SHARED,
LM_FLAG_NOEXP | GL_EXACT,
&sdp->sd_jinode_gh);
static int init_inodes(struct gfs2_sbd *sdp, int undo)
{
int error = 0;
+ struct gfs2_inode *ip;
if (undo)
goto fail_qinode;
fs_err(sdp, "can't get resource index inode: %d\n", error);
goto fail_statfs;
}
- set_bit(GLF_STICKY, &get_v2ip(sdp->sd_rindex)->i_gl->gl_flags);
- sdp->sd_rindex_vn = get_v2ip(sdp->sd_rindex)->i_gl->gl_vn - 1;
+ ip = sdp->sd_rindex->u.generic_ip;
+ set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
+ sdp->sd_rindex_vn = ip->i_gl->gl_vn - 1;
/* Read in the quota inode */
error = gfs2_lookup_simple(sdp->sd_master_dir, "quota",
struct inode *pn = NULL;
char buf[30];
int error = 0;
+ struct gfs2_inode *ip;
if (sdp->sd_args.ar_spectator)
return 0;
iput(pn);
pn = NULL;
- error = gfs2_glock_nq_init(get_v2ip(sdp->sd_ir_inode)->i_gl,
+ ip = sdp->sd_ir_inode->u.generic_ip;
+ error = gfs2_glock_nq_init(ip->i_gl,
LM_ST_EXCLUSIVE, GL_NEVER_RECURSE,
&sdp->sd_ir_gh);
if (error) {
goto fail_qc_i;
}
- error = gfs2_glock_nq_init(get_v2ip(sdp->sd_sc_inode)->i_gl,
+ ip = sdp->sd_sc_inode->u.generic_ip;
+ error = gfs2_glock_nq_init(ip->i_gl,
LM_ST_EXCLUSIVE, GL_NEVER_RECURSE,
&sdp->sd_sc_gh);
if (error) {
goto fail_ir_gh;
}
- error = gfs2_glock_nq_init(get_v2ip(sdp->sd_ut_inode)->i_gl,
+ ip = sdp->sd_ut_inode->u.generic_ip;
+ error = gfs2_glock_nq_init(ip->i_gl,
LM_ST_EXCLUSIVE, GL_NEVER_RECURSE,
&sdp->sd_ut_gh);
if (error) {
goto fail_sc_gh;
}
- error = gfs2_glock_nq_init(get_v2ip(sdp->sd_qc_inode)->i_gl,
+ ip = sdp->sd_qc_inode->u.generic_ip;
+ error = gfs2_glock_nq_init(ip->i_gl,
LM_ST_EXCLUSIVE, GL_NEVER_RECURSE,
&sdp->sd_qc_gh);
if (error) {
fail:
vfree(sdp);
- set_v2sdp(sb, NULL);
+ sb->s_fs_info = NULL;
return error;
}
#include <linux/mm.h>
#include <linux/xattr.h>
#include <linux/posix_acl.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include <asm/uaccess.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "acl.h"
#include "bmap.h"
#include "dir.h"
#include "rgrp.h"
#include "trans.h"
#include "unlinked.h"
+#include "util.h"
/**
* gfs2_create - Create a file
static int gfs2_create(struct inode *dir, struct dentry *dentry,
int mode, struct nameidata *nd)
{
- struct gfs2_inode *dip = get_v2ip(dir);
+ struct gfs2_inode *dip = dir->u.generic_ip;
struct gfs2_sbd *sdp = dip->i_sbd;
struct gfs2_holder ghs[2];
struct inode *inode;
static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
struct nameidata *nd)
{
- struct gfs2_inode *dip = get_v2ip(dir);
+ struct gfs2_inode *dip = dir->u.generic_ip;
struct gfs2_sbd *sdp = dip->i_sbd;
struct inode *inode = NULL;
int error;
static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *dentry)
{
- struct gfs2_inode *dip = get_v2ip(dir);
+ struct gfs2_inode *dip = dir->u.generic_ip;
struct gfs2_sbd *sdp = dip->i_sbd;
struct inode *inode = old_dentry->d_inode;
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_holder ghs[2];
int alloc_required;
int error;
static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
{
- struct gfs2_inode *dip = get_v2ip(dir);
+ struct gfs2_inode *dip = dir->u.generic_ip;
struct gfs2_sbd *sdp = dip->i_sbd;
- struct gfs2_inode *ip = get_v2ip(dentry->d_inode);
+ struct gfs2_inode *ip = dentry->d_inode->u.generic_ip;
struct gfs2_unlinked *ul;
struct gfs2_holder ghs[2];
int error;
static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
const char *symname)
{
- struct gfs2_inode *dip = get_v2ip(dir), *ip;
+ struct gfs2_inode *dip = dir->u.generic_ip, *ip;
struct gfs2_sbd *sdp = dip->i_sbd;
struct gfs2_holder ghs[2];
struct inode *inode;
return PTR_ERR(inode);
}
- ip = get_gl2ip(ghs[1].gh_gl);
+ ip = ghs[1].gh_gl->gl_object;
ip->i_di.di_size = size;
static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
- struct gfs2_inode *dip = get_v2ip(dir), *ip;
+ struct gfs2_inode *dip = dir->u.generic_ip, *ip;
struct gfs2_sbd *sdp = dip->i_sbd;
struct gfs2_holder ghs[2];
struct inode *inode;
return PTR_ERR(inode);
}
- ip = get_gl2ip(ghs[1].gh_gl);
+ ip = ghs[1].gh_gl->gl_object;
ip->i_di.di_nlink = 2;
ip->i_di.di_size = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
static int gfs2_rmdir(struct inode *dir, struct dentry *dentry)
{
- struct gfs2_inode *dip = get_v2ip(dir);
+ struct gfs2_inode *dip = dir->u.generic_ip;
struct gfs2_sbd *sdp = dip->i_sbd;
- struct gfs2_inode *ip = get_v2ip(dentry->d_inode);
+ struct gfs2_inode *ip = dentry->d_inode->u.generic_ip;
struct gfs2_unlinked *ul;
struct gfs2_holder ghs[2];
int error;
static int gfs2_mknod(struct inode *dir, struct dentry *dentry, int mode,
dev_t dev)
{
- struct gfs2_inode *dip = get_v2ip(dir), *ip;
+ struct gfs2_inode *dip = dir->u.generic_ip, *ip;
struct gfs2_sbd *sdp = dip->i_sbd;
struct gfs2_holder ghs[2];
struct inode *inode;
return PTR_ERR(inode);
}
- ip = get_gl2ip(ghs[1].gh_gl);
+ ip = ghs[1].gh_gl->gl_object;
ip->i_di.di_major = major;
ip->i_di.di_minor = minor;
static int gfs2_rename(struct inode *odir, struct dentry *odentry,
struct inode *ndir, struct dentry *ndentry)
{
- struct gfs2_inode *odip = get_v2ip(odir);
- struct gfs2_inode *ndip = get_v2ip(ndir);
- struct gfs2_inode *ip = get_v2ip(odentry->d_inode);
+ struct gfs2_inode *odip = odir->u.generic_ip;
+ struct gfs2_inode *ndip = ndir->u.generic_ip;
+ struct gfs2_inode *ip = odentry->d_inode->u.generic_ip;
struct gfs2_inode *nip = NULL;
struct gfs2_sbd *sdp = odip->i_sbd;
struct gfs2_unlinked *ul;
int error;
if (ndentry->d_inode) {
- nip = get_v2ip(ndentry->d_inode);
+ nip = ndentry->d_inode->u.generic_ip;
if (ip == nip)
return 0;
}
static int gfs2_readlink(struct dentry *dentry, char __user *user_buf,
int user_size)
{
- struct gfs2_inode *ip = get_v2ip(dentry->d_inode);
+ struct gfs2_inode *ip = dentry->d_inode->u.generic_ip;
char array[GFS2_FAST_NAME_SIZE], *buf = array;
unsigned int len = GFS2_FAST_NAME_SIZE;
int error;
static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
{
- struct gfs2_inode *ip = get_v2ip(dentry->d_inode);
+ struct gfs2_inode *ip = dentry->d_inode->u.generic_ip;
char array[GFS2_FAST_NAME_SIZE], *buf = array;
unsigned int len = GFS2_FAST_NAME_SIZE;
int error;
static int gfs2_permission(struct inode *inode, int mask, struct nameidata *nd)
{
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_holder i_gh;
int error;
static int setattr_size(struct inode *inode, struct iattr *attr)
{
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
int error;
if (attr->ia_size != ip->i_di.di_size) {
static int setattr_chown(struct inode *inode, struct iattr *attr)
{
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_sbd *sdp = ip->i_sbd;
struct buffer_head *dibh;
uint32_t ouid, ogid, nuid, ngid;
static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
{
struct inode *inode = dentry->d_inode;
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_holder i_gh;
int error;
struct kstat *stat)
{
struct inode *inode = dentry->d_inode;
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_holder gh;
int error;
static int gfs2_setxattr(struct dentry *dentry, const char *name,
const void *data, size_t size, int flags)
{
- struct gfs2_inode *ip = get_v2ip(dentry->d_inode);
+ struct gfs2_inode *ip = dentry->d_inode->u.generic_ip;
struct gfs2_ea_request er;
memset(&er, 0, sizeof(struct gfs2_ea_request));
er.er_name_len = strlen(er.er_name);
er.er_data_len = size;
- return gfs2_ea_get(get_v2ip(dentry->d_inode), &er);
+ return gfs2_ea_get(dentry->d_inode->u.generic_ip, &er);
}
static ssize_t gfs2_listxattr(struct dentry *dentry, char *buffer, size_t size)
er.er_data = (size) ? buffer : NULL;
er.er_data_len = size;
- return gfs2_ea_list(get_v2ip(dentry->d_inode), &er);
+ return gfs2_ea_list(dentry->d_inode->u.generic_ip, &er);
}
static int gfs2_removexattr(struct dentry *dentry, const char *name)
return -EOPNOTSUPP;
er.er_name_len = strlen(er.er_name);
- return gfs2_ea_remove(get_v2ip(dentry->d_inode), &er);
+ return gfs2_ea_remove(dentry->d_inode->u.generic_ip, &er);
}
struct inode_operations gfs2_file_iops = {
#include <linux/mount.h>
#include <linux/kthread.h>
#include <linux/delay.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "glock.h"
#include "inode.h"
#include "lm.h"
#include "rgrp.h"
#include "super.h"
#include "sys.h"
+#include "util.h"
/**
* gfs2_write_inode - Make sure the inode is stable on the disk
static int gfs2_write_inode(struct inode *inode, int sync)
{
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
if (current->flags & PF_MEMALLOC)
return 0;
static void gfs2_put_super(struct super_block *sb)
{
- struct gfs2_sbd *sdp = get_v2sdp(sb);
+ struct gfs2_sbd *sdp = sb->s_fs_info;
int error;
if (!sdp)
vfree(sdp);
- set_v2sdp(sb, NULL);
+ sb->s_fs_info = NULL;
}
/**
static void gfs2_write_super(struct super_block *sb)
{
- struct gfs2_sbd *sdp = get_v2sdp(sb);
+ struct gfs2_sbd *sdp = sb->s_fs_info;
gfs2_log_flush(sdp);
}
static void gfs2_write_super_lockfs(struct super_block *sb)
{
- struct gfs2_sbd *sdp = get_v2sdp(sb);
+ struct gfs2_sbd *sdp = sb->s_fs_info;
int error;
for (;;) {
static void gfs2_unlockfs(struct super_block *sb)
{
- struct gfs2_sbd *sdp = get_v2sdp(sb);
+ struct gfs2_sbd *sdp = sb->s_fs_info;
gfs2_unfreeze_fs(sdp);
}
static int gfs2_statfs(struct super_block *sb, struct kstatfs *buf)
{
- struct gfs2_sbd *sdp = get_v2sdp(sb);
+ struct gfs2_sbd *sdp = sb->s_fs_info;
struct gfs2_statfs_change sc;
int error;
static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)
{
- struct gfs2_sbd *sdp = get_v2sdp(sb);
+ struct gfs2_sbd *sdp = sb->s_fs_info;
int error;
error = gfs2_mount_args(sdp, data, 1);
static void gfs2_clear_inode(struct inode *inode)
{
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
if (ip) {
spin_lock(&ip->i_spin);
ip->i_vnode = NULL;
- set_v2ip(inode, NULL);
+ inode->u.generic_ip = NULL;
spin_unlock(&ip->i_spin);
gfs2_glock_schedule_for_reclaim(ip->i_gl);
static int gfs2_show_options(struct seq_file *s, struct vfsmount *mnt)
{
- struct gfs2_sbd *sdp = get_v2sdp(mnt->mnt_sb);
+ struct gfs2_sbd *sdp = mnt->mnt_sb->s_fs_info;
struct gfs2_args *args = &sdp->sd_args;
if (args->ar_lockproto[0])
#include <linux/buffer_head.h>
#include <linux/mm.h>
#include <linux/pagemap.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bmap.h"
#include "glock.h"
#include "inode.h"
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
+#include "util.h"
static void pfault_be_greedy(struct gfs2_inode *ip)
{
static struct page *gfs2_private_nopage(struct vm_area_struct *area,
unsigned long address, int *type)
{
- struct gfs2_inode *ip = get_v2ip(area->vm_file->f_mapping->host);
+ struct gfs2_inode *ip = area->vm_file->f_mapping->host->u.generic_ip;
struct gfs2_holder i_gh;
struct page *result;
int error;
static struct page *gfs2_sharewrite_nopage(struct vm_area_struct *area,
unsigned long address, int *type)
{
- struct gfs2_inode *ip = get_v2ip(area->vm_file->f_mapping->host);
+ struct gfs2_inode *ip = area->vm_file->f_mapping->host->u.generic_ip;
struct gfs2_holder i_gh;
struct page *result = NULL;
unsigned long index = ((address - area->vm_start) >> PAGE_CACHE_SHIFT) +
#include <linux/buffer_head.h>
#include <linux/pagemap.h>
#include <linux/mm.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bmap.h"
#include "inode.h"
#include "page.h"
#include "trans.h"
#include "ops_address.h"
+#include "util.h"
/**
* gfs2_pte_inval - Sync and invalidate all PTEs associated with a glock
struct gfs2_inode *ip;
struct inode *inode;
- ip = get_gl2ip(gl);
+ ip = gl->gl_object;
if (!ip || !S_ISREG(ip->i_di.di_mode))
return;
struct gfs2_inode *ip;
struct inode *inode;
- ip = get_gl2ip(gl);
+ ip = gl->gl_object;
if (!ip || !S_ISREG(ip->i_di.di_mode))
return;
struct gfs2_inode *ip;
struct inode *inode;
- ip = get_gl2ip(gl);
+ ip = gl->gl_object;
if (!ip || !S_ISREG(ip->i_di.di_mode))
return;
int gfs2_block_truncate_page(struct address_space *mapping)
{
struct inode *inode = mapping->host;
- struct gfs2_inode *ip = get_v2ip(inode);
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_sbd *sdp = ip->i_sbd;
loff_t from = inode->i_size;
unsigned long index = from >> PAGE_CACHE_SHIFT;
#include <linux/tty.h>
#include <linux/sort.h>
#include <linux/fs.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bmap.h"
#include "glock.h"
#include "glops.h"
#include "log.h"
+#include "lvb.h"
#include "meta_io.h"
#include "quota.h"
#include "rgrp.h"
#include "inode.h"
#include "ops_file.h"
#include "ops_address.h"
+#include "util.h"
#define QUOTA_USER 1
#define QUOTA_GROUP 0
static int bh_get(struct gfs2_quota_data *qd)
{
struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
- struct gfs2_inode *ip = get_v2ip(sdp->sd_qc_inode);
+ struct gfs2_inode *ip = sdp->sd_qc_inode->u.generic_ip;
unsigned int block, offset;
uint64_t dblock;
int new = 0;
static void do_qc(struct gfs2_quota_data *qd, int64_t change)
{
struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
- struct gfs2_inode *ip = get_v2ip(sdp->sd_qc_inode);
+ struct gfs2_inode *ip = sdp->sd_qc_inode->u.generic_ip;
struct gfs2_quota_change *qc = qd->qd_bh_qc;
int64_t x;
static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
{
struct gfs2_sbd *sdp = (*qda)->qd_gl->gl_sbd;
- struct gfs2_inode *ip = get_v2ip(sdp->sd_quota_inode);
+ struct gfs2_inode *ip = sdp->sd_quota_inode->u.generic_ip;
unsigned int data_blocks, ind_blocks;
struct file_ra_state ra_state;
struct gfs2_holder *ghs, i_gh;
struct gfs2_holder *q_gh)
{
struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
+ struct gfs2_inode *ip = sdp->sd_quota_inode->u.generic_ip;
struct gfs2_holder i_gh;
struct gfs2_quota q;
char buf[sizeof(struct gfs2_quota)];
if (error)
return error;
- error = gfs2_glock_nq_init(get_v2ip(sdp->sd_quota_inode)->i_gl,
+ error = gfs2_glock_nq_init(ip->i_gl,
LM_ST_SHARED, 0,
&i_gh);
if (error)
memset(buf, 0, sizeof(struct gfs2_quota));
pos = qd2offset(qd);
- error = gfs2_internal_read(get_v2ip(sdp->sd_quota_inode),
+ error = gfs2_internal_read(ip,
&ra_state, buf,
&pos,
sizeof(struct gfs2_quota));
int gfs2_quota_init(struct gfs2_sbd *sdp)
{
- struct gfs2_inode *ip = get_v2ip(sdp->sd_qc_inode);
+ struct gfs2_inode *ip = sdp->sd_qc_inode->u.generic_ip;
unsigned int blocks = ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift;
unsigned int x, slot = 0;
unsigned int found = 0;
return -EIO;
}
sdp->sd_quota_slots = blocks * sdp->sd_qc_per_block;
- sdp->sd_quota_chunks = DIV_RU(sdp->sd_quota_slots, 8 * PAGE_SIZE);
+ sdp->sd_quota_chunks = DIV_ROUND_UP(sdp->sd_quota_slots, 8 * PAGE_SIZE);
error = -ENOMEM;
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bmap.h"
#include "glock.h"
#include "glops.h"
#include "meta_io.h"
#include "recovery.h"
#include "super.h"
+#include "util.h"
int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk,
struct buffer_head **bh)
{
- struct gfs2_glock *gl = get_v2ip(jd->jd_inode)->i_gl;
+ struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
+ struct gfs2_glock *gl = ip->i_gl;
int new = 0;
uint64_t dblock;
uint32_t extlen;
int error;
- error = gfs2_block_map(get_v2ip(jd->jd_inode), blk, &new, &dblock,
+ error = gfs2_block_map(ip, blk, &new, &dblock,
&extlen);
if (error)
return error;
if (!dblock) {
- gfs2_consist_inode(get_v2ip(jd->jd_inode));
+ gfs2_consist_inode(ip);
return -EIO;
}
*blk = 0;
if (*blk == orig_blk) {
- gfs2_consist_inode(get_v2ip(jd->jd_inode));
+ gfs2_consist_inode(jd->jd_inode->u.generic_ip);
return -EIO;
}
}
continue;
if (lh.lh_sequence == head->lh_sequence) {
- gfs2_consist_inode(get_v2ip(jd->jd_inode));
+ gfs2_consist_inode(jd->jd_inode->u.generic_ip);
return -EIO;
}
if (lh.lh_sequence < head->lh_sequence)
static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start,
unsigned int end, int pass)
{
- struct gfs2_sbd *sdp = get_v2ip(jd->jd_inode)->i_sbd;
+ struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
+ struct gfs2_sbd *sdp = ip->i_sbd;
struct buffer_head *bh;
struct gfs2_log_descriptor *ld;
int error = 0;
continue;
}
if (error == 1) {
- gfs2_consist_inode(get_v2ip(jd->jd_inode));
+ gfs2_consist_inode(jd->jd_inode->u.generic_ip);
error = -EIO;
}
brelse(bh);
static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
{
- struct gfs2_inode *ip = get_v2ip(jd->jd_inode);
+ struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
struct gfs2_sbd *sdp = ip->i_sbd;
unsigned int lblock;
int new = 0;
int gfs2_recover_journal(struct gfs2_jdesc *jd, int wait)
{
- struct gfs2_sbd *sdp = get_v2ip(jd->jd_inode)->i_sbd;
+ struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
+ struct gfs2_sbd *sdp = ip->i_sbd;
struct gfs2_log_header head;
struct gfs2_holder j_gh, ji_gh, t_gh;
unsigned long t;
goto fail;
};
- error = gfs2_glock_nq_init(get_v2ip(jd->jd_inode)->i_gl, LM_ST_SHARED,
+ error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
LM_FLAG_NOEXP, &ji_gh);
if (error)
goto fail_gunlock_j;
gfs2_glock_dq_uninit(&t_gh);
- t = DIV_RU(jiffies - t, HZ);
+ t = DIV_ROUND_UP(jiffies - t, HZ);
fs_info(sdp, "jid=%u: Journal replayed in %lus\n",
jd->jd_jid, t);
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/fs.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bits.h"
#include "glock.h"
#include "glops.h"
#include "super.h"
#include "trans.h"
#include "ops_file.h"
+#include "util.h"
/**
* gfs2_rgrp_verify - Verify that a resource group is consistent
list_del(&rgd->rd_list_mru);
if (gl) {
- set_gl2rgd(gl, NULL);
+ gl->gl_object = NULL;
gfs2_glock_put(gl);
}
if (error)
goto fail;
- set_gl2rgd(rgd->rd_gl, rgd);
+ rgd->rd_gl->gl_object = rgd;
rgd->rd_rg_vn = rgd->rd_gl->gl_vn - 1;
}
int gfs2_rindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ri_gh)
{
- struct gfs2_inode *ip = get_v2ip(sdp->sd_rindex);
+ struct gfs2_inode *ip = sdp->sd_rindex->u.generic_ip;
struct gfs2_glock *gl = ip->i_gl;
int error;
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bmap.h"
#include "dir.h"
#include "format.h"
#include "super.h"
#include "trans.h"
#include "unlinked.h"
+#include "util.h"
/**
* gfs2_tune_init - Fill a gfs2_tune structure with default values
/* Compute maximum reservation required to add a entry to a directory */
- hash_blocks = DIV_RU(sizeof(uint64_t) * (1 << GFS2_DIR_MAX_DEPTH),
+ hash_blocks = DIV_ROUND_UP(sizeof(uint64_t) * (1 << GFS2_DIR_MAX_DEPTH),
sdp->sd_jbsize);
ind_blocks = 0;
for (tmp_blocks = hash_blocks; tmp_blocks > sdp->sd_diptrs;) {
- tmp_blocks = DIV_RU(tmp_blocks, sdp->sd_inptrs);
+ tmp_blocks = DIV_ROUND_UP(tmp_blocks, sdp->sd_inptrs);
ind_blocks += tmp_blocks;
}
int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
{
- struct gfs2_inode *dip = get_v2ip(sdp->sd_jindex);
+ struct gfs2_inode *dip = sdp->sd_jindex->u.generic_ip;
struct qstr name;
char buf[20];
struct gfs2_jdesc *jd;
name.len = sprintf(buf, "journal%u", sdp->sd_journals);
- error = gfs2_dir_search(get_v2ip(sdp->sd_jindex),
+ error = gfs2_dir_search(sdp->sd_jindex->u.generic_ip,
&name, NULL, NULL);
if (error == -ENOENT) {
error = 0;
int gfs2_jdesc_check(struct gfs2_jdesc *jd)
{
- struct gfs2_inode *ip = get_v2ip(jd->jd_inode);
+ struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
struct gfs2_sbd *sdp = ip->i_sbd;
int ar;
int error;
int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
{
- struct gfs2_glock *j_gl = get_v2ip(sdp->sd_jdesc->jd_inode)->i_gl;
+ struct gfs2_inode *ip = sdp->sd_jdesc->jd_inode->u.generic_ip;
+ struct gfs2_glock *j_gl = ip->i_gl;
struct gfs2_holder t_gh;
struct gfs2_log_header head;
int error;
if (error)
return error;
- gfs2_meta_cache_flush(get_v2ip(sdp->sd_jdesc->jd_inode));
+ gfs2_meta_cache_flush(ip);
j_gl->gl_ops->go_inval(j_gl, DIO_METADATA | DIO_DATA);
error = gfs2_find_jhead(sdp->sd_jdesc, &head);
int gfs2_statfs_init(struct gfs2_sbd *sdp)
{
- struct gfs2_inode *m_ip = get_v2ip(sdp->sd_statfs_inode);
+ struct gfs2_inode *m_ip = sdp->sd_statfs_inode->u.generic_ip;
struct gfs2_statfs_change *m_sc = &sdp->sd_statfs_master;
- struct gfs2_inode *l_ip = get_v2ip(sdp->sd_sc_inode);
+ struct gfs2_inode *l_ip = sdp->sd_sc_inode->u.generic_ip;
struct gfs2_statfs_change *l_sc = &sdp->sd_statfs_local;
struct buffer_head *m_bh, *l_bh;
struct gfs2_holder gh;
void gfs2_statfs_change(struct gfs2_sbd *sdp, int64_t total, int64_t free,
int64_t dinodes)
{
- struct gfs2_inode *l_ip = get_v2ip(sdp->sd_sc_inode);
+ struct gfs2_inode *l_ip = sdp->sd_sc_inode->u.generic_ip;
struct gfs2_statfs_change *l_sc = &sdp->sd_statfs_local;
struct buffer_head *l_bh;
int error;
int gfs2_statfs_sync(struct gfs2_sbd *sdp)
{
- struct gfs2_inode *m_ip = get_v2ip(sdp->sd_statfs_inode);
- struct gfs2_inode *l_ip = get_v2ip(sdp->sd_sc_inode);
+ struct gfs2_inode *m_ip = sdp->sd_statfs_inode->u.generic_ip;
+ struct gfs2_inode *l_ip = sdp->sd_sc_inode->u.generic_ip;
struct gfs2_statfs_change *m_sc = &sdp->sd_statfs_master;
struct gfs2_statfs_change *l_sc = &sdp->sd_statfs_local;
struct gfs2_holder gh;
error = err;
} else {
if (!error)
- error = statfs_slow_fill(get_gl2rgd(gh->gh_gl), sc);
+ error = statfs_slow_fill(
+ gh->gh_gl->gl_object, sc);
gfs2_glock_dq_uninit(gh);
}
}
int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp, struct gfs2_holder *t_gh)
{
+ struct gfs2_inode *ip;
struct gfs2_holder ji_gh;
struct gfs2_jdesc *jd;
struct lfcc *lfcc;
error = -ENOMEM;
goto out;
}
- error = gfs2_glock_nq_init(get_v2ip(jd->jd_inode)->i_gl,
+ ip = jd->jd_inode->u.generic_ip;
+ error = gfs2_glock_nq_init(ip->i_gl,
LM_ST_SHARED, 0,
&lfcc->gh);
if (error) {
#include <linux/buffer_head.h>
#include <linux/module.h>
#include <linux/kobject.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include <asm/uaccess.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "lm.h"
#include "sys.h"
#include "super.h"
#include "glock.h"
#include "quota.h"
+#include "util.h"
char *gfs2_sys_margs;
spinlock_t gfs2_sys_margs_lock;
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "glock.h"
#include "log.h"
#include "lops.h"
#include "meta_io.h"
#include "trans.h"
+#include "util.h"
int gfs2_trans_begin_i(struct gfs2_sbd *sdp, unsigned int blocks,
unsigned int revokes, char *file, unsigned int line)
struct gfs2_trans *tr;
int error;
- if (gfs2_assert_warn(sdp, !get_transaction) ||
+ if (gfs2_assert_warn(sdp, !current->journal_info) ||
gfs2_assert_warn(sdp, blocks || revokes)) {
fs_warn(sdp, "(%s, %u)\n", file, line);
return -EINVAL;
if (error)
goto fail_gunlock;
- set_transaction(tr);
+ current->journal_info = tr;
return 0;
struct gfs2_trans *tr;
struct gfs2_holder *t_gh;
- tr = get_transaction;
- set_transaction(NULL);
+ tr = current->journal_info;
+ current->journal_info = NULL;
if (gfs2_assert_warn(sdp, tr))
return;
struct gfs2_sbd *sdp = gl->gl_sbd;
struct gfs2_bufdata *bd;
- bd = get_v2bd(bh);
+ bd = bh->b_private;
if (bd)
gfs2_assert(sdp, bd->bd_gl == gl);
else {
gfs2_attach_bufdata(gl, bh, meta);
- bd = get_v2bd(bh);
+ bd = bh->b_private;
}
lops_add(sdp, &bd->bd_le);
}
gfs2_log_unlock(sdp);
if (found) {
+ struct gfs2_trans *tr = current->journal_info;
kfree(rv);
- get_transaction->tr_num_revoke_rm++;
+ tr->tr_num_revoke_rm++;
}
}
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/kthread.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bmap.h"
#include "inode.h"
#include "meta_io.h"
#include "trans.h"
#include "unlinked.h"
+#include "util.h"
static int munge_ondisk(struct gfs2_sbd *sdp, unsigned int slot,
struct gfs2_unlinked_tag *ut)
{
- struct gfs2_inode *ip = get_v2ip(sdp->sd_ut_inode);
+ struct gfs2_inode *ip = sdp->sd_ut_inode->u.generic_ip;
unsigned int block, offset;
uint64_t dblock;
int new = 0;
int gfs2_unlinked_init(struct gfs2_sbd *sdp)
{
- struct gfs2_inode *ip = get_v2ip(sdp->sd_ut_inode);
+ struct gfs2_inode *ip = sdp->sd_ut_inode->u.generic_ip;
unsigned int blocks = ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift;
unsigned int x, slot = 0;
unsigned int found = 0;
return -EIO;
}
sdp->sd_unlinked_slots = blocks * sdp->sd_ut_per_block;
- sdp->sd_unlinked_chunks = DIV_RU(sdp->sd_unlinked_slots, 8 * PAGE_SIZE);
+ sdp->sd_unlinked_chunks = DIV_ROUND_UP(sdp->sd_unlinked_slots,
+ 8 * PAGE_SIZE);
error = -ENOMEM;
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/crc32.h>
+#include <linux/gfs2_ondisk.h>
#include <asm/semaphore.h>
#include <asm/uaccess.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "glock.h"
#include "lm.h"
+#include "util.h"
kmem_cache_t *gfs2_glock_cachep __read_mostly;
kmem_cache_t *gfs2_inode_cachep __read_mostly;
* An on-disk inode number
*/
-#define gfs2_inum_equal(ino1, ino2) \
- (((ino1)->no_formal_ino == (ino2)->no_formal_ino) && \
- ((ino1)->no_addr == (ino2)->no_addr))
-
struct gfs2_inum {
__be64 no_formal_ino;
__be64 no_addr;
};
+static inline int gfs2_inum_equal(const struct gfs2_inum *ino1,
+ const struct gfs2_inum *ino2)
+{
+ return ino1->no_formal_ino == ino2->no_formal_ino &&
+ ino1->no_addr == ino2->no_addr;
+}
+
/*
* Generic metadata head structure
* Every inplace buffer logged in the journal must start with this.
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
#define ALIGN(x,a) (((x)+(a)-1)&~((a)-1))
+#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
#define KERN_EMERG "<0>" /* system is unusable */
#define KERN_ALERT "<1>" /* action must be taken immediately */
git://bbs.cooldavid.org / net-next-2.6.git / commitdiff