errcode_t quota_remove_inode(ext2_filsys fs, int qtype)
{
ext2_ino_t qf_ino;
errcode_t retval;
retval = ext2fs_read_bitmaps(fs);
if (retval) {
log_err("Couldn't read bitmaps: %s", error_message(retval));
return retval;
}
qf_ino = (qtype == USRQUOTA) ? fs->super->s_usr_quota_inum :
fs->super->s_grp_quota_inum;
quota_set_sb_inum(fs, 0, qtype);
/* Truncate the inode only if its a reserved one. */
if (qf_ino < EXT2_FIRST_INODE(fs->super))
quota_inode_truncate(fs, qf_ino);
ext2fs_mark_super_dirty(fs);
fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
retval = ext2fs_write_bitmaps(fs);
if (retval) {
log_err("Couldn't write bitmaps: %s", error_message(retval));
return retval;
}
return 0;
}
errcode_t quota_write_inode(quota_ctx_t qctx, int qtype)
{
int retval = 0, i;
dict_t *dict;
ext2_filsys fs;
struct quota_handle *h = NULL;
int fmt = QFMT_VFS_V1;
if (!qctx)
return 0;
fs = qctx->fs;
retval = ext2fs_get_mem(sizeof(struct quota_handle), &h);
if (retval) {
log_err("Unable to allocate quota handle", "");
goto out;
}
ext2fs_read_bitmaps(fs);
for (i = 0; i < MAXQUOTAS; i++) {
if ((qtype != -1) && (i != qtype))
continue;
dict = qctx->quota_dict[i];
if (!dict)
continue;
retval = quota_file_create(h, fs, i, fmt);
if (retval < 0) {
log_err("Cannot initialize io on quotafile", "");
continue;
}
write_dquots(dict, h);
retval = quota_file_close(h);
if (retval < 0) {
log_err("Cannot finish IO on new quotafile: %s",
strerror(errno));
if (h->qh_qf.e2_file)
ext2fs_file_close(h->qh_qf.e2_file);
quota_inode_truncate(fs, h->qh_qf.ino);
continue;
}
/* Set quota inode numbers in superblock. */
quota_set_sb_inum(fs, h->qh_qf.ino, i);
ext2fs_mark_super_dirty(fs);
ext2fs_mark_bb_dirty(fs);
fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
}
ext2fs_write_bitmaps(fs);
out:
if (h)
ext2fs_free_mem(&h);
return retval;
}
errcode_t write_quota_inode(quota_ctx_t qctx, int qtype)
{
int retval, i;
unsigned long qf_inums[MAXQUOTAS];
struct dquot *dquot;
dict_t *dict;
ext2_filsys fs;
struct quota_handle *h;
int fmt = QFMT_VFS_V1;
if (!qctx)
return;
fs = qctx->fs;
h = smalloc(sizeof(struct quota_handle));
ext2fs_read_bitmaps(fs);
for (i = 0; i < MAXQUOTAS; i++) {
if ((qtype != -1) && (i != qtype))
continue;
dict = qctx->quota_dict[i];
if (!dict)
continue;
retval = new_io(h, fs, i, fmt);
if (retval < 0) {
log_err("Cannot initialize io on quotafile", "");
continue;
}
write_dquots(dict, h);
retval = end_io(h);
if (retval < 0) {
log_err("Cannot finish IO on new quotafile: %s",
strerror(errno));
if (h->qh_qf.e2_file)
ext2fs_file_close(h->qh_qf.e2_file);
truncate_quota_inode(fs, h->qh_qf.ino);
continue;
}
/* Set quota inode numbers in superblock. */
set_sb_quota_inum(fs, h->qh_qf.ino, i);
ext2fs_mark_super_dirty(fs);
ext2fs_mark_bb_dirty(fs);
fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
}
ext2fs_write_bitmaps(fs);
out:
free(h);
return retval;
}
void e2fsck_write_bitmaps(e2fsck_t ctx)
{
ext2_filsys fs = ctx->fs;
errcode_t retval;
const char *old_op;
old_op = ehandler_operation(_("writing block and inode bitmaps"));
retval = ext2fs_write_bitmaps(fs);
ehandler_operation(old_op);
if (retval) {
com_err(ctx->program_name, retval,
_("while rewriting block and inode bitmaps for %s"),
ctx->device_name);
fatal_error(ctx, 0);
}
}
errcode_t quota_remove_inode(ext2_filsys fs, int qtype)
{
ext2_ino_t qf_ino;
ext2fs_read_bitmaps(fs);
qf_ino = (qtype == USRQUOTA) ? fs->super->s_usr_quota_inum :
fs->super->s_grp_quota_inum;
quota_set_sb_inum(fs, 0, qtype);
/* Truncate the inode only if its a reserved one. */
if (qf_ino < EXT2_FIRST_INODE(fs->super))
quota_inode_truncate(fs, qf_ino);
ext2fs_mark_super_dirty(fs);
ext2fs_write_bitmaps(fs);
return 0;
}
errcode_t quota_remove_inode(ext2_filsys fs, enum quota_type qtype)
{
ext2_ino_t qf_ino;
errcode_t retval;
retval = ext2fs_read_bitmaps(fs);
if (retval) {
log_debug("Couldn't read bitmaps: %s", error_message(retval));
return retval;
}
qf_ino = *quota_sb_inump(fs->super, qtype);
if (qf_ino == 0)
return 0;
retval = quota_inode_truncate(fs, qf_ino);
if (retval)
return retval;
if (qf_ino >= EXT2_FIRST_INODE(fs->super)) {
struct ext2_inode inode;
retval = ext2fs_read_inode(fs, qf_ino, &inode);
if (!retval) {
memset(&inode, 0, sizeof(struct ext2_inode));
ext2fs_write_inode(fs, qf_ino, &inode);
}
ext2fs_inode_alloc_stats2(fs, qf_ino, -1, 0);
ext2fs_mark_ib_dirty(fs);
}
quota_set_sb_inum(fs, 0, qtype);
ext2fs_mark_super_dirty(fs);
fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
retval = ext2fs_write_bitmaps(fs);
if (retval) {
log_debug("Couldn't write bitmaps: %s", error_message(retval));
return retval;
}
return 0;
}
errcode_t quota_write_inode(quota_ctx_t qctx, unsigned int qtype_bits)
{
int retval = 0;
enum quota_type qtype;
dict_t *dict;
ext2_filsys fs;
struct quota_handle *h = NULL;
int fmt = QFMT_VFS_V1;
if (!qctx)
return 0;
fs = qctx->fs;
retval = ext2fs_get_mem(sizeof(struct quota_handle), &h);
if (retval) {
log_debug("Unable to allocate quota handle: %s",
error_message(retval));
goto out;
}
retval = ext2fs_read_bitmaps(fs);
if (retval) {
log_debug("Couldn't read bitmaps: %s", error_message(retval));
goto out;
}
for (qtype = 0; qtype < MAXQUOTAS; qtype++) {
if (((1 << qtype) & qtype_bits) == 0)
continue;
dict = qctx->quota_dict[qtype];
if (!dict)
continue;
retval = quota_file_create(h, fs, qtype, fmt);
if (retval) {
log_debug("Cannot initialize io on quotafile: %s",
error_message(retval));
goto out;
}
write_dquots(dict, h);
retval = quota_file_close(qctx, h);
if (retval) {
log_debug("Cannot finish IO on new quotafile: %s",
strerror(errno));
if (h->qh_qf.e2_file)
ext2fs_file_close(h->qh_qf.e2_file);
(void) quota_inode_truncate(fs, h->qh_qf.ino);
goto out;
}
/* Set quota inode numbers in superblock. */
quota_set_sb_inum(fs, h->qh_qf.ino, qtype);
ext2fs_mark_super_dirty(fs);
ext2fs_mark_bb_dirty(fs);
fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
}
retval = ext2fs_write_bitmaps(fs);
if (retval) {
log_debug("Couldn't write bitmaps: %s", error_message(retval));
goto out;
}
out:
if (h)
ext2fs_free_mem(&h);
return retval;
}
