Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1a0bba4f authored by Markus Elfring's avatar Markus Elfring Committed by Tyler Hicks
Browse files

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: default avatarMarkus Elfring <elfring@users.sourceforge.net>
Signed-off-by: default avatarTyler Hicks <tyhicks@canonical.com>
parent db86be3a

fs/ecryptfs/crypto.c

+0 −16
Original line number Diff line number Diff line
@@ -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;

		}

fs/ecryptfs/inode.c

+0 −3
Original line number Diff line number Diff line
@@ -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);

	}

fs/ecryptfs/keystore.c

+6 −27
Original line number Diff line number Diff line
@@ -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);

fs/ecryptfs/messaging.c

+0 −6
Original line number Diff line number Diff line
@@ -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);

fs/ecryptfs/miscdev.c

+1 −5
Original line number Diff line number Diff line
@@ -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;