2006-01-16 09:50:04 -07:00
|
|
|
/*
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2006-05-18 13:09:15 -06:00
|
|
|
* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
|
2006-01-16 09:50:04 -07:00
|
|
|
*
|
|
|
|
* This copyrighted material is made available to anyone wishing to use,
|
|
|
|
* modify, copy, or redistribute it subject to the terms and conditions
|
2006-09-01 09:05:15 -06:00
|
|
|
* of the GNU General Public License version 2.
|
2006-01-16 09:50:04 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __INODE_DOT_H__
|
|
|
|
#define __INODE_DOT_H__
|
|
|
|
|
2008-10-14 09:05:55 -06:00
|
|
|
#include <linux/fs.h>
|
2009-05-22 03:01:55 -06:00
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/mm.h>
|
2008-02-12 07:17:27 -07:00
|
|
|
#include "util.h"
|
|
|
|
|
2009-05-22 03:01:55 -06:00
|
|
|
extern int gfs2_releasepage(struct page *page, gfp_t gfp_mask);
|
|
|
|
extern int gfs2_internal_read(struct gfs2_inode *ip,
|
|
|
|
char *buf, loff_t *pos, unsigned size);
|
|
|
|
extern void gfs2_set_aops(struct inode *inode);
|
|
|
|
|
2007-05-15 08:37:50 -06:00
|
|
|
static inline int gfs2_is_stuffed(const struct gfs2_inode *ip)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2008-01-28 03:37:35 -07:00
|
|
|
return !ip->i_height;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
2007-05-15 08:37:50 -06:00
|
|
|
static inline int gfs2_is_jdata(const struct gfs2_inode *ip)
|
2006-01-16 09:50:04 -07:00
|
|
|
{
|
2008-11-04 03:05:22 -07:00
|
|
|
return ip->i_diskflags & GFS2_DIF_JDATA;
|
2006-01-16 09:50:04 -07:00
|
|
|
}
|
|
|
|
|
2007-10-17 01:35:19 -06:00
|
|
|
static inline int gfs2_is_writeback(const struct gfs2_inode *ip)
|
|
|
|
{
|
|
|
|
const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
|
|
|
return (sdp->sd_args.ar_data == GFS2_DATA_WRITEBACK) && !gfs2_is_jdata(ip);
|
|
|
|
}
|
|
|
|
|
2007-10-17 01:47:38 -06:00
|
|
|
static inline int gfs2_is_ordered(const struct gfs2_inode *ip)
|
|
|
|
{
|
|
|
|
const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
|
|
|
return (sdp->sd_args.ar_data == GFS2_DATA_ORDERED) && !gfs2_is_jdata(ip);
|
|
|
|
}
|
|
|
|
|
2007-05-15 08:37:50 -06:00
|
|
|
static inline int gfs2_is_dir(const struct gfs2_inode *ip)
|
2006-02-08 04:50:51 -07:00
|
|
|
{
|
2006-11-01 10:22:46 -07:00
|
|
|
return S_ISDIR(ip->i_inode.i_mode);
|
2006-02-08 04:50:51 -07:00
|
|
|
}
|
|
|
|
|
2008-02-12 07:17:27 -07:00
|
|
|
static inline void gfs2_set_inode_blocks(struct inode *inode, u64 blocks)
|
|
|
|
{
|
|
|
|
inode->i_blocks = blocks <<
|
|
|
|
(GFS2_SB(inode)->sd_sb.sb_bsize_shift - GFS2_BASIC_BLOCK_SHIFT);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u64 gfs2_get_inode_blocks(const struct inode *inode)
|
2006-11-08 13:45:46 -07:00
|
|
|
{
|
2008-02-12 07:17:27 -07:00
|
|
|
return inode->i_blocks >>
|
2006-11-08 13:45:46 -07:00
|
|
|
(GFS2_SB(inode)->sd_sb.sb_bsize_shift - GFS2_BASIC_BLOCK_SHIFT);
|
|
|
|
}
|
|
|
|
|
2008-02-12 07:17:27 -07:00
|
|
|
static inline void gfs2_add_inode_blocks(struct inode *inode, s64 change)
|
|
|
|
{
|
|
|
|
gfs2_assert(GFS2_SB(inode), (change >= 0 || inode->i_blocks > -change));
|
|
|
|
change *= (GFS2_SB(inode)->sd_sb.sb_bsize/GFS2_BASIC_BLOCK);
|
|
|
|
inode->i_blocks += change;
|
|
|
|
}
|
|
|
|
|
2007-05-15 08:37:50 -06:00
|
|
|
static inline int gfs2_check_inum(const struct gfs2_inode *ip, u64 no_addr,
|
|
|
|
u64 no_formal_ino)
|
|
|
|
{
|
|
|
|
return ip->i_no_addr == no_addr && ip->i_no_formal_ino == no_formal_ino;
|
|
|
|
}
|
|
|
|
|
2007-06-01 07:11:58 -06:00
|
|
|
static inline void gfs2_inum_out(const struct gfs2_inode *ip,
|
|
|
|
struct gfs2_dirent *dent)
|
|
|
|
{
|
|
|
|
dent->de_inum.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
|
|
|
|
dent->de_inum.no_addr = cpu_to_be64(ip->i_no_addr);
|
|
|
|
}
|
|
|
|
|
2010-08-11 02:53:11 -06:00
|
|
|
static inline int gfs2_check_internal_file_size(struct inode *inode,
|
|
|
|
u64 minsize, u64 maxsize)
|
|
|
|
{
|
|
|
|
u64 size = i_size_read(inode);
|
|
|
|
if (size < minsize || size > maxsize)
|
|
|
|
goto err;
|
2016-08-02 11:05:27 -06:00
|
|
|
if (size & (BIT(inode->i_blkbits) - 1))
|
2010-08-11 02:53:11 -06:00
|
|
|
goto err;
|
|
|
|
return 0;
|
|
|
|
err:
|
|
|
|
gfs2_consist_inode(GFS2_I(inode));
|
|
|
|
return -EIO;
|
|
|
|
}
|
2007-06-01 07:11:58 -06:00
|
|
|
|
2009-05-22 03:01:55 -06:00
|
|
|
extern struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned type,
|
gfs2: Fix gfs2_lookup_by_inum lock inversion
The current gfs2_lookup_by_inum takes the glock of a presumed inode
identified by block number, verifies that the block is indeed an inode,
and then instantiates and reads the new inode via gfs2_inode_lookup.
However, instantiating a new inode may block on freeing a previous
instance of that inode (__wait_on_freeing_inode), and freeing an inode
requires to take the glock already held, leading to lock inversion and
deadlock.
Fix this by first instantiating the new inode, then verifying that the
block is an inode (if required), and then reading in the new inode, all
in gfs2_inode_lookup.
If the block we are looking for is not an inode, we discard the new
inode via iget_failed, which marks inodes as bad and unhashes them.
Other tasks waiting on that inode will get back a bad inode back from
ilookup or iget_locked; in that case, retry the lookup.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
2016-06-14 11:22:27 -06:00
|
|
|
u64 no_addr, u64 no_formal_ino,
|
|
|
|
unsigned int blktype);
|
2010-11-03 14:01:07 -06:00
|
|
|
extern struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr,
|
|
|
|
u64 *no_formal_ino,
|
|
|
|
unsigned int blktype);
|
2009-05-22 03:01:55 -06:00
|
|
|
|
|
|
|
extern int gfs2_inode_refresh(struct gfs2_inode *ip);
|
|
|
|
|
|
|
|
extern struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
|
|
|
|
int is_root);
|
2011-06-20 17:28:19 -06:00
|
|
|
extern int gfs2_permission(struct inode *inode, int mask);
|
2011-08-15 07:20:36 -06:00
|
|
|
extern int gfs2_setattr_simple(struct inode *inode, struct iattr *attr);
|
2009-05-22 03:01:55 -06:00
|
|
|
extern struct inode *gfs2_lookup_simple(struct inode *dip, const char *name);
|
|
|
|
extern void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf);
|
2013-06-14 04:17:15 -06:00
|
|
|
extern int gfs2_open_common(struct inode *inode, struct file *file);
|
2017-03-15 12:12:59 -06:00
|
|
|
extern loff_t gfs2_seek_data(struct file *file, loff_t offset);
|
|
|
|
extern loff_t gfs2_seek_hole(struct file *file, loff_t offset);
|
2006-01-16 09:50:04 -07:00
|
|
|
|
2008-10-14 09:05:55 -06:00
|
|
|
extern const struct inode_operations gfs2_file_iops;
|
|
|
|
extern const struct inode_operations gfs2_dir_iops;
|
|
|
|
extern const struct inode_operations gfs2_symlink_iops;
|
2009-04-07 11:42:17 -06:00
|
|
|
extern const struct file_operations gfs2_file_fops_nolock;
|
|
|
|
extern const struct file_operations gfs2_dir_fops_nolock;
|
2008-10-14 09:05:55 -06:00
|
|
|
|
|
|
|
extern void gfs2_set_inode_flags(struct inode *inode);
|
2009-01-12 03:43:39 -07:00
|
|
|
|
|
|
|
#ifdef CONFIG_GFS2_FS_LOCKING_DLM
|
2009-04-07 11:42:17 -06:00
|
|
|
extern const struct file_operations gfs2_file_fops;
|
|
|
|
extern const struct file_operations gfs2_dir_fops;
|
|
|
|
|
2009-01-12 03:43:39 -07:00
|
|
|
static inline int gfs2_localflocks(const struct gfs2_sbd *sdp)
|
|
|
|
{
|
|
|
|
return sdp->sd_args.ar_localflocks;
|
|
|
|
}
|
|
|
|
#else /* Single node only */
|
2009-04-07 11:42:17 -06:00
|
|
|
#define gfs2_file_fops gfs2_file_fops_nolock
|
|
|
|
#define gfs2_dir_fops gfs2_dir_fops_nolock
|
|
|
|
|
2009-01-12 03:43:39 -07:00
|
|
|
static inline int gfs2_localflocks(const struct gfs2_sbd *sdp)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_GFS2_FS_LOCKING_DLM */
|
2008-10-14 09:05:55 -06:00
|
|
|
|
2006-01-16 09:50:04 -07:00
|
|
|
#endif /* __INODE_DOT_H__ */
|
|
|
|
|