/**
* ubifs_jnl_write_2_inodes - write 2 inodes to the journal.
* @c: UBIFS file-system description object
* @inode1: first inode to write
* @inode2: second inode to write
* @sync: non-zero if the write-buffer has to be synchronized
*
* This function writes 2 inodes @inode1 and @inode2 to the journal (to the
* base head - first @inode1, then @inode2). Returns zero in case of success
* and a negative error code in case of failure.
*/
int ubifs_jnl_write_2_inodes(struct ubifs_info *c, const struct inode *inode1,
const struct inode *inode2, int sync)
{
int err, len1, len2, aligned_len, aligned_len1, lnum, offs;
struct ubifs_ino_node *ino;
union ubifs_key key;
dbg_jnl("ino %lu, ino %lu", inode1->i_ino, inode2->i_ino);
ubifs_assert(inode1->i_nlink > 0);
ubifs_assert(inode2->i_nlink > 0);
len1 = UBIFS_INO_NODE_SZ + ubifs_inode(inode1)->data_len;
len2 = UBIFS_INO_NODE_SZ + ubifs_inode(inode2)->data_len;
aligned_len1 = ALIGN(len1, 8);
aligned_len = aligned_len1 + ALIGN(len2, 8);
ino = kmalloc(aligned_len, GFP_NOFS);
if (!ino)
return -ENOMEM;
/* Make reservation before allocating sequence numbers */
err = make_reservation(c, BASEHD, aligned_len);
if (err)
goto out_free;
pack_inode(c, ino, inode1, 0, 0);
pack_inode(c, (void *)ino + aligned_len1, inode2, 1, 0);
err = write_head(c, BASEHD, ino, aligned_len, &lnum, &offs, 0);
if (!sync && !err) {
struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
ubifs_wbuf_add_ino_nolock(wbuf, inode1->i_ino);
ubifs_wbuf_add_ino_nolock(wbuf, inode2->i_ino);
}
release_head(c, BASEHD);
if (err)
goto out_ro;
ino_key_init(c, &key, inode1->i_ino);
err = ubifs_tnc_add(c, &key, lnum, offs, len1);
if (err)
goto out_ro;
ino_key_init(c, &key, inode2->i_ino);
err = ubifs_tnc_add(c, &key, lnum, offs + aligned_len1, len2);
if (err)
goto out_ro;
finish_reservation(c);
kfree(ino);
return 0;
out_ro:
ubifs_ro_mode(c, err);
finish_reservation(c);
out_free:
kfree(ino);
return err;
}
/**
* ubifs_jrn_write_inode - flush inode to the journal.
* @c: UBIFS file-system description object
* @inode: inode to flush
* @last_reference: inode has been deleted
* @sync: non-zero if the write-buffer has to be synchronized
*
* This function writes inode @inode to the journal (to the base head). Returns
* zero in case of success and a negative error code in case of failure.
*/
int ubifs_jrn_write_inode(struct ubifs_info *c, const struct inode *inode,
int last_reference, int sync)
{
int err, len, lnum, offs;
struct ubifs_ino_node *ino;
struct ubifs_inode *ui = ubifs_inode(inode);
dbg_jrn("ino %lu%s", inode->i_ino,
last_reference ? " (last reference)" : "");
if (last_reference)
ubifs_assert(inode->i_nlink == 0);
/* If the inode is deleted, do not write the attached data */
len = UBIFS_INO_NODE_SZ;
if (!last_reference)
len += ui->data_len;
ino = kmalloc(len, GFP_NOFS);
if (!ino)
return -ENOMEM;
pack_inode(c, ino, inode, 1, last_reference);
err = make_reservation(c, BASEHD, len);
if (err)
goto out_free;
err = write_head(c, BASEHD, ino, len, &lnum, &offs, sync);
if (!sync && !err)
ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf,
inode->i_ino);
release_head(c, BASEHD);
if (err)
goto out_ro;
if (last_reference) {
err = ubifs_tnc_remove_ino(c, inode->i_ino);
if (err)
goto out_ro;
ubifs_delete_orphan(c, inode->i_ino);
err = ubifs_add_dirt(c, lnum, len);
} else {
union ubifs_key key;
ino_key_init(c, &key, inode->i_ino);
err = ubifs_tnc_add(c, &key, lnum, offs, len);
}
if (err)
goto out_ro;
finish_reservation(c);
kfree(ino);
return 0;
out_ro:
ubifs_ro_mode(c, err);
finish_reservation(c);
out_free:
kfree(ino);
return err;
}
/**
* ubifs_jrn_truncate - update the journal for a truncation.
* @c: UBIFS file-system description object
* @inum: inode number of inode being truncated
* @old_size: old size
* @new_size: new size
*
* When the size of a file decreases due to truncation, a truncation node is
* written, the journal tree is updated, and the last data block is re-written
* if it has been affected.
*
* This function returns %0 in the case of success, and a negative error code in
* case of failure.
*/
int ubifs_jrn_truncate(struct ubifs_info *c, ino_t inum,
loff_t old_size, loff_t new_size)
{
union ubifs_key key, to_key;
struct ubifs_trun_node *trun;
struct ubifs_data_node *dn;
int err, dlen, len, lnum, offs, bit, sz;
unsigned int blk;
dbg_jrn("ino %lu, size %lld -> %lld", inum, old_size, new_size);
sz = UBIFS_TRUN_NODE_SZ + UBIFS_MAX_DATA_NODE_SZ * WORST_COMPR_FACTOR;
trun = kmalloc(sz, GFP_NOFS);
if (!trun)
return -ENOMEM;
trun->ch.node_type = UBIFS_TRUN_NODE;
trun_key_init_flash(c, &trun->key, inum);
trun->old_size = cpu_to_le64(old_size);
trun->new_size = cpu_to_le64(new_size);
ubifs_prepare_node(c, trun, UBIFS_TRUN_NODE_SZ, 0);
dlen = new_size & (UBIFS_BLOCK_SIZE - 1);
if (dlen) {
/* Get last data block so it can be truncated */
dn = (void *)trun + ALIGN(UBIFS_TRUN_NODE_SZ, 8);
blk = new_size / UBIFS_BLOCK_SIZE;
data_key_init(c, &key, inum, blk);
dbg_jrn_key(c, &key, "key");
err = ubifs_tnc_lookup(c, &key, dn);
if (err == -ENOENT)
dlen = 0; /* Not found (so it is a hole) */
else if (err)
goto out_free;
else {
if (le32_to_cpu(dn->size) <= dlen)
dlen = 0; /* Nothing to do */
else {
int compr_type = le16_to_cpu(dn->compr_type);
if (compr_type != UBIFS_COMPR_NONE) {
err = recomp_data_node(dn, &dlen);
if (err)
goto out_free;
} else {
dn->size = cpu_to_le32(dlen);
dlen += UBIFS_DATA_NODE_SZ;
}
zero_data_node_unused(dn);
ubifs_prepare_node(c, dn, dlen, 0);
}
}
}
if (dlen)
len = ALIGN(UBIFS_TRUN_NODE_SZ, 8) + dlen;
else
len = UBIFS_TRUN_NODE_SZ;
err = make_reservation(c, BASEHD, len);
if (err)
goto out_free;
err = write_head(c, BASEHD, trun, len, &lnum, &offs, 0);
if (!err)
ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, inum);
release_head(c, BASEHD);
if (err)
goto out_ro;
if (dlen) {
offs += ALIGN(UBIFS_TRUN_NODE_SZ, 8);
err = ubifs_tnc_add(c, &key, lnum, offs, dlen);
if (err)
goto out_ro;
}
err = ubifs_add_dirt(c, lnum, UBIFS_TRUN_NODE_SZ);
if (err)
goto out_ro;
bit = new_size & (UBIFS_BLOCK_SIZE - 1);
blk = new_size / UBIFS_BLOCK_SIZE + (bit ? 1 : 0);
data_key_init(c, &key, inum, blk);
bit = old_size & (UBIFS_BLOCK_SIZE - 1);
blk = old_size / UBIFS_BLOCK_SIZE - (bit ? 0: 1);
data_key_init(c, &to_key, inum, blk);
err = ubifs_tnc_remove_range(c, &key, &to_key);
if (err)
goto out_ro;
finish_reservation(c);
kfree(trun);
return 0;
out_ro:
ubifs_ro_mode(c, err);
finish_reservation(c);
out_free:
kfree(trun);
return err;
}
/**
* ubifs_jrn_rename - rename a directory entry.
* @c: UBIFS file-system description object
* @old_dir: parent inode of directory entry to rename
* @old_dentry: directory entry to rename
* @new_dir: parent inode of directory entry to rename
* @new_dentry: new directory entry (or directory entry to replace)
* @sync: non-zero if the write-buffer has to be synchronized
*
* Returns zero in case of success and a negative error code in case of failure.
*/
int ubifs_jrn_rename(struct ubifs_info *c, const struct inode *old_dir,
const struct dentry *old_dentry,
const struct inode *new_dir,
const struct dentry *new_dentry, int sync)
{
const struct inode *old_inode = old_dentry->d_inode;
const struct inode *new_inode = new_dentry->d_inode;
int err, dlen1, dlen2, ilen, lnum, offs, len;
int aligned_dlen1, aligned_dlen2, plen = UBIFS_INO_NODE_SZ;
int last_reference = !!(new_inode && new_inode->i_nlink == 0);
struct ubifs_dent_node *dent, *dent2;
void *p;
union ubifs_key key;
dbg_jrn("dent '%.*s' in dir ino %lu to dent '%.*s' in dir ino %lu",
old_dentry->d_name.len, old_dentry->d_name.name,
old_dir->i_ino, new_dentry->d_name.len,
new_dentry->d_name.name, new_dir->i_ino);
ubifs_assert(ubifs_inode(old_dir)->data_len == 0);
ubifs_assert(ubifs_inode(new_dir)->data_len == 0);
dlen1 = UBIFS_DENT_NODE_SZ + new_dentry->d_name.len + 1;
dlen2 = UBIFS_DENT_NODE_SZ + old_dentry->d_name.len + 1;
if (new_inode) {
ilen = UBIFS_INO_NODE_SZ;
if (!last_reference)
ilen += ubifs_inode(new_inode)->data_len;
} else
ilen = 0;
aligned_dlen1 = ALIGN(dlen1, 8);
aligned_dlen2 = ALIGN(dlen2, 8);
len = aligned_dlen1 + aligned_dlen2 + ALIGN(ilen, 8) + ALIGN(plen, 8);
if (old_dir != new_dir)
len += plen;
dent = kmalloc(len, GFP_NOFS);
if (!dent)
return -ENOMEM;
/* Make new dent */
dent->ch.node_type = UBIFS_DENT_NODE;
dent_key_init_flash(c, &dent->key, new_dir->i_ino, &new_dentry->d_name);
dent->inum = cpu_to_le64(old_inode->i_ino);
dent->type = get_dent_type(old_inode->i_mode);
dent->nlen = cpu_to_le16(new_dentry->d_name.len);
memcpy(dent->name, new_dentry->d_name.name, new_dentry->d_name.len);
dent->name[new_dentry->d_name.len] = '\0';
zero_dent_node_unused(dent);
ubifs_prep_grp_node(c, dent, dlen1, 0);
dent2 = (void *)dent + aligned_dlen1;
/* Make deletion dent */
dent2->ch.node_type = UBIFS_DENT_NODE;
dent_key_init_flash(c, &dent2->key, old_dir->i_ino,
&old_dentry->d_name);
dent2->inum = cpu_to_le64(0);
dent2->type = DT_UNKNOWN;
dent2->nlen = cpu_to_le16(old_dentry->d_name.len);
memcpy(dent2->name, old_dentry->d_name.name, old_dentry->d_name.len);
dent2->name[old_dentry->d_name.len] = '\0';
zero_dent_node_unused(dent2);
ubifs_prep_grp_node(c, dent2, dlen2, 0);
p = (void *)dent2 + aligned_dlen2;
if (new_inode) {
pack_inode(c, p, new_inode, 0, last_reference);
p += ALIGN(ilen, 8);
}
if (old_dir == new_dir)
pack_inode(c, p, old_dir, 1, 0);
else {
pack_inode(c, p, old_dir, 0, 0);
p += ALIGN(plen, 8);
pack_inode(c, p, new_dir, 1, 0);
}
err = make_reservation(c, BASEHD, len);
if (err)
goto out_free;
if (last_reference) {
err = ubifs_add_orphan(c, new_inode->i_ino);
if (err) {
release_head(c, BASEHD);
goto out_finish;
}
}
err = write_head(c, BASEHD, dent, len, &lnum, &offs, sync);
if (!sync && !err) {
struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
ubifs_wbuf_add_ino_nolock(wbuf, new_dir->i_ino);
ubifs_wbuf_add_ino_nolock(wbuf, old_dir->i_ino);
}
release_head(c, BASEHD);
if (err)
goto out_ro;
if (new_inode)
ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf,
new_inode->i_ino);
dent_key_init(c, &key, new_dir->i_ino, &new_dentry->d_name);
err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen1, &new_dentry->d_name);
if (err)
goto out_ro;
err = ubifs_add_dirt(c, lnum, dlen2);
if (err)
goto out_ro;
dent_key_init(c, &key, old_dir->i_ino, &old_dentry->d_name);
err = ubifs_tnc_remove_nm(c, &key, &old_dentry->d_name);
if (err)
goto out_ro;
offs += aligned_dlen1 + aligned_dlen2;
if (new_inode) {
ino_key_init(c, &key, new_inode->i_ino);
err = ubifs_tnc_add(c, &key, lnum, offs, ilen);
if (err)
goto out_ro;
offs += ALIGN(ilen, 8);
}
ino_key_init(c, &key, old_dir->i_ino);
err = ubifs_tnc_add(c, &key, lnum, offs, plen);
if (err)
goto out_ro;
if (old_dir != new_dir) {
offs += ALIGN(plen, 8);
ino_key_init(c, &key, new_dir->i_ino);
err = ubifs_tnc_add(c, &key, lnum, offs, plen);
if (err)
goto out_ro;
}
finish_reservation(c);
kfree(dent);
return 0;
out_ro:
ubifs_ro_mode(c, err);
if (last_reference)
ubifs_delete_orphan(c, new_inode->i_ino);
out_finish:
finish_reservation(c);
out_free:
kfree(dent);
return err;
}
/**
* ubifs_jrn_write_data - write a data node to the journal.
* @c: UBIFS file-system description object
* @inode: inode the data node belongs to
* @key: node key
* @buf: buffer to write
* @len: data length (must not exceed %UBIFS_BLOCK_SIZE)
*
* This function writes a data node to the journal. Returns %0 if the data node
* was successfully written, and a negative error code in case of failure.
*/
int ubifs_jrn_write_data(struct ubifs_info *c, const struct inode *inode,
const union ubifs_key *key, const void *buf, int len)
{
int err, lnum, offs, compr_type, out_len;
int dlen = UBIFS_DATA_NODE_SZ + UBIFS_BLOCK_SIZE * WORST_COMPR_FACTOR;
const struct ubifs_inode *ui = ubifs_inode(inode);
struct ubifs_data_node *data;
dbg_jrn_key(c, key, "ino %lu, blk %u, len %d, key ",
key_ino(c, key), key_block(c, key), len);
ubifs_assert(len <= UBIFS_BLOCK_SIZE);
data = kmalloc(dlen, GFP_NOFS);
if (!data)
return -ENOMEM;
data->ch.node_type = UBIFS_DATA_NODE;
key_write(c, key, &data->key);
data->size = cpu_to_le32(len);
zero_data_node_unused(data);
if (!(ui->flags && UBIFS_COMPR_FL))
/* Compression is disabled for this inode */
compr_type = UBIFS_COMPR_NONE;
else
compr_type = ui->compr_type;
out_len = dlen - UBIFS_DATA_NODE_SZ;
ubifs_compress(buf, len, &data->data, &out_len, &compr_type);
ubifs_assert(out_len <= UBIFS_BLOCK_SIZE);
dlen = UBIFS_DATA_NODE_SZ + out_len;
data->compr_type = cpu_to_le16(compr_type);
err = make_reservation(c, DATAHD, dlen);
if (err)
goto out_free;
err = write_node(c, DATAHD, data, dlen, &lnum, &offs);
if (!err)
ubifs_wbuf_add_ino_nolock(&c->jheads[DATAHD].wbuf,
key_ino(c, key));
release_head(c, DATAHD);
if (err)
goto out_ro;
err = ubifs_tnc_add(c, key, lnum, offs, dlen);
if (err)
goto out_ro;
finish_reservation(c);
kfree(data);
return 0;
out_ro:
ubifs_ro_mode(c, err);
finish_reservation(c);
out_free:
kfree(data);
return err;
}
/**
* ubifs_jrn_update - update inode.
* @c: UBIFS file-system description object
* @dir: parent inode or host inode in case of extended attributes
* @nm: directory entry name
* @inode: inode
* @deletion: indicates a directory entry deletion i.e unlink or rmdir
* @sync: non-zero if the write-buffer has to be synchronized
* @xent: non-zero if the directory entry is an extended attribute entry
*
* This function updates an inode by writing a directory entry (or extended
* attribute entry), the inode itself, and the parent directory inode (or the
* host inode) to the journal.
*
* The function writes the host inode @dir last, which is important in case of
* extended attributes. Indeed, then we guarantee that if the host inode gets
* synchronized, and the write-buffer it sits in gets flushed, the extended
* attribute inode gets flushed too. And this is exactly what the user expects -
* synchronizing the host inode synchronizes its extended attributes.
* Similarly, this guarantees that if @dir is synchronized, its directory entry
* corresponding to @nm gets synchronized too.
*
* This function returns %0 on success and a negative error code on failure.
*/
int ubifs_jrn_update(struct ubifs_info *c, const struct inode *dir,
const struct qstr *nm, const struct inode *inode,
int deletion, int sync, int xent)
{
int err, dlen, ilen, len, lnum, ino_offs, dent_offs;
int aligned_dlen, aligned_ilen;
int last_reference = !!(deletion && inode->i_nlink == 0);
struct ubifs_dent_node *dent;
struct ubifs_ino_node *ino;
union ubifs_key dent_key, ino_key;
dbg_jrn("ino %lu, dent '%.*s', data len %d in dir ino %lu",
inode->i_ino, nm->len, nm->name, ubifs_inode(inode)->data_len,
dir->i_ino);
ubifs_assert(ubifs_inode(dir)->data_len == 0);
dlen = UBIFS_DENT_NODE_SZ + nm->len + 1;
ilen = UBIFS_INO_NODE_SZ;
/*
* If the last reference to the inode is being deleted, then there is no
* need to attach and write inode data, it is being deleted anyway.
*/
if (!last_reference)
ilen += ubifs_inode(inode)->data_len;
aligned_dlen = ALIGN(dlen, 8);
aligned_ilen = ALIGN(ilen, 8);
len = aligned_dlen + aligned_ilen + UBIFS_INO_NODE_SZ;
dent = kmalloc(len, GFP_NOFS);
if (!dent)
return -ENOMEM;
if (!xent) {
dent->ch.node_type = UBIFS_DENT_NODE;
dent_key_init(c, &dent_key, dir->i_ino, nm);
} else {
dent->ch.node_type = UBIFS_XENT_NODE;
xent_key_init(c, &dent_key, dir->i_ino, nm);
}
key_write(c, &dent_key, dent->key);
dent->inum = deletion ? 0 : cpu_to_le64(inode->i_ino);
dent->type = get_dent_type(inode->i_mode);
dent->nlen = cpu_to_le16(nm->len);
memcpy(dent->name, nm->name, nm->len);
dent->name[nm->len] = '\0';
zero_dent_node_unused(dent);
ubifs_prep_grp_node(c, dent, dlen, 0);
ino = (void *)dent + aligned_dlen;
pack_inode(c, ino, inode, 0, last_reference);
ino = (void *)ino + aligned_ilen;
pack_inode(c, ino, dir, 1, 0);
err = make_reservation(c, BASEHD, len);
if (err)
goto out_free;
if (last_reference) {
err = ubifs_add_orphan(c, inode->i_ino);
if (err) {
release_head(c, BASEHD);
goto out_finish;
}
}
err = write_head(c, BASEHD, dent, len, &lnum, &dent_offs, sync);
if (!sync && !err) {
struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
ubifs_wbuf_add_ino_nolock(wbuf, inode->i_ino);
ubifs_wbuf_add_ino_nolock(wbuf, dir->i_ino);
}
release_head(c, BASEHD);
kfree(dent);
if (err)
goto out_ro;
if (deletion) {
err = ubifs_tnc_remove_nm(c, &dent_key, nm);
if (err)
goto out_ro;
err = ubifs_add_dirt(c, lnum, dlen);
} else
err = ubifs_tnc_add_nm(c, &dent_key, lnum, dent_offs, dlen, nm);
if (err)
goto out_ro;
/*
* Note, we do not remove the inode from TNC even if the last reference
* to it has just been deleted, because the inode may still be opened.
* Instead, the inode has been added to orphan lists and the orphan
* subsystem will take further care about it.
*/
ino_key_init(c, &ino_key, inode->i_ino);
ino_offs = dent_offs + aligned_dlen;
err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs, ilen);
if (err)
goto out_ro;
ino_key_init(c, &ino_key, dir->i_ino);
ino_offs += aligned_ilen;
err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs, UBIFS_INO_NODE_SZ);
if (err)
goto out_ro;
finish_reservation(c);
return 0;
out_finish:
finish_reservation(c);
out_free:
kfree(dent);
return err;
out_ro:
ubifs_ro_mode(c, err);
if (last_reference)
ubifs_delete_orphan(c, inode->i_ino);
finish_reservation(c);
return err;
}
int ubifs_jrn_delete_xattr(struct ubifs_info *c, const struct inode *host,
const struct inode *inode, const struct qstr *nm,
int sync)
{
int err, xlen, hlen, len, lnum, xent_offs, aligned_xlen;
struct ubifs_dent_node *xent;
struct ubifs_ino_node *ino;
union ubifs_key xent_key, key1, key2;
dbg_jrn("host %lu, xattr ino %lu, name '%s', data len %d",
host->i_ino, inode->i_ino, nm->name,
ubifs_inode(inode)->data_len);
ubifs_assert(inode->i_nlink == 0);
/*
* Since we are deleting the inode, we do not bother to attach any data
* to it and assume its length is %UBIFS_INO_NODE_SZ.
*/
xlen = UBIFS_DENT_NODE_SZ + nm->len + 1;
aligned_xlen = ALIGN(xlen, 8);
hlen = ubifs_inode(host)->data_len + UBIFS_INO_NODE_SZ;
len = aligned_xlen + UBIFS_INO_NODE_SZ + ALIGN(hlen, 8);
xent = kmalloc(len, GFP_NOFS);
if (!xent)
return -ENOMEM;
xent->ch.node_type = UBIFS_XENT_NODE;
xent_key_init(c, &xent_key, host->i_ino, nm);
key_write(c, &xent_key, xent->key);
xent->inum = 0;
xent->type = get_dent_type(inode->i_mode);
xent->nlen = cpu_to_le16(nm->len);
memcpy(xent->name, nm->name, nm->len);
xent->name[nm->len] = '\0';
zero_dent_node_unused(xent);
ubifs_prep_grp_node(c, xent, xlen, 0);
ino = (void *)xent + aligned_xlen;
pack_inode(c, ino, inode, 0, 1);
ino = (void *)ino + UBIFS_INO_NODE_SZ;
pack_inode(c, ino, host, 1, 0);
err = make_reservation(c, BASEHD, len);
if (err) {
kfree(xent);
return err;
}
err = write_head(c, BASEHD, xent, len, &lnum, &xent_offs, sync);
if (!sync && !err)
ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, host->i_ino);
release_head(c, BASEHD);
kfree(xent);
if (err)
goto out_ro;
/* Remove the extended attribute entry from TNC */
err = ubifs_tnc_remove_nm(c, &xent_key, nm);
if (err)
goto out_ro;
err = ubifs_add_dirt(c, lnum, xlen);
if (err)
goto out_ro;
/*
* Remove all nodes belonging to the extended attribute inode from TNC.
* Well, there actually must be only one node - the inode itself.
*/
lowest_ino_key(c, &key1, inode->i_ino);
highest_ino_key(c, &key2, inode->i_ino);
err = ubifs_tnc_remove_range(c, &key1, &key2);
if (err)
goto out_ro;
err = ubifs_add_dirt(c, lnum, UBIFS_INO_NODE_SZ);
if (err)
goto out_ro;
/* And update TNC with the new host inode position */
ino_key_init(c, &key1, host->i_ino);
err = ubifs_tnc_add(c, &key1, lnum, xent_offs + len - hlen, hlen);
if (err)
goto out_ro;
finish_reservation(c);
return 0;
out_ro:
ubifs_ro_mode(c, err);
finish_reservation(c);
return err;
}