livepatch: add old_sympos as disambiguator field to klp_func

 * struct klp_func - function structure for live patching

 * @old_name:	name of the function to be patched

 * @new_func:	pointer to the patched function code

 * @old_addr:	a hint conveying at what address the old function

 *		can be found (optional, vmlinux patches only)

 * @old_sympos: a hint indicating which symbol position the old function

 *		can be found (optional)

 * @old_addr:	the address of the function being patched

 * @kobj:	kobject for sysfs resources

 * @state:	tracks function-level patch application state

 * @stack_node:	list node for klp_ops func_stack list

	const char *old_name;

	void *new_func;

	/*

	 * The old_addr field is optional and can be used to resolve

	 * duplicate symbol names in the vmlinux object.  If this

	 * information is not present, the symbol is located by name

	 * with kallsyms. If the name is not unique and old_addr is

	 * not provided, the patch application fails as there is no

	 * way to resolve the ambiguity.

	 * The old_sympos field is optional and can be used to resolve

	 * duplicate symbol names in livepatch objects. If this field is zero,

	 * it is expected the symbol is unique, otherwise patching fails. If

	 * this value is greater than zero then that occurrence of the symbol

	 * in kallsyms for the given object is used.

	 */

	unsigned long old_addr;

	unsigned long old_sympos;

	/* internal */

	unsigned long old_addr;

	struct kobject kobj;

	enum klp_state state;

	struct list_head stack_node;

	const char *objname;

	const char *name;

	unsigned long addr;

	/*

	 * If count == 0, the symbol was not found. If count == 1, a unique

	 * match was found and addr is set.  If count > 1, there is

	 * unresolvable ambiguity among "count" number of symbols with the same

	 * name in the same object.

	 */

	unsigned long count;

	unsigned long pos;

};

static int klp_find_callback(void *data, const char *name,

	if (args->objname && strcmp(args->objname, mod->name))

		return 0;

	/*

	 * args->addr might be overwritten if another match is found

	 * but klp_find_object_symbol() handles this and only returns the

	 * addr if count == 1.

	 */

	args->addr = addr;

	args->count++;

	/*

	 * Finish the search when the symbol is found for the desired position

	 * or the position is not defined for a non-unique symbol.

	 */

	if ((args->pos && (args->count == args->pos)) ||

	    (!args->pos && (args->count > 1)))

		return 1;

	return 0;

}

static int klp_find_object_symbol(const char *objname, const char *name,

				  unsigned long *addr)

				  unsigned long sympos, unsigned long *addr)

{

	struct klp_find_arg args = {

		.objname = objname,

		.name = name,

		.addr = 0,

		.count = 0

		.count = 0,

		.pos = sympos,

	};

	mutex_lock(&module_mutex);

	kallsyms_on_each_symbol(klp_find_callback, &args);

	mutex_unlock(&module_mutex);

	if (args.count == 0)

	/*

	 * Ensure an address was found. If sympos is 0, ensure symbol is unique;

	 * otherwise ensure the symbol position count matches sympos.

	 */

	if (args.addr == 0)

		pr_err("symbol '%s' not found in symbol table\n", name);

	else if (args.count > 1)

	else if (args.count > 1 && sympos == 0) {

		pr_err("unresolvable ambiguity (%lu matches) on symbol '%s' in object '%s'\n",

		       args.count, name, objname);

	else {

	} else if (sympos != args.count && sympos > 0) {

		pr_err("symbol position %lu for symbol '%s' in object '%s' not found\n",

		       sympos, name, objname ? objname : "vmlinux");

	} else {

		*addr = args.addr;

		return 0;

	}

	return 0;

}

static int klp_find_verify_func_addr(struct klp_object *obj,

				     struct klp_func *func)

{

	int ret;

#if defined(CONFIG_RANDOMIZE_BASE)

	/* If KASLR has been enabled, adjust old_addr accordingly */

	if (kaslr_enabled() && func->old_addr)

		func->old_addr += kaslr_offset();

#endif

	if (!func->old_addr || klp_is_module(obj))

		ret = klp_find_object_symbol(obj->name, func->old_name,

					     &func->old_addr);

	else

		ret = klp_verify_vmlinux_symbol(func->old_name,

						func->old_addr);

	return ret;

}

/*

 * external symbols are located outside the parent object (where the parent

 * object is either vmlinux or the kmod being patched).

	}

	preempt_enable();

	/* otherwise check if it's in another .o within the patch module */

	return klp_find_object_symbol(pmod->name, name, addr);

	/*

	 * Check if it's in another .o within the patch module. This also

	 * checks that the external symbol is unique.

	 */

	return klp_find_object_symbol(pmod->name, name, 0, addr);

}

static int klp_write_object_relocations(struct module *pmod,

			else

				ret = klp_find_object_symbol(obj->mod->name,

							     reloc->name,

							     &reloc->val);

							     0, &reloc->val);

			if (ret)

				return ret;

		}

	}

	klp_for_each_func(obj, func) {

		ret = klp_find_verify_func_addr(obj, func);

		ret = klp_find_object_symbol(obj->name, func->old_name,

					     func->old_sympos,

					     &func->old_addr);

		if (ret)

			return ret;

	}