// SPDX-License-Identifier: GPL-2.0-only#include <linux/codetag.h>#include <linux/idr.h>#include <linux/kallsyms.h>#include <linux/module.h>#include <linux/seq_buf.h>#include <linux/slab.h>#include <linux/vmalloc.h> struct codetag_type {	struct list_head link;	unsigned int count;	struct idr mod_idr;	/*	 * protects mod_idr, next_mod_seq,	 * iter->mod_seq and cmod->mod_seq	 */	struct rw_semaphore mod_lock;	struct codetag_type_desc desc;	/* generates unique sequence number for module load */	unsigned long next_mod_seq;}; struct codetag_range {	struct codetag *start;	struct codetag *stop;}; struct codetag_module {	struct module *mod;	struct codetag_range range;	unsigned long mod_seq;}; static DEFINE_MUTEX(codetag_lock);static LIST_HEAD(codetag_types); void codetag_lock_module_list(struct codetag_type *cttype, bool lock){	if (lock)		down_read(&cttype->mod_lock);	else		up_read(&cttype->mod_lock);} bool codetag_trylock_module_list(struct codetag_type *cttype){	return down_read_trylock(&cttype->mod_lock) != 0;} struct codetag_iterator codetag_get_ct_iter(struct codetag_type *cttype){	struct codetag_iterator iter = {		.cttype = cttype,		.cmod = NULL,		.mod_id = 0,		.ct = NULL,		.mod_seq = 0,	}; 	return iter;} static inline struct codetag *get_first_module_ct(struct codetag_module *cmod){	return cmod->range.start < cmod->range.stop ? cmod->range.start : NULL;} static inlinestruct codetag *get_next_module_ct(struct codetag_iterator *iter){	struct codetag *res = (struct codetag *)			((char *)iter->ct + iter->cttype->desc.tag_size); 	return res < iter->cmod->range.stop ? res : NULL;} struct codetag *codetag_next_ct(struct codetag_iterator *iter){	struct codetag_type *cttype = iter->cttype;	struct codetag_module *cmod;	struct codetag *ct; 	lockdep_assert_held(&cttype->mod_lock); 	if (unlikely(idr_is_empty(&cttype->mod_idr)))		return NULL; 	ct = NULL;	while (true) {		cmod = idr_find(&cttype->mod_idr, iter->mod_id); 		/* If module was removed move to the next one */		if (!cmod)			cmod = idr_get_next_ul(&cttype->mod_idr,					       &iter->mod_id); 		/* Exit if no more modules */		if (!cmod)			break; 		if (!iter->cmod || iter->mod_seq != cmod->mod_seq) {			iter->cmod = cmod;			iter->mod_seq = cmod->mod_seq;			ct = get_first_module_ct(cmod);		} else {			ct = get_next_module_ct(iter);		} 		if (ct)			break; 		iter->mod_id++;	} 	iter->ct = ct;	return ct;} void codetag_to_text(struct seq_buf *out, struct codetag *ct){	if (ct->modname)		seq_buf_printf(out, "%s:%u [%s] func:%s",			       ct->filename, ct->lineno,			       ct->modname, ct->function);	else		seq_buf_printf(out, "%s:%u func:%s",			       ct->filename, ct->lineno, ct->function);} static inline size_t range_size(const struct codetag_type *cttype,				const struct codetag_range *range){	return ((char *)range->stop - (char *)range->start) /			cttype->desc.tag_size;} static void *get_symbol(struct module *mod, const char *prefix, const char *name){	DECLARE_SEQ_BUF(sb, KSYM_NAME_LEN);	const char *buf;	void *ret; 	seq_buf_printf(&sb, "%s%s", prefix, name);	if (seq_buf_has_overflowed(&sb))		return NULL; 	buf = seq_buf_str(&sb);	preempt_disable();	ret = mod ?		(void *)find_kallsyms_symbol_value(mod, buf) :		(void *)kallsyms_lookup_name(buf);	preempt_enable(); 	return ret;} static struct codetag_range get_section_range(struct module *mod,					      const char *section){	return (struct codetag_range) {		get_symbol(mod, CODETAG_SECTION_START_PREFIX, section),		get_symbol(mod, CODETAG_SECTION_STOP_PREFIX, section),	};} static const char *get_mod_name(__maybe_unused struct module *mod){#ifdef CONFIG_MODULES	if (mod)		return mod->name;#endif	return "(built-in)";} static int codetag_module_init(struct codetag_type *cttype, struct module *mod){	struct codetag_range range;	struct codetag_module *cmod;	int mod_id;	int err; 	range = get_section_range(mod, cttype->desc.section);	if (!range.start || !range.stop) {		pr_warn("Failed to load code tags of type %s from the module %s\n",			cttype->desc.section, get_mod_name(mod));		return -EINVAL;	} 	/* Ignore empty ranges */	if (range.start == range.stop)		return 0; 	BUG_ON(range.start > range.stop); 	cmod = kmalloc(sizeof(*cmod), GFP_KERNEL);	if (unlikely(!cmod))		return -ENOMEM; 	cmod->mod = mod;	cmod->range = range; 	down_write(&cttype->mod_lock);	cmod->mod_seq = ++cttype->next_mod_seq;	mod_id = idr_alloc(&cttype->mod_idr, cmod, 0, 0, GFP_KERNEL);	if (mod_id >= 0) {		if (cttype->desc.module_load) {			err = cttype->desc.module_load(mod, range.start, range.stop);			if (!err)				cttype->count += range_size(cttype, &range);			else				idr_remove(&cttype->mod_idr, mod_id);		} else {			cttype->count += range_size(cttype, &range);			err = 0;		}	} else {		err = mod_id;	}	up_write(&cttype->mod_lock); 	if (err < 0) {		kfree(cmod);		return err;	} 	return 0;} #ifdef CONFIG_MODULES#define CODETAG_SECTION_PREFIX	".codetag." /* Some codetag types need a separate module section */bool codetag_needs_module_section(struct module *mod, const char *name,				  unsigned long size){	const char *type_name;	struct codetag_type *cttype;	bool ret = false; 	if (strncmp(name, CODETAG_SECTION_PREFIX, strlen(CODETAG_SECTION_PREFIX)))		return false; 	type_name = name + strlen(CODETAG_SECTION_PREFIX);	mutex_lock(&codetag_lock);	list_for_each_entry(cttype, &codetag_types, link) {		if (strcmp(type_name, cttype->desc.section) == 0) {			if (!cttype->desc.needs_section_mem)				break; 			down_write(&cttype->mod_lock);			ret = cttype->desc.needs_section_mem(mod, size);			up_write(&cttype->mod_lock);			break;		}	}	mutex_unlock(&codetag_lock); 	return ret;} void *codetag_alloc_module_section(struct module *mod, const char *name,				   unsigned long size, unsigned int prepend,				   unsigned long align){	const char *type_name = name + strlen(CODETAG_SECTION_PREFIX);	struct codetag_type *cttype;	void *ret = ERR_PTR(-EINVAL); 	mutex_lock(&codetag_lock);	list_for_each_entry(cttype, &codetag_types, link) {		if (strcmp(type_name, cttype->desc.section) == 0) {			if (WARN_ON(!cttype->desc.alloc_section_mem))				break; 			down_write(&cttype->mod_lock);			ret = cttype->desc.alloc_section_mem(mod, size, prepend, align);			up_write(&cttype->mod_lock);			break;		}	}	mutex_unlock(&codetag_lock); 	return ret;} void codetag_free_module_sections(struct module *mod){	struct codetag_type *cttype; 	mutex_lock(&codetag_lock);	list_for_each_entry(cttype, &codetag_types, link) {		if (!cttype->desc.free_section_mem)			continue; 		down_write(&cttype->mod_lock);		cttype->desc.free_section_mem(mod, false);		up_write(&cttype->mod_lock);	}	mutex_unlock(&codetag_lock);} void codetag_module_replaced(struct module *mod, struct module *new_mod){	struct codetag_type *cttype; 	mutex_lock(&codetag_lock);	list_for_each_entry(cttype, &codetag_types, link) {		if (!cttype->desc.module_replaced)			continue; 		down_write(&cttype->mod_lock);		cttype->desc.module_replaced(mod, new_mod);		up_write(&cttype->mod_lock);	}	mutex_unlock(&codetag_lock);} int codetag_load_module(struct module *mod){	struct codetag_type *cttype;	int ret = 0; 	if (!mod)		return 0; 	mutex_lock(&codetag_lock);	list_for_each_entry(cttype, &codetag_types, link) {		ret = codetag_module_init(cttype, mod);		if (ret)			break;	}	mutex_unlock(&codetag_lock); 	return ret;} void codetag_unload_module(struct module *mod){	struct codetag_type *cttype; 	if (!mod)		return; 	/* await any module's kfree_rcu() operations to complete */	kvfree_rcu_barrier(); 	mutex_lock(&codetag_lock);	list_for_each_entry(cttype, &codetag_types, link) {		struct codetag_module *found = NULL;		struct codetag_module *cmod;		unsigned long mod_id, tmp; 		down_write(&cttype->mod_lock);		idr_for_each_entry_ul(&cttype->mod_idr, cmod, tmp, mod_id) {			if (cmod->mod && cmod->mod == mod) {				found = cmod;				break;			}		}		if (found) {			if (cttype->desc.module_unload)				cttype->desc.module_unload(cmod->mod,					cmod->range.start, cmod->range.stop); 			cttype->count -= range_size(cttype, &cmod->range);			idr_remove(&cttype->mod_idr, mod_id);			kfree(cmod);		}		up_write(&cttype->mod_lock);		if (found && cttype->desc.free_section_mem)			cttype->desc.free_section_mem(mod, true);	}	mutex_unlock(&codetag_lock);}#endif /* CONFIG_MODULES */ struct codetag_type *codetag_register_type(const struct codetag_type_desc *desc){	struct codetag_type *cttype;	int err; 	BUG_ON(desc->tag_size <= 0); 	cttype = kzalloc(sizeof(*cttype), GFP_KERNEL);	if (unlikely(!cttype))		return ERR_PTR(-ENOMEM); 	cttype->desc = *desc;	idr_init(&cttype->mod_idr);	init_rwsem(&cttype->mod_lock); 	err = codetag_module_init(cttype, NULL);	if (unlikely(err)) {		kfree(cttype);		return ERR_PTR(err);	} 	mutex_lock(&codetag_lock);	list_add_tail(&cttype->link, &codetag_types);	mutex_unlock(&codetag_lock); 	return cttype;}