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