~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/csky/abiv1/alignment.c

Version: ~ [ linux-5.15-rc5 ] ~ [ linux-5.14.11 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.72 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.152 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.210 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.250 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.286 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.288 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 // Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd.
  3 
  4 #include <linux/kernel.h>
  5 #include <linux/uaccess.h>
  6 #include <linux/ptrace.h>
  7 
  8 static int align_kern_enable = 1;
  9 static int align_usr_enable = 1;
 10 static int align_kern_count = 0;
 11 static int align_usr_count = 0;
 12 
 13 static inline uint32_t get_ptreg(struct pt_regs *regs, uint32_t rx)
 14 {
 15         return rx == 15 ? regs->lr : *((uint32_t *)&(regs->a0) - 2 + rx);
 16 }
 17 
 18 static inline void put_ptreg(struct pt_regs *regs, uint32_t rx, uint32_t val)
 19 {
 20         if (rx == 15)
 21                 regs->lr = val;
 22         else
 23                 *((uint32_t *)&(regs->a0) - 2 + rx) = val;
 24 }
 25 
 26 /*
 27  * Get byte-value from addr and set it to *valp.
 28  *
 29  * Success: return 0
 30  * Failure: return 1
 31  */
 32 static int ldb_asm(uint32_t addr, uint32_t *valp)
 33 {
 34         uint32_t val;
 35         int err;
 36 
 37         asm volatile (
 38                 "movi   %0, 0\n"
 39                 "1:\n"
 40                 "ldb    %1, (%2)\n"
 41                 "br     3f\n"
 42                 "2:\n"
 43                 "movi   %0, 1\n"
 44                 "br     3f\n"
 45                 ".section __ex_table,\"a\"\n"
 46                 ".align 2\n"
 47                 ".long  1b, 2b\n"
 48                 ".previous\n"
 49                 "3:\n"
 50                 : "=&r"(err), "=r"(val)
 51                 : "r" (addr)
 52         );
 53 
 54         *valp = val;
 55 
 56         return err;
 57 }
 58 
 59 /*
 60  * Put byte-value to addr.
 61  *
 62  * Success: return 0
 63  * Failure: return 1
 64  */
 65 static int stb_asm(uint32_t addr, uint32_t val)
 66 {
 67         int err;
 68 
 69         asm volatile (
 70                 "movi   %0, 0\n"
 71                 "1:\n"
 72                 "stb    %1, (%2)\n"
 73                 "br     3f\n"
 74                 "2:\n"
 75                 "movi   %0, 1\n"
 76                 "br     3f\n"
 77                 ".section __ex_table,\"a\"\n"
 78                 ".align 2\n"
 79                 ".long  1b, 2b\n"
 80                 ".previous\n"
 81                 "3:\n"
 82                 : "=&r"(err)
 83                 : "r"(val), "r" (addr)
 84         );
 85 
 86         return err;
 87 }
 88 
 89 /*
 90  * Get half-word from [rx + imm]
 91  *
 92  * Success: return 0
 93  * Failure: return 1
 94  */
 95 static int ldh_c(struct pt_regs *regs, uint32_t rz, uint32_t addr)
 96 {
 97         uint32_t byte0, byte1;
 98 
 99         if (ldb_asm(addr, &byte0))
100                 return 1;
101         addr += 1;
102         if (ldb_asm(addr, &byte1))
103                 return 1;
104 
105         byte0 |= byte1 << 8;
106         put_ptreg(regs, rz, byte0);
107 
108         return 0;
109 }
110 
111 /*
112  * Store half-word to [rx + imm]
113  *
114  * Success: return 0
115  * Failure: return 1
116  */
117 static int sth_c(struct pt_regs *regs, uint32_t rz, uint32_t addr)
118 {
119         uint32_t byte0, byte1;
120 
121         byte0 = byte1 = get_ptreg(regs, rz);
122 
123         byte0 &= 0xff;
124 
125         if (stb_asm(addr, byte0))
126                 return 1;
127 
128         addr += 1;
129         byte1 = (byte1 >> 8) & 0xff;
130         if (stb_asm(addr, byte1))
131                 return 1;
132 
133         return 0;
134 }
135 
136 /*
137  * Get word from [rx + imm]
138  *
139  * Success: return 0
140  * Failure: return 1
141  */
142 static int ldw_c(struct pt_regs *regs, uint32_t rz, uint32_t addr)
143 {
144         uint32_t byte0, byte1, byte2, byte3;
145 
146         if (ldb_asm(addr, &byte0))
147                 return 1;
148 
149         addr += 1;
150         if (ldb_asm(addr, &byte1))
151                 return 1;
152 
153         addr += 1;
154         if (ldb_asm(addr, &byte2))
155                 return 1;
156 
157         addr += 1;
158         if (ldb_asm(addr, &byte3))
159                 return 1;
160 
161         byte0 |= byte1 << 8;
162         byte0 |= byte2 << 16;
163         byte0 |= byte3 << 24;
164 
165         put_ptreg(regs, rz, byte0);
166 
167         return 0;
168 }
169 
170 /*
171  * Store word to [rx + imm]
172  *
173  * Success: return 0
174  * Failure: return 1
175  */
176 static int stw_c(struct pt_regs *regs, uint32_t rz, uint32_t addr)
177 {
178         uint32_t byte0, byte1, byte2, byte3;
179 
180         byte0 = byte1 = byte2 = byte3 = get_ptreg(regs, rz);
181 
182         byte0 &= 0xff;
183 
184         if (stb_asm(addr, byte0))
185                 return 1;
186 
187         addr += 1;
188         byte1 = (byte1 >> 8) & 0xff;
189         if (stb_asm(addr, byte1))
190                 return 1;
191 
192         addr += 1;
193         byte2 = (byte2 >> 16) & 0xff;
194         if (stb_asm(addr, byte2))
195                 return 1;
196 
197         addr += 1;
198         byte3 = (byte3 >> 24) & 0xff;
199         if (stb_asm(addr, byte3))
200                 return 1;
201 
202         return 0;
203 }
204 
205 extern int fixup_exception(struct pt_regs *regs);
206 
207 #define OP_LDH 0xc000
208 #define OP_STH 0xd000
209 #define OP_LDW 0x8000
210 #define OP_STW 0x9000
211 
212 void csky_alignment(struct pt_regs *regs)
213 {
214         int ret;
215         uint16_t tmp;
216         uint32_t opcode = 0;
217         uint32_t rx     = 0;
218         uint32_t rz     = 0;
219         uint32_t imm    = 0;
220         uint32_t addr   = 0;
221 
222         if (!user_mode(regs))
223                 goto kernel_area;
224 
225         if (!align_usr_enable) {
226                 pr_err("%s user disabled.\n", __func__);
227                 goto bad_area;
228         }
229 
230         align_usr_count++;
231 
232         ret = get_user(tmp, (uint16_t *)instruction_pointer(regs));
233         if (ret) {
234                 pr_err("%s get_user failed.\n", __func__);
235                 goto bad_area;
236         }
237 
238         goto good_area;
239 
240 kernel_area:
241         if (!align_kern_enable) {
242                 pr_err("%s kernel disabled.\n", __func__);
243                 goto bad_area;
244         }
245 
246         align_kern_count++;
247 
248         tmp = *(uint16_t *)instruction_pointer(regs);
249 
250 good_area:
251         opcode = (uint32_t)tmp;
252 
253         rx  = opcode & 0xf;
254         imm = (opcode >> 4) & 0xf;
255         rz  = (opcode >> 8) & 0xf;
256         opcode &= 0xf000;
257 
258         if (rx == 0 || rx == 1 || rz == 0 || rz == 1)
259                 goto bad_area;
260 
261         switch (opcode) {
262         case OP_LDH:
263                 addr = get_ptreg(regs, rx) + (imm << 1);
264                 ret = ldh_c(regs, rz, addr);
265                 break;
266         case OP_LDW:
267                 addr = get_ptreg(regs, rx) + (imm << 2);
268                 ret = ldw_c(regs, rz, addr);
269                 break;
270         case OP_STH:
271                 addr = get_ptreg(regs, rx) + (imm << 1);
272                 ret = sth_c(regs, rz, addr);
273                 break;
274         case OP_STW:
275                 addr = get_ptreg(regs, rx) + (imm << 2);
276                 ret = stw_c(regs, rz, addr);
277                 break;
278         }
279 
280         if (ret)
281                 goto bad_area;
282 
283         regs->pc += 2;
284 
285         return;
286 
287 bad_area:
288         if (!user_mode(regs)) {
289                 if (fixup_exception(regs))
290                         return;
291 
292                 bust_spinlocks(1);
293                 pr_alert("%s opcode: %x, rz: %d, rx: %d, imm: %d, addr: %x.\n",
294                                 __func__, opcode, rz, rx, imm, addr);
295                 show_regs(regs);
296                 bust_spinlocks(0);
297                 do_exit(SIGKILL);
298         }
299 
300         force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *)addr);
301 }
302 
303 static struct ctl_table alignment_tbl[5] = {
304         {
305                 .procname = "kernel_enable",
306                 .data = &align_kern_enable,
307                 .maxlen = sizeof(align_kern_enable),
308                 .mode = 0666,
309                 .proc_handler = &proc_dointvec
310         },
311         {
312                 .procname = "user_enable",
313                 .data = &align_usr_enable,
314                 .maxlen = sizeof(align_usr_enable),
315                 .mode = 0666,
316                 .proc_handler = &proc_dointvec
317         },
318         {
319                 .procname = "kernel_count",
320                 .data = &align_kern_count,
321                 .maxlen = sizeof(align_kern_count),
322                 .mode = 0666,
323                 .proc_handler = &proc_dointvec
324         },
325         {
326                 .procname = "user_count",
327                 .data = &align_usr_count,
328                 .maxlen = sizeof(align_usr_count),
329                 .mode = 0666,
330                 .proc_handler = &proc_dointvec
331         },
332         {}
333 };
334 
335 static struct ctl_table sysctl_table[2] = {
336         {
337          .procname = "csky_alignment",
338          .mode = 0555,
339          .child = alignment_tbl},
340         {}
341 };
342 
343 static struct ctl_path sysctl_path[2] = {
344         {.procname = "csky"},
345         {}
346 };
347 
348 static int __init csky_alignment_init(void)
349 {
350         register_sysctl_paths(sysctl_path, sysctl_table);
351         return 0;
352 }
353 
354 arch_initcall(csky_alignment_init);
355 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp