1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* ----------------------------------------------------------------------- * |
3 | * |
4 | * Copyright 2000-2008 H. Peter Anvin - All Rights Reserved |
5 | * |
6 | * ----------------------------------------------------------------------- */ |
7 | |
8 | /* |
9 | * x86 CPUID access device |
10 | * |
11 | * This device is accessed by lseek() to the appropriate CPUID level |
12 | * and then read in chunks of 16 bytes. A larger size means multiple |
13 | * reads of consecutive levels. |
14 | * |
15 | * The lower 32 bits of the file position is used as the incoming %eax, |
16 | * and the upper 32 bits of the file position as the incoming %ecx, |
17 | * the latter intended for "counting" eax levels like eax=4. |
18 | * |
19 | * This driver uses /dev/cpu/%d/cpuid where %d is the minor number, and on |
20 | * an SMP box will direct the access to CPU %d. |
21 | */ |
22 | |
23 | #include <linux/module.h> |
24 | |
25 | #include <linux/types.h> |
26 | #include <linux/errno.h> |
27 | #include <linux/fcntl.h> |
28 | #include <linux/init.h> |
29 | #include <linux/poll.h> |
30 | #include <linux/smp.h> |
31 | #include <linux/major.h> |
32 | #include <linux/fs.h> |
33 | #include <linux/device.h> |
34 | #include <linux/cpu.h> |
35 | #include <linux/notifier.h> |
36 | #include <linux/uaccess.h> |
37 | #include <linux/gfp.h> |
38 | #include <linux/completion.h> |
39 | |
40 | #include <asm/processor.h> |
41 | #include <asm/msr.h> |
42 | |
43 | static enum cpuhp_state cpuhp_cpuid_state; |
44 | |
45 | struct cpuid_regs_done { |
46 | struct cpuid_regs regs; |
47 | struct completion done; |
48 | }; |
49 | |
50 | static void cpuid_smp_cpuid(void *cmd_block) |
51 | { |
52 | struct cpuid_regs_done *cmd = cmd_block; |
53 | |
54 | cpuid_count(op: cmd->regs.eax, count: cmd->regs.ecx, |
55 | eax: &cmd->regs.eax, ebx: &cmd->regs.ebx, |
56 | ecx: &cmd->regs.ecx, edx: &cmd->regs.edx); |
57 | |
58 | complete(&cmd->done); |
59 | } |
60 | |
61 | static ssize_t cpuid_read(struct file *file, char __user *buf, |
62 | size_t count, loff_t *ppos) |
63 | { |
64 | char __user *tmp = buf; |
65 | struct cpuid_regs_done cmd; |
66 | int cpu = iminor(inode: file_inode(f: file)); |
67 | u64 pos = *ppos; |
68 | ssize_t bytes = 0; |
69 | int err = 0; |
70 | |
71 | if (count % 16) |
72 | return -EINVAL; /* Invalid chunk size */ |
73 | |
74 | init_completion(x: &cmd.done); |
75 | for (; count; count -= 16) { |
76 | call_single_data_t csd; |
77 | |
78 | INIT_CSD(&csd, cpuid_smp_cpuid, &cmd); |
79 | |
80 | cmd.regs.eax = pos; |
81 | cmd.regs.ecx = pos >> 32; |
82 | |
83 | err = smp_call_function_single_async(cpu, csd: &csd); |
84 | if (err) |
85 | break; |
86 | wait_for_completion(&cmd.done); |
87 | if (copy_to_user(to: tmp, from: &cmd.regs, n: 16)) { |
88 | err = -EFAULT; |
89 | break; |
90 | } |
91 | tmp += 16; |
92 | bytes += 16; |
93 | *ppos = ++pos; |
94 | reinit_completion(x: &cmd.done); |
95 | } |
96 | |
97 | return bytes ? bytes : err; |
98 | } |
99 | |
100 | static int cpuid_open(struct inode *inode, struct file *file) |
101 | { |
102 | unsigned int cpu; |
103 | struct cpuinfo_x86 *c; |
104 | |
105 | cpu = iminor(inode: file_inode(f: file)); |
106 | if (cpu >= nr_cpu_ids || !cpu_online(cpu)) |
107 | return -ENXIO; /* No such CPU */ |
108 | |
109 | c = &cpu_data(cpu); |
110 | if (c->cpuid_level < 0) |
111 | return -EIO; /* CPUID not supported */ |
112 | |
113 | return 0; |
114 | } |
115 | |
116 | /* |
117 | * File operations we support |
118 | */ |
119 | static const struct file_operations cpuid_fops = { |
120 | .owner = THIS_MODULE, |
121 | .llseek = no_seek_end_llseek, |
122 | .read = cpuid_read, |
123 | .open = cpuid_open, |
124 | }; |
125 | |
126 | static char *cpuid_devnode(const struct device *dev, umode_t *mode) |
127 | { |
128 | return kasprintf(GFP_KERNEL, fmt: "cpu/%u/cpuid" , MINOR(dev->devt)); |
129 | } |
130 | |
131 | static const struct class cpuid_class = { |
132 | .name = "cpuid" , |
133 | .devnode = cpuid_devnode, |
134 | }; |
135 | |
136 | static int cpuid_device_create(unsigned int cpu) |
137 | { |
138 | struct device *dev; |
139 | |
140 | dev = device_create(cls: &cpuid_class, NULL, MKDEV(CPUID_MAJOR, cpu), NULL, |
141 | fmt: "cpu%d" , cpu); |
142 | return PTR_ERR_OR_ZERO(ptr: dev); |
143 | } |
144 | |
145 | static int cpuid_device_destroy(unsigned int cpu) |
146 | { |
147 | device_destroy(cls: &cpuid_class, MKDEV(CPUID_MAJOR, cpu)); |
148 | return 0; |
149 | } |
150 | |
151 | static int __init cpuid_init(void) |
152 | { |
153 | int err; |
154 | |
155 | if (__register_chrdev(CPUID_MAJOR, baseminor: 0, NR_CPUS, |
156 | name: "cpu/cpuid" , fops: &cpuid_fops)) { |
157 | printk(KERN_ERR "cpuid: unable to get major %d for cpuid\n" , |
158 | CPUID_MAJOR); |
159 | return -EBUSY; |
160 | } |
161 | err = class_register(class: &cpuid_class); |
162 | if (err) |
163 | goto out_chrdev; |
164 | |
165 | err = cpuhp_setup_state(state: CPUHP_AP_ONLINE_DYN, name: "x86/cpuid:online" , |
166 | startup: cpuid_device_create, teardown: cpuid_device_destroy); |
167 | if (err < 0) |
168 | goto out_class; |
169 | |
170 | cpuhp_cpuid_state = err; |
171 | return 0; |
172 | |
173 | out_class: |
174 | class_unregister(class: &cpuid_class); |
175 | out_chrdev: |
176 | __unregister_chrdev(CPUID_MAJOR, baseminor: 0, NR_CPUS, name: "cpu/cpuid" ); |
177 | return err; |
178 | } |
179 | module_init(cpuid_init); |
180 | |
181 | static void __exit cpuid_exit(void) |
182 | { |
183 | cpuhp_remove_state(state: cpuhp_cpuid_state); |
184 | class_unregister(class: &cpuid_class); |
185 | __unregister_chrdev(CPUID_MAJOR, baseminor: 0, NR_CPUS, name: "cpu/cpuid" ); |
186 | } |
187 | module_exit(cpuid_exit); |
188 | |
189 | MODULE_AUTHOR("H. Peter Anvin <hpa@zytor.com>" ); |
190 | MODULE_DESCRIPTION("x86 generic CPUID driver" ); |
191 | MODULE_LICENSE("GPL" ); |
192 | |