#include <linux/reiserfs_xattr.h>
#include <linux/smp_lock.h>
#include <linux/quotaops.h>
+#include <linux/vserver/xid.h>
#define INC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) { i->i_nlink++; if (i->i_nlink >= REISERFS_LINK_MAX) i->i_nlink=1; }
#define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) i->i_nlink--;
REISERFS_SB(dir->i_sb)->priv_root &&
REISERFS_SB(dir->i_sb)->priv_root->d_inode &&
de.de_objectid == le32_to_cpu (INODE_PKEY(REISERFS_SB(dir->i_sb)->priv_root->d_inode)->k_objectid)) {
+ reiserfs_write_unlock (dir->i_sb);
return ERR_PTR (-EACCES);
}
reiserfs_write_unlock(dir->i_sb);
return ERR_PTR(-EACCES);
}
+ vx_propagate_xid(nd, inode);
/* Propogate the priv_object flag so we know we're in the priv tree */
if (is_reiserfs_priv_object (dir))
int buflen, paste_size;
int retval;
+ BUG_ON (!th->t_trans_id);
/* cannot allow items to be added into a busy deleted directory */
if (!namelen)
}
dir->i_size += paste_size;
- dir->i_mtime = dir->i_ctime = CURRENT_TIME;
+ dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
if (!S_ISDIR (inode->i_mode) && visible)
// reiserfs_mkdir or reiserfs_rename will do that by itself
reiserfs_update_sd (th, dir);
/* quota utility function, call if you've had to abort after calling
** new_inode_init, and have not called reiserfs_new_inode yet.
-** This should only be called on inodes that do not hav stat data
+** This should only be called on inodes that do not have stat data
** inserted into the tree yet.
*/
static int drop_new_inode(struct inode *inode) {
}
/* utility function that does setup for reiserfs_new_inode.
-** DQUOT_ALLOC_INODE cannot be called inside a transaction, so we had
-** to pull some bits of reiserfs_new_inode out into this func.
-** Yes, the actual quota calls are missing, they are part of the quota
-** patch.
+** DQUOT_INIT needs lots of credits so it's better to have it
+** outside of a transaction, so we had to pull some bits of
+** reiserfs_new_inode out into this func.
*/
static int new_inode_init(struct inode *inode, struct inode *dir, int mode) {
inode->i_gid = current->fsgid;
}
DQUOT_INIT(inode);
- if (DQUOT_ALLOC_INODE(inode)) {
- drop_new_inode(inode);
- return -EDQUOT;
- }
return 0 ;
}
{
int retval;
struct inode * inode;
- int jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 ;
+ /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
+ int jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
struct reiserfs_transaction_handle th ;
int locked;
if (!(inode = new_inode(dir->i_sb))) {
return -ENOMEM ;
}
- retval = new_inode_init(inode, dir, mode);
- if (retval)
- return retval;
+ new_inode_init(inode, dir, mode);
locked = reiserfs_cache_default_acl (dir);
if (locked)
reiserfs_write_lock_xattrs (dir->i_sb);
- journal_begin(&th, dir->i_sb, jbegin_count) ;
- retval = reiserfs_new_inode (&th, dir, mode, NULL, 0/*i_size*/, dentry, inode);
-
- if (locked)
- reiserfs_write_unlock_xattrs (dir->i_sb);
-
+ retval = journal_begin(&th, dir->i_sb, jbegin_count);
if (retval) {
+ drop_new_inode (inode);
goto out_failed;
}
+
+ retval = reiserfs_new_inode (&th, dir, mode, 0, 0/*i_size*/, dentry, inode);
+ if (retval)
+ goto out_failed;
+ if (locked) {
+ reiserfs_write_unlock_xattrs (dir->i_sb);
+ locked = 0;
+ }
+
inode->i_op = &reiserfs_file_inode_operations;
inode->i_fop = &reiserfs_file_operations;
inode->i_mapping->a_ops = &reiserfs_address_space_operations ;
retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
inode, 1/*visible*/);
if (retval) {
+ int err;
inode->i_nlink--;
reiserfs_update_sd (&th, inode);
- journal_end(&th, dir->i_sb, jbegin_count) ;
+ err = journal_end(&th, dir->i_sb, jbegin_count) ;
+ if (err)
+ retval = err;
iput (inode);
goto out_failed;
}
reiserfs_update_inode_transaction(dir) ;
d_instantiate(dentry, inode);
- journal_end(&th, dir->i_sb, jbegin_count) ;
+ retval = journal_end(&th, dir->i_sb, jbegin_count) ;
out_failed:
+ if (locked)
+ reiserfs_write_unlock_xattrs (dir->i_sb);
reiserfs_write_unlock(dir->i_sb);
return retval;
}
int retval;
struct inode * inode;
struct reiserfs_transaction_handle th ;
- int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
+ /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
+ int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
int locked;
if (!new_valid_dev(rdev))
if (!(inode = new_inode(dir->i_sb))) {
return -ENOMEM ;
}
- retval = new_inode_init(inode, dir, mode);
- if (retval)
- return retval;
+ new_inode_init(inode, dir, mode);
locked = reiserfs_cache_default_acl (dir);
if (locked)
reiserfs_write_lock_xattrs (dir->i_sb);
- journal_begin(&th, dir->i_sb, jbegin_count) ;
+ retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
+ if (retval) {
+ drop_new_inode (inode);
+ goto out_failed;
+ }
retval = reiserfs_new_inode (&th, dir, mode, NULL, 0/*i_size*/, dentry, inode);
-
- if (locked)
- reiserfs_write_unlock_xattrs (dir->i_sb);
-
if (retval) {
goto out_failed;
}
+ if (locked) {
+ reiserfs_write_unlock_xattrs (dir->i_sb);
+ locked = 0;
+ }
+
+
inode->i_op = &reiserfs_special_inode_operations;
init_special_inode(inode, inode->i_mode, rdev) ;
retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
inode, 1/*visible*/);
if (retval) {
+ int err;
inode->i_nlink--;
reiserfs_update_sd (&th, inode);
- journal_end(&th, dir->i_sb, jbegin_count) ;
+ err = journal_end(&th, dir->i_sb, jbegin_count) ;
+ if (err)
+ retval = err;
iput (inode);
goto out_failed;
}
d_instantiate(dentry, inode);
- journal_end(&th, dir->i_sb, jbegin_count) ;
+ retval = journal_end(&th, dir->i_sb, jbegin_count) ;
out_failed:
+ if (locked)
+ reiserfs_write_unlock_xattrs (dir->i_sb);
reiserfs_write_unlock(dir->i_sb);
return retval;
}
int retval;
struct inode * inode;
struct reiserfs_transaction_handle th ;
- int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
+ /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
+ int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
int locked;
#ifdef DISPLACE_NEW_PACKING_LOCALITIES
if (!(inode = new_inode(dir->i_sb))) {
return -ENOMEM ;
}
- retval = new_inode_init(inode, dir, mode);
- if (retval)
- return retval;
+ new_inode_init(inode, dir, mode);
locked = reiserfs_cache_default_acl (dir);
reiserfs_write_lock(dir->i_sb);
if (locked)
reiserfs_write_lock_xattrs (dir->i_sb);
- journal_begin(&th, dir->i_sb, jbegin_count) ;
+
+ retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
+ if (retval) {
+ drop_new_inode (inode);
+ goto out_failed;
+ }
+
/* inc the link count now, so another writer doesn't overflow it while
** we sleep later on.
old_format_only (dir->i_sb) ?
EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
dentry, inode);
- if (locked)
- reiserfs_write_unlock_xattrs (dir->i_sb);
-
if (retval) {
dir->i_nlink-- ;
goto out_failed;
}
+
+ if (locked) {
+ reiserfs_write_unlock_xattrs (dir->i_sb);
+ locked = 0;
+ }
+
reiserfs_update_inode_transaction(inode) ;
reiserfs_update_inode_transaction(dir) ;
retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
inode, 1/*visible*/);
if (retval) {
+ int err;
inode->i_nlink = 0;
DEC_DIR_INODE_NLINK(dir);
reiserfs_update_sd (&th, inode);
- journal_end(&th, dir->i_sb, jbegin_count) ;
+ err = journal_end(&th, dir->i_sb, jbegin_count) ;
+ if (err)
+ retval = err;
iput (inode);
goto out_failed;
}
reiserfs_update_sd (&th, dir);
d_instantiate(dentry, inode);
- journal_end(&th, dir->i_sb, jbegin_count) ;
+ retval = journal_end(&th, dir->i_sb, jbegin_count) ;
out_failed:
+ if (locked)
+ reiserfs_write_unlock_xattrs (dir->i_sb);
reiserfs_write_unlock(dir->i_sb);
return retval;
}
static int reiserfs_rmdir (struct inode * dir, struct dentry *dentry)
{
- int retval;
+ int retval, err;
struct inode * inode;
struct reiserfs_transaction_handle th ;
int jbegin_count;
struct reiserfs_dir_entry de;
- /* we will be doing 2 balancings and update 2 stat data */
- jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2;
+ /* we will be doing 2 balancings and update 2 stat data, we change quotas
+ * of the owner of the directory and of the owner of the parent directory */
+ jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
reiserfs_write_lock(dir->i_sb);
- journal_begin(&th, dir->i_sb, jbegin_count) ;
+ retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
+ if (retval)
+ goto out_rmdir;
de.de_gen_number_bit_string = NULL;
if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) {
"!= 2 (%d)", __FUNCTION__, inode->i_nlink);
inode->i_nlink = 0;
- inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+ inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
reiserfs_update_sd (&th, inode);
DEC_DIR_INODE_NLINK(dir)
/* prevent empty directory from getting lost */
add_save_link (&th, inode, 0/* not truncate */);
- journal_end(&th, dir->i_sb, jbegin_count) ;
+ retval = journal_end(&th, dir->i_sb, jbegin_count) ;
reiserfs_check_path(&path) ;
+out_rmdir:
reiserfs_write_unlock(dir->i_sb);
- return 0;
+ return retval;
end_rmdir:
/* we must release path, because we did not call
reiserfs_cut_from_item, or reiserfs_cut_from_item does not
release path if operation was not complete */
pathrelse (&path);
- journal_end(&th, dir->i_sb, jbegin_count) ;
+ err = journal_end(&th, dir->i_sb, jbegin_count) ;
reiserfs_write_unlock(dir->i_sb);
- return retval;
+ return err ? err : retval;
}
static int reiserfs_unlink (struct inode * dir, struct dentry *dentry)
{
- int retval;
+ int retval, err;
struct inode * inode;
struct reiserfs_dir_entry de;
INITIALIZE_PATH (path);
inode = dentry->d_inode;
/* in this transaction we can be doing at max two balancings and update
- two stat datas */
- jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2;
+ two stat datas, we change quotas of the owner of the directory and of
+ the owner of the parent directory */
+ jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
reiserfs_write_lock(dir->i_sb);
- journal_begin(&th, dir->i_sb, jbegin_count) ;
+ retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
+ if (retval)
+ goto out_unlink;
de.de_gen_number_bit_string = NULL;
if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) {
inode->i_nlink++;
goto end_unlink;
}
- inode->i_ctime = CURRENT_TIME;
+ inode->i_ctime = CURRENT_TIME_SEC;
reiserfs_update_sd (&th, inode);
dir->i_size -= (de.de_entrylen + DEH_SIZE);
- dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+ dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
reiserfs_update_sd (&th, dir);
if (!savelink)
/* prevent file from getting lost */
add_save_link (&th, inode, 0/* not truncate */);
- journal_end(&th, dir->i_sb, jbegin_count) ;
+ retval = journal_end(&th, dir->i_sb, jbegin_count) ;
reiserfs_check_path(&path) ;
reiserfs_write_unlock(dir->i_sb);
- return 0;
+ return retval;
end_unlink:
pathrelse (&path);
- journal_end(&th, dir->i_sb, jbegin_count) ;
+ err = journal_end(&th, dir->i_sb, jbegin_count) ;
reiserfs_check_path(&path) ;
+ if (err)
+ retval = err;
+out_unlink:
reiserfs_write_unlock(dir->i_sb);
return retval;
}
int item_len;
struct reiserfs_transaction_handle th ;
int mode = S_IFLNK | S_IRWXUGO;
- int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
+ /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
+ int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
if (!(inode = new_inode(parent_dir->i_sb))) {
return -ENOMEM ;
}
- retval = new_inode_init(inode, parent_dir, mode);
- if (retval) {
- return retval;
- }
+ new_inode_init(inode, parent_dir, mode);
reiserfs_write_lock(parent_dir->i_sb);
item_len = ROUND_UP (strlen (symname));
/* We would inherit the default ACL here, but symlinks don't get ACLs */
- journal_begin(&th, parent_dir->i_sb, jbegin_count) ;
+ retval = journal_begin(&th, parent_dir->i_sb, jbegin_count) ;
+ if (retval) {
+ drop_new_inode (inode);
+ reiserfs_kfree (name, item_len, parent_dir->i_sb);
+ goto out_failed;
+ }
retval = reiserfs_new_inode (&th, parent_dir, mode, name, strlen (symname),
dentry, inode);
retval = reiserfs_add_entry (&th, parent_dir, dentry->d_name.name,
dentry->d_name.len, inode, 1/*visible*/);
if (retval) {
+ int err;
inode->i_nlink--;
reiserfs_update_sd (&th, inode);
- journal_end(&th, parent_dir->i_sb, jbegin_count) ;
+ err = journal_end(&th, parent_dir->i_sb, jbegin_count) ;
+ if (err)
+ retval = err;
iput (inode);
goto out_failed;
}
d_instantiate(dentry, inode);
- journal_end(&th, parent_dir->i_sb, jbegin_count) ;
+ retval = journal_end(&th, parent_dir->i_sb, jbegin_count) ;
out_failed:
reiserfs_write_unlock(parent_dir->i_sb);
return retval;
int retval;
struct inode *inode = old_dentry->d_inode;
struct reiserfs_transaction_handle th ;
- int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
+ /* We need blocks for transaction + update of quotas for the owners of the directory */
+ int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 2 * REISERFS_QUOTA_TRANS_BLOCKS;
reiserfs_write_lock(dir->i_sb);
if (inode->i_nlink >= REISERFS_LINK_MAX) {
return -EMLINK;
}
if (inode->i_nlink == 0) {
+ reiserfs_write_unlock(dir->i_sb);
return -ENOENT;
}
/* inc before scheduling so reiserfs_unlink knows we are here */
inode->i_nlink++;
- journal_begin(&th, dir->i_sb, jbegin_count) ;
+ retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
+ if (retval) {
+ inode->i_nlink--;
+ reiserfs_write_unlock (dir->i_sb);
+ return retval;
+ }
/* create new entry */
retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
reiserfs_update_inode_transaction(dir) ;
if (retval) {
+ int err;
inode->i_nlink--;
- journal_end(&th, dir->i_sb, jbegin_count) ;
+ err = journal_end(&th, dir->i_sb, jbegin_count) ;
reiserfs_write_unlock(dir->i_sb);
- return retval;
+ return err ? err : retval;
}
- inode->i_ctime = CURRENT_TIME;
+ inode->i_ctime = CURRENT_TIME_SEC;
reiserfs_update_sd (&th, inode);
atomic_inc(&inode->i_count) ;
d_instantiate(dentry, inode);
- journal_end(&th, dir->i_sb, jbegin_count) ;
+ retval = journal_end(&th, dir->i_sb, jbegin_count) ;
reiserfs_write_unlock(dir->i_sb);
- return 0;
+ return retval;
}
/* sets key of objectid the entry has to point to */
-static void set_ino_in_dir_entry (struct reiserfs_dir_entry * de, struct key * key)
+static void set_ino_in_dir_entry (struct reiserfs_dir_entry * de, struct reiserfs_key * key)
{
/* JDM These operations are endian safe - both are le */
de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
(2) new directory and (3) maybe old object stat data (when it is
directory) and (4) maybe stat data of object to which new entry
pointed initially and (5) maybe block containing ".." of
- renamed directory */
- jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 5;
+ renamed directory
+ quota updates: two parent directories */
+ jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 5 + 4 * REISERFS_QUOTA_TRANS_BLOCKS;
old_inode = old_dentry->d_inode;
new_dentry_inode = new_dentry->d_inode;
}
}
- journal_begin(&th, old_dir->i_sb, jbegin_count) ;
+ retval = journal_begin(&th, old_dir->i_sb, jbegin_count) ;
+ if (retval) {
+ reiserfs_write_unlock (old_dir->i_sb);
+ return retval;
+ }
+
/* add new entry (or find the existing one) */
retval = reiserfs_add_entry (&th, new_dir, new_dentry->d_name.name, new_dentry->d_name.len,
"vs-7050: new entry is found, new inode == 0\n");
}
} else if (retval) {
- journal_end(&th, old_dir->i_sb, jbegin_count) ;
+ int err = journal_end(&th, old_dir->i_sb, jbegin_count) ;
reiserfs_write_unlock(old_dir->i_sb);
- return retval;
+ return err ? err : retval;
}
reiserfs_update_inode_transaction(old_dir) ;
}
RFALSE( S_ISDIR(old_inode_mode) &&
- !reiserfs_buffer_prepared(dot_dot_de.de_bh), "" );
+ !buffer_journal_prepared(dot_dot_de.de_bh), "" );
break;
}
mark_de_hidden (old_de.de_deh + old_de.de_entry_num);
journal_mark_dirty (&th, old_dir->i_sb, old_de.de_bh);
- ctime = CURRENT_TIME;
+ ctime = CURRENT_TIME_SEC;
old_dir->i_ctime = old_dir->i_mtime = ctime;
new_dir->i_ctime = new_dir->i_mtime = ctime;
/* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
reiserfs_update_sd (&th, new_dentry_inode);
}
- journal_end(&th, old_dir->i_sb, jbegin_count) ;
+ retval = journal_end(&th, old_dir->i_sb, jbegin_count) ;
reiserfs_write_unlock(old_dir->i_sb);
- return 0;
+ return retval;
}
/*
.permission = reiserfs_permission,
};
-
-
git://git.onelab.eu / linux-2.6.git / blobdiff