/*
- * Copyright (C) International Business Machines Corp., 2000-2003
+ * Copyright (C) International Business Machines Corp., 2000-2004
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
*/
#include <linux/fs.h>
+#include <linux/quotaops.h>
#include "jfs_incore.h"
#include "jfs_superblock.h"
#include "jfs_filsys.h"
static void dtGetKey(dtpage_t * p, int i, struct component_name * key,
int flag);
-static void ciGetLeafPrefixKey(dtpage_t * lp, int li, dtpage_t * rp,
- int ri, struct component_name * key, int flag);
+static int ciGetLeafPrefixKey(dtpage_t * lp, int li, dtpage_t * rp,
+ int ri, struct component_name * key, int flag);
static void dtInsertEntry(dtpage_t * p, int index, struct component_name * key,
ddata_t * data, struct dt_lock **);
jfs_warn("find_entry called with index = %d", index);
maxWarnings--;
}
- return 0;
+ return NULL;
}
if (index >= jfs_ip->next_index) {
jfs_warn("find_entry called with index >= next_index");
- return 0;
+ return NULL;
}
if (jfs_ip->next_index <= (MAX_INLINE_DIRTABLE_ENTRY + 1)) {
/*
* Inline directory table
*/
- *mp = 0;
+ *mp = NULL;
slot = &jfs_ip->i_dirtable[index - 2];
} else {
offset = (index - 2) * sizeof(struct dir_table_slot);
if (*mp && (*lblock != blkno)) {
release_metapage(*mp);
- *mp = 0;
+ *mp = NULL;
}
if (*mp == 0) {
*lblock = blkno;
}
if (*mp == 0) {
jfs_err("free_index: error reading directory table");
- return 0;
+ return NULL;
}
slot =
struct metapage *mp;
s64 offset;
uint page_offset;
- int rc;
struct tlock *tlck;
s64 xaddr;
return index;
}
if (index == (MAX_INLINE_DIRTABLE_ENTRY + 1)) {
+ struct dir_table_slot temp_table[12];
+
/*
* It's time to move the inline table to an external
* page and begin to build the xtree
*/
+ if (DQUOT_ALLOC_BLOCK(ip, sbi->nbperpage) ||
+ dbAlloc(ip, 0, sbi->nbperpage, &xaddr))
+ goto clean_up; /* No space */
/*
* Save the table, we're going to overwrite it with the
* xtree root
*/
- struct dir_table_slot temp_table[12];
memcpy(temp_table, &jfs_ip->i_dirtable, sizeof(temp_table));
/*
/*
* Allocate the first block & add it to the xtree
*/
- xaddr = 0;
- if ((rc =
- xtInsert(tid, ip, 0, 0, sbi->nbperpage,
- &xaddr, 0))) {
+ if (xtInsert(tid, ip, 0, 0, sbi->nbperpage, &xaddr, 0)) {
+ /* This really shouldn't fail */
jfs_warn("add_index: xtInsert failed!");
- return -EPERM;
+ memcpy(&jfs_ip->i_dirtable, temp_table,
+ sizeof (temp_table));
+ goto clean_up;
}
ip->i_size = PSIZE;
- ip->i_blocks += LBLK2PBLK(sb, sbi->nbperpage);
if ((mp = get_index_page(ip, 0)) == 0) {
jfs_err("add_index: get_metapage failed!");
xtTruncate(tid, ip, 0, COMMIT_PWMAP);
- return -EPERM;
+ memcpy(&jfs_ip->i_dirtable, temp_table,
+ sizeof (temp_table));
+ goto clean_up;
}
tlck = txLock(tid, ip, mp, tlckDATA);
llck = (struct linelock *) & tlck->lock;
* This will be the beginning of a new page
*/
xaddr = 0;
- if ((rc =
- xtInsert(tid, ip, 0, blkno, sbi->nbperpage,
- &xaddr, 0))) {
+ if (xtInsert(tid, ip, 0, blkno, sbi->nbperpage, &xaddr, 0)) {
jfs_warn("add_index: xtInsert failed!");
- jfs_ip->next_index--;
- return -EPERM;
+ goto clean_up;
}
ip->i_size += PSIZE;
- ip->i_blocks += LBLK2PBLK(sb, sbi->nbperpage);
if ((mp = get_index_page(ip, blkno)))
memset(mp->data, 0, PSIZE); /* Just looks better */
if (mp == 0) {
jfs_err("add_index: get/read_metapage failed!");
- return -EPERM;
+ goto clean_up;
}
lock_index(tid, ip, mp, index);
release_metapage(mp);
return index;
+
+ clean_up:
+
+ jfs_ip->next_index--;
+
+ return 0;
}
/*
{
struct dir_table_slot *dirtab_slot;
s64 lblock;
- struct metapage *mp = 0;
+ struct metapage *mp = NULL;
dirtab_slot = find_index(ip, index, &mp, &lblock);
struct dir_table_slot * dirtab_slot)
{
s64 lblock;
- struct metapage *mp = 0;
+ struct metapage *mp = NULL;
struct dir_table_slot *slot;
slot = find_index(ip, index, &mp, &lblock);
*/
getChild:
/* update max. number of pages to split */
- if (btstack->nsplit >= 8) {
+ if (BT_STACK_FULL(btstack)) {
/* Something's corrupted, mark filesytem dirty so
* chkdsk will fix it.
*/
jfs_error(sb, "stack overrun in dtSearch!");
+ BT_STACK_DUMP(btstack);
rc = -EIO;
goto out;
}
data.leaf.ip = ip;
} else {
n = NDTLEAF_LEGACY(name->namlen);
- data.leaf.ip = 0; /* signifies legacy directory format */
+ data.leaf.ip = NULL; /* signifies legacy directory format */
}
data.leaf.ino = cpu_to_le32(*fsn);
int xlen, xsize;
struct pxdlist pxdlist;
pxd_t *pxd;
- struct component_name key = { 0, 0 };
+ struct component_name key = { 0, NULL };
ddata_t *data = split->data;
int n;
struct dt_lock *dtlck;
struct tlock *tlck;
struct lv *lv;
+ int quota_allocation = 0;
/* get split page */
smp = split->mp;
n -= DTROOTMAXSLOT - sp->header.freecnt; /* header + entries */
if (n <= split->nslot)
xlen++;
- if ((rc = dbAlloc(ip, 0, (s64) xlen, &xaddr)))
+ if ((rc = dbAlloc(ip, 0, (s64) xlen, &xaddr))) {
+ DT_PUTPAGE(smp);
goto freeKeyName;
+ }
pxdlist.maxnpxd = 1;
pxdlist.npxd = 0;
split->pxdlist = &pxdlist;
rc = dtSplitRoot(tid, ip, split, &rmp);
- if (!rc)
+ if (rc)
+ dbFree(ip, xaddr, xlen);
+ else
DT_PUTPAGE(rmp);
DT_PUTPAGE(smp);
n = xlen + (xlen << 1);
else
n = xlen;
+
+ /* Allocate blocks to quota. */
+ if (DQUOT_ALLOC_BLOCK(ip, n)) {
+ rc = -EDQUOT;
+ goto extendOut;
+ }
+ quota_allocation += n;
+
if ((rc = dbReAlloc(sbi->ipbmap, xaddr, (s64) xlen,
(s64) n, &nxaddr)))
goto extendOut;
if ((sp->header.flag & BT_ROOT && skip > 1) ||
sp->header.prev != 0 || skip > 1) {
/* compute uppercase router prefix key */
- ciGetLeafPrefixKey(lp,
- lp->header.nextindex - 1,
- rp, 0, &key, sbi->mntflag);
+ rc = ciGetLeafPrefixKey(lp,
+ lp->header.nextindex-1,
+ rp, 0, &key,
+ sbi->mntflag);
+ if (rc) {
+ DT_PUTPAGE(lmp);
+ DT_PUTPAGE(rmp);
+ DT_PUTPAGE(smp);
+ goto splitOut;
+ }
} else {
/* next to leftmost entry of
lowest internal level */
freeKeyName:
kfree(key.name);
+ /* Rollback quota allocation */
+ if (rc && quota_allocation)
+ DQUOT_FREE_BLOCK(ip, quota_allocation);
+
dtSplitUp_Exit:
return rc;
static int dtSplitPage(tid_t tid, struct inode *ip, struct dtsplit * split,
struct metapage ** rmpp, dtpage_t ** rpp, pxd_t * rpxdp)
{
- struct super_block *sb = ip->i_sb;
int rc = 0;
struct metapage *smp;
dtpage_t *sp;
if (rmp == NULL)
return -EIO;
+ /* Allocate blocks to quota. */
+ if (DQUOT_ALLOC_BLOCK(ip, lengthPXD(pxd))) {
+ release_metapage(rmp);
+ return -EDQUOT;
+ }
+
jfs_info("dtSplitPage: ip:0x%p smp:0x%p rmp:0x%p", ip, smp, rmp);
BT_MARK_DIRTY(rmp, ip);
if ((rp->header.flag & BT_LEAF) && DO_INDEX(ip)) {
s64 lblock;
- mp = 0;
+ mp = NULL;
stbl = DT_GETSTBL(rp);
for (n = 0; n < rp->header.nextindex; n++) {
ldtentry = (struct ldtentry *) & rp->slot[stbl[n]];
*rmpp = rmp;
*rpxdp = *pxd;
- ip->i_blocks += LBLK2PBLK(sb, lengthPXD(pxd));
-
return rc;
}
if (DO_INDEX(ip)) {
s64 lblock;
- mp = 0;
+ mp = NULL;
stbl = DT_GETSTBL(sp);
for (n = 0; n < sp->header.nextindex; n++) {
ldtentry =
tpxd = (pxd_t *) & pp->slot[1];
*tpxd = *pxd;
- /* Since the directory might have an EA and/or ACL associated with it
- * we need to make sure we take that into account when setting the
- * i_nblocks
- */
- ip->i_blocks = LBLK2PBLK(ip->i_sb, xlen +
- ((JFS_IP(ip)->ea.flag & DXD_EXTENT) ?
- lengthDXD(&JFS_IP(ip)->ea) : 0) +
- ((JFS_IP(ip)->acl.flag & DXD_EXTENT) ?
- lengthDXD(&JFS_IP(ip)->acl) : 0));
-
DT_PUTPAGE(pmp);
return 0;
}
rp = rmp->data;
+ /* Allocate blocks to quota. */
+ if (DQUOT_ALLOC_BLOCK(ip, lengthPXD(pxd))) {
+ release_metapage(rmp);
+ return -EDQUOT;
+ }
+
BT_MARK_DIRTY(rmp, ip);
/*
* acquire a transaction lock on the new right page
*/
if ((rp->header.flag & BT_LEAF) && DO_INDEX(ip)) {
s64 lblock;
- struct metapage *mp = 0;
+ struct metapage *mp = NULL;
struct ldtentry *ldtentry;
stbl = DT_GETSTBL(rp);
*rmpp = rmp;
- ip->i_blocks += LBLK2PBLK(ip->i_sb, lengthPXD(pxd));
return 0;
}
if (DO_INDEX(ip) && index < p->header.nextindex) {
s64 lblock;
- imp = 0;
+ imp = NULL;
stbl = DT_GETSTBL(p);
for (i = index; i < p->header.nextindex; i++) {
ldtentry =
}
xlen = lengthPXD(&fp->header.self);
- ip->i_blocks -= LBLK2PBLK(ip->i_sb, xlen);
+
+ /* Free quota allocation. */
+ DQUOT_FREE_BLOCK(ip, xlen);
/* free/invalidate its buffer page */
discard_metapage(fmp);
}
xlen = lengthPXD(&p->header.self);
- ip->i_blocks -= LBLK2PBLK(ip->i_sb, xlen);
+
+ /* Free quota allocation */
+ DQUOT_FREE_BLOCK(ip, xlen);
/* free/invalidate its buffer page */
discard_metapage(mp);
/* init '..' entry */
p->header.idotdot = cpu_to_le32(idotdot);
-#if 0
- ip->i_blocks = LBLK2PBLK(ip->i_sb,
- ((jfs_ip->ea.flag & DXD_EXTENT) ?
- lengthDXD(&jfs_ip->ea) : 0) +
- ((jfs_ip->acl.flag & DXD_EXTENT) ?
- lengthDXD(&jfs_ip->acl) : 0));
-#endif
-
return;
}
/*
* descend down to leftmost child page
*/
+ if (BT_STACK_FULL(btstack)) {
+ DT_PUTPAGE(mp);
+ jfs_error(ip->i_sb, "dtReadFirst: btstack overrun");
+ BT_STACK_DUMP(btstack);
+ return -EIO;
+ }
/* push (bn, index) of the parent page/entry */
BT_PUSH(btstack, bn, 0);
* from two adjacent leaf entries
* across page boundary
*
- * return:
- * Number of prefix bytes needed to distinguish b from a.
+ * return: non-zero on error
+ *
*/
-static void ciGetLeafPrefixKey(dtpage_t * lp, int li, dtpage_t * rp,
+static int ciGetLeafPrefixKey(dtpage_t * lp, int li, dtpage_t * rp,
int ri, struct component_name * key, int flag)
{
int klen, namlen;
wchar_t *pl, *pr, *kname;
- wchar_t lname[JFS_NAME_MAX + 1];
- struct component_name lkey = { 0, lname };
- wchar_t rname[JFS_NAME_MAX + 1];
- struct component_name rkey = { 0, rname };
+ struct component_name lkey;
+ struct component_name rkey;
+
+ lkey.name = (wchar_t *) kmalloc((JFS_NAME_MAX + 1) * sizeof(wchar_t),
+ GFP_KERNEL);
+ if (lkey.name == NULL)
+ return -ENOSPC;
+
+ rkey.name = (wchar_t *) kmalloc((JFS_NAME_MAX + 1) * sizeof(wchar_t),
+ GFP_KERNEL);
+ if (rkey.name == NULL) {
+ kfree(lkey.name);
+ return -ENOSPC;
+ }
/* get left and right key */
dtGetKey(lp, li, &lkey, flag);
*kname = *pr;
if (*pl != *pr) {
key->namlen = klen + 1;
- return;
+ goto free_names;
}
}
} else /* l->namelen == r->namelen */
key->namlen = klen;
- return;
+free_names:
+ kfree(lkey.name);
+ kfree(rkey.name);
+ return 0;
}
ddata_t * data, struct dt_lock ** dtlock)
{
struct dtslot *h, *t;
- struct ldtentry *lh = 0;
- struct idtentry *ih = 0;
+ struct ldtentry *lh = NULL;
+ struct idtentry *ih = NULL;
int hsi, fsi, klen, len, nextindex;
wchar_t *kname, *name;
s8 *stbl;
struct lv *lv;
int xsi, n;
s64 bn = 0;
- struct metapage *mp = 0;
+ struct metapage *mp = NULL;
klen = key->namlen;
kname = key->name;
* Need to update slot number for entries that moved
* in the stbl
*/
- mp = 0;
+ mp = NULL;
for (n = index + 1; n <= nextindex; n++) {
lh = (struct ldtentry *) & (p->slot[stbl[n]]);
modify_index(data->leaf.tid, data->leaf.ip,
int dsi; /* dst slot index */
s8 *sstbl, *dstbl; /* sorted entry table */
int snamlen, len;
- struct ldtentry *slh, *dlh = 0;
- struct idtentry *sih, *dih = 0;
+ struct ldtentry *slh, *dlh = NULL;
+ struct idtentry *sih, *dih = NULL;
struct dtslot *h, *s, *d;
struct dt_lock *sdtlck = *sdtlock, *ddtlck = *ddtlock;
struct lv *slv, *dlv;
git://git.onelab.eu / linux-2.6.git / blobdiff