Merge tag 'devprop-5.5-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm (361b0d28) · Commits · EulixOS / Software / Kernel

Documentation/core-api/printk-formats.rst

+24 −10

Original line number	Diff line number	Diff line
		@@ -98,8 +98,6 @@ Symbols/Function Pointers

		%pS versatile_init+0x0/0x110
		%ps versatile_init
		%pF versatile_init+0x0/0x110
		%pf versatile_init
		%pSR versatile_init+0x9/0x110
		(with __builtin_extract_return_addr() translation)
		%pB prev_fn_of_versatile_init+0x88/0x88
		@@ -109,14 +107,6 @@ The ``S`` and ``s`` specifiers are used for printing a pointer in symbolic
		format. They result in the symbol name with (S) or without (s)
		offsets. If KALLSYMS are disabled then the symbol address is printed instead.

		Note, that the ``F`` and ``f`` specifiers are identical to ``S`` (``s``)
		and thus deprecated. We have ``F`` and ``f`` because on ia64, ppc64 and
		parisc64 function pointers are indirect and, in fact, are function
		descriptors, which require additional dereferencing before we can lookup
		the symbol. As of now, ``S`` and ``s`` perform dereferencing on those
		platforms (when needed), so ``F`` and ``f`` exist for compatibility
		reasons only.

		The ``B`` specifier results in the symbol name with offsets and should be
		used when printing stack backtraces. The specifier takes into
		consideration the effect of compiler optimisations which may occur
		@@ -440,6 +430,30 @@ Examples::

		Passed by reference.

		Fwnode handles
		--------------

		::

		%pfw[fP]

		For printing information on fwnode handles. The default is to print the full
		node name, including the path. The modifiers are functionally equivalent to
		%pOF above.

		- f - full name of the node, including the path
		- P - the name of the node including an address (if there is one)

		Examples (ACPI)::

		%pfwf \_SB.PCI0.CIO2.port@1.endpoint@0 - Full node name
		%pfwP endpoint@0 - Node name

		Examples (OF)::

		%pfwf /ocp@68000000/i2c@48072000/camera@10/port/endpoint - Full name
		%pfwP endpoint - Node name

		Time and date (struct rtc_time)
		-------------------------------

drivers/acpi/property.c

+48 −0

Original line number	Diff line number	Diff line
		@@ -1317,6 +1317,52 @@ acpi_fwnode_get_reference_args(const struct fwnode_handle *fwnode,
		args_count, args);
		}

		static const char acpi_fwnode_get_name(const struct fwnode_handle fwnode)
		{
		const struct acpi_device *adev;
		struct fwnode_handle *parent;

		/* Is this the root node? */
		parent = fwnode_get_parent(fwnode);
		if (!parent)
		return "\\";

		fwnode_handle_put(parent);

		if (is_acpi_data_node(fwnode)) {
		const struct acpi_data_node *dn = to_acpi_data_node(fwnode);

		return dn->name;
		}

		adev = to_acpi_device_node(fwnode);
		if (WARN_ON(!adev))
		return NULL;

		return acpi_device_bid(adev);
		}

		static const char *
		acpi_fwnode_get_name_prefix(const struct fwnode_handle *fwnode)
		{
		struct fwnode_handle *parent;

		/* Is this the root node? */
		parent = fwnode_get_parent(fwnode);
		if (!parent)
		return "";

		/* Is this 2nd node from the root? */
		parent = fwnode_get_next_parent(parent);
		if (!parent)
		return "";

		fwnode_handle_put(parent);

		/* ACPI device or data node. */
		return ".";
		}

		static struct fwnode_handle *
		acpi_fwnode_get_parent(struct fwnode_handle *fwnode)
		{
		@@ -1357,6 +1403,8 @@ acpi_fwnode_device_get_match_data(const struct fwnode_handle *fwnode,
		.get_parent = acpi_node_get_parent, \
		.get_next_child_node = acpi_get_next_subnode, \
		.get_named_child_node = acpi_fwnode_get_named_child_node, \
		.get_name = acpi_fwnode_get_name, \
		.get_name_prefix = acpi_fwnode_get_name_prefix, \
		.get_reference_args = acpi_fwnode_get_reference_args, \
		.graph_get_next_endpoint = \
		acpi_graph_get_next_endpoint, \

drivers/base/property.c

+76 −7

Original line number	Diff line number	Diff line
		@@ -556,6 +556,42 @@ int device_add_properties(struct device *dev,
		}
		EXPORT_SYMBOL_GPL(device_add_properties);

		/**
		* fwnode_get_name - Return the name of a node
		* @fwnode: The firmware node
		*
		* Returns a pointer to the node name.
		*/
		const char fwnode_get_name(const struct fwnode_handle fwnode)
		{
		return fwnode_call_ptr_op(fwnode, get_name);
		}

		/**
		* fwnode_get_name_prefix - Return the prefix of node for printing purposes
		* @fwnode: The firmware node
		*
		* Returns the prefix of a node, intended to be printed right before the node.
		* The prefix works also as a separator between the nodes.
		*/
		const char fwnode_get_name_prefix(const struct fwnode_handle fwnode)
		{
		return fwnode_call_ptr_op(fwnode, get_name_prefix);
		}

		/**
		* fwnode_get_parent - Return parent firwmare node
		* @fwnode: Firmware whose parent is retrieved
		*
		* Return parent firmware node of the given node if possible or %NULL if no
		* parent was available.
		*/
		struct fwnode_handle fwnode_get_parent(const struct fwnode_handle fwnode)
		{
		return fwnode_call_ptr_op(fwnode, get_parent);
		}
		EXPORT_SYMBOL_GPL(fwnode_get_parent);

		/**
		* fwnode_get_next_parent - Iterate to the node's parent
		* @fwnode: Firmware whose parent is retrieved
		@@ -578,17 +614,50 @@ struct fwnode_handle fwnode_get_next_parent(struct fwnode_handle fwnode)
		EXPORT_SYMBOL_GPL(fwnode_get_next_parent);

		/**
		* fwnode_get_parent - Return parent firwmare node
		* @fwnode: Firmware whose parent is retrieved
		* fwnode_count_parents - Return the number of parents a node has
		* @fwnode: The node the parents of which are to be counted
		*
		* Return parent firmware node of the given node if possible or %NULL if no
		* parent was available.
		* Returns the number of parents a node has.
		*/
		struct fwnode_handle fwnode_get_parent(const struct fwnode_handle fwnode)
		unsigned int fwnode_count_parents(const struct fwnode_handle *fwnode)
		{
		return fwnode_call_ptr_op(fwnode, get_parent);
		struct fwnode_handle *__fwnode;
		unsigned int count;

		__fwnode = fwnode_get_parent(fwnode);

		for (count = 0; __fwnode; count++)
		__fwnode = fwnode_get_next_parent(__fwnode);

		return count;
		}
		EXPORT_SYMBOL_GPL(fwnode_get_parent);
		EXPORT_SYMBOL_GPL(fwnode_count_parents);

		/**
		* fwnode_get_nth_parent - Return an nth parent of a node
		* @fwnode: The node the parent of which is requested
		* @depth: Distance of the parent from the node
		*
		* Returns the nth parent of a node. If there is no parent at the requested
		* @depth, %NULL is returned. If @depth is 0, the functionality is equivalent to
		* fwnode_handle_get(). For @depth == 1, it is fwnode_get_parent() and so on.
		*
		* The caller is responsible for calling fwnode_handle_put() for the returned
		* node.
		*/
		struct fwnode_handle fwnode_get_nth_parent(struct fwnode_handle fwnode,
		unsigned int depth)
		{
		unsigned int i;

		fwnode_handle_get(fwnode);

		for (i = 0; i < depth && fwnode; i++)
		fwnode = fwnode_get_next_parent(fwnode);

		return fwnode;
		}
		EXPORT_SYMBOL_GPL(fwnode_get_nth_parent);

		/**
		* fwnode_get_next_child_node - Return the next child node handle for a node

drivers/base/swnode.c

+88 −170

Original line number	Diff line number	Diff line
		@@ -71,9 +71,9 @@ software_node_to_swnode(const struct software_node *node)
		return swnode;
		}

		const struct software_node to_software_node(struct fwnode_handle fwnode)
		const struct software_node to_software_node(const struct fwnode_handle fwnode)
		{
		struct swnode *swnode = to_swnode(fwnode);
		const struct swnode *swnode = to_swnode(fwnode);

		return swnode ? swnode->node : NULL;
		}
		@@ -103,71 +103,15 @@ property_entry_get(const struct property_entry prop, const char name)
		return NULL;
		}

		static void
		property_set_pointer(struct property_entry prop, const void pointer)
		{
		switch (prop->type) {
		case DEV_PROP_U8:
		if (prop->is_array)
		prop->pointer.u8_data = pointer;
		else
		prop->value.u8_data = ((u8 )pointer);
		break;
		case DEV_PROP_U16:
		if (prop->is_array)
		prop->pointer.u16_data = pointer;
		else
		prop->value.u16_data = ((u16 )pointer);
		break;
		case DEV_PROP_U32:
		if (prop->is_array)
		prop->pointer.u32_data = pointer;
		else
		prop->value.u32_data = ((u32 )pointer);
		break;
		case DEV_PROP_U64:
		if (prop->is_array)
		prop->pointer.u64_data = pointer;
		else
		prop->value.u64_data = ((u64 )pointer);
		break;
		case DEV_PROP_STRING:
		if (prop->is_array)
		prop->pointer.str = pointer;
		else
		prop->value.str = pointer;
		break;
		default:
		break;
		}
		}

		static const void property_get_pointer(const struct property_entry prop)
		{
		switch (prop->type) {
		case DEV_PROP_U8:
		if (prop->is_array)
		return prop->pointer.u8_data;
		return &prop->value.u8_data;
		case DEV_PROP_U16:
		if (prop->is_array)
		return prop->pointer.u16_data;
		return &prop->value.u16_data;
		case DEV_PROP_U32:
		if (prop->is_array)
		return prop->pointer.u32_data;
		return &prop->value.u32_data;
		case DEV_PROP_U64:
		if (prop->is_array)
		return prop->pointer.u64_data;
		return &prop->value.u64_data;
		case DEV_PROP_STRING:
		if (prop->is_array)
		return prop->pointer.str;
		return &prop->value.str;
		default:
		if (!prop->length)
		return NULL;
		}

		if (prop->is_array)
		return prop->pointer;

		return &prop->value;
		}

		static const void property_entry_find(const struct property_entry props,
		@@ -187,66 +131,6 @@ static const void property_entry_find(const struct property_entry props,
		return pointer;
		}

		static int property_entry_read_u8_array(const struct property_entry *props,
		const char *propname,
		u8 *values, size_t nval)
		{
		const void *pointer;
		size_t length = nval * sizeof(*values);

		pointer = property_entry_find(props, propname, length);
		if (IS_ERR(pointer))
		return PTR_ERR(pointer);

		memcpy(values, pointer, length);
		return 0;
		}

		static int property_entry_read_u16_array(const struct property_entry *props,
		const char *propname,
		u16 *values, size_t nval)
		{
		const void *pointer;
		size_t length = nval * sizeof(*values);

		pointer = property_entry_find(props, propname, length);
		if (IS_ERR(pointer))
		return PTR_ERR(pointer);

		memcpy(values, pointer, length);
		return 0;
		}

		static int property_entry_read_u32_array(const struct property_entry *props,
		const char *propname,
		u32 *values, size_t nval)
		{
		const void *pointer;
		size_t length = nval * sizeof(*values);

		pointer = property_entry_find(props, propname, length);
		if (IS_ERR(pointer))
		return PTR_ERR(pointer);

		memcpy(values, pointer, length);
		return 0;
		}

		static int property_entry_read_u64_array(const struct property_entry *props,
		const char *propname,
		u64 *values, size_t nval)
		{
		const void *pointer;
		size_t length = nval * sizeof(*values);

		pointer = property_entry_find(props, propname, length);
		if (IS_ERR(pointer))
		return PTR_ERR(pointer);

		memcpy(values, pointer, length);
		return 0;
		}

		static int
		property_entry_count_elems_of_size(const struct property_entry *props,
		const char *propname, size_t length)
		@@ -265,49 +149,45 @@ static int property_entry_read_int_array(const struct property_entry *props,
		unsigned int elem_size, void *val,
		size_t nval)
		{
		const void *pointer;
		size_t length;

		if (!val)
		return property_entry_count_elems_of_size(props, name,
		elem_size);
		switch (elem_size) {
		case sizeof(u8):
		return property_entry_read_u8_array(props, name, val, nval);
		case sizeof(u16):
		return property_entry_read_u16_array(props, name, val, nval);
		case sizeof(u32):
		return property_entry_read_u32_array(props, name, val, nval);
		case sizeof(u64):
		return property_entry_read_u64_array(props, name, val, nval);
		}

		if (!is_power_of_2(elem_size) \|\| elem_size > sizeof(u64))
		return -ENXIO;

		length = nval * elem_size;

		pointer = property_entry_find(props, name, length);
		if (IS_ERR(pointer))
		return PTR_ERR(pointer);

		memcpy(val, pointer, length);
		return 0;
		}

		static int property_entry_read_string_array(const struct property_entry *props,
		const char *propname,
		const char **strings, size_t nval)
		{
		const struct property_entry *prop;
		const void *pointer;
		size_t array_len, length;
		size_t length;
		int array_len;

		/* Find out the array length. */
		prop = property_entry_get(props, propname);
		if (!prop)
		return -EINVAL;

		if (prop->is_array)
		/* Find the length of an array. */
		array_len = property_entry_count_elems_of_size(props, propname,
		sizeof(const char *));
		else
		/* The array length for a non-array string property is 1. */
		array_len = 1;
		if (array_len < 0)
		return array_len;

		/* Return how many there are if strings is NULL. */
		if (!strings)
		return array_len;

		array_len = min(nval, array_len);
		array_len = min_t(size_t, nval, array_len);
		length = array_len * sizeof(*strings);

		pointer = property_entry_find(props, propname, length);
		@@ -322,13 +202,15 @@ static int property_entry_read_string_array(const struct property_entry *props,
		static void property_entry_free_data(const struct property_entry *p)
		{
		const void *pointer = property_get_pointer(p);
		const char * const *src_str;
		size_t i, nval;

		if (p->is_array) {
		if (p->type == DEV_PROP_STRING && p->pointer.str) {
		if (p->type == DEV_PROP_STRING && p->pointer) {
		src_str = p->pointer;
		nval = p->length / sizeof(const char *);
		for (i = 0; i < nval; i++)
		kfree(p->pointer.str[i]);
		kfree(src_str[i]);
		}
		kfree(pointer);
		} else if (p->type == DEV_PROP_STRING) {
		@@ -337,29 +219,29 @@ static void property_entry_free_data(const struct property_entry *p)
		kfree(p->name);
		}

		static int property_copy_string_array(struct property_entry *dst,
		const struct property_entry *src)
		static const char * const *
		property_copy_string_array(const struct property_entry *src)
		{
		const char **d;
		const char * const *src_str = src->pointer;
		size_t nval = src->length / sizeof(*d);
		int i;

		d = kcalloc(nval, sizeof(*d), GFP_KERNEL);
		if (!d)
		return -ENOMEM;
		return NULL;

		for (i = 0; i < nval; i++) {
		d[i] = kstrdup(src->pointer.str[i], GFP_KERNEL);
		if (!d[i] && src->pointer.str[i]) {
		d[i] = kstrdup(src_str[i], GFP_KERNEL);
		if (!d[i] && src_str[i]) {
		while (--i >= 0)
		kfree(d[i]);
		kfree(d);
		return -ENOMEM;
		return NULL;
		}
		}

		dst->pointer.str = d;
		return 0;
		return d;
		}

		static int property_entry_copy_data(struct property_entry *dst,
		@@ -367,36 +249,35 @@ static int property_entry_copy_data(struct property_entry *dst,
		{
		const void *pointer = property_get_pointer(src);
		const void *new;
		int error;

		if (src->is_array) {
		if (!src->length)
		return -ENODATA;

		if (src->type == DEV_PROP_STRING) {
		error = property_copy_string_array(dst, src);
		if (error)
		return error;
		new = dst->pointer.str;
		new = property_copy_string_array(src);
		if (!new)
		return -ENOMEM;
		} else {
		new = kmemdup(pointer, src->length, GFP_KERNEL);
		if (!new)
		return -ENOMEM;
		}

		dst->is_array = true;
		dst->pointer = new;
		} else if (src->type == DEV_PROP_STRING) {
		new = kstrdup(src->value.str, GFP_KERNEL);
		if (!new && src->value.str)
		return -ENOMEM;

		dst->value.str = new;
		} else {
		new = pointer;
		dst->value = src->value;
		}

		dst->length = src->length;
		dst->is_array = src->is_array;
		dst->type = src->type;

		property_set_pointer(dst, new);

		dst->name = kstrdup(src->name, GFP_KERNEL);
		if (!dst->name)
		goto out_free_data;
		@@ -515,12 +396,47 @@ static int software_node_read_string_array(const struct fwnode_handle *fwnode,
		propname, val, nval);
		}

		static const char *
		software_node_get_name(const struct fwnode_handle *fwnode)
		{
		const struct swnode *swnode = to_swnode(fwnode);

		if (!swnode)
		return "(null)";

		return kobject_name(&swnode->kobj);
		}

		static const char *
		software_node_get_name_prefix(const struct fwnode_handle *fwnode)
		{
		struct fwnode_handle *parent;
		const char *prefix;

		parent = fwnode_get_parent(fwnode);
		if (!parent)
		return "";

		/* Figure out the prefix from the parents. */
		while (is_software_node(parent))
		parent = fwnode_get_next_parent(parent);

		prefix = fwnode_get_name_prefix(parent);
		fwnode_handle_put(parent);

		/* Guess something if prefix was NULL. */
		return prefix ?: "/";
		}

		static struct fwnode_handle *
		software_node_get_parent(const struct fwnode_handle *fwnode)
		{
		struct swnode *swnode = to_swnode(fwnode);

		return swnode ? (swnode->parent ? &swnode->parent->fwnode : NULL) : NULL;
		if (!swnode \|\| !swnode->parent)
		return NULL;

		return fwnode_handle_get(&swnode->parent->fwnode);
		}

		static struct fwnode_handle *
		@@ -612,6 +528,8 @@ static const struct fwnode_operations software_node_ops = {
		.property_present = software_node_property_present,
		.property_read_int_array = software_node_read_int_array,
		.property_read_string_array = software_node_read_string_array,
		.get_name = software_node_get_name,
		.get_name_prefix = software_node_get_name_prefix,
		.get_parent = software_node_get_parent,
		.get_next_child_node = software_node_get_next_child,
		.get_named_child_node = software_node_get_named_child_node,

drivers/firmware/efi/apple-properties.c

+8 −10

Original line number	Diff line number	Diff line
		@@ -53,7 +53,8 @@ static void __init unmarshal_key_value_pairs(struct dev_header *dev_header,

		for (i = 0; i < dev_header->prop_count; i++) {
		int remaining = dev_header->len - (ptr - (void *)dev_header);
		u32 key_len, val_len;
		u32 key_len, val_len, entry_len;
		const u8 *entry_data;
		char *key;

		if (sizeof(key_len) > remaining)
		@@ -85,17 +86,14 @@ static void __init unmarshal_key_value_pairs(struct dev_header *dev_header,
		ucs2_as_utf8(key, ptr + sizeof(key_len),
		key_len - sizeof(key_len));

		entry[i].name = key;
		entry[i].length = val_len - sizeof(val_len);
		entry[i].is_array = !!entry[i].length;
		entry[i].type = DEV_PROP_U8;
		entry[i].pointer.u8_data = ptr + key_len + sizeof(val_len);

		entry_data = ptr + key_len + sizeof(val_len);
		entry_len = val_len - sizeof(val_len);
		entry[i] = PROPERTY_ENTRY_U8_ARRAY_LEN(key, entry_data,
		entry_len);
		if (dump_properties) {
		dev_info(dev, "property: %s\n", entry[i].name);
		dev_info(dev, "property: %s\n", key);
		print_hex_dump(KERN_INFO, pr_fmt(), DUMP_PREFIX_OFFSET,
		16, 1, entry[i].pointer.u8_data,
		entry[i].length, true);
		16, 1, entry_data, entry_len, true);
		}

		ptr += key_len + val_len;