Merge tag 'random-6.1-rc1-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...

[platform/kernel/linux-starfive.git] / fs / ubifs / journal.c

diff --git a/fs/ubifs/journal.c b/fs/ubifs/journal.c
index 75dab0a..d025099 100644 (file)
--- a/fs/ubifs/journal.c
+++ b/fs/ubifs/journal.c
@@ -503,7 +503,7 @@ static void mark_inode_clean(struct ubifs_info *c, struct ubifs_inode *ui)
 static void set_dent_cookie(struct ubifs_info *c, struct ubifs_dent_node *dent)
 {
        if (c->double_hash)
-               dent->cookie = (__force __le32) prandom_u32();
+               dent->cookie = (__force __le32) get_random_u32();
        else
                dent->cookie = 0;
 }
@@ -1472,23 +1472,25 @@ out_free:
  * @block: data block number
  * @dn: data node to re-compress
  * @new_len: new length
+ * @dn_size: size of the data node @dn in memory
  *
  * This function is used when an inode is truncated and the last data node of
  * the inode has to be re-compressed/encrypted and re-written.
  */
 static int truncate_data_node(const struct ubifs_info *c, const struct inode *inode,
                              unsigned int block, struct ubifs_data_node *dn,
-                             int *new_len)
+                             int *new_len, int dn_size)
 {
        void *buf;
-       int err, dlen, compr_type, out_len, old_dlen;
+       int err, dlen, compr_type, out_len, data_size;
 
        out_len = le32_to_cpu(dn->size);
        buf = kmalloc_array(out_len, WORST_COMPR_FACTOR, GFP_NOFS);
        if (!buf)
                return -ENOMEM;
 
-       dlen = old_dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
+       dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
+       data_size = dn_size - UBIFS_DATA_NODE_SZ;
        compr_type = le16_to_cpu(dn->compr_type);
 
        if (IS_ENCRYPTED(inode)) {
@@ -1508,11 +1510,11 @@ static int truncate_data_node(const struct ubifs_info *c, const struct inode *in
        }
 
        if (IS_ENCRYPTED(inode)) {
-               err = ubifs_encrypt(inode, dn, out_len, &old_dlen, block);
+               err = ubifs_encrypt(inode, dn, out_len, &data_size, block);
                if (err)
                        goto out;
 
-               out_len = old_dlen;
+               out_len = data_size;
        } else {
                dn->compr_size = 0;
        }
@@ -1550,6 +1552,7 @@ int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode,
        struct ubifs_trun_node *trun;
        struct ubifs_data_node *dn;
        int err, dlen, len, lnum, offs, bit, sz, sync = IS_SYNC(inode);
+       int dn_size;
        struct ubifs_inode *ui = ubifs_inode(inode);
        ino_t inum = inode->i_ino;
        unsigned int blk;
@@ -1562,10 +1565,13 @@ int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode,
        ubifs_assert(c, S_ISREG(inode->i_mode));
        ubifs_assert(c, mutex_is_locked(&ui->ui_mutex));
 
-       sz = UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ +
-            UBIFS_MAX_DATA_NODE_SZ * WORST_COMPR_FACTOR;
+       dn_size = COMPRESSED_DATA_NODE_BUF_SZ;
 
-       sz += ubifs_auth_node_sz(c);
+       if (IS_ENCRYPTED(inode))
+               dn_size += UBIFS_CIPHER_BLOCK_SIZE;
+
+       sz =  UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ +
+               dn_size + ubifs_auth_node_sz(c);
 
        ino = kmalloc(sz, GFP_NOFS);
        if (!ino)
@@ -1596,15 +1602,15 @@ int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode,
                        if (dn_len <= 0 || dn_len > UBIFS_BLOCK_SIZE) {
                                ubifs_err(c, "bad data node (block %u, inode %lu)",
                                          blk, inode->i_ino);
-                               ubifs_dump_node(c, dn, sz - UBIFS_INO_NODE_SZ -
-                                               UBIFS_TRUN_NODE_SZ);
+                               ubifs_dump_node(c, dn, dn_size);
                                goto out_free;
                        }
 
                        if (dn_len <= dlen)
                                dlen = 0; /* Nothing to do */
                        else {
-                               err = truncate_data_node(c, inode, blk, dn, &dlen);
+                               err = truncate_data_node(c, inode, blk, dn,
+                                               &dlen, dn_size);
                                if (err)
                                        goto out_free;
                        }