2006-01-16 17:50:04 +01:00
|
|
|
/*
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2008-01-28 18:15:57 +01:00
|
|
|
* Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
|
2006-01-16 17:50:04 +01: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 17:05:15 +02:00
|
|
|
* of the GNU General Public License version 2.
|
2006-01-16 17:50:04 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/posix_acl.h>
|
|
|
|
#include <linux/sort.h>
|
2006-02-27 23:23:27 +01:00
|
|
|
#include <linux/gfs2_ondisk.h>
|
2006-03-28 21:14:04 +02:00
|
|
|
#include <linux/crc32.h>
|
2006-10-03 17:57:35 +02:00
|
|
|
#include <linux/security.h>
|
2008-09-18 14:53:59 +02:00
|
|
|
#include <linux/time.h>
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
#include "gfs2.h"
|
2006-02-27 23:23:27 +01:00
|
|
|
#include "incore.h"
|
2006-01-16 17:50:04 +01:00
|
|
|
#include "acl.h"
|
|
|
|
#include "bmap.h"
|
|
|
|
#include "dir.h"
|
2009-08-26 19:51:04 +02:00
|
|
|
#include "xattr.h"
|
2006-01-16 17:50:04 +01:00
|
|
|
#include "glock.h"
|
|
|
|
#include "glops.h"
|
|
|
|
#include "inode.h"
|
|
|
|
#include "log.h"
|
|
|
|
#include "meta_io.h"
|
|
|
|
#include "quota.h"
|
|
|
|
#include "rgrp.h"
|
|
|
|
#include "trans.h"
|
2006-02-27 23:23:27 +01:00
|
|
|
#include "util.h"
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2007-06-01 15:11:58 +02:00
|
|
|
struct gfs2_inum_range_host {
|
|
|
|
u64 ir_start;
|
|
|
|
u64 ir_length;
|
|
|
|
};
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
static int iget_test(struct inode *inode, void *opaque)
|
|
|
|
{
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2007-05-15 16:37:50 +02:00
|
|
|
u64 *no_addr = opaque;
|
2006-06-14 21:32:57 +02:00
|
|
|
|
2009-12-08 13:12:13 +01:00
|
|
|
if (ip->i_no_addr == *no_addr)
|
2006-06-14 21:32:57 +02:00
|
|
|
return 1;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int iget_set(struct inode *inode, void *opaque)
|
2006-01-16 17:50:04 +01:00
|
|
|
{
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2007-05-15 16:37:50 +02:00
|
|
|
u64 *no_addr = opaque;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2007-05-15 16:37:50 +02:00
|
|
|
inode->i_ino = (unsigned long)*no_addr;
|
|
|
|
ip->i_no_addr = *no_addr;
|
2006-06-14 21:32:57 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2007-05-15 16:37:50 +02:00
|
|
|
struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr)
|
2006-06-14 21:32:57 +02:00
|
|
|
{
|
2007-05-15 16:37:50 +02:00
|
|
|
unsigned long hash = (unsigned long)no_addr;
|
|
|
|
return ilookup5(sb, hash, iget_test, &no_addr);
|
2006-06-14 21:32:57 +02:00
|
|
|
}
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2007-05-15 16:37:50 +02:00
|
|
|
static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr)
|
2006-06-14 21:32:57 +02:00
|
|
|
{
|
2007-05-15 16:37:50 +02:00
|
|
|
unsigned long hash = (unsigned long)no_addr;
|
|
|
|
return iget5_locked(sb, hash, iget_test, iget_set, &no_addr);
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
[GFS2] Alternate gfs2_iget to avoid looking up inodes being freed
There is a possible deadlock between two processes on the same node, where one
process is deleting an inode, and another process is looking for allocated but
unused inodes to delete in order to create more space.
process A does an iput() on inode X, and it's i_count drops to 0. This causes
iput_final() to be called, which puts an inode into state I_FREEING at
generic_delete_inode(). There no point between when iput_final() is called, and
when I_FREEING is set where GFS2 could acquire any glocks. Once I_FREEING is
set, no other process on that node can successfully look up that inode until
the delete finishes.
process B locks the the resource group for the same inode in get_local_rgrp(),
which is called by gfs2_inplace_reserve_i()
process A tries to lock the resource group for the inode in
gfs2_dinode_dealloc(), but it's already locked by process B
process B waits in find_inode for the inode to have the I_FREEING state cleared.
Deadlock.
This patch solves the problem by adding an alternative to gfs2_iget(),
gfs2_iget_skip(), that simply skips any inodes that are in the I_FREEING
state.o The alternate test function is just like the original one, except that
it fails if the inode is being freed, and sets a skipped flag. The alternate
set function is just like the original, except that it fails if the skipped
flag is set. Only try_rgrp_unlink() calls gfs2_iget_skip() instead of
gfs2_iget().
Signed-off-by: Benjamin E. Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-09-18 20:33:18 +02:00
|
|
|
struct gfs2_skip_data {
|
|
|
|
u64 no_addr;
|
|
|
|
int skipped;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int iget_skip_test(struct inode *inode, void *opaque)
|
|
|
|
{
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_skip_data *data = opaque;
|
|
|
|
|
2009-12-08 13:12:13 +01:00
|
|
|
if (ip->i_no_addr == data->no_addr) {
|
[GFS2] Alternate gfs2_iget to avoid looking up inodes being freed
There is a possible deadlock between two processes on the same node, where one
process is deleting an inode, and another process is looking for allocated but
unused inodes to delete in order to create more space.
process A does an iput() on inode X, and it's i_count drops to 0. This causes
iput_final() to be called, which puts an inode into state I_FREEING at
generic_delete_inode(). There no point between when iput_final() is called, and
when I_FREEING is set where GFS2 could acquire any glocks. Once I_FREEING is
set, no other process on that node can successfully look up that inode until
the delete finishes.
process B locks the the resource group for the same inode in get_local_rgrp(),
which is called by gfs2_inplace_reserve_i()
process A tries to lock the resource group for the inode in
gfs2_dinode_dealloc(), but it's already locked by process B
process B waits in find_inode for the inode to have the I_FREEING state cleared.
Deadlock.
This patch solves the problem by adding an alternative to gfs2_iget(),
gfs2_iget_skip(), that simply skips any inodes that are in the I_FREEING
state.o The alternate test function is just like the original one, except that
it fails if the inode is being freed, and sets a skipped flag. The alternate
set function is just like the original, except that it fails if the skipped
flag is set. Only try_rgrp_unlink() calls gfs2_iget_skip() instead of
gfs2_iget().
Signed-off-by: Benjamin E. Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-09-18 20:33:18 +02:00
|
|
|
if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)){
|
|
|
|
data->skipped = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int iget_skip_set(struct inode *inode, void *opaque)
|
|
|
|
{
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_skip_data *data = opaque;
|
|
|
|
|
|
|
|
if (data->skipped)
|
|
|
|
return 1;
|
|
|
|
inode->i_ino = (unsigned long)(data->no_addr);
|
|
|
|
ip->i_no_addr = data->no_addr;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct inode *gfs2_iget_skip(struct super_block *sb,
|
|
|
|
u64 no_addr)
|
|
|
|
{
|
|
|
|
struct gfs2_skip_data data;
|
|
|
|
unsigned long hash = (unsigned long)no_addr;
|
|
|
|
|
|
|
|
data.no_addr = no_addr;
|
|
|
|
data.skipped = 0;
|
|
|
|
return iget5_locked(sb, hash, iget_skip_test, iget_skip_set, &data);
|
|
|
|
}
|
|
|
|
|
2007-06-27 23:07:53 +02:00
|
|
|
/**
|
|
|
|
* GFS2 lookup code fills in vfs inode contents based on info obtained
|
|
|
|
* from directory entry inside gfs2_inode_lookup(). This has caused issues
|
|
|
|
* with NFS code path since its get_dentry routine doesn't have the relevant
|
|
|
|
* directory entry when gfs2_inode_lookup() is invoked. Part of the code
|
|
|
|
* segment inside gfs2_inode_lookup code needs to get moved around.
|
|
|
|
*
|
2009-12-17 14:25:01 +01:00
|
|
|
* Clears I_NEW as well.
|
2007-06-27 23:07:53 +02:00
|
|
|
**/
|
|
|
|
|
|
|
|
void gfs2_set_iop(struct inode *inode)
|
|
|
|
{
|
2007-11-29 23:56:51 +01:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2007-06-27 23:07:53 +02:00
|
|
|
umode_t mode = inode->i_mode;
|
|
|
|
|
|
|
|
if (S_ISREG(mode)) {
|
|
|
|
inode->i_op = &gfs2_file_iops;
|
2009-01-12 11:43:39 +01:00
|
|
|
if (gfs2_localflocks(sdp))
|
2009-04-07 19:42:17 +02:00
|
|
|
inode->i_fop = &gfs2_file_fops_nolock;
|
2007-11-29 23:56:51 +01:00
|
|
|
else
|
2009-04-07 19:42:17 +02:00
|
|
|
inode->i_fop = &gfs2_file_fops;
|
2007-06-27 23:07:53 +02:00
|
|
|
} else if (S_ISDIR(mode)) {
|
|
|
|
inode->i_op = &gfs2_dir_iops;
|
2009-01-12 11:43:39 +01:00
|
|
|
if (gfs2_localflocks(sdp))
|
2009-04-07 19:42:17 +02:00
|
|
|
inode->i_fop = &gfs2_dir_fops_nolock;
|
2007-11-29 23:56:51 +01:00
|
|
|
else
|
2009-04-07 19:42:17 +02:00
|
|
|
inode->i_fop = &gfs2_dir_fops;
|
2007-06-27 23:07:53 +02:00
|
|
|
} else if (S_ISLNK(mode)) {
|
|
|
|
inode->i_op = &gfs2_symlink_iops;
|
|
|
|
} else {
|
2008-02-26 08:25:03 +01:00
|
|
|
inode->i_op = &gfs2_file_iops;
|
2008-02-26 08:25:04 +01:00
|
|
|
init_special_inode(inode, inode->i_mode, inode->i_rdev);
|
2007-06-27 23:07:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
unlock_new_inode(inode);
|
|
|
|
}
|
|
|
|
|
2006-01-16 17:50:04 +01:00
|
|
|
/**
|
2006-06-14 21:32:57 +02:00
|
|
|
* gfs2_inode_lookup - Lookup an inode
|
|
|
|
* @sb: The super block
|
2007-05-15 16:37:50 +02:00
|
|
|
* @no_addr: The inode number
|
2006-06-14 21:32:57 +02:00
|
|
|
* @type: The type of the inode
|
2006-01-16 17:50:04 +01:00
|
|
|
*
|
2006-06-14 21:32:57 +02:00
|
|
|
* Returns: A VFS inode, or an error
|
2006-01-16 17:50:04 +01:00
|
|
|
*/
|
|
|
|
|
2008-04-29 19:35:48 +02:00
|
|
|
struct inode *gfs2_inode_lookup(struct super_block *sb,
|
2007-06-27 23:07:08 +02:00
|
|
|
unsigned int type,
|
|
|
|
u64 no_addr,
|
2010-04-14 17:58:16 +02:00
|
|
|
u64 no_formal_ino)
|
2006-01-16 17:50:04 +01:00
|
|
|
{
|
[GFS2] Alternate gfs2_iget to avoid looking up inodes being freed
There is a possible deadlock between two processes on the same node, where one
process is deleting an inode, and another process is looking for allocated but
unused inodes to delete in order to create more space.
process A does an iput() on inode X, and it's i_count drops to 0. This causes
iput_final() to be called, which puts an inode into state I_FREEING at
generic_delete_inode(). There no point between when iput_final() is called, and
when I_FREEING is set where GFS2 could acquire any glocks. Once I_FREEING is
set, no other process on that node can successfully look up that inode until
the delete finishes.
process B locks the the resource group for the same inode in get_local_rgrp(),
which is called by gfs2_inplace_reserve_i()
process A tries to lock the resource group for the inode in
gfs2_dinode_dealloc(), but it's already locked by process B
process B waits in find_inode for the inode to have the I_FREEING state cleared.
Deadlock.
This patch solves the problem by adding an alternative to gfs2_iget(),
gfs2_iget_skip(), that simply skips any inodes that are in the I_FREEING
state.o The alternate test function is just like the original one, except that
it fails if the inode is being freed, and sets a skipped flag. The alternate
set function is just like the original, except that it fails if the skipped
flag is set. Only try_rgrp_unlink() calls gfs2_iget_skip() instead of
gfs2_iget().
Signed-off-by: Benjamin E. Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-09-18 20:33:18 +02:00
|
|
|
struct inode *inode;
|
|
|
|
struct gfs2_inode *ip;
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_glock *io_gl;
|
|
|
|
int error;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2010-04-14 17:58:16 +02:00
|
|
|
inode = gfs2_iget(sb, no_addr);
|
[GFS2] Alternate gfs2_iget to avoid looking up inodes being freed
There is a possible deadlock between two processes on the same node, where one
process is deleting an inode, and another process is looking for allocated but
unused inodes to delete in order to create more space.
process A does an iput() on inode X, and it's i_count drops to 0. This causes
iput_final() to be called, which puts an inode into state I_FREEING at
generic_delete_inode(). There no point between when iput_final() is called, and
when I_FREEING is set where GFS2 could acquire any glocks. Once I_FREEING is
set, no other process on that node can successfully look up that inode until
the delete finishes.
process B locks the the resource group for the same inode in get_local_rgrp(),
which is called by gfs2_inplace_reserve_i()
process A tries to lock the resource group for the inode in
gfs2_dinode_dealloc(), but it's already locked by process B
process B waits in find_inode for the inode to have the I_FREEING state cleared.
Deadlock.
This patch solves the problem by adding an alternative to gfs2_iget(),
gfs2_iget_skip(), that simply skips any inodes that are in the I_FREEING
state.o The alternate test function is just like the original one, except that
it fails if the inode is being freed, and sets a skipped flag. The alternate
set function is just like the original, except that it fails if the skipped
flag is set. Only try_rgrp_unlink() calls gfs2_iget_skip() instead of
gfs2_iget().
Signed-off-by: Benjamin E. Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-09-18 20:33:18 +02:00
|
|
|
ip = GFS2_I(inode);
|
|
|
|
|
2006-10-30 22:59:08 +01:00
|
|
|
if (!inode)
|
|
|
|
return ERR_PTR(-ENOBUFS);
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
if (inode->i_state & I_NEW) {
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2007-06-27 23:07:08 +02:00
|
|
|
ip->i_no_formal_ino = no_formal_ino;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2007-05-15 16:37:50 +02:00
|
|
|
error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
|
2006-06-14 21:32:57 +02:00
|
|
|
if (unlikely(error))
|
|
|
|
goto fail;
|
|
|
|
ip->i_gl->gl_object = ip;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2007-05-15 16:37:50 +02:00
|
|
|
error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
|
2006-06-14 21:32:57 +02:00
|
|
|
if (unlikely(error))
|
|
|
|
goto fail_put;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-11-01 22:05:38 +01:00
|
|
|
set_bit(GIF_INVALID, &ip->i_flags);
|
2006-06-14 21:32:57 +02:00
|
|
|
error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
|
|
|
|
if (unlikely(error))
|
|
|
|
goto fail_iopen;
|
2007-06-11 09:22:32 +02:00
|
|
|
ip->i_iopen_gh.gh_gl->gl_object = ip;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
gfs2_glock_put(io_gl);
|
2007-06-08 11:05:33 +02:00
|
|
|
|
2007-06-27 23:07:53 +02:00
|
|
|
if ((type == DT_UNKNOWN) && (no_formal_ino == 0))
|
|
|
|
goto gfs2_nfsbypass;
|
|
|
|
|
|
|
|
inode->i_mode = DT2IF(type);
|
|
|
|
|
2007-06-08 11:05:33 +02:00
|
|
|
/*
|
|
|
|
* We must read the inode in order to work out its type in
|
|
|
|
* this case. Note that this doesn't happen often as we normally
|
|
|
|
* know the type beforehand. This code path only occurs during
|
|
|
|
* unlinked inode recovery (where it is safe to do this glock,
|
|
|
|
* which is not true in the general case).
|
|
|
|
*/
|
|
|
|
if (type == DT_UNKNOWN) {
|
|
|
|
struct gfs2_holder gh;
|
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
|
|
|
|
if (unlikely(error))
|
|
|
|
goto fail_glock;
|
|
|
|
/* Inode is now uptodate */
|
|
|
|
gfs2_glock_dq_uninit(&gh);
|
|
|
|
}
|
|
|
|
|
2007-06-27 23:07:53 +02:00
|
|
|
gfs2_set_iop(inode);
|
2006-06-14 21:32:57 +02:00
|
|
|
}
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2007-06-27 23:07:53 +02:00
|
|
|
gfs2_nfsbypass:
|
2006-01-16 17:50:04 +01:00
|
|
|
return inode;
|
2007-06-08 11:05:33 +02:00
|
|
|
fail_glock:
|
|
|
|
gfs2_glock_dq(&ip->i_iopen_gh);
|
2006-06-14 21:32:57 +02:00
|
|
|
fail_iopen:
|
|
|
|
gfs2_glock_put(io_gl);
|
|
|
|
fail_put:
|
2010-04-14 17:58:16 +02:00
|
|
|
if (inode->i_state & I_NEW)
|
|
|
|
ip->i_gl->gl_object = NULL;
|
2006-06-14 21:32:57 +02:00
|
|
|
gfs2_glock_put(ip->i_gl);
|
|
|
|
fail:
|
2010-04-14 17:58:16 +02:00
|
|
|
if (inode->i_state & I_NEW)
|
|
|
|
iget_failed(inode);
|
|
|
|
else
|
|
|
|
iput(inode);
|
2006-06-14 21:32:57 +02:00
|
|
|
return ERR_PTR(error);
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
2010-04-14 17:58:16 +02:00
|
|
|
/**
|
|
|
|
* gfs2_unlinked_inode_lookup - Lookup an unlinked inode for reclamation
|
|
|
|
* @sb: The super block
|
|
|
|
* no_addr: The inode number
|
|
|
|
* @@inode: A pointer to the inode found, if any
|
|
|
|
*
|
|
|
|
* Returns: 0 and *inode if no errors occurred. If an error occurs,
|
|
|
|
* the resulting *inode may or may not be NULL.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int gfs2_unlinked_inode_lookup(struct super_block *sb, u64 no_addr,
|
|
|
|
struct inode **inode)
|
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp;
|
|
|
|
struct gfs2_inode *ip;
|
|
|
|
struct gfs2_glock *io_gl;
|
|
|
|
int error;
|
|
|
|
struct gfs2_holder gh;
|
|
|
|
|
|
|
|
*inode = gfs2_iget_skip(sb, no_addr);
|
|
|
|
|
|
|
|
if (!(*inode))
|
|
|
|
return -ENOBUFS;
|
|
|
|
|
|
|
|
if (!((*inode)->i_state & I_NEW))
|
|
|
|
return -ENOBUFS;
|
|
|
|
|
|
|
|
ip = GFS2_I(*inode);
|
|
|
|
sdp = GFS2_SB(*inode);
|
|
|
|
ip->i_no_formal_ino = -1;
|
|
|
|
|
|
|
|
error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
|
|
|
|
if (unlikely(error))
|
|
|
|
goto fail;
|
|
|
|
ip->i_gl->gl_object = ip;
|
|
|
|
|
|
|
|
error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
|
|
|
|
if (unlikely(error))
|
|
|
|
goto fail_put;
|
|
|
|
|
|
|
|
set_bit(GIF_INVALID, &ip->i_flags);
|
|
|
|
error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, LM_FLAG_TRY | GL_EXACT,
|
|
|
|
&ip->i_iopen_gh);
|
|
|
|
if (unlikely(error)) {
|
|
|
|
if (error == GLR_TRYFAILED)
|
|
|
|
error = 0;
|
|
|
|
goto fail_iopen;
|
|
|
|
}
|
|
|
|
ip->i_iopen_gh.gh_gl->gl_object = ip;
|
|
|
|
gfs2_glock_put(io_gl);
|
|
|
|
|
|
|
|
(*inode)->i_mode = DT2IF(DT_UNKNOWN);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We must read the inode in order to work out its type in
|
|
|
|
* this case. Note that this doesn't happen often as we normally
|
|
|
|
* know the type beforehand. This code path only occurs during
|
|
|
|
* unlinked inode recovery (where it is safe to do this glock,
|
|
|
|
* which is not true in the general case).
|
|
|
|
*/
|
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, LM_FLAG_TRY,
|
|
|
|
&gh);
|
|
|
|
if (unlikely(error)) {
|
|
|
|
if (error == GLR_TRYFAILED)
|
|
|
|
error = 0;
|
|
|
|
goto fail_glock;
|
|
|
|
}
|
|
|
|
/* Inode is now uptodate */
|
|
|
|
gfs2_glock_dq_uninit(&gh);
|
|
|
|
gfs2_set_iop(*inode);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
fail_glock:
|
|
|
|
gfs2_glock_dq(&ip->i_iopen_gh);
|
|
|
|
fail_iopen:
|
|
|
|
gfs2_glock_put(io_gl);
|
|
|
|
fail_put:
|
|
|
|
ip->i_gl->gl_object = NULL;
|
|
|
|
gfs2_glock_put(ip->i_gl);
|
|
|
|
fail:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-11-01 16:34:15 +01:00
|
|
|
static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
|
2006-10-31 21:28:00 +01:00
|
|
|
{
|
|
|
|
const struct gfs2_dinode *str = buf;
|
2008-09-18 14:53:59 +02:00
|
|
|
struct timespec atime;
|
2008-02-01 10:23:44 +01:00
|
|
|
u16 height, depth;
|
2006-10-31 21:28:00 +01:00
|
|
|
|
2008-01-28 11:37:35 +01:00
|
|
|
if (unlikely(ip->i_no_addr != be64_to_cpu(str->di_num.no_addr)))
|
|
|
|
goto corrupt;
|
2007-05-15 16:37:50 +02:00
|
|
|
ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino);
|
2006-11-01 18:22:46 +01:00
|
|
|
ip->i_inode.i_mode = be32_to_cpu(str->di_mode);
|
2006-11-01 03:45:08 +01:00
|
|
|
ip->i_inode.i_rdev = 0;
|
2006-11-01 18:22:46 +01:00
|
|
|
switch (ip->i_inode.i_mode & S_IFMT) {
|
2006-11-01 03:45:08 +01:00
|
|
|
case S_IFBLK:
|
|
|
|
case S_IFCHR:
|
|
|
|
ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major),
|
|
|
|
be32_to_cpu(str->di_minor));
|
|
|
|
break;
|
|
|
|
};
|
|
|
|
|
2006-11-01 19:23:29 +01:00
|
|
|
ip->i_inode.i_uid = be32_to_cpu(str->di_uid);
|
|
|
|
ip->i_inode.i_gid = be32_to_cpu(str->di_gid);
|
2006-11-01 20:04:17 +01:00
|
|
|
/*
|
|
|
|
* We will need to review setting the nlink count here in the
|
|
|
|
* light of the forthcoming ro bind mount work. This is a reminder
|
|
|
|
* to do that.
|
|
|
|
*/
|
|
|
|
ip->i_inode.i_nlink = be32_to_cpu(str->di_nlink);
|
2008-11-04 10:47:33 +01:00
|
|
|
ip->i_disksize = be64_to_cpu(str->di_size);
|
|
|
|
i_size_write(&ip->i_inode, ip->i_disksize);
|
2008-02-12 15:17:27 +01:00
|
|
|
gfs2_set_inode_blocks(&ip->i_inode, be64_to_cpu(str->di_blocks));
|
2008-09-18 14:53:59 +02:00
|
|
|
atime.tv_sec = be64_to_cpu(str->di_atime);
|
|
|
|
atime.tv_nsec = be32_to_cpu(str->di_atime_nsec);
|
|
|
|
if (timespec_compare(&ip->i_inode.i_atime, &atime) < 0)
|
|
|
|
ip->i_inode.i_atime = atime;
|
2006-11-01 20:35:17 +01:00
|
|
|
ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime);
|
2007-06-05 10:39:18 +02:00
|
|
|
ip->i_inode.i_mtime.tv_nsec = be32_to_cpu(str->di_mtime_nsec);
|
2006-11-01 20:35:17 +01:00
|
|
|
ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime);
|
2007-06-05 10:39:18 +02:00
|
|
|
ip->i_inode.i_ctime.tv_nsec = be32_to_cpu(str->di_ctime_nsec);
|
2006-10-31 21:28:00 +01:00
|
|
|
|
2008-02-06 10:25:45 +01:00
|
|
|
ip->i_goal = be64_to_cpu(str->di_goal_meta);
|
2008-11-03 14:39:46 +01:00
|
|
|
ip->i_generation = be64_to_cpu(str->di_generation);
|
2006-10-31 21:28:00 +01:00
|
|
|
|
2008-11-04 11:05:22 +01:00
|
|
|
ip->i_diskflags = be32_to_cpu(str->di_flags);
|
2006-11-08 18:51:06 +01:00
|
|
|
gfs2_set_inode_flags(&ip->i_inode);
|
2008-01-28 11:37:35 +01:00
|
|
|
height = be16_to_cpu(str->di_height);
|
|
|
|
if (unlikely(height > GFS2_MAX_META_HEIGHT))
|
|
|
|
goto corrupt;
|
|
|
|
ip->i_height = (u8)height;
|
2006-10-31 21:28:00 +01:00
|
|
|
|
2008-02-01 10:23:44 +01:00
|
|
|
depth = be16_to_cpu(str->di_depth);
|
|
|
|
if (unlikely(depth > GFS2_DIR_MAX_DEPTH))
|
|
|
|
goto corrupt;
|
|
|
|
ip->i_depth = (u8)depth;
|
2008-11-03 14:59:19 +01:00
|
|
|
ip->i_entries = be32_to_cpu(str->di_entries);
|
2006-10-31 21:28:00 +01:00
|
|
|
|
2008-11-03 15:28:42 +01:00
|
|
|
ip->i_eattr = be64_to_cpu(str->di_eattr);
|
2007-10-17 09:47:38 +02:00
|
|
|
if (S_ISREG(ip->i_inode.i_mode))
|
|
|
|
gfs2_set_aops(&ip->i_inode);
|
|
|
|
|
2006-11-01 16:34:15 +01:00
|
|
|
return 0;
|
2008-01-28 11:37:35 +01:00
|
|
|
corrupt:
|
|
|
|
if (gfs2_consist_inode(ip))
|
|
|
|
gfs2_dinode_print(ip);
|
|
|
|
return -EIO;
|
2006-10-31 21:28:00 +01:00
|
|
|
}
|
|
|
|
|
2006-01-16 17:50:04 +01:00
|
|
|
/**
|
|
|
|
* gfs2_inode_refresh - Refresh the incore copy of the dinode
|
|
|
|
* @ip: The GFS2 inode
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
int gfs2_inode_refresh(struct gfs2_inode *ip)
|
|
|
|
{
|
|
|
|
struct buffer_head *dibh;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(ip, &dibh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) {
|
2006-01-16 17:50:04 +01:00
|
|
|
brelse(dibh);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2006-11-01 16:34:15 +01:00
|
|
|
error = gfs2_dinode_in(ip, dibh->b_data);
|
2006-01-16 17:50:04 +01:00
|
|
|
brelse(dibh);
|
2006-11-01 22:05:38 +01:00
|
|
|
clear_bit(GIF_INVALID, &ip->i_flags);
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-11-01 16:34:15 +01:00
|
|
|
return error;
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
int gfs2_dinode_dealloc(struct gfs2_inode *ip)
|
2006-01-16 17:50:04 +01:00
|
|
|
{
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2006-01-16 17:50:04 +01:00
|
|
|
struct gfs2_alloc *al;
|
|
|
|
struct gfs2_rgrpd *rgd;
|
|
|
|
int error;
|
|
|
|
|
2008-02-12 15:17:27 +01:00
|
|
|
if (gfs2_get_inode_blocks(&ip->i_inode) != 1) {
|
2006-01-16 17:50:04 +01:00
|
|
|
if (gfs2_consist_inode(ip))
|
2006-11-01 01:00:24 +01:00
|
|
|
gfs2_dinode_print(ip);
|
2006-01-16 17:50:04 +01:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
al = gfs2_alloc_get(ip);
|
2008-03-03 19:54:21 +01:00
|
|
|
if (!al)
|
|
|
|
return -ENOMEM;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
|
|
|
|
if (error)
|
|
|
|
goto out_qs;
|
|
|
|
|
2007-05-15 16:37:50 +02:00
|
|
|
rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (!rgd) {
|
|
|
|
gfs2_consist_inode(ip);
|
|
|
|
error = -EIO;
|
|
|
|
goto out_rindex_relse;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
|
|
|
|
&al->al_rgd_gh);
|
|
|
|
if (error)
|
|
|
|
goto out_rindex_relse;
|
|
|
|
|
2006-07-31 21:42:17 +02:00
|
|
|
error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
|
|
|
goto out_rg_gunlock;
|
|
|
|
|
2007-11-08 15:25:12 +01:00
|
|
|
set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
|
|
|
|
set_bit(GLF_LFLUSH, &ip->i_gl->gl_flags);
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
gfs2_free_di(rgd, ip);
|
|
|
|
|
|
|
|
gfs2_trans_end(sdp);
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
out_rg_gunlock:
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_glock_dq_uninit(&al->al_rgd_gh);
|
2006-06-14 21:32:57 +02:00
|
|
|
out_rindex_relse:
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_glock_dq_uninit(&al->al_ri_gh);
|
2006-06-14 21:32:57 +02:00
|
|
|
out_qs:
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_quota_unhold(ip);
|
2006-04-28 16:46:21 +02:00
|
|
|
out:
|
2006-06-14 21:32:57 +02:00
|
|
|
gfs2_alloc_put(ip);
|
2006-01-16 17:50:04 +01:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-01-18 22:07:03 +01:00
|
|
|
* gfs2_change_nlink - Change nlink count on inode
|
2006-01-16 17:50:04 +01:00
|
|
|
* @ip: The GFS2 inode
|
|
|
|
* @diff: The change in the nlink count required
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
2007-01-18 22:07:03 +01:00
|
|
|
int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
|
2006-01-16 17:50:04 +01:00
|
|
|
{
|
|
|
|
struct buffer_head *dibh;
|
2006-09-04 18:49:07 +02:00
|
|
|
u32 nlink;
|
2006-01-16 17:50:04 +01:00
|
|
|
int error;
|
|
|
|
|
2006-11-01 20:04:17 +01:00
|
|
|
BUG_ON(diff != 1 && diff != -1);
|
|
|
|
nlink = ip->i_inode.i_nlink + diff;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
/* If we are reducing the nlink count, but the new value ends up being
|
|
|
|
bigger than the old one, we must have underflowed. */
|
2006-11-01 20:04:17 +01:00
|
|
|
if (diff < 0 && nlink > ip->i_inode.i_nlink) {
|
2006-01-16 17:50:04 +01:00
|
|
|
if (gfs2_consist_inode(ip))
|
2006-11-01 01:00:24 +01:00
|
|
|
gfs2_dinode_print(ip);
|
2006-01-16 17:50:04 +01:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(ip, &dibh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2006-11-01 20:04:17 +01:00
|
|
|
if (diff > 0)
|
|
|
|
inc_nlink(&ip->i_inode);
|
|
|
|
else
|
|
|
|
drop_nlink(&ip->i_inode);
|
|
|
|
|
2007-06-05 10:39:18 +02:00
|
|
|
ip->i_inode.i_ctime = CURRENT_TIME;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-01-18 12:19:28 +01:00
|
|
|
gfs2_trans_add_bh(ip->i_gl, dibh, 1);
|
2006-10-31 21:07:05 +01:00
|
|
|
gfs2_dinode_out(ip, dibh->b_data);
|
2006-01-16 17:50:04 +01:00
|
|
|
brelse(dibh);
|
2006-06-14 21:32:57 +02:00
|
|
|
mark_inode_dirty(&ip->i_inode);
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2007-01-18 22:07:03 +01:00
|
|
|
if (ip->i_inode.i_nlink == 0)
|
2007-01-30 00:13:44 +01:00
|
|
|
gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */
|
2007-01-18 22:07:03 +01:00
|
|
|
|
2007-01-18 21:56:34 +01:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-03-20 18:30:04 +01:00
|
|
|
struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
|
|
|
|
{
|
|
|
|
struct qstr qstr;
|
2007-01-09 00:47:51 +01:00
|
|
|
struct inode *inode;
|
2006-03-28 21:14:04 +02:00
|
|
|
gfs2_str2qstr(&qstr, name);
|
2008-07-23 20:42:05 +02:00
|
|
|
inode = gfs2_lookupi(dip, &qstr, 1);
|
2007-01-09 00:47:51 +01:00
|
|
|
/* gfs2_lookupi has inconsistent callers: vfs
|
|
|
|
* related routines expect NULL for no entry found,
|
|
|
|
* gfs2_lookup_simple callers expect ENOENT
|
|
|
|
* and do not check for NULL.
|
|
|
|
*/
|
|
|
|
if (inode == NULL)
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
else
|
|
|
|
return inode;
|
2006-03-20 18:30:04 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-01-16 17:50:04 +01:00
|
|
|
/**
|
|
|
|
* gfs2_lookupi - Look up a filename in a directory and return its inode
|
|
|
|
* @d_gh: An initialized holder for the directory glock
|
|
|
|
* @name: The name of the inode to look for
|
|
|
|
* @is_root: If 1, ignore the caller's permissions
|
|
|
|
* @i_gh: An uninitialized holder for the new inode glock
|
|
|
|
*
|
2007-01-25 18:14:59 +01:00
|
|
|
* This can be called via the VFS filldir function when NFS is doing
|
|
|
|
* a readdirplus and the inode which its intending to stat isn't
|
|
|
|
* already in cache. In this case we must not take the directory glock
|
|
|
|
* again, since the readdir call will have already taken that lock.
|
2006-01-16 17:50:04 +01:00
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
|
2008-07-23 20:42:05 +02:00
|
|
|
int is_root)
|
2006-01-16 17:50:04 +01:00
|
|
|
{
|
2006-03-01 21:31:02 +01:00
|
|
|
struct super_block *sb = dir->i_sb;
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_inode *dip = GFS2_I(dir);
|
2006-01-16 17:50:04 +01:00
|
|
|
struct gfs2_holder d_gh;
|
2007-06-09 01:42:14 +02:00
|
|
|
int error = 0;
|
2006-03-20 18:30:04 +01:00
|
|
|
struct inode *inode = NULL;
|
2007-01-25 18:14:59 +01:00
|
|
|
int unlock = 0;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
if (!name->len || name->len > GFS2_FNAMESIZE)
|
2006-03-20 18:30:04 +01:00
|
|
|
return ERR_PTR(-ENAMETOOLONG);
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-03-20 18:30:04 +01:00
|
|
|
if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
|
|
|
|
(name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
|
|
|
|
dir == sb->s_root->d_inode)) {
|
2006-05-18 22:25:27 +02:00
|
|
|
igrab(dir);
|
|
|
|
return dir;
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
2008-02-22 17:07:18 +01:00
|
|
|
if (gfs2_glock_is_locked_by_me(dip->i_gl) == NULL) {
|
2007-01-25 18:14:59 +01:00
|
|
|
error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
|
|
|
|
if (error)
|
|
|
|
return ERR_PTR(error);
|
|
|
|
unlock = 1;
|
|
|
|
}
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
if (!is_root) {
|
2008-07-02 21:12:01 +02:00
|
|
|
error = gfs2_permission(dir, MAY_EXEC);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2007-05-15 16:37:50 +02:00
|
|
|
inode = gfs2_dir_search(dir, name);
|
|
|
|
if (IS_ERR(inode))
|
|
|
|
error = PTR_ERR(inode);
|
2006-02-13 13:27:43 +01:00
|
|
|
out:
|
2007-01-25 18:14:59 +01:00
|
|
|
if (unlock)
|
|
|
|
gfs2_glock_dq_uninit(&d_gh);
|
2006-03-20 18:30:04 +01:00
|
|
|
if (error == -ENOENT)
|
|
|
|
return NULL;
|
2007-01-25 18:14:59 +01:00
|
|
|
return inode ? inode : ERR_PTR(error);
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* create_ok - OK to create a new on-disk inode here?
|
|
|
|
* @dip: Directory in which dinode is to be created
|
|
|
|
* @name: Name of new dinode
|
|
|
|
* @mode:
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
|
2006-01-16 17:50:04 +01:00
|
|
|
unsigned int mode)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2008-07-02 21:12:01 +02:00
|
|
|
error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/* Don't create entries in an unlinked directory */
|
2006-11-01 20:04:17 +01:00
|
|
|
if (!dip->i_inode.i_nlink)
|
2006-01-16 17:50:04 +01:00
|
|
|
return -EPERM;
|
|
|
|
|
2007-05-15 16:37:50 +02:00
|
|
|
error = gfs2_dir_check(&dip->i_inode, name, NULL);
|
2006-01-16 17:50:04 +01:00
|
|
|
switch (error) {
|
|
|
|
case -ENOENT:
|
|
|
|
error = 0;
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
return -EEXIST;
|
|
|
|
default:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2008-11-03 14:59:19 +01:00
|
|
|
if (dip->i_entries == (u32)-1)
|
2006-01-16 17:50:04 +01:00
|
|
|
return -EFBIG;
|
2006-11-01 20:04:17 +01:00
|
|
|
if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
|
2006-01-16 17:50:04 +01:00
|
|
|
return -EMLINK;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode,
|
|
|
|
unsigned int *uid, unsigned int *gid)
|
|
|
|
{
|
2006-06-14 21:32:57 +02:00
|
|
|
if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
|
2006-11-01 19:23:29 +01:00
|
|
|
(dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) {
|
2006-01-16 17:50:04 +01:00
|
|
|
if (S_ISDIR(*mode))
|
|
|
|
*mode |= S_ISUID;
|
2008-11-14 00:38:53 +01:00
|
|
|
else if (dip->i_inode.i_uid != current_fsuid())
|
2006-01-16 17:50:04 +01:00
|
|
|
*mode &= ~07111;
|
2006-11-01 19:23:29 +01:00
|
|
|
*uid = dip->i_inode.i_uid;
|
2006-01-16 17:50:04 +01:00
|
|
|
} else
|
2008-11-14 00:38:53 +01:00
|
|
|
*uid = current_fsuid();
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-11-01 18:22:46 +01:00
|
|
|
if (dip->i_inode.i_mode & S_ISGID) {
|
2006-01-16 17:50:04 +01:00
|
|
|
if (S_ISDIR(*mode))
|
|
|
|
*mode |= S_ISGID;
|
2006-11-01 19:23:29 +01:00
|
|
|
*gid = dip->i_inode.i_gid;
|
2006-01-16 17:50:04 +01:00
|
|
|
} else
|
2008-11-14 00:38:53 +01:00
|
|
|
*gid = current_fsgid();
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
2007-05-15 16:37:50 +02:00
|
|
|
static int alloc_dinode(struct gfs2_inode *dip, u64 *no_addr, u64 *generation)
|
2006-01-16 17:50:04 +01:00
|
|
|
{
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
|
2006-01-16 17:50:04 +01:00
|
|
|
int error;
|
|
|
|
|
2008-01-10 16:18:55 +01:00
|
|
|
if (gfs2_alloc_get(dip) == NULL)
|
|
|
|
return -ENOMEM;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2008-01-10 16:18:55 +01:00
|
|
|
dip->i_alloc->al_requested = RES_DINODE;
|
2006-01-16 17:50:04 +01:00
|
|
|
error = gfs2_inplace_reserve(dip);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
|
|
|
goto out_ipreserv;
|
|
|
|
|
2009-07-31 17:19:40 +02:00
|
|
|
error = gfs2_alloc_di(dip, no_addr, generation);
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
gfs2_trans_end(sdp);
|
|
|
|
|
2006-07-11 15:46:33 +02:00
|
|
|
out_ipreserv:
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_inplace_release(dip);
|
2006-07-11 15:46:33 +02:00
|
|
|
out:
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_alloc_put(dip);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* init_dinode - Fill in a new dinode structure
|
|
|
|
* @dip: the directory this inode is being created in
|
|
|
|
* @gl: The glock covering the new inode
|
|
|
|
* @inum: the inode number
|
|
|
|
* @mode: the file permissions
|
|
|
|
* @uid:
|
|
|
|
* @gid:
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
|
2006-10-14 04:51:24 +02:00
|
|
|
const struct gfs2_inum_host *inum, unsigned int mode,
|
2006-07-11 15:46:33 +02:00
|
|
|
unsigned int uid, unsigned int gid,
|
2007-08-24 15:15:01 +02:00
|
|
|
const u64 *generation, dev_t dev, struct buffer_head **bhp)
|
2006-01-16 17:50:04 +01:00
|
|
|
{
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
|
2006-01-18 11:57:10 +01:00
|
|
|
struct gfs2_dinode *di;
|
2006-01-16 17:50:04 +01:00
|
|
|
struct buffer_head *dibh;
|
2007-06-05 10:39:18 +02:00
|
|
|
struct timespec tv = CURRENT_TIME;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
dibh = gfs2_meta_new(gl, inum->no_addr);
|
2006-01-18 12:19:28 +01:00
|
|
|
gfs2_trans_add_bh(gl, dibh, 1);
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
|
|
|
|
gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
|
2006-01-18 11:57:10 +01:00
|
|
|
di = (struct gfs2_dinode *)dibh->b_data;
|
|
|
|
|
2006-01-30 12:49:32 +01:00
|
|
|
di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino);
|
|
|
|
di->di_num.no_addr = cpu_to_be64(inum->no_addr);
|
2006-01-18 11:57:10 +01:00
|
|
|
di->di_mode = cpu_to_be32(mode);
|
|
|
|
di->di_uid = cpu_to_be32(uid);
|
|
|
|
di->di_gid = cpu_to_be32(gid);
|
2006-11-02 17:59:28 +01:00
|
|
|
di->di_nlink = 0;
|
|
|
|
di->di_size = 0;
|
2006-01-18 11:57:10 +01:00
|
|
|
di->di_blocks = cpu_to_be64(1);
|
2007-06-05 10:39:18 +02:00
|
|
|
di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec);
|
2006-11-01 03:45:08 +01:00
|
|
|
di->di_major = cpu_to_be32(MAJOR(dev));
|
|
|
|
di->di_minor = cpu_to_be32(MINOR(dev));
|
2006-01-18 11:57:10 +01:00
|
|
|
di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
|
2006-07-11 15:46:33 +02:00
|
|
|
di->di_generation = cpu_to_be64(*generation);
|
2006-11-02 17:59:28 +01:00
|
|
|
di->di_flags = 0;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
if (S_ISREG(mode)) {
|
2008-11-04 11:05:22 +01:00
|
|
|
if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_tune_get(sdp, gt_new_files_jdata))
|
2006-01-18 11:57:10 +01:00
|
|
|
di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
|
2006-01-16 17:50:04 +01:00
|
|
|
} else if (S_ISDIR(mode)) {
|
2008-11-04 11:05:22 +01:00
|
|
|
di->di_flags |= cpu_to_be32(dip->i_diskflags &
|
2006-02-27 18:00:42 +01:00
|
|
|
GFS2_DIF_INHERIT_JDATA);
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
2006-01-18 11:57:10 +01:00
|
|
|
di->__pad1 = 0;
|
2006-11-02 02:09:14 +01:00
|
|
|
di->di_payload_format = cpu_to_be32(S_ISDIR(mode) ? GFS2_FORMAT_DE : 0);
|
2006-11-02 17:59:28 +01:00
|
|
|
di->di_height = 0;
|
2006-01-18 11:57:10 +01:00
|
|
|
di->__pad2 = 0;
|
|
|
|
di->__pad3 = 0;
|
2006-11-02 17:59:28 +01:00
|
|
|
di->di_depth = 0;
|
|
|
|
di->di_entries = 0;
|
2006-01-18 11:57:10 +01:00
|
|
|
memset(&di->__pad4, 0, sizeof(di->__pad4));
|
2006-11-02 17:59:28 +01:00
|
|
|
di->di_eattr = 0;
|
2007-06-05 10:39:18 +02:00
|
|
|
di->di_atime_nsec = cpu_to_be32(tv.tv_nsec);
|
|
|
|
di->di_mtime_nsec = cpu_to_be32(tv.tv_nsec);
|
|
|
|
di->di_ctime_nsec = cpu_to_be32(tv.tv_nsec);
|
2006-01-18 11:57:10 +01:00
|
|
|
memset(&di->di_reserved, 0, sizeof(di->di_reserved));
|
2007-08-24 15:15:01 +02:00
|
|
|
|
|
|
|
set_buffer_uptodate(dibh);
|
2006-01-18 11:57:10 +01:00
|
|
|
|
2007-08-24 15:15:01 +02:00
|
|
|
*bhp = dibh;
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
|
2006-10-14 04:51:24 +02:00
|
|
|
unsigned int mode, const struct gfs2_inum_host *inum,
|
2007-08-24 15:15:01 +02:00
|
|
|
const u64 *generation, dev_t dev, struct buffer_head **bhp)
|
2006-01-16 17:50:04 +01:00
|
|
|
{
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
|
2006-01-16 17:50:04 +01:00
|
|
|
unsigned int uid, gid;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
munge_mode_uid_gid(dip, &mode, &uid, &gid);
|
2008-03-03 19:54:21 +01:00
|
|
|
if (!gfs2_alloc_get(dip))
|
|
|
|
return -ENOMEM;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
error = gfs2_quota_lock(dip, uid, gid);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
error = gfs2_quota_check(dip, uid, gid);
|
|
|
|
if (error)
|
|
|
|
goto out_quota;
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
|
|
|
goto out_quota;
|
|
|
|
|
2007-08-24 15:15:01 +02:00
|
|
|
init_dinode(dip, gl, inum, mode, uid, gid, generation, dev, bhp);
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_quota_change(dip, +1, uid, gid);
|
|
|
|
gfs2_trans_end(sdp);
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
out_quota:
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_quota_unlock(dip);
|
2006-06-14 21:32:57 +02:00
|
|
|
out:
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_alloc_put(dip);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
|
|
|
|
struct gfs2_inode *ip)
|
2006-01-16 17:50:04 +01:00
|
|
|
{
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
|
2006-01-16 17:50:04 +01:00
|
|
|
struct gfs2_alloc *al;
|
|
|
|
int alloc_required;
|
|
|
|
struct buffer_head *dibh;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
al = gfs2_alloc_get(dip);
|
2008-03-03 19:54:21 +01:00
|
|
|
if (!al)
|
|
|
|
return -ENOMEM;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
|
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name);
|
2006-03-20 18:30:04 +01:00
|
|
|
if (alloc_required < 0)
|
2008-01-20 04:50:24 +01:00
|
|
|
goto fail_quota_locks;
|
2006-01-16 17:50:04 +01:00
|
|
|
if (alloc_required) {
|
2006-11-01 19:23:29 +01:00
|
|
|
error = gfs2_quota_check(dip, dip->i_inode.i_uid, dip->i_inode.i_gid);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
|
|
|
goto fail_quota_locks;
|
|
|
|
|
|
|
|
al->al_requested = sdp->sd_max_dirres;
|
|
|
|
|
|
|
|
error = gfs2_inplace_reserve(dip);
|
|
|
|
if (error)
|
|
|
|
goto fail_quota_locks;
|
|
|
|
|
2006-05-18 22:25:27 +02:00
|
|
|
error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
|
2007-06-01 15:11:58 +02:00
|
|
|
al->al_rgd->rd_length +
|
2006-09-25 15:26:04 +02:00
|
|
|
2 * RES_DINODE +
|
2006-01-16 17:50:04 +01:00
|
|
|
RES_STATFS + RES_QUOTA, 0);
|
|
|
|
if (error)
|
|
|
|
goto fail_ipreserv;
|
|
|
|
} else {
|
2006-06-14 21:32:57 +02:00
|
|
|
error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
|
|
|
goto fail_quota_locks;
|
|
|
|
}
|
|
|
|
|
2007-05-15 16:37:50 +02:00
|
|
|
error = gfs2_dir_add(&dip->i_inode, name, ip, IF2DT(ip->i_inode.i_mode));
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
|
|
|
goto fail_end_trans;
|
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(ip, &dibh);
|
|
|
|
if (error)
|
|
|
|
goto fail_end_trans;
|
2006-11-01 20:04:17 +01:00
|
|
|
ip->i_inode.i_nlink = 1;
|
2006-01-18 12:19:28 +01:00
|
|
|
gfs2_trans_add_bh(ip->i_gl, dibh, 1);
|
2006-10-31 21:07:05 +01:00
|
|
|
gfs2_dinode_out(ip, dibh->b_data);
|
2006-01-16 17:50:04 +01:00
|
|
|
brelse(dibh);
|
|
|
|
return 0;
|
|
|
|
|
2006-05-18 22:25:27 +02:00
|
|
|
fail_end_trans:
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_trans_end(sdp);
|
|
|
|
|
2006-05-18 22:25:27 +02:00
|
|
|
fail_ipreserv:
|
2008-01-10 16:18:55 +01:00
|
|
|
if (dip->i_alloc->al_rgd)
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_inplace_release(dip);
|
|
|
|
|
2006-05-18 22:25:27 +02:00
|
|
|
fail_quota_locks:
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_quota_unlock(dip);
|
|
|
|
|
2006-05-18 22:25:27 +02:00
|
|
|
fail:
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_alloc_put(dip);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-10-03 17:57:35 +02:00
|
|
|
static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
size_t len;
|
|
|
|
void *value;
|
|
|
|
char *name;
|
|
|
|
|
|
|
|
err = security_inode_init_security(&ip->i_inode, &dip->i_inode,
|
|
|
|
&name, &value, &len);
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
if (err == -EOPNOTSUPP)
|
|
|
|
return 0;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-11-13 10:52:56 +01:00
|
|
|
err = __gfs2_xattr_set(&ip->i_inode, name, value, len, 0,
|
|
|
|
GFS2_EATYPE_SECURITY);
|
2006-10-03 17:57:35 +02:00
|
|
|
kfree(value);
|
|
|
|
kfree(name);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2006-01-16 17:50:04 +01:00
|
|
|
/**
|
|
|
|
* gfs2_createi - Create a new inode
|
|
|
|
* @ghs: An array of two holders
|
|
|
|
* @name: The name of the new file
|
|
|
|
* @mode: the permissions on the new inode
|
|
|
|
*
|
|
|
|
* @ghs[0] is an initialized holder for the directory
|
|
|
|
* @ghs[1] is the holder for the inode lock
|
|
|
|
*
|
2006-02-13 13:27:43 +01:00
|
|
|
* If the return value is not NULL, the glocks on both the directory and the new
|
2006-01-16 17:50:04 +01:00
|
|
|
* file are held. A transaction has been started and an inplace reservation
|
|
|
|
* is held, as well.
|
|
|
|
*
|
2006-02-13 13:27:43 +01:00
|
|
|
* Returns: An inode
|
2006-01-16 17:50:04 +01:00
|
|
|
*/
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
|
2006-11-01 03:45:08 +01:00
|
|
|
unsigned int mode, dev_t dev)
|
2006-01-16 17:50:04 +01:00
|
|
|
{
|
2007-06-07 12:47:52 +02:00
|
|
|
struct inode *inode = NULL;
|
2006-02-27 23:23:27 +01:00
|
|
|
struct gfs2_inode *dip = ghs->gh_gl->gl_object;
|
2006-06-14 21:32:57 +02:00
|
|
|
struct inode *dir = &dip->i_inode;
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
|
2007-05-15 16:37:50 +02:00
|
|
|
struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 };
|
2006-01-16 17:50:04 +01:00
|
|
|
int error;
|
2006-07-11 15:46:33 +02:00
|
|
|
u64 generation;
|
2007-10-15 17:29:05 +02:00
|
|
|
struct buffer_head *bh = NULL;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
if (!name->len || name->len > GFS2_FNAMESIZE)
|
2006-02-13 13:27:43 +01:00
|
|
|
return ERR_PTR(-ENAMETOOLONG);
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
|
|
|
|
error = gfs2_glock_nq(ghs);
|
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
error = create_ok(dip, name, mode);
|
|
|
|
if (error)
|
|
|
|
goto fail_gunlock;
|
|
|
|
|
2007-05-15 16:37:50 +02:00
|
|
|
error = alloc_dinode(dip, &inum.no_addr, &generation);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
|
|
|
goto fail_gunlock;
|
2009-08-27 16:51:07 +02:00
|
|
|
inum.no_formal_ino = generation;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-11-22 17:13:21 +01:00
|
|
|
error = gfs2_glock_nq_num(sdp, inum.no_addr, &gfs2_inode_glops,
|
|
|
|
LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
|
|
|
|
if (error)
|
|
|
|
goto fail_gunlock;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2007-08-24 15:15:01 +02:00
|
|
|
error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev, &bh);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
|
|
|
goto fail_gunlock2;
|
|
|
|
|
2009-08-27 16:51:07 +02:00
|
|
|
inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode), inum.no_addr,
|
2010-04-14 17:58:16 +02:00
|
|
|
inum.no_formal_ino);
|
2006-06-14 21:32:57 +02:00
|
|
|
if (IS_ERR(inode))
|
2006-01-16 17:50:04 +01:00
|
|
|
goto fail_gunlock2;
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
error = gfs2_inode_refresh(GFS2_I(inode));
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
2007-06-07 12:47:52 +02:00
|
|
|
goto fail_gunlock2;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2009-10-02 13:00:00 +02:00
|
|
|
error = gfs2_acl_create(dip, inode);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
2007-06-07 12:47:52 +02:00
|
|
|
goto fail_gunlock2;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-10-03 17:57:35 +02:00
|
|
|
error = gfs2_security_init(dip, GFS2_I(inode));
|
|
|
|
if (error)
|
2007-06-07 12:47:52 +02:00
|
|
|
goto fail_gunlock2;
|
2006-10-03 17:57:35 +02:00
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
error = link_dinode(dip, name, GFS2_I(inode));
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
2007-06-07 12:47:52 +02:00
|
|
|
goto fail_gunlock2;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2007-10-15 17:29:05 +02:00
|
|
|
if (bh)
|
|
|
|
brelse(bh);
|
2006-02-13 13:27:43 +01:00
|
|
|
return inode;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-05-18 22:25:27 +02:00
|
|
|
fail_gunlock2:
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_glock_dq_uninit(ghs + 1);
|
2008-09-01 10:51:22 +02:00
|
|
|
if (inode && !IS_ERR(inode))
|
2007-06-07 12:47:52 +02:00
|
|
|
iput(inode);
|
2006-05-18 22:25:27 +02:00
|
|
|
fail_gunlock:
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_glock_dq(ghs);
|
2006-05-18 22:25:27 +02:00
|
|
|
fail:
|
2007-10-15 17:29:05 +02:00
|
|
|
if (bh)
|
|
|
|
brelse(bh);
|
2006-02-13 13:27:43 +01:00
|
|
|
return ERR_PTR(error);
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
2009-05-22 11:48:59 +02:00
|
|
|
static int __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
|
2006-01-16 17:50:04 +01:00
|
|
|
{
|
|
|
|
struct buffer_head *dibh;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(ip, &dibh);
|
|
|
|
if (!error) {
|
2006-06-14 21:32:57 +02:00
|
|
|
error = inode_setattr(&ip->i_inode, attr);
|
|
|
|
gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
|
2006-01-18 12:19:28 +01:00
|
|
|
gfs2_trans_add_bh(ip->i_gl, dibh, 1);
|
2006-10-31 21:07:05 +01:00
|
|
|
gfs2_dinode_out(ip, dibh->b_data);
|
2006-01-16 17:50:04 +01:00
|
|
|
brelse(dibh);
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_setattr_simple -
|
|
|
|
* @ip:
|
|
|
|
* @attr:
|
|
|
|
*
|
|
|
|
* Called with a reference on the vnode.
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2006-02-27 23:23:27 +01:00
|
|
|
if (current->journal_info)
|
2006-01-16 17:50:04 +01:00
|
|
|
return __gfs2_setattr_simple(ip, attr);
|
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE, 0);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
error = __gfs2_setattr_simple(ip, attr);
|
2006-06-14 21:32:57 +02:00
|
|
|
gfs2_trans_end(GFS2_SB(&ip->i_inode));
|
2006-01-16 17:50:04 +01:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-06-01 15:11:58 +02:00
|
|
|
void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
|
|
|
|
{
|
|
|
|
struct gfs2_dinode *str = buf;
|
|
|
|
|
|
|
|
str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
|
|
|
|
str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI);
|
|
|
|
str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI);
|
|
|
|
str->di_num.no_addr = cpu_to_be64(ip->i_no_addr);
|
|
|
|
str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
|
|
|
|
str->di_mode = cpu_to_be32(ip->i_inode.i_mode);
|
|
|
|
str->di_uid = cpu_to_be32(ip->i_inode.i_uid);
|
|
|
|
str->di_gid = cpu_to_be32(ip->i_inode.i_gid);
|
|
|
|
str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink);
|
2008-11-04 10:47:33 +01:00
|
|
|
str->di_size = cpu_to_be64(ip->i_disksize);
|
2008-02-12 15:17:27 +01:00
|
|
|
str->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
|
2007-06-01 15:11:58 +02:00
|
|
|
str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
|
|
|
|
str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec);
|
|
|
|
str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec);
|
|
|
|
|
2008-02-06 10:25:45 +01:00
|
|
|
str->di_goal_meta = cpu_to_be64(ip->i_goal);
|
|
|
|
str->di_goal_data = cpu_to_be64(ip->i_goal);
|
2008-11-03 14:39:46 +01:00
|
|
|
str->di_generation = cpu_to_be64(ip->i_generation);
|
2007-06-01 15:11:58 +02:00
|
|
|
|
2008-11-04 11:05:22 +01:00
|
|
|
str->di_flags = cpu_to_be32(ip->i_diskflags);
|
2008-01-28 11:37:35 +01:00
|
|
|
str->di_height = cpu_to_be16(ip->i_height);
|
2007-06-01 15:11:58 +02:00
|
|
|
str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) &&
|
2008-11-04 11:05:22 +01:00
|
|
|
!(ip->i_diskflags & GFS2_DIF_EXHASH) ?
|
2007-06-01 15:11:58 +02:00
|
|
|
GFS2_FORMAT_DE : 0);
|
2008-02-01 10:23:44 +01:00
|
|
|
str->di_depth = cpu_to_be16(ip->i_depth);
|
2008-11-03 14:59:19 +01:00
|
|
|
str->di_entries = cpu_to_be32(ip->i_entries);
|
2007-06-01 15:11:58 +02:00
|
|
|
|
2008-11-03 15:28:42 +01:00
|
|
|
str->di_eattr = cpu_to_be64(ip->i_eattr);
|
2007-06-05 10:39:18 +02:00
|
|
|
str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec);
|
|
|
|
str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec);
|
|
|
|
str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec);
|
2007-06-01 15:11:58 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void gfs2_dinode_print(const struct gfs2_inode *ip)
|
|
|
|
{
|
|
|
|
printk(KERN_INFO " no_formal_ino = %llu\n",
|
|
|
|
(unsigned long long)ip->i_no_formal_ino);
|
|
|
|
printk(KERN_INFO " no_addr = %llu\n",
|
|
|
|
(unsigned long long)ip->i_no_addr);
|
2008-11-04 10:47:33 +01:00
|
|
|
printk(KERN_INFO " i_disksize = %llu\n",
|
|
|
|
(unsigned long long)ip->i_disksize);
|
2008-02-12 15:17:27 +01:00
|
|
|
printk(KERN_INFO " blocks = %llu\n",
|
|
|
|
(unsigned long long)gfs2_get_inode_blocks(&ip->i_inode));
|
2008-02-06 10:25:45 +01:00
|
|
|
printk(KERN_INFO " i_goal = %llu\n",
|
|
|
|
(unsigned long long)ip->i_goal);
|
2008-11-04 11:05:22 +01:00
|
|
|
printk(KERN_INFO " i_diskflags = 0x%.8X\n", ip->i_diskflags);
|
2008-01-28 18:15:57 +01:00
|
|
|
printk(KERN_INFO " i_height = %u\n", ip->i_height);
|
2008-02-01 10:23:44 +01:00
|
|
|
printk(KERN_INFO " i_depth = %u\n", ip->i_depth);
|
2008-11-03 14:59:19 +01:00
|
|
|
printk(KERN_INFO " i_entries = %u\n", ip->i_entries);
|
2008-11-03 15:28:42 +01:00
|
|
|
printk(KERN_INFO " i_eattr = %llu\n",
|
|
|
|
(unsigned long long)ip->i_eattr);
|
2007-06-01 15:11:58 +02:00
|
|
|
}
|
|
|
|
|