github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-09-22 04:34:03 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

fsverity: simplify handling of errors during initcall

Browse Source 
Since CONFIG_FS_VERITY is a bool, not a tristate, fs/verity/ can only be
builtin or absent entirely; it can't be a loadable module.  Therefore,
the error code that gets returned from the fsverity_init() initcall is
never used.  If any part of the initcall does fail, which should never
happen, the kernel will be left in a bad state.

Following the usual convention for builtin code, just panic the kernel
if any of part of the initcall fails.

Link: https://lore.kernel.org/r/20230705212743.42180-2-ebiggers@kernel.org
Signed-off-by: Eric Biggers <ebiggers@google.com>
This commit is contained in:
Eric Biggers 2023-07-05 14:27:42 -07:00
parent 5d37a11980
commit e77000ccc5
5 changed files with 28 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
fs/verity/fsverity_private.h
View File

@ -118,8 +118,7 @@ void fsverity_free_info(struct fsverity_info *vi);
int fsverity_get_descriptor(struct inode *inode, int fsverity_get_descriptor(struct inode *inode,
struct fsverity_descriptor **desc_ret); struct fsverity_descriptor **desc_ret);
int __init fsverity_init_info_cache(void); void __init fsverity_init_info_cache(void);
void __init fsverity_exit_info_cache(void);
/* signature.c */ /* signature.c */
@ -127,7 +126,7 @@ void __init fsverity_exit_info_cache(void);
int fsverity_verify_signature(const struct fsverity_info *vi, int fsverity_verify_signature(const struct fsverity_info *vi,
const u8 *signature, size_t sig_size); const u8 *signature, size_t sig_size);
int __init fsverity_init_signature(void); void __init fsverity_init_signature(void);
#else /* !CONFIG_FS_VERITY_BUILTIN_SIGNATURES */ #else /* !CONFIG_FS_VERITY_BUILTIN_SIGNATURES */
static inline int static inline int
fsverity_verify_signature(const struct fsverity_info *vi, fsverity_verify_signature(const struct fsverity_info *vi,
@ -136,15 +135,13 @@ fsverity_verify_signature(const struct fsverity_info *vi,
return 0; return 0;
} }
static inline int fsverity_init_signature(void) static inline void fsverity_init_signature(void)
{ {
return 0;
} }
#endif /* !CONFIG_FS_VERITY_BUILTIN_SIGNATURES */ #endif /* !CONFIG_FS_VERITY_BUILTIN_SIGNATURES */
/* verify.c */ /* verify.c */
int __init fsverity_init_workqueue(void); void __init fsverity_init_workqueue(void);
void __init fsverity_exit_workqueue(void);
#endif /* _FSVERITY_PRIVATE_H */ #endif /* _FSVERITY_PRIVATE_H */

24
fs/verity/init.c
View File

@ -33,28 +33,10 @@ void fsverity_msg(const struct inode *inode, const char *level,
static int __init fsverity_init(void) static int __init fsverity_init(void)
{ {
int err;
fsverity_check_hash_algs(); fsverity_check_hash_algs();
fsverity_init_info_cache();
err = fsverity_init_info_cache(); fsverity_init_workqueue();
if (err) fsverity_init_signature();
return err;
err = fsverity_init_workqueue();
if (err)
goto err_exit_info_cache;
err = fsverity_init_signature();
if (err)
goto err_exit_workqueue;
return 0; return 0;
err_exit_workqueue:
fsverity_exit_workqueue();
err_exit_info_cache:
fsverity_exit_info_cache();
return err;
} }
late_initcall(fsverity_init) late_initcall(fsverity_init)

18
fs/verity/open.c
View File

@ -408,18 +408,10 @@ void __fsverity_cleanup_inode(struct inode *inode)
} }
EXPORT_SYMBOL_GPL(__fsverity_cleanup_inode); EXPORT_SYMBOL_GPL(__fsverity_cleanup_inode);
int __init fsverity_init_info_cache(void) void __init fsverity_init_info_cache(void)
{ {
fsverity_info_cachep = KMEM_CACHE_USERCOPY(fsverity_info, fsverity_info_cachep = KMEM_CACHE_USERCOPY(
SLAB_RECLAIM_ACCOUNT, fsverity_info,
file_digest); SLAB_RECLAIM_ACCOUNT | SLAB_PANIC,
if (!fsverity_info_cachep) file_digest);
return -ENOMEM;
return 0;
}
void __init fsverity_exit_info_cache(void)
{
kmem_cache_destroy(fsverity_info_cachep);
fsverity_info_cachep = NULL;
} }

42
fs/verity/signature.c
View File

@ -109,43 +109,29 @@ static struct ctl_table fsverity_sysctl_table[] = {
{ } { }
}; };
static int __init fsverity_sysctl_init(void) static void __init fsverity_sysctl_init(void)
{ {
fsverity_sysctl_header = register_sysctl("fs/verity", fsverity_sysctl_table); fsverity_sysctl_header = register_sysctl("fs/verity",
if (!fsverity_sysctl_header) { fsverity_sysctl_table);
pr_err("sysctl registration failed!\n"); if (!fsverity_sysctl_header)
return -ENOMEM; panic("fsverity sysctl registration failed");
}
return 0;
} }
#else /* !CONFIG_SYSCTL */ #else /* !CONFIG_SYSCTL */
static inline int __init fsverity_sysctl_init(void) static inline void fsverity_sysctl_init(void)
{ {
return 0;
} }
#endif /* !CONFIG_SYSCTL */ #endif /* !CONFIG_SYSCTL */
int __init fsverity_init_signature(void) void __init fsverity_init_signature(void)
{ {
struct key *ring; fsverity_keyring =
int err; keyring_alloc(".fs-verity", KUIDT_INIT(0), KGIDT_INIT(0),
current_cred(), KEY_POS_SEARCH |
ring = keyring_alloc(".fs-verity", KUIDT_INIT(0), KGIDT_INIT(0),
current_cred(), KEY_POS_SEARCH |
KEY_USR_VIEW | KEY_USR_READ | KEY_USR_WRITE | KEY_USR_VIEW | KEY_USR_READ | KEY_USR_WRITE |
KEY_USR_SEARCH | KEY_USR_SETATTR, KEY_USR_SEARCH | KEY_USR_SETATTR,
KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL); KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL);
if (IS_ERR(ring)) if (IS_ERR(fsverity_keyring))
return PTR_ERR(ring); panic("failed to allocate \".fs-verity\" keyring");
err = fsverity_sysctl_init(); fsverity_sysctl_init();
if (err)
goto err_put_ring;
fsverity_keyring = ring;
return 0;
err_put_ring:
key_put(ring);
return err;
} }

11
fs/verity/verify.c
View File

@ -346,7 +346,7 @@ void fsverity_enqueue_verify_work(struct work_struct *work)
} }
EXPORT_SYMBOL_GPL(fsverity_enqueue_verify_work); EXPORT_SYMBOL_GPL(fsverity_enqueue_verify_work);
int __init fsverity_init_workqueue(void) void __init fsverity_init_workqueue(void)
{ {
/* /*
* Use a high-priority workqueue to prioritize verification work, which * Use a high-priority workqueue to prioritize verification work, which
@ -360,12 +360,5 @@ int __init fsverity_init_workqueue(void)
WQ_HIGHPRI, WQ_HIGHPRI,
num_online_cpus()); num_online_cpus());
if (!fsverity_read_workqueue) if (!fsverity_read_workqueue)
return -ENOMEM; panic("failed to allocate fsverity_read_queue");
return 0;
}
void __init fsverity_exit_workqueue(void)
{
destroy_workqueue(fsverity_read_workqueue);
fsverity_read_workqueue = NULL;
} }