hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[GFS2] Macros removal in gfs2.h 

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>
This commit is contained in:
Steven Whitehouse 2006-02-27 17:23:27 -05:00
parent f3b270a478
commit 5c676f6d35
40 changed files with 416 additions and 272 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
fs/gfs2/acl.c
View File

@ -15,8 +15,11 @@
#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"
@ -24,6 +27,7 @@
#include "inode.h"
#include "meta_io.h"
#include "trans.h"
#include "util.h"
#define ACL_ACCESS 1
#define ACL_DEFAULT 0
@ -157,7 +161,7 @@ int gfs2_check_acl_locked(struct inode *inode, int mask)
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;
@ -172,7 +176,7 @@ int gfs2_check_acl_locked(struct inode *inode, int mask)
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;

4
fs/gfs2/bits.c
View File

@ -21,10 +21,14 @@
#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 */

10
fs/gfs2/bmap.c
View File

@ -12,9 +12,12 @@
#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"
@ -24,6 +27,7 @@
#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
@ -660,7 +664,7 @@ static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh,
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;
}
@ -1021,7 +1025,7 @@ void gfs2_write_calc_reserv(struct gfs2_inode *ip, unsigned int len,
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;
@ -1029,7 +1033,7 @@ void gfs2_write_calc_reserv(struct gfs2_inode *ip, unsigned int len,
}
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;
}
}

4
fs/gfs2/daemon.c
View File

@ -14,9 +14,12 @@
#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"
@ -24,6 +27,7 @@
#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

8
fs/gfs2/dir.c
View File

@ -59,9 +59,12 @@
#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"
@ -70,6 +73,7 @@
#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 */
@ -2196,7 +2200,7 @@ static int leaf_dealloc(struct gfs2_inode *dip, uint32_t index, uint32_t len,
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;
}
@ -2205,7 +2209,7 @@ static int leaf_dealloc(struct gfs2_inode *dip, uint32_t index, uint32_t len,
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;

4
fs/gfs2/eaops.c
View File

@ -13,13 +13,17 @@
#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

19
fs/gfs2/eattr.c
View File

@ -13,10 +13,13 @@
#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"
@ -26,6 +29,7 @@
#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
@ -478,7 +482,7 @@ static int ea_get_unstuffed(struct gfs2_inode *ip, struct gfs2_ea_header *ea,
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;
@ -676,7 +680,7 @@ static int ea_write(struct gfs2_inode *ip, struct gfs2_ea_header *ea,
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;
@ -810,7 +814,7 @@ static int ea_init(struct gfs2_inode *ip, struct gfs2_ea_request *er)
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);
}
@ -962,7 +966,8 @@ static int ea_set_simple(struct gfs2_inode *ip, struct buffer_head *bh,
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);
@ -1066,7 +1071,7 @@ static int ea_set_i(struct gfs2_inode *ip, struct gfs2_ea_request *er,
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);
}
@ -1250,7 +1255,7 @@ static int ea_acl_chmod_unstuffed(struct gfs2_inode *ip,
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;
@ -1402,7 +1407,7 @@ static int ea_dealloc_indirect(struct gfs2_inode *ip)
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;
}

2
fs/gfs2/eattr.h
View File

@ -29,7 +29,7 @@ ALIGN(sizeof(struct gfs2_ea_header) + (er)->er_name_len + (er)->er_data_len, 8)
#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)

29
fs/gfs2/gfs2.h
View File

@ -10,13 +10,6 @@
#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,
@ -32,29 +25,7 @@ enum {
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__ */

20
fs/gfs2/glock.c
View File

@ -16,10 +16,13 @@
#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"
@ -28,6 +31,7 @@
#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 {
@ -1962,7 +1966,7 @@ void gfs2_try_toss_inode(struct gfs2_sbd *sdp, struct gfs2_inum *inum)
if (!gfs2_glmutex_trylock(gl))
goto out;
ip = get_gl2ip(gl);
ip = gl->gl_object;
if (!ip)
goto out_unlock;
@ -1994,7 +1998,7 @@ void gfs2_iopen_go_callback(struct gfs2_glock *io_gl, unsigned int state)
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);
@ -2004,7 +2008,7 @@ void gfs2_iopen_go_callback(struct gfs2_glock *io_gl, unsigned int state)
}
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);
@ -2093,7 +2097,7 @@ void gfs2_reclaim_glock(struct gfs2_sbd *sdp)
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);
}
@ -2174,7 +2178,7 @@ static void scan_glock(struct gfs2_glock *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))
goto out_schedule;
}
@ -2234,7 +2238,7 @@ static void clear_glock(struct gfs2_glock *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);
}
@ -2430,10 +2434,10 @@ static int dump_glock(struct gfs2_glock *gl)
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 {

21
fs/gfs2/glops.c
View File

@ -12,9 +12,12 @@
#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"
@ -24,6 +27,7 @@
#include "page.h"
#include "recovery.h"
#include "rgrp.h"
#include "util.h"
/**
* meta_go_sync - sync out the metadata for this glock
@ -193,7 +197,7 @@ static int inode_go_demote_ok(struct gfs2_glock *gl)
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 +
@ -214,7 +218,7 @@ static int inode_go_demote_ok(struct gfs2_glock *gl)
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)
@ -246,7 +250,7 @@ static int inode_go_lock(struct gfs2_holder *gh)
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);
@ -264,7 +268,7 @@ static void inode_go_unlock(struct gfs2_holder *gh)
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;
@ -311,7 +315,7 @@ static int rgrp_go_demote_ok(struct gfs2_glock *gl)
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);
}
/**
@ -324,7 +328,7 @@ static int rgrp_go_lock(struct gfs2_holder *gh)
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);
}
/**
@ -358,13 +362,14 @@ static void trans_go_xmote_th(struct gfs2_glock *gl, unsigned int state,
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);

8
fs/gfs2/incore.h
View File

@ -313,6 +313,14 @@ enum {
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;

38
fs/gfs2/inode.c
View File

@ -14,9 +14,12 @@
#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"
@ -33,6 +36,7 @@
#include "rgrp.h"
#include "trans.h"
#include "unlinked.h"
#include "util.h"
/**
* inode_attr_in - Copy attributes from the dinode into the VFS inode
@ -176,7 +180,7 @@ struct inode *gfs2_ip2v(struct gfs2_inode *ip)
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);
@ -196,7 +200,7 @@ struct inode *gfs2_ip2v(struct gfs2_inode *ip)
gfs2_inode_hold(ip);
ip->i_vnode = inode;
set_v2ip(inode, ip);
inode->u.generic_ip = ip;
spin_unlock(&ip->i_spin);
@ -207,7 +211,7 @@ struct inode *gfs2_ip2v(struct gfs2_inode *ip)
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)
@ -320,11 +324,11 @@ static int inode_create(struct gfs2_glock *i_gl, struct gfs2_inum *inum,
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);
@ -359,7 +363,7 @@ int gfs2_inode_get(struct gfs2_glock *i_gl, struct gfs2_inum *inum, int create,
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)
@ -404,10 +408,10 @@ void gfs2_inode_destroy(struct gfs2_inode *ip)
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);
@ -416,7 +420,7 @@ void gfs2_inode_destroy(struct gfs2_inode *ip)
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);
@ -524,7 +528,7 @@ static int inode_dealloc(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul,
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);
@ -715,7 +719,7 @@ int gfs2_lookupi(struct inode *dir, struct qstr *name, int is_root,
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;
@ -774,7 +778,7 @@ done:
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;
@ -815,8 +819,8 @@ static int pick_formal_ino_1(struct gfs2_sbd *sdp, uint64_t *formal_ino)
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;
@ -1194,7 +1198,7 @@ struct inode *gfs2_createi(struct gfs2_holder *ghs, struct qstr *name,
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;
@ -1570,7 +1574,7 @@ int gfs2_glock_nq_atime(struct gfs2_holder *gh)
{
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;
@ -1817,7 +1821,7 @@ int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
{
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);

5
fs/gfs2/lm.c
View File

@ -13,12 +13,17 @@
#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

8
fs/gfs2/log.c
View File

@ -12,14 +12,18 @@
#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
@ -80,7 +84,7 @@ unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct,
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;
@ -257,7 +261,7 @@ static uint64_t log_bmap(struct gfs2_sbd *sdp, unsigned int lbn)
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);

56
fs/gfs2/lops.c
View File

@ -12,9 +12,12 @@
#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"
@ -22,12 +25,14 @@
#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;
@ -68,7 +73,7 @@ static void buf_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le)
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);
@ -179,7 +184,8 @@ static void buf_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
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;
@ -192,8 +198,9 @@ static int buf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
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;
@ -238,17 +245,18 @@ static int buf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
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);
@ -258,7 +266,7 @@ static void revoke_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le)
{
struct gfs2_trans *tr;
tr = get_transaction;
tr = current->journal_info;
tr->tr_touched = 1;
tr->tr_num_revoke++;
@ -324,7 +332,8 @@ static void revoke_lo_before_commit(struct gfs2_sbd *sdp)
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;
@ -337,7 +346,8 @@ static int revoke_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
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;
@ -383,7 +393,8 @@ static int revoke_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
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);
@ -401,8 +412,9 @@ static void revoke_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
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;
@ -451,9 +463,9 @@ static void rg_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
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) &&
@ -633,7 +645,7 @@ static void databuf_lo_before_commit(struct gfs2_sbd *sdp)
bh = bd1->bd_bh;
if (bh) {
set_v2bd(bh, NULL);
bh->b_private = NULL;
gfs2_log_unlock(sdp);
wait_on_buffer(bh);
brelse(bh);
@ -651,8 +663,9 @@ static int databuf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
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;
@ -701,10 +714,11 @@ static int databuf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
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;
}
@ -712,7 +726,7 @@ static void databuf_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
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);

4
fs/gfs2/lvb.c
View File

@ -12,9 +12,13 @@
#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);

8
fs/gfs2/lvb.h
View File

@ -12,14 +12,6 @@
#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);

4
fs/gfs2/main.c
View File

@ -14,11 +14,15 @@
#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

37
fs/gfs2/meta_io.c
View File

@ -17,9 +17,12 @@
#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"
@ -28,6 +31,7 @@
#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)))
@ -37,7 +41,7 @@
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;
}
@ -55,15 +59,15 @@ static int gfs2_aspace_writepage(struct page *page,
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;
@ -78,7 +82,7 @@ static void stuck_releasepage(struct buffer_head *bh)
(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)
@ -110,7 +114,7 @@ static void stuck_releasepage(struct buffer_head *bh)
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;
@ -139,14 +143,14 @@ static int gfs2_aspace_releasepage(struct page *page, gfp_t gfp_mask)
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;
@ -184,7 +188,7 @@ struct inode *gfs2_aspace_get(struct gfs2_sbd *sdp)
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);
}
@ -523,7 +527,7 @@ int gfs2_meta_reread(struct gfs2_sbd *sdp, struct buffer_head *bh, int flags)
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;
@ -550,7 +554,7 @@ void gfs2_attach_bufdata(struct gfs2_glock *gl, struct buffer_head *bh,
if (meta)
lock_page(bh->b_page);
if (get_v2bd(bh)) {
if (bh->b_private) {
if (meta)
unlock_page(bh->b_page);
return;
@ -569,7 +573,7 @@ void gfs2_attach_bufdata(struct gfs2_glock *gl, struct buffer_head *bh,
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);
@ -584,7 +588,7 @@ void gfs2_attach_bufdata(struct gfs2_glock *gl, struct buffer_head *bh,
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));
@ -621,7 +625,7 @@ void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh)
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));
@ -662,15 +666,16 @@ void gfs2_meta_wipe(struct gfs2_inode *ip, uint64_t bstart, uint32_t blen)
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) {

4
fs/gfs2/mount.c
View File

@ -12,11 +12,15 @@
#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

34
fs/gfs2/ops_address.c
View File

@ -15,9 +15,12 @@
#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"
@ -29,6 +32,7 @@
#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
@ -43,7 +47,7 @@
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;
@ -75,7 +79,7 @@ int gfs2_get_block(struct inode *inode, sector_t lblock,
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;
@ -96,7 +100,7 @@ static int get_blocks(struct inode *inode, sector_t lblock,
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;
@ -124,7 +128,7 @@ static int get_blocks_noalloc(struct inode *inode, sector_t lblock,
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;
@ -158,7 +162,7 @@ static int get_blocks_noalloc(struct inode *inode, sector_t lblock,
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;
@ -170,7 +174,7 @@ static int gfs2_writepage(struct page *page, struct writeback_control *wbc)
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) */
@ -259,7 +263,7 @@ static int zero_readpage(struct page *page)
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;
@ -307,7 +311,7 @@ out_unlock:
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;
@ -402,7 +406,7 @@ static int gfs2_commit_write(struct file *file, struct page *page,
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;
@ -482,7 +486,7 @@ fail_nounlock:
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;
@ -504,10 +508,10 @@ static void discard_buffer(struct gfs2_sbd *sdp, struct buffer_head *bh)
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
@ -525,7 +529,7 @@ static void discard_buffer(struct gfs2_sbd *sdp, struct buffer_head *bh)
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;
@ -557,7 +561,7 @@ static ssize_t gfs2_direct_IO_write(struct kiocb *iocb, const struct iovec *iov,
{
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;
@ -604,7 +608,7 @@ static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
{
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)

8
fs/gfs2/ops_dentry.c
View File

@ -13,12 +13,16 @@
#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
@ -34,7 +38,7 @@
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;
@ -66,7 +70,7 @@ static int gfs2_drevalidate(struct dentry *dentry, struct nameidata *nd)
goto fail_gunlock;
}
ip = get_v2ip(inode);
ip = inode->u.generic_ip;
if (!gfs2_inum_equal(&ip->i_num, &inum))
goto invalid_gunlock;

17
fs/gfs2/ops_export.c
View File

@ -12,9 +12,12 @@
#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"
@ -61,7 +64,7 @@ static int gfs2_encode_fh(struct dentry *dentry, __u32 *fh, int *len,
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))
@ -77,12 +80,12 @@ static int gfs2_encode_fh(struct dentry *dentry, __u32 *fh, int *len,
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);
@ -138,8 +141,8 @@ static int gfs2_get_name(struct dentry *parent, char *name,
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;
@ -181,7 +184,7 @@ static struct dentry *gfs2_get_parent(struct dentry *child)
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;
@ -194,7 +197,7 @@ static struct dentry *gfs2_get_dentry(struct super_block *sb, void *inum_p)
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);

40
fs/gfs2/ops_file.c
View File

@ -19,10 +19,13 @@
#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"
@ -36,6 +39,7 @@
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
#include "util.h"
/* "bad" is for NFS support */
struct filldir_bad_entry {
@ -125,7 +129,7 @@ int gfs2_internal_read(struct gfs2_inode *ip, struct file_ra_state *ra_state,
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;
@ -172,7 +176,7 @@ static ssize_t __gfs2_file_aio_read(struct kiocb *iocb,
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;
@ -354,7 +358,7 @@ static int filldir_reg_func(void *opaque, const char *name, unsigned int length,
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;
@ -443,7 +447,7 @@ static int filldir_bad_func(void *opaque, const char *name, unsigned int length,
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;
@ -608,7 +612,7 @@ out:
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:
@ -630,7 +634,7 @@ static int gfs2_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
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;
@ -665,7 +669,7 @@ static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
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;
@ -679,8 +683,8 @@ static int gfs2_open(struct inode *inode, struct file *file)
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,
@ -708,7 +712,7 @@ static int gfs2_open(struct inode *inode, struct file *file)
gfs2_glock_dq_uninit(&i_gh);
fail:
set_v2fp(file, NULL);
file->private_data = NULL;
kfree(fp);
return error;
@ -724,11 +728,11 @@ static int gfs2_open(struct inode *inode, struct file *file)
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;
@ -748,7 +752,7 @@ static int gfs2_close(struct inode *inode, struct file *file)
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);
@ -766,7 +770,7 @@ static int gfs2_fsync(struct file *file, struct dentry *dentry, int datasync)
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,
@ -824,7 +828,7 @@ static ssize_t gfs2_sendfile(struct file *in_file, loff_t *offset, size_t count,
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;
@ -874,7 +878,7 @@ static int do_flock(struct file *file, int cmd, struct file_lock *fl)
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);
@ -895,7 +899,7 @@ static void do_unflock(struct file *file, struct file_lock *fl)
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))

35
fs/gfs2/ops_fstype.c
View File

@ -15,9 +15,12 @@
#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"
@ -32,6 +35,7 @@
#include "super.h"
#include "unlinked.h"
#include "sys.h"
#include "util.h"
#define DO 0
#define UNDO 1
@ -47,7 +51,7 @@ static struct gfs2_sbd *init_sbd(struct super_block *sb)
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);
@ -382,6 +386,7 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
{
struct gfs2_holder ji_gh;
struct task_struct *p;
struct gfs2_inode *ip;
int jindex = 1;
int error = 0;
@ -396,7 +401,8 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
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 */
@ -436,8 +442,8 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
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);
@ -522,6 +528,7 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
static int init_inodes(struct gfs2_sbd *sdp, int undo)
{
int error = 0;
struct gfs2_inode *ip;
if (undo)
goto fail_qinode;
@ -560,8 +567,9 @@ static int init_inodes(struct gfs2_sbd *sdp, int undo)
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",
@ -597,6 +605,7 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
struct inode *pn = NULL;
char buf[30];
int error = 0;
struct gfs2_inode *ip;
if (sdp->sd_args.ar_spectator)
return 0;
@ -641,7 +650,8 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
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) {
@ -649,7 +659,8 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
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) {
@ -657,7 +668,8 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
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) {
@ -665,7 +677,8 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
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) {
@ -862,7 +875,7 @@ static int fill_super(struct super_block *sb, void *data, int silent)
fail:
vfree(sdp);
set_v2sdp(sb, NULL);
sb->s_fs_info = NULL;
return error;
}

62
fs/gfs2/ops_inode.c
View File

@ -17,10 +17,13 @@
#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"
@ -36,6 +39,7 @@
#include "rgrp.h"
#include "trans.h"
#include "unlinked.h"
#include "util.h"
/**
* gfs2_create - Create a file
@ -49,7 +53,7 @@
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;
@ -106,7 +110,7 @@ static int gfs2_create(struct inode *dir, struct dentry *dentry,
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;
@ -140,10 +144,10 @@ static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
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;
@ -274,9 +278,9 @@ static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
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;
@ -329,7 +333,7 @@ static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
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;
@ -350,7 +354,7 @@ static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
return PTR_ERR(inode);
}
ip = get_gl2ip(ghs[1].gh_gl);
ip = ghs[1].gh_gl->gl_object;
ip->i_di.di_size = size;
@ -388,7 +392,7 @@ static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
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;
@ -403,7 +407,7 @@ static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
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);
@ -468,9 +472,9 @@ static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
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;
@ -534,7 +538,7 @@ static int gfs2_rmdir(struct inode *dir, struct dentry *dentry)
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;
@ -563,7 +567,7 @@ static int gfs2_mknod(struct inode *dir, struct dentry *dentry, int mode,
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;
@ -602,9 +606,9 @@ static int gfs2_mknod(struct inode *dir, struct dentry *dentry, int mode,
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;
@ -616,7 +620,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
int error;
if (ndentry->d_inode) {
nip = get_v2ip(ndentry->d_inode);
nip = ndentry->d_inode->u.generic_ip;
if (ip == nip)
return 0;
}
@ -848,7 +852,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
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;
@ -884,7 +888,7 @@ static int gfs2_readlink(struct dentry *dentry, char __user *user_buf,
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;
@ -910,7 +914,7 @@ static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
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;
@ -930,7 +934,7 @@ static int gfs2_permission(struct inode *inode, int mask, struct nameidata *nd)
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) {
@ -948,7 +952,7 @@ static int setattr_size(struct inode *inode, struct iattr *attr)
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;
@ -1025,7 +1029,7 @@ static int setattr_chown(struct inode *inode, struct iattr *attr)
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;
@ -1072,7 +1076,7 @@ static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
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;
@ -1088,7 +1092,7 @@ static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
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));
@ -1118,7 +1122,7 @@ static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
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)
@ -1129,7 +1133,7 @@ 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)
@ -1142,7 +1146,7 @@ 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 = {

26
fs/gfs2/ops_super.c
View File

@ -18,9 +18,12 @@
#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"
@ -33,6 +36,7 @@
#include "rgrp.h"
#include "super.h"
#include "sys.h"
#include "util.h"
/**
* gfs2_write_inode - Make sure the inode is stable on the disk
@ -44,7 +48,7 @@
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;
@ -62,7 +66,7 @@ static int gfs2_write_inode(struct inode *inode, int sync)
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)
@ -138,7 +142,7 @@ static void gfs2_put_super(struct super_block *sb)
vfree(sdp);
set_v2sdp(sb, NULL);
sb->s_fs_info = NULL;
}
/**
@ -151,7 +155,7 @@ static void gfs2_put_super(struct super_block *sb)
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);
}
@ -163,7 +167,7 @@ static void gfs2_write_super(struct super_block *sb)
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 (;;) {
@ -194,7 +198,7 @@ static void gfs2_write_super_lockfs(struct super_block *sb)
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);
}
@ -208,7 +212,7 @@ static void gfs2_unlockfs(struct super_block *sb)
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;
@ -245,7 +249,7 @@ static int gfs2_statfs(struct super_block *sb, struct kstatfs *buf)
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);
@ -283,12 +287,12 @@ static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)
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);
@ -306,7 +310,7 @@ static void gfs2_clear_inode(struct inode *inode)
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])

8
fs/gfs2/ops_vm.c
View File

@ -14,9 +14,12 @@
#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"
@ -25,6 +28,7 @@
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
#include "util.h"
static void pfault_be_greedy(struct gfs2_inode *ip)
{
@ -43,7 +47,7 @@ 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;
@ -141,7 +145,7 @@ static int alloc_page_backing(struct gfs2_inode *ip, struct page *page)
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) +

12
fs/gfs2/page.c
View File

@ -14,14 +14,18 @@
#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
@ -34,7 +38,7 @@ void gfs2_pte_inval(struct gfs2_glock *gl)
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;
@ -64,7 +68,7 @@ void gfs2_page_inval(struct gfs2_glock *gl)
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;
@ -95,7 +99,7 @@ void gfs2_page_sync(struct gfs2_glock *gl, int flags)
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;
@ -192,7 +196,7 @@ int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
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;

20
fs/gfs2/quota.c
View File

@ -44,13 +44,17 @@
#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"
@ -59,6 +63,7 @@
#include "inode.h"
#include "ops_file.h"
#include "ops_address.h"
#include "util.h"
#define QUOTA_USER 1
#define QUOTA_GROUP 0
@ -244,7 +249,7 @@ static void slot_put(struct gfs2_quota_data *qd)
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;
@ -526,7 +531,7 @@ static int sort_qd(const void *a, const void *b)
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;
@ -642,7 +647,7 @@ unlock:
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;
@ -753,6 +758,7 @@ static int do_glock(struct gfs2_quota_data *qd, int force_refresh,
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)];
@ -776,7 +782,7 @@ static int do_glock(struct gfs2_quota_data *qd, int force_refresh,
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)
@ -784,7 +790,7 @@ static int do_glock(struct gfs2_quota_data *qd, int force_refresh,
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));
@ -1118,7 +1124,7 @@ int gfs2_quota_read(struct gfs2_sbd *sdp, int user, uint32_t id,
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;
@ -1133,7 +1139,7 @@ int gfs2_quota_init(struct gfs2_sbd *sdp)
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;

29
fs/gfs2/recovery.c
View File

@ -12,9 +12,12 @@
#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"
@ -23,22 +26,24 @@
#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;
}
@ -185,7 +190,7 @@ static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk,
*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;
}
}
@ -219,7 +224,7 @@ static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
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)
@ -295,7 +300,8 @@ int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
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;
@ -324,7 +330,7 @@ static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start,
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);
@ -361,7 +367,7 @@ static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start,
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;
@ -420,7 +426,8 @@ static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
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;
@ -450,7 +457,7 @@ int gfs2_recover_journal(struct gfs2_jdesc *jd, int wait)
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;
@ -516,7 +523,7 @@ int gfs2_recover_journal(struct gfs2_jdesc *jd, int wait)
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);

10
fs/gfs2/rgrp.c
View File

@ -13,9 +13,12 @@
#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"
@ -26,6 +29,7 @@
#include "super.h"
#include "trans.h"
#include "ops_file.h"
#include "util.h"
/**
* gfs2_rgrp_verify - Verify that a resource group is consistent
@ -171,7 +175,7 @@ static void clear_rgrpdi(struct gfs2_sbd *sdp)
list_del(&rgd->rd_list_mru);
if (gl) {
set_gl2rgd(gl, NULL);
gl->gl_object = NULL;
gfs2_glock_put(gl);
}
@ -320,7 +324,7 @@ static int gfs2_ri_update(struct gfs2_inode *ip)
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;
}
@ -354,7 +358,7 @@ static int gfs2_ri_update(struct gfs2_inode *ip)
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;

36
fs/gfs2/super.c
View File

@ -12,9 +12,12 @@
#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"
@ -29,6 +32,7 @@
#include "super.h"
#include "trans.h"
#include "unlinked.h"
#include "util.h"
/**
* gfs2_tune_init - Fill a gfs2_tune structure with default values
@ -207,12 +211,12 @@ int gfs2_read_sb(struct gfs2_sbd *sdp, struct gfs2_glock *gl, int silent)
/* 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;
}
@ -278,7 +282,7 @@ int gfs2_do_upgrade(struct gfs2_sbd *sdp, struct gfs2_glock *sb_gl)
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;
@ -296,7 +300,7 @@ int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
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;
@ -419,7 +423,7 @@ struct gfs2_jdesc *gfs2_jdesc_find_dirty(struct gfs2_sbd *sdp)
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;
@ -471,7 +475,8 @@ int gfs2_lookup_master_dir(struct gfs2_sbd *sdp)
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;
@ -481,7 +486,7 @@ int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
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);
@ -559,9 +564,9 @@ int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
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;
@ -608,7 +613,7 @@ int gfs2_statfs_init(struct gfs2_sbd *sdp)
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;
@ -634,8 +639,8 @@ void gfs2_statfs_change(struct gfs2_sbd *sdp, int64_t total, int64_t free,
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;
@ -795,7 +800,8 @@ int gfs2_statfs_slow(struct gfs2_sbd *sdp, struct gfs2_statfs_change *sc)
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);
}
}
@ -846,6 +852,7 @@ struct lfcc {
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;
@ -863,7 +870,8 @@ int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp, struct gfs2_holder *t_gh)
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) {

4
fs/gfs2/sys.c
View File

@ -14,15 +14,19 @@
#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;

19
fs/gfs2/trans.c
View File

@ -12,14 +12,18 @@
#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)
@ -27,7 +31,7 @@ int gfs2_trans_begin_i(struct gfs2_sbd *sdp, unsigned int blocks,
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;
@ -69,7 +73,7 @@ int gfs2_trans_begin_i(struct gfs2_sbd *sdp, unsigned int blocks,
if (error)
goto fail_gunlock;
set_transaction(tr);
current->journal_info = tr;
return 0;
@ -90,8 +94,8 @@ void gfs2_trans_end(struct gfs2_sbd *sdp)
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;
@ -147,12 +151,12 @@ void gfs2_trans_add_bh(struct gfs2_glock *gl, struct buffer_head *bh, int meta)
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);
}
@ -186,8 +190,9 @@ void gfs2_trans_add_unrevoke(struct gfs2_sbd *sdp, uint64_t blkno)
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++;
}
}

11
fs/gfs2/unlinked.c
View File

@ -13,19 +13,23 @@
#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;
@ -312,7 +316,7 @@ int gfs2_unlinked_dealloc(struct gfs2_sbd *sdp)
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;
@ -327,7 +331,8 @@ int gfs2_unlinked_init(struct gfs2_sbd *sdp)
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;

4
fs/gfs2/util.c
View File

@ -13,12 +13,16 @@
#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;

11
include/linux/gfs2_ondisk.h
View File

@ -50,15 +50,18 @@
* 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.

1
include/linux/kernel.h
View File

@ -29,6 +29,7 @@ extern const char linux_banner[];
#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 */