oinfo->dqi_gi.dqi_free_entry =

be32_to_cpu(lvb->lvb_free_entry);

} else {

if (status) {

mlog_errno(status);

goto bail;

struct ocfs2_super *osb = OCFS2_SB(sb);

struct buffer_head *bh = NULL;

handle_t *handle = NULL;

struct dquot *transfer_to[MAXQUOTAS] = { };

mlog_entry("(0x%p, '%.*s')\n", dentry,

dentry->d_name.len, dentry->d_name.name);

if (status)

return status;

size_change = S_ISREG(inode->i_mode) && attr->ia_valid & ATTR_SIZE;

if (size_change) {

status = ocfs2_rw_lock(inode, 1);

if (status < 0) {

mlog_errno(status);

OCFS2_FEATURE_RO_COMPAT_USRQUOTA)) {

transfer_to[USRQUOTA] = dqget(sb, attr->ia_uid,

USRQUOTA);

status = -ESRCH;

goto bail_unlock;

}

OCFS2_FEATURE_RO_COMPAT_GRPQUOTA)) {

transfer_to[GRPQUOTA] = dqget(sb, attr->ia_gid,

GRPQUOTA);

status = -ESRCH;

goto bail_unlock;

}

mlog_errno(status);

goto bail_unlock;

}

if (status < 0)

goto bail_commit;

} else {

brelse(bh);

/* Release quota pointers in case we acquired them */

dqput(transfer_to[qtype]);

if (!status && attr->ia_valid & ATTR_MODE) {

status = ocfs2_acl_chmod(inode);

struct ocfs2_dquot {

struct dquot dq_dquot; /* Generic VFS dquot */

loff_t dq_local_off; /* Offset in the local quota file */

struct ocfs2_quota_chunk *dq_chunk; /* Chunk dquot is in */

unsigned int dq_use_count; /* Number of nodes having reference to this entry in global quota file */

s64 dq_origspace; /* Last globally synced space usage */

struct ocfs2_lock_res dqi_gqlock; /* Lock protecting quota information structure */

struct buffer_head *dqi_gqi_bh; /* Buffer head with global quota file inode - set only if inode lock is obtained */

int dqi_gqi_count; /* Number of holders of dqi_gqi_bh */

struct buffer_head *dqi_lqi_bh; /* Buffer head with local quota file inode */

struct qtree_mem_dqinfo dqi_gi; /* Info about global file */

struct delayed_work dqi_sync_work; /* Work for syncing dquots */

struct ocfs2_quota_recovery *dqi_rec; /* Pointer to recovery

int ocfs2_lock_global_qf(struct ocfs2_mem_dqinfo *oinfo, int ex);

void ocfs2_unlock_global_qf(struct ocfs2_mem_dqinfo *oinfo, int ex);

extern const struct dquot_operations ocfs2_quota_operations;

extern struct quota_format_type ocfs2_quota_format;

#include "dlmglue.h"

#include "uptodate.h"

#include "super.h"

#include "quota.h"

static struct workqueue_struct *ocfs2_quota_wq = NULL;

static void qsync_work_fn(struct work_struct *work);

.is_id = ocfs2_global_is_id,

};

{

struct ocfs2_disk_dqtrailer *dqt =

ocfs2_block_dqtrailer(sb->s_blocksize, bh->b_data);

return ocfs2_validate_meta_ecc(sb, bh->b_data, &dqt->dq_check);

}

{

if (rc)

mlog_errno(rc);

return rc;

}

/* Read data from global quotafile - avoid pagecache and such because we cannot

* afford acquiring the locks... We use quota cluster lock to serialize

* operations. Caller is responsible for acquiring it. */

int err = 0;

struct buffer_head *bh;

size_t toread, tocopy;

if (off > i_size)

return 0;

toread = len;

while (toread > 0) {

tocopy = min_t(size_t, (sb->s_blocksize - offset), toread);

bh = NULL;

if (err) {

mlog_errno(err);

return err;

int err = 0, new = 0, ja_type;

struct buffer_head *bh = NULL;

handle_t *handle = journal_current_handle();

if (!handle) {

mlog(ML_ERROR, "Quota write (off=%llu, len=%llu) cancelled "

len = sb->s_blocksize - OCFS2_QBLK_RESERVED_SPACE - offset;

}

if (gqinode->i_size < off + len) {

loff_t rounded_end =

ocfs2_align_bytes_to_blocks(sb, off + len);

err = ocfs2_simple_size_update(gqinode,

oinfo->dqi_gqi_bh,

rounded_end);

goto out;

new = 1;

}

/* Not rewriting whole block? */

if ((offset || len < sb->s_blocksize - OCFS2_QBLK_RESERVED_SPACE) &&

!new) {

ja_type = OCFS2_JOURNAL_ACCESS_WRITE;

} else {

ja_type = OCFS2_JOURNAL_ACCESS_CREATE;

}

if (err) {

brelse(bh);

out:

if (err) {

mlog_errno(err);

return err;

}

gqinode->i_version++;

ocfs2_mark_inode_dirty(handle, gqinode, oinfo->dqi_gqi_bh);

return len;

}

else

WARN_ON(bh != oinfo->dqi_gqi_bh);

spin_unlock(&dq_data_lock);

return 0;

}

void ocfs2_unlock_global_qf(struct ocfs2_mem_dqinfo *oinfo, int ex)

{

ocfs2_inode_unlock(oinfo->dqi_gqinode, ex);

brelse(oinfo->dqi_gqi_bh);

spin_lock(&dq_data_lock);

struct ocfs2_global_disk_dqinfo dinfo;

struct mem_dqinfo *info = sb_dqinfo(sb, type);

struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;

int status;

mlog_entry_void();

mlog_errno(status);

goto out_err;

}

status = sb->s_op->quota_read(sb, type, (char *)&dinfo,

sizeof(struct ocfs2_global_disk_dqinfo),

OCFS2_GLOBAL_INFO_OFF);

ocfs2_unlock_global_qf(oinfo, 0);

if (status != sizeof(struct ocfs2_global_disk_dqinfo)) {

mlog(ML_ERROR, "Cannot read global quota info (%d).\n",

out_err:

mlog_exit(status);

return status;

}

/* Write information to global quota file. Expects exlusive lock on quota

static int ocfs2_calc_global_qinit_credits(struct super_block *sb, int type)

{

return (ocfs2_global_qinit_alloc(sb, type) + 2) *

}

/* Sync local information about quota modifications with global quota file.

}

mutex_lock(&sb_dqopt(sb)->dqio_mutex);

status = ocfs2_sync_dquot(dquot);

if (status < 0)

mlog_errno(status);

/* We have to write local structure as well... */

if (status < 0)

mlog_errno(status);

ocfs2_commit_trans(osb, handle);

out_ilock:

ocfs2_unlock_global_qf(oinfo, 1);

mlog_errno(status);

goto out;

}

ocfs2_commit_trans(osb, handle);

out:

mlog_exit(status);

mlog_entry("id=%u, type=%d", dquot->dq_id, dquot->dq_type);

status = ocfs2_lock_global_qf(oinfo, 1);

if (status < 0)

goto out;

mlog_errno(status);

goto out_ilock;

}

ocfs2_commit_trans(osb, handle);

out_ilock:

ocfs2_unlock_global_qf(oinfo, 1);

out:

mlog_exit(status);

return status;

}

static int ocfs2_acquire_dquot(struct dquot *dquot)

{

if (status < 0)

goto out;

out:

mlog_exit(status);

return status;

}

struct ocfs2_super *osb = OCFS2_SB(sb);

mlog_entry("id=%u, type=%d", dquot->dq_id, type);

/* In case user set some limits, sync dquot immediately to global

* quota file so that information propagates quicker */

mlog_errno(status);

goto out_ilock;

}

status = ocfs2_sync_dquot(dquot);

if (status < 0) {

mlog_errno(status);

}

/* Now write updated local dquot structure */

ocfs2_commit_trans(osb, handle);

out_ilock:

ocfs2_unlock_global_qf(oinfo, 1);

}

const struct dquot_operations ocfs2_quota_operations = {

.acquire_dquot = ocfs2_acquire_dquot,

.release_dquot = ocfs2_release_dquot,

.mark_dirty = ocfs2_mark_dquot_dirty,

#include "dlmglue.h"

#include "quota.h"

#include "uptodate.h"

/* Number of local quota structures per block */

static inline unsigned int ol_quota_entries_per_block(struct super_block *sb)

return 0;

}

/* Check whether we understand format of quota files */

static int ocfs2_local_check_quota_file(struct super_block *sb, int type)

{

INIT_LIST_HEAD(&oinfo->dqi_chunk);

oinfo->dqi_rec = NULL;

oinfo->dqi_lqi_bh = NULL;

status = ocfs2_global_read_info(sb, type);

if (status < 0)

info->dqi_flags = le32_to_cpu(ldinfo->dqi_flags);

oinfo->dqi_chunks = le32_to_cpu(ldinfo->dqi_chunks);

oinfo->dqi_blocks = le32_to_cpu(ldinfo->dqi_blocks);

/* We crashed when using local quota file? */

if (!(info->dqi_flags & OLQF_CLEAN)) {

{

struct mem_dqinfo *info = sb_dqinfo(sb, type);

struct buffer_head *bh = ((struct ocfs2_mem_dqinfo *)info->dqi_priv)

int status;

status = ocfs2_modify_bh(sb_dqopt(sb)->files[type], bh, olq_update_info,

int mark_clean = 1, len;

int status;

iput(oinfo->dqi_gqinode);

ocfs2_simple_drop_lockres(OCFS2_SB(sb), &oinfo->dqi_gqlock);

ocfs2_lock_res_free(&oinfo->dqi_gqlock);

/* Mark local file as clean */

info->dqi_flags |= OLQF_CLEAN;

status = ocfs2_modify_bh(sb_dqopt(sb)->files[type],

olq_update_info,

info);

if (status < 0) {

out:

ocfs2_inode_unlock(sb_dqopt(sb)->files[type], 1);

brelse(oinfo->dqi_lqi_bh);

kfree(oinfo);

return 0;

}

/* Write dquot to local quota file */

{

struct super_block *sb = dquot->dq_sb;

struct ocfs2_dquot *od = OCFS2_DQUOT(dquot);

int status;

if (status) {

mlog_errno(status);

goto out;

}

if (status < 0) {

mlog_errno(status);

goto out;

}

/* Initialize chunk header */

status = ocfs2_extent_map_get_blocks(lqinode, oinfo->dqi_blocks,

&p_blkno, NULL, NULL);

if (status < 0) {

mlog_errno(status);

goto out_trans;

ocfs2_journal_dirty(handle, bh);

/* Initialize new block with structures */

status = ocfs2_extent_map_get_blocks(lqinode, oinfo->dqi_blocks + 1,

&p_blkno, NULL, NULL);

if (status < 0) {

mlog_errno(status);

goto out_trans;

}

/* Get buffer from the just added block */

status = ocfs2_extent_map_get_blocks(lqinode, oinfo->dqi_blocks,

&p_blkno, NULL, NULL);

if (status < 0) {

mlog_errno(status);

goto out;

}

/* Create dquot in the local file for given id */

{

struct super_block *sb = dquot->dq_sb;

int type = dquot->dq_type;

struct ocfs2_dquot *od = OCFS2_DQUOT(dquot);

int offset;

int status;

chunk = ocfs2_find_free_entry(sb, type, &offset);

if (!chunk) {

chunk = ocfs2_extend_local_quota_file(sb, type, &offset);

} else if (IS_ERR(chunk)) {

}

od->dq_local_off = ol_dqblk_off(sb, chunk->qc_num, offset);

od->dq_chunk = chunk;

/* Initialize dquot structure on disk */

status = ocfs2_local_write_dquot(dquot);

goto out;

}

out:

return status;

}

{

int status;

int type = dquot->dq_type;

struct super_block *sb = dquot->dq_sb;

struct ocfs2_local_disk_chunk *dchunk;

int offset;

status = ocfs2_journal_access_dq(handle,

INODE_CACHE(sb_dqopt(sb)->files[type]),

.read_file_info = ocfs2_local_read_info,

.write_file_info = ocfs2_global_write_info,

.free_file_info = ocfs2_local_free_info,

};

struct quota_format_type ocfs2_quota_format = {

int type;

struct inode *inode;

struct super_block *sb = osb->sb;

/* We mostly ignore errors in this function because there's not much

* we can do when we see them */

for (type = 0; type < MAXQUOTAS; type++) {

if (!sb_has_quota_loaded(sb, type))

continue;

inode = igrab(sb->s_dquot.files[type]);

/* Turn off quotas. This will remove all dquot structures from

* memory and so they will be automatically synced to global