ecryptfs: Delete 21 error messages for a failed memory allocation

Omit extra messages for a memory allocation failure in these functions.

This issue was detected by using the Coccinelle software.

Signed-off-by: Markus Elfring <elfring@users.sourceforge.net>
Signed-off-by: Tyler Hicks <tyhicks@canonical.com>

diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index 7acd57d..4a7ef33 100644 (file)
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -1419,8 +1419,6 @@ int ecryptfs_read_metadata(struct dentry *ecryptfs_dentry)
        page_virt = kmem_cache_alloc(ecryptfs_header_cache, GFP_USER);
        if (!page_virt) {
                rc = -ENOMEM;
-               printk(KERN_ERR "%s: Unable to allocate page_virt\n",
-                      __func__);
                goto out;
        }
        rc = ecryptfs_read_lower(page_virt, 0, crypt_stat->extent_size,
@@ -1507,9 +1505,6 @@ ecryptfs_encrypt_filename(struct ecryptfs_filename *filename,
                filename->encrypted_filename =
                        kmalloc(filename->encrypted_filename_size, GFP_KERNEL);
                if (!filename->encrypted_filename) {
-                       printk(KERN_ERR "%s: Out of memory whilst attempting "
-                              "to kmalloc [%zd] bytes\n", __func__,
-                              filename->encrypted_filename_size);
                        rc = -ENOMEM;
                        goto out;
                }
@@ -1658,8 +1653,6 @@ ecryptfs_add_new_key_tfm(struct ecryptfs_key_tfm **key_tfm, char *cipher_name,
                (*key_tfm) = tmp_tfm;
        if (!tmp_tfm) {
                rc = -ENOMEM;
-               printk(KERN_ERR "Error attempting to allocate from "
-                      "ecryptfs_key_tfm_cache\n");
                goto out;
        }
        mutex_init(&tmp_tfm->key_tfm_mutex);
@@ -1934,9 +1927,6 @@ int ecryptfs_encrypt_and_encode_filename(
 
                filename = kzalloc(sizeof(*filename), GFP_KERNEL);
                if (!filename) {
-                       printk(KERN_ERR "%s: Out of memory whilst attempting "
-                              "to kzalloc [%zd] bytes\n", __func__,
-                              sizeof(*filename));
                        rc = -ENOMEM;
                        goto out;
                }
@@ -1965,9 +1955,6 @@ int ecryptfs_encrypt_and_encode_filename(
                                 + encoded_name_no_prefix_size);
                (*encoded_name) = kmalloc((*encoded_name_size) + 1, GFP_KERNEL);
                if (!(*encoded_name)) {
-                       printk(KERN_ERR "%s: Out of memory whilst attempting "
-                              "to kzalloc [%zd] bytes\n", __func__,
-                              (*encoded_name_size));
                        rc = -ENOMEM;
                        kfree(filename->encrypted_filename);
                        kfree(filename);
@@ -2049,9 +2036,6 @@ int ecryptfs_decode_and_decrypt_filename(char **plaintext_name,
                                              name, name_size);
                decoded_name = kmalloc(decoded_name_size, GFP_KERNEL);
                if (!decoded_name) {
-                       printk(KERN_ERR "%s: Out of memory whilst attempting "
-                              "to kmalloc [%zd] bytes\n", __func__,
-                              decoded_name_size);
                        rc = -ENOMEM;
                        goto out;
                }

diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index efc2db4..93ed19a 100644 (file)
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -334,9 +334,6 @@ static struct dentry *ecryptfs_lookup_interpose(struct dentry *dentry,
 
        dentry_info = kmem_cache_alloc(ecryptfs_dentry_info_cache, GFP_KERNEL);
        if (!dentry_info) {
-               printk(KERN_ERR "%s: Out of memory whilst attempting "
-                      "to allocate ecryptfs_dentry_info struct\n",
-                       __func__);
                dput(lower_dentry);
                return ERR_PTR(-ENOMEM);
        }

diff --git a/fs/ecryptfs/keystore.c b/fs/ecryptfs/keystore.c
index 3eb1420..540952d 100644 (file)
--- a/fs/ecryptfs/keystore.c
+++ b/fs/ecryptfs/keystore.c
@@ -639,11 +639,9 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
        int rc = 0;
 
        s = kzalloc(sizeof(*s), GFP_KERNEL);
-       if (!s) {
-               printk(KERN_ERR "%s: Out of memory whilst trying to kmalloc "
-                      "[%zd] bytes of kernel memory\n", __func__, sizeof(*s));
+       if (!s)
                return -ENOMEM;
-       }
+
        (*packet_size) = 0;
        rc = ecryptfs_find_auth_tok_for_sig(
                &auth_tok_key,
@@ -714,9 +712,6 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
        s->block_aligned_filename = kzalloc(s->block_aligned_filename_size,
                                            GFP_KERNEL);
        if (!s->block_aligned_filename) {
-               printk(KERN_ERR "%s: Out of kernel memory whilst attempting to "
-                      "kzalloc [%zd] bytes\n", __func__,
-                      s->block_aligned_filename_size);
                rc = -ENOMEM;
                goto out_unlock;
        }
@@ -769,10 +764,6 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
        s->hash_desc = kmalloc(sizeof(*s->hash_desc) +
                               crypto_shash_descsize(s->hash_tfm), GFP_KERNEL);
        if (!s->hash_desc) {
-               printk(KERN_ERR "%s: Out of kernel memory whilst attempting to "
-                      "kmalloc [%zd] bytes\n", __func__,
-                      sizeof(*s->hash_desc) +
-                      crypto_shash_descsize(s->hash_tfm));
                rc = -ENOMEM;
                goto out_release_free_unlock;
        }
@@ -925,11 +916,9 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
        (*filename_size) = 0;
        (*filename) = NULL;
        s = kzalloc(sizeof(*s), GFP_KERNEL);
-       if (!s) {
-               printk(KERN_ERR "%s: Out of memory whilst trying to kmalloc "
-                      "[%zd] bytes of kernel memory\n", __func__, sizeof(*s));
+       if (!s)
                return -ENOMEM;
-       }
+
        if (max_packet_size < ECRYPTFS_TAG_70_MIN_METADATA_SIZE) {
                printk(KERN_WARNING "%s: max_packet_size is [%zd]; it must be "
                       "at least [%d]\n", __func__, max_packet_size,
@@ -1015,9 +1004,6 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
        s->decrypted_filename = kmalloc(s->block_aligned_filename_size,
                                        GFP_KERNEL);
        if (!s->decrypted_filename) {
-               printk(KERN_ERR "%s: Out of memory whilst attempting to "
-                      "kmalloc [%zd] bytes\n", __func__,
-                      s->block_aligned_filename_size);
                rc = -ENOMEM;
                goto out_unlock;
        }
@@ -1097,9 +1083,6 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
        }
        (*filename) = kmalloc(((*filename_size) + 1), GFP_KERNEL);
        if (!(*filename)) {
-               printk(KERN_ERR "%s: Out of memory whilst attempting to "
-                      "kmalloc [%zd] bytes\n", __func__,
-                      ((*filename_size) + 1));
                rc = -ENOMEM;
                goto out_free_unlock;
        }
@@ -2525,11 +2508,9 @@ int ecryptfs_add_keysig(struct ecryptfs_crypt_stat *crypt_stat, char *sig)
        struct ecryptfs_key_sig *new_key_sig;
 
        new_key_sig = kmem_cache_alloc(ecryptfs_key_sig_cache, GFP_KERNEL);
-       if (!new_key_sig) {
-               printk(KERN_ERR
-                      "Error allocating from ecryptfs_key_sig_cache\n");
+       if (!new_key_sig)
                return -ENOMEM;
-       }
+
        memcpy(new_key_sig->keysig, sig, ECRYPTFS_SIG_SIZE_HEX);
        new_key_sig->keysig[ECRYPTFS_SIG_SIZE_HEX] = '\0';
        /* Caller must hold keysig_list_mutex */
@@ -2551,8 +2532,6 @@ ecryptfs_add_global_auth_tok(struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
                                        GFP_KERNEL);
        if (!new_auth_tok) {
                rc = -ENOMEM;
-               printk(KERN_ERR "Error allocating from "
-                      "ecryptfs_global_auth_tok_cache\n");
                goto out;
        }
        memcpy(new_auth_tok->sig, sig, ECRYPTFS_SIG_SIZE_HEX);

diff --git a/fs/ecryptfs/messaging.c b/fs/ecryptfs/messaging.c
index 4f457d5..9fdd5bc 100644 (file)
--- a/fs/ecryptfs/messaging.c
+++ b/fs/ecryptfs/messaging.c
@@ -147,8 +147,6 @@ ecryptfs_spawn_daemon(struct ecryptfs_daemon **daemon, struct file *file)
        (*daemon) = kzalloc(sizeof(**daemon), GFP_KERNEL);
        if (!(*daemon)) {
                rc = -ENOMEM;
-               printk(KERN_ERR "%s: Failed to allocate [%zd] bytes of "
-                      "GFP_KERNEL memory\n", __func__, sizeof(**daemon));
                goto out;
        }
        (*daemon)->file = file;
@@ -250,8 +248,6 @@ int ecryptfs_process_response(struct ecryptfs_daemon *daemon,
        msg_ctx->msg = kmemdup(msg, msg_size, GFP_KERNEL);
        if (!msg_ctx->msg) {
                rc = -ENOMEM;
-               printk(KERN_ERR "%s: Failed to allocate [%zd] bytes of "
-                      "GFP_KERNEL memory\n", __func__, msg_size);
                goto unlock;
        }
        msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_DONE;
@@ -386,7 +382,6 @@ int __init ecryptfs_init_messaging(void)
                                       GFP_KERNEL);
        if (!ecryptfs_daemon_hash) {
                rc = -ENOMEM;
-               printk(KERN_ERR "%s: Failed to allocate memory\n", __func__);
                mutex_unlock(&ecryptfs_daemon_hash_mux);
                goto out;
        }
@@ -398,7 +393,6 @@ int __init ecryptfs_init_messaging(void)
                                       GFP_KERNEL);
        if (!ecryptfs_msg_ctx_arr) {
                rc = -ENOMEM;
-               printk(KERN_ERR "%s: Failed to allocate memory\n", __func__);
                goto out;
        }
        mutex_init(&ecryptfs_msg_ctx_lists_mux);

diff --git a/fs/ecryptfs/miscdev.c b/fs/ecryptfs/miscdev.c
index 595e684..f09caca 100644 (file)
--- a/fs/ecryptfs/miscdev.c
+++ b/fs/ecryptfs/miscdev.c
@@ -163,12 +163,8 @@ int ecryptfs_send_miscdev(char *data, size_t data_size,
        struct ecryptfs_message *msg;
 
        msg = kmalloc((sizeof(*msg) + data_size), GFP_KERNEL);
-       if (!msg) {
-               printk(KERN_ERR "%s: Out of memory whilst attempting "
-                      "to kmalloc(%zd, GFP_KERNEL)\n", __func__,
-                      (sizeof(*msg) + data_size));
+       if (!msg)
                return -ENOMEM;
-       }
 
        mutex_lock(&msg_ctx->mux);
        msg_ctx->msg = msg;

diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 1f0c471..cdf358b 100644 (file)
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -431,8 +431,6 @@ static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
        }
        xattr_virt = kmem_cache_alloc(ecryptfs_xattr_cache, GFP_KERNEL);
        if (!xattr_virt) {
-               printk(KERN_ERR "Out of memory whilst attempting to write "
-                      "inode size to xattr\n");
                rc = -ENOMEM;
                goto out;
        }