1// SPDX-License-Identifier: GPL-2.0
  2#include <linux/export.h>
  3#include <linux/percpu.h>
  4#include <linux/preempt.h>
  5#include <asm/msr.h>
  6#define CREATE_TRACE_POINTS
  7#include <asm/msr-trace.h>
  8
  9struct msr *msrs_alloc(void)
 10{
 11	struct msr *msrs = NULL;
 12
 13	msrs = alloc_percpu(struct msr);
 14	if (!msrs) {
 15		pr_warn("%s: error allocating msrs\n", __func__);
 16		return NULL;
 17	}
 18
 19	return msrs;
 20}
 21EXPORT_SYMBOL(msrs_alloc);
 22
 23void msrs_free(struct msr *msrs)
 24{
 25	free_percpu(msrs);
 26}
 27EXPORT_SYMBOL(msrs_free);
 28
 29/**
 30 * msr_read - Read an MSR with error handling
 
 31 * @msr: MSR to read
 32 * @m: value to read into
 33 *
 34 * It returns read data only on success, otherwise it doesn't change the output
 35 * argument @m.
 36 *
 37 * Return: %0 for success, otherwise an error code
 38 */
 39static int msr_read(u32 msr, struct msr *m)
 40{
 41	int err;
 42	u64 val;
 43
 44	err = rdmsrl_safe(msr, &val);
 45	if (!err)
 46		m->q = val;
 47
 48	return err;
 49}
 50
 51/**
 52 * msr_write - Write an MSR with error handling
 53 *
 54 * @msr: MSR to write
 55 * @m: value to write
 56 *
 57 * Return: %0 for success, otherwise an error code
 58 */
 59static int msr_write(u32 msr, struct msr *m)
 60{
 61	return wrmsrl_safe(msr, m->q);
 62}
 63
 64static inline int __flip_bit(u32 msr, u8 bit, bool set)
 65{
 66	struct msr m, m1;
 67	int err = -EINVAL;
 68
 69	if (bit > 63)
 70		return err;
 71
 72	err = msr_read(msr, &m);
 73	if (err)
 74		return err;
 75
 76	m1 = m;
 77	if (set)
 78		m1.q |=  BIT_64(bit);
 79	else
 80		m1.q &= ~BIT_64(bit);
 81
 82	if (m1.q == m.q)
 83		return 0;
 84
 85	err = msr_write(msr, &m1);
 86	if (err)
 87		return err;
 88
 89	return 1;
 90}
 91
 92/**
 93 * msr_set_bit - Set @bit in a MSR @msr.
 94 * @msr: MSR to write
 95 * @bit: bit number to set
 96 *
 97 * Return:
 98 * * < 0: An error was encountered.
 99 * * = 0: Bit was already set.
100 * * > 0: Hardware accepted the MSR write.
101 */
102int msr_set_bit(u32 msr, u8 bit)
103{
104	return __flip_bit(msr, bit, true);
105}
106
107/**
108 * msr_clear_bit - Clear @bit in a MSR @msr.
109 * @msr: MSR to write
110 * @bit: bit number to clear
111 *
112 * Return:
113 * * < 0: An error was encountered.
114 * * = 0: Bit was already cleared.
115 * * > 0: Hardware accepted the MSR write.
116 */
117int msr_clear_bit(u32 msr, u8 bit)
118{
119	return __flip_bit(msr, bit, false);
120}
121
122#ifdef CONFIG_TRACEPOINTS
123void do_trace_write_msr(unsigned int msr, u64 val, int failed)
124{
125	trace_write_msr(msr, val, failed);
126}
127EXPORT_SYMBOL(do_trace_write_msr);
128EXPORT_TRACEPOINT_SYMBOL(write_msr);
129
130void do_trace_read_msr(unsigned int msr, u64 val, int failed)
131{
132	trace_read_msr(msr, val, failed);
133}
134EXPORT_SYMBOL(do_trace_read_msr);
135EXPORT_TRACEPOINT_SYMBOL(read_msr);
136
137void do_trace_rdpmc(unsigned counter, u64 val, int failed)
138{
139	trace_rdpmc(counter, val, failed);
140}
141EXPORT_SYMBOL(do_trace_rdpmc);
142EXPORT_TRACEPOINT_SYMBOL(rdpmc);
143
144#endif

  1// SPDX-License-Identifier: GPL-2.0
  2#include <linux/export.h>
  3#include <linux/percpu.h>
  4#include <linux/preempt.h>
  5#include <asm/msr.h>
  6#define CREATE_TRACE_POINTS
  7#include <asm/msr-trace.h>
  8
  9struct msr *msrs_alloc(void)
 10{
 11	struct msr *msrs = NULL;
 12
 13	msrs = alloc_percpu(struct msr);
 14	if (!msrs) {
 15		pr_warn("%s: error allocating msrs\n", __func__);
 16		return NULL;
 17	}
 18
 19	return msrs;
 20}
 21EXPORT_SYMBOL(msrs_alloc);
 22
 23void msrs_free(struct msr *msrs)
 24{
 25	free_percpu(msrs);
 26}
 27EXPORT_SYMBOL(msrs_free);
 28
 29/**
 30 * Read an MSR with error handling
 31 *
 32 * @msr: MSR to read
 33 * @m: value to read into
 34 *
 35 * It returns read data only on success, otherwise it doesn't change the output
 36 * argument @m.
 37 *
 
 38 */
 39static int msr_read(u32 msr, struct msr *m)
 40{
 41	int err;
 42	u64 val;
 43
 44	err = rdmsrl_safe(msr, &val);
 45	if (!err)
 46		m->q = val;
 47
 48	return err;
 49}
 50
 51/**
 52 * Write an MSR with error handling
 53 *
 54 * @msr: MSR to write
 55 * @m: value to write
 
 
 56 */
 57static int msr_write(u32 msr, struct msr *m)
 58{
 59	return wrmsrl_safe(msr, m->q);
 60}
 61
 62static inline int __flip_bit(u32 msr, u8 bit, bool set)
 63{
 64	struct msr m, m1;
 65	int err = -EINVAL;
 66
 67	if (bit > 63)
 68		return err;
 69
 70	err = msr_read(msr, &m);
 71	if (err)
 72		return err;
 73
 74	m1 = m;
 75	if (set)
 76		m1.q |=  BIT_64(bit);
 77	else
 78		m1.q &= ~BIT_64(bit);
 79
 80	if (m1.q == m.q)
 81		return 0;
 82
 83	err = msr_write(msr, &m1);
 84	if (err)
 85		return err;
 86
 87	return 1;
 88}
 89
 90/**
 91 * Set @bit in a MSR @msr.
 
 
 92 *
 93 * Retval:
 94 * < 0: An error was encountered.
 95 * = 0: Bit was already set.
 96 * > 0: Hardware accepted the MSR write.
 97 */
 98int msr_set_bit(u32 msr, u8 bit)
 99{
100	return __flip_bit(msr, bit, true);
101}
102
103/**
104 * Clear @bit in a MSR @msr.
 
 
105 *
106 * Retval:
107 * < 0: An error was encountered.
108 * = 0: Bit was already cleared.
109 * > 0: Hardware accepted the MSR write.
110 */
111int msr_clear_bit(u32 msr, u8 bit)
112{
113	return __flip_bit(msr, bit, false);
114}
115
116#ifdef CONFIG_TRACEPOINTS
117void do_trace_write_msr(unsigned int msr, u64 val, int failed)
118{
119	trace_write_msr(msr, val, failed);
120}
121EXPORT_SYMBOL(do_trace_write_msr);
122EXPORT_TRACEPOINT_SYMBOL(write_msr);
123
124void do_trace_read_msr(unsigned int msr, u64 val, int failed)
125{
126	trace_read_msr(msr, val, failed);
127}
128EXPORT_SYMBOL(do_trace_read_msr);
129EXPORT_TRACEPOINT_SYMBOL(read_msr);
130
131void do_trace_rdpmc(unsigned counter, u64 val, int failed)
132{
133	trace_rdpmc(counter, val, failed);
134}
135EXPORT_SYMBOL(do_trace_rdpmc);
136EXPORT_TRACEPOINT_SYMBOL(rdpmc);
137
138#endif