// SPDX-License-Identifier: GPL-2.0-only/* * Copyright 2023 Red Hat */ #include "errors.h" #include <linux/compiler.h>#include <linux/errno.h> #include "logger.h"#include "permassert.h"#include "string-utils.h" static const struct error_info successful = { "UDS_SUCCESS", "Success" }; static const char *const message_table[] = {	[EPERM] = "Operation not permitted",	[ENOENT] = "No such file or directory",	[ESRCH] = "No such process",	[EINTR] = "Interrupted system call",	[EIO] = "Input/output error",	[ENXIO] = "No such device or address",	[E2BIG] = "Argument list too long",	[ENOEXEC] = "Exec format error",	[EBADF] = "Bad file descriptor",	[ECHILD] = "No child processes",	[EAGAIN] = "Resource temporarily unavailable",	[ENOMEM] = "Cannot allocate memory",	[EACCES] = "Permission denied",	[EFAULT] = "Bad address",	[ENOTBLK] = "Block device required",	[EBUSY] = "Device or resource busy",	[EEXIST] = "File exists",	[EXDEV] = "Invalid cross-device link",	[ENODEV] = "No such device",	[ENOTDIR] = "Not a directory",	[EISDIR] = "Is a directory",	[EINVAL] = "Invalid argument",	[ENFILE] = "Too many open files in system",	[EMFILE] = "Too many open files",	[ENOTTY] = "Inappropriate ioctl for device",	[ETXTBSY] = "Text file busy",	[EFBIG] = "File too large",	[ENOSPC] = "No space left on device",	[ESPIPE] = "Illegal seek",	[EROFS] = "Read-only file system",	[EMLINK] = "Too many links",	[EPIPE] = "Broken pipe",	[EDOM] = "Numerical argument out of domain",	[ERANGE] = "Numerical result out of range"}; static const struct error_info error_list[] = {	{ "UDS_OVERFLOW", "Index overflow" },	{ "UDS_INVALID_ARGUMENT", "Invalid argument passed to internal routine" },	{ "UDS_BAD_STATE", "UDS data structures are in an invalid state" },	{ "UDS_DUPLICATE_NAME", "Attempt to enter the same name into a delta index twice" },	{ "UDS_ASSERTION_FAILED", "Assertion failed" },	{ "UDS_QUEUED", "Request queued" },	{ "UDS_ALREADY_REGISTERED", "Error range already registered" },	{ "UDS_OUT_OF_RANGE", "Cannot access data outside specified limits" },	{ "UDS_DISABLED", "UDS library context is disabled" },	{ "UDS_UNSUPPORTED_VERSION", "Unsupported version" },	{ "UDS_CORRUPT_DATA", "Some index structure is corrupt" },	{ "UDS_NO_INDEX", "No index found" },	{ "UDS_INDEX_NOT_SAVED_CLEANLY", "Index not saved cleanly" },}; struct error_block {	const char *name;	int base;	int last;	int max;	const struct error_info *infos;}; #define MAX_ERROR_BLOCKS 6 static struct {	int allocated;	int count;	struct error_block blocks[MAX_ERROR_BLOCKS];} registered_errors = {	.allocated = MAX_ERROR_BLOCKS,	.count = 1,	.blocks = { {			.name = "UDS Error",			.base = UDS_ERROR_CODE_BASE,			.last = UDS_ERROR_CODE_LAST,			.max = UDS_ERROR_CODE_BLOCK_END,			.infos = error_list,		  } },}; /* Get the error info for an error number. Also returns the name of the error block, if known. */static const char *get_error_info(int errnum, const struct error_info **info_ptr){	struct error_block *block; 	if (errnum == UDS_SUCCESS) {		*info_ptr = &successful;		return NULL;	} 	for (block = registered_errors.blocks;	     block < registered_errors.blocks + registered_errors.count;	     block++) {		if ((errnum >= block->base) && (errnum < block->last)) {			*info_ptr = block->infos + (errnum - block->base);			return block->name;		} else if ((errnum >= block->last) && (errnum < block->max)) {			*info_ptr = NULL;			return block->name;		}	} 	return NULL;} /* Return a string describing a system error message. */static const char *system_string_error(int errnum, char *buf, size_t buflen){	size_t len;	const char *error_string = NULL; 	if ((errnum > 0) && (errnum < ARRAY_SIZE(message_table)))		error_string = message_table[errnum]; 	len = ((error_string == NULL) ?		 snprintf(buf, buflen, "Unknown error %d", errnum) :		 snprintf(buf, buflen, "%s", error_string));	if (len < buflen)		return buf; 	buf[0] = '\0';	return "System error";} /* Convert an error code to a descriptive string. */const char *uds_string_error(int errnum, char *buf, size_t buflen){	char *buffer = buf;	char *buf_end = buf + buflen;	const struct error_info *info = NULL;	const char *block_name; 	if (buf == NULL)		return NULL; 	if (errnum < 0)		errnum = -errnum; 	block_name = get_error_info(errnum, &info);	if (block_name != NULL) {		if (info != NULL) {			buffer = vdo_append_to_buffer(buffer, buf_end, "%s: %s",						      block_name, info->message);		} else {			buffer = vdo_append_to_buffer(buffer, buf_end, "Unknown %s %d",						      block_name, errnum);		}	} else if (info != NULL) {		buffer = vdo_append_to_buffer(buffer, buf_end, "%s", info->message);	} else {		const char *tmp = system_string_error(errnum, buffer, buf_end - buffer); 		if (tmp != buffer)			buffer = vdo_append_to_buffer(buffer, buf_end, "%s", tmp);		else			buffer += strlen(tmp);	} 	return buf;} /* Convert an error code to its name. */const char *uds_string_error_name(int errnum, char *buf, size_t buflen){	char *buffer = buf;	char *buf_end = buf + buflen;	const struct error_info *info = NULL;	const char *block_name; 	if (errnum < 0)		errnum = -errnum; 	block_name = get_error_info(errnum, &info);	if (block_name != NULL) {		if (info != NULL) {			buffer = vdo_append_to_buffer(buffer, buf_end, "%s", info->name);		} else {			buffer = vdo_append_to_buffer(buffer, buf_end, "%s %d",						      block_name, errnum);		}	} else if (info != NULL) {		buffer = vdo_append_to_buffer(buffer, buf_end, "%s", info->name);	} else {		const char *tmp; 		tmp = system_string_error(errnum, buffer, buf_end - buffer);		if (tmp != buffer)			buffer = vdo_append_to_buffer(buffer, buf_end, "%s", tmp);		else			buffer += strlen(tmp);	} 	return buf;} /* * Translate an error code into a value acceptable to the kernel. The input error code may be a * system-generated value (such as -EIO), or an internal UDS status code. The result will be a * negative errno value. */int uds_status_to_errno(int error){	char error_name[VDO_MAX_ERROR_NAME_SIZE];	char error_message[VDO_MAX_ERROR_MESSAGE_SIZE]; 	/* 0 is success, and negative values are already system error codes. */	if (likely(error <= 0))		return error; 	if (error < 1024) {		/* This is probably an errno from userspace. */		return -error;	} 	/* Internal UDS errors */	switch (error) {	case UDS_NO_INDEX:	case UDS_CORRUPT_DATA:		/* The index doesn't exist or can't be recovered. */		return -ENOENT; 	case UDS_INDEX_NOT_SAVED_CLEANLY:	case UDS_UNSUPPORTED_VERSION:		/*		 * The index exists, but can't be loaded. Tell the client it exists so they don't		 * destroy it inadvertently.		 */		return -EEXIST; 	case UDS_DISABLED:		/* The session is unusable; only returned by requests. */		return -EIO; 	default:		/* Translate an unexpected error into something generic. */		vdo_log_info("%s: mapping status code %d (%s: %s) to -EIO",			     __func__, error,			     uds_string_error_name(error, error_name,						   sizeof(error_name)),			     uds_string_error(error, error_message,					      sizeof(error_message)));		return -EIO;	}} /* * Register a block of error codes. * * @block_name: the name of the block of error codes * @first_error: the first error code in the block * @next_free_error: one past the highest possible error in the block * @infos: a pointer to the error info array for the block * @info_size: the size of the error info array */int uds_register_error_block(const char *block_name, int first_error,			     int next_free_error, const struct error_info *infos,			     size_t info_size){	int result;	struct error_block *block;	struct error_block new_block = {		.name = block_name,		.base = first_error,		.last = first_error + (info_size / sizeof(struct error_info)),		.max = next_free_error,		.infos = infos,	}; 	result = VDO_ASSERT(first_error < next_free_error,			    "well-defined error block range");	if (result != VDO_SUCCESS)		return result; 	if (registered_errors.count == registered_errors.allocated) {		/* This should never happen. */		return UDS_OVERFLOW;	} 	for (block = registered_errors.blocks;	     block < registered_errors.blocks + registered_errors.count;	     block++) {		if (strcmp(block_name, block->name) == 0)			return UDS_DUPLICATE_NAME; 		/* Ensure error ranges do not overlap. */		if ((first_error < block->max) && (next_free_error > block->base))			return UDS_ALREADY_REGISTERED;	} 	registered_errors.blocks[registered_errors.count++] = new_block;	return UDS_SUCCESS;}