Revision 5e98e916f95bdc50e90f3199d7f3d74b94fa5976 authored by Linus Torvalds on 12 February 2023, 21:52:17 UTC, committed by Linus Torvalds on 12 February 2023, 21:52:17 UTC
Pull tracing fix from Steven Rostedt: "Fix showing of TASK_COMM_LEN instead of its value The TASK_COMM_LEN was converted from a macro into an enum so that BTF would have access to it. But this unfortunately caused TASK_COMM_LEN to display in the format fields of trace events, as they are created by the TRACE_EVENT() macro and such, macros convert to their values, where as enums do not. To handle this, instead of using the field itself to be display, save the value of the array size as another field in the trace_event_fields structure, and use that instead. Not only does this fix the issue, but also converts the other trace events that have this same problem (but were not breaking tooling). With this change, the original work around b3bc8547d3be6 ("tracing: Have TRACE_DEFINE_ENUM affect trace event types as well") could be reverted (but that should be done in the merge window)" * tag 'trace-v6.2-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-trace: tracing: Fix TASK_COMM_LEN in trace event format file
polynomial.c
// SPDX-License-Identifier: GPL-2.0-only
/*
* Generic polynomial calculation using integer coefficients.
*
* Copyright (C) 2020 BAIKAL ELECTRONICS, JSC
*
* Authors:
* Maxim Kaurkin <maxim.kaurkin@baikalelectronics.ru>
* Serge Semin <Sergey.Semin@baikalelectronics.ru>
*
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/polynomial.h>
/*
* Originally this was part of drivers/hwmon/bt1-pvt.c.
* There the following conversion is used and should serve as an example here:
*
* The original translation formulae of the temperature (in degrees of Celsius)
* to PVT data and vice-versa are following:
*
* N = 1.8322e-8*(T^4) + 2.343e-5*(T^3) + 8.7018e-3*(T^2) + 3.9269*(T^1) +
* 1.7204e2
* T = -1.6743e-11*(N^4) + 8.1542e-8*(N^3) + -1.8201e-4*(N^2) +
* 3.1020e-1*(N^1) - 4.838e1
*
* where T = [-48.380, 147.438]C and N = [0, 1023].
*
* They must be accordingly altered to be suitable for the integer arithmetics.
* The technique is called 'factor redistribution', which just makes sure the
* multiplications and divisions are made so to have a result of the operations
* within the integer numbers limit. In addition we need to translate the
* formulae to accept millidegrees of Celsius. Here what they look like after
* the alterations:
*
* N = (18322e-20*(T^4) + 2343e-13*(T^3) + 87018e-9*(T^2) + 39269e-3*T +
* 17204e2) / 1e4
* T = -16743e-12*(D^4) + 81542e-9*(D^3) - 182010e-6*(D^2) + 310200e-3*D -
* 48380
* where T = [-48380, 147438] mC and N = [0, 1023].
*
* static const struct polynomial poly_temp_to_N = {
* .total_divider = 10000,
* .terms = {
* {4, 18322, 10000, 10000},
* {3, 2343, 10000, 10},
* {2, 87018, 10000, 10},
* {1, 39269, 1000, 1},
* {0, 1720400, 1, 1}
* }
* };
*
* static const struct polynomial poly_N_to_temp = {
* .total_divider = 1,
* .terms = {
* {4, -16743, 1000, 1},
* {3, 81542, 1000, 1},
* {2, -182010, 1000, 1},
* {1, 310200, 1000, 1},
* {0, -48380, 1, 1}
* }
* };
*/
/**
* polynomial_calc - calculate a polynomial using integer arithmetic
*
* @poly: pointer to the descriptor of the polynomial
* @data: input value of the polynimal
*
* Calculate the result of a polynomial using only integer arithmetic. For
* this to work without too much loss of precision the coefficients has to
* be altered. This is called factor redistribution.
*
* Returns the result of the polynomial calculation.
*/
long polynomial_calc(const struct polynomial *poly, long data)
{
const struct polynomial_term *term = poly->terms;
long total_divider = poly->total_divider ?: 1;
long tmp, ret = 0;
int deg;
/*
* Here is the polynomial calculation function, which performs the
* redistributed terms calculations. It's pretty straightforward.
* We walk over each degree term up to the free one, and perform
* the redistributed multiplication of the term coefficient, its
* divider (as for the rationale fraction representation), data
* power and the rational fraction divider leftover. Then all of
* this is collected in a total sum variable, which value is
* normalized by the total divider before being returned.
*/
do {
tmp = term->coef;
for (deg = 0; deg < term->deg; ++deg)
tmp = mult_frac(tmp, data, term->divider);
ret += tmp / term->divider_leftover;
} while ((term++)->deg);
return ret / total_divider;
}
EXPORT_SYMBOL_GPL(polynomial_calc);
MODULE_DESCRIPTION("Generic polynomial calculations");
MODULE_LICENSE("GPL");
![swh spinner](/static/img/swh-spinner.gif)
Computing file changes ...