hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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>
This commit is contained in:
Markus Elfring 2017-08-19 17:37:30 +02:00 committed by Tyler Hicks
parent db86be3a12
commit 1a0bba4ff0
6 changed files with 7 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
fs/ecryptfs/crypto.c
View File

@ -1419,8 +1419,6 @@ int ecryptfs_read_metadata(struct dentry *ecryptfs_dentry)
page_virt = kmem_cache_alloc(ecryptfs_header_cache, GFP_USER); page_virt = kmem_cache_alloc(ecryptfs_header_cache, GFP_USER);
if (!page_virt) { if (!page_virt) {
rc = -ENOMEM; rc = -ENOMEM;
printk(KERN_ERR "%s: Unable to allocate page_virt\n",
__func__);
goto out; goto out;
} }
rc = ecryptfs_read_lower(page_virt, 0, crypt_stat->extent_size, 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 = filename->encrypted_filename =
kmalloc(filename->encrypted_filename_size, GFP_KERNEL); kmalloc(filename->encrypted_filename_size, GFP_KERNEL);
if (!filename->encrypted_filename) { 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; rc = -ENOMEM;
goto out; goto out;
} }
@ -1658,8 +1653,6 @@ ecryptfs_add_new_key_tfm(struct ecryptfs_key_tfm **key_tfm, char *cipher_name,
(*key_tfm) = tmp_tfm; (*key_tfm) = tmp_tfm;
if (!tmp_tfm) { if (!tmp_tfm) {
rc = -ENOMEM; rc = -ENOMEM;
printk(KERN_ERR "Error attempting to allocate from "
"ecryptfs_key_tfm_cache\n");
goto out; goto out;
} }
mutex_init(&tmp_tfm->key_tfm_mutex); mutex_init(&tmp_tfm->key_tfm_mutex);
@ -1934,9 +1927,6 @@ int ecryptfs_encrypt_and_encode_filename(
filename = kzalloc(sizeof(*filename), GFP_KERNEL); filename = kzalloc(sizeof(*filename), GFP_KERNEL);
if (!filename) { if (!filename) {
printk(KERN_ERR "%s: Out of memory whilst attempting "
"to kzalloc [%zd] bytes\n", __func__,
sizeof(*filename));
rc = -ENOMEM; rc = -ENOMEM;
goto out; goto out;
} }
@ -1965,9 +1955,6 @@ int ecryptfs_encrypt_and_encode_filename(
+ encoded_name_no_prefix_size); + encoded_name_no_prefix_size);
(*encoded_name) = kmalloc((*encoded_name_size) + 1, GFP_KERNEL); (*encoded_name) = kmalloc((*encoded_name_size) + 1, GFP_KERNEL);
if (!(*encoded_name)) { if (!(*encoded_name)) {
printk(KERN_ERR "%s: Out of memory whilst attempting "
"to kzalloc [%zd] bytes\n", __func__,
(*encoded_name_size));
rc = -ENOMEM; rc = -ENOMEM;
kfree(filename->encrypted_filename); kfree(filename->encrypted_filename);
kfree(filename); kfree(filename);
@ -2049,9 +2036,6 @@ int ecryptfs_decode_and_decrypt_filename(char **plaintext_name,
name, name_size); name, name_size);
decoded_name = kmalloc(decoded_name_size, GFP_KERNEL); decoded_name = kmalloc(decoded_name_size, GFP_KERNEL);
if (!decoded_name) { if (!decoded_name) {
printk(KERN_ERR "%s: Out of memory whilst attempting "
"to kmalloc [%zd] bytes\n", __func__,
decoded_name_size);
rc = -ENOMEM; rc = -ENOMEM;
goto out; goto out;
} }

3
fs/ecryptfs/inode.c
View File

@ -334,9 +334,6 @@ static struct dentry *ecryptfs_lookup_interpose(struct dentry *dentry,
dentry_info = kmem_cache_alloc(ecryptfs_dentry_info_cache, GFP_KERNEL); dentry_info = kmem_cache_alloc(ecryptfs_dentry_info_cache, GFP_KERNEL);
if (!dentry_info) { if (!dentry_info) {
printk(KERN_ERR "%s: Out of memory whilst attempting "
"to allocate ecryptfs_dentry_info struct\n",
__func__);
dput(lower_dentry); dput(lower_dentry);
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
} }

33
fs/ecryptfs/keystore.c
View File

@ -639,11 +639,9 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
int rc = 0; int rc = 0;
s = kzalloc(sizeof(*s), GFP_KERNEL); s = kzalloc(sizeof(*s), GFP_KERNEL);
if (!s) { if (!s)
printk(KERN_ERR "%s: Out of memory whilst trying to kmalloc "
"[%zd] bytes of kernel memory\n", __func__, sizeof(*s));
return -ENOMEM; return -ENOMEM;
}
(*packet_size) = 0; (*packet_size) = 0;
rc = ecryptfs_find_auth_tok_for_sig( rc = ecryptfs_find_auth_tok_for_sig(
&auth_tok_key, &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, s->block_aligned_filename = kzalloc(s->block_aligned_filename_size,
GFP_KERNEL); GFP_KERNEL);
if (!s->block_aligned_filename) { 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; rc = -ENOMEM;
goto out_unlock; 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) + s->hash_desc = kmalloc(sizeof(*s->hash_desc) +
crypto_shash_descsize(s->hash_tfm), GFP_KERNEL); crypto_shash_descsize(s->hash_tfm), GFP_KERNEL);
if (!s->hash_desc) { 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; rc = -ENOMEM;
goto out_release_free_unlock; goto out_release_free_unlock;
} }
@ -925,11 +916,9 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
(*filename_size) = 0; (*filename_size) = 0;
(*filename) = NULL; (*filename) = NULL;
s = kzalloc(sizeof(*s), GFP_KERNEL); s = kzalloc(sizeof(*s), GFP_KERNEL);
if (!s) { if (!s)
printk(KERN_ERR "%s: Out of memory whilst trying to kmalloc "
"[%zd] bytes of kernel memory\n", __func__, sizeof(*s));
return -ENOMEM; return -ENOMEM;
}
if (max_packet_size < ECRYPTFS_TAG_70_MIN_METADATA_SIZE) { if (max_packet_size < ECRYPTFS_TAG_70_MIN_METADATA_SIZE) {
printk(KERN_WARNING "%s: max_packet_size is [%zd]; it must be " printk(KERN_WARNING "%s: max_packet_size is [%zd]; it must be "
"at least [%d]\n", __func__, max_packet_size, "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, s->decrypted_filename = kmalloc(s->block_aligned_filename_size,
GFP_KERNEL); GFP_KERNEL);
if (!s->decrypted_filename) { 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; rc = -ENOMEM;
goto out_unlock; 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); (*filename) = kmalloc(((*filename_size) + 1), GFP_KERNEL);
if (!(*filename)) { if (!(*filename)) {
printk(KERN_ERR "%s: Out of memory whilst attempting to "
"kmalloc [%zd] bytes\n", __func__,
((*filename_size) + 1));
rc = -ENOMEM; rc = -ENOMEM;
goto out_free_unlock; 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; struct ecryptfs_key_sig *new_key_sig;
new_key_sig = kmem_cache_alloc(ecryptfs_key_sig_cache, GFP_KERNEL); new_key_sig = kmem_cache_alloc(ecryptfs_key_sig_cache, GFP_KERNEL);
if (!new_key_sig) { if (!new_key_sig)
printk(KERN_ERR
"Error allocating from ecryptfs_key_sig_cache\n");
return -ENOMEM; return -ENOMEM;
}
memcpy(new_key_sig->keysig, sig, ECRYPTFS_SIG_SIZE_HEX); memcpy(new_key_sig->keysig, sig, ECRYPTFS_SIG_SIZE_HEX);
new_key_sig->keysig[ECRYPTFS_SIG_SIZE_HEX] = '\0'; new_key_sig->keysig[ECRYPTFS_SIG_SIZE_HEX] = '\0';
/* Caller must hold keysig_list_mutex */ /* 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); GFP_KERNEL);
if (!new_auth_tok) { if (!new_auth_tok) {
rc = -ENOMEM; rc = -ENOMEM;
printk(KERN_ERR "Error allocating from "
"ecryptfs_global_auth_tok_cache\n");
goto out; goto out;
} }
memcpy(new_auth_tok->sig, sig, ECRYPTFS_SIG_SIZE_HEX); memcpy(new_auth_tok->sig, sig, ECRYPTFS_SIG_SIZE_HEX);

6
fs/ecryptfs/messaging.c
View File

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

6
fs/ecryptfs/miscdev.c
View File

@ -163,12 +163,8 @@ int ecryptfs_send_miscdev(char *data, size_t data_size,
struct ecryptfs_message *msg; struct ecryptfs_message *msg;
msg = kmalloc((sizeof(*msg) + data_size), GFP_KERNEL); msg = kmalloc((sizeof(*msg) + data_size), GFP_KERNEL);
if (!msg) { if (!msg)
printk(KERN_ERR "%s: Out of memory whilst attempting "
"to kmalloc(%zd, GFP_KERNEL)\n", __func__,
(sizeof(*msg) + data_size));
return -ENOMEM; return -ENOMEM;
}
mutex_lock(&msg_ctx->mux); mutex_lock(&msg_ctx->mux);
msg_ctx->msg = msg; msg_ctx->msg = msg;

2
fs/ecryptfs/mmap.c
View File

@ -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); xattr_virt = kmem_cache_alloc(ecryptfs_xattr_cache, GFP_KERNEL);
if (!xattr_virt) { if (!xattr_virt) {
printk(KERN_ERR "Out of memory whilst attempting to write "
"inode size to xattr\n");
rc = -ENOMEM; rc = -ENOMEM;
goto out; goto out;
} }