开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
unaligned.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：14k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

unaligned.c：源码内容
  1. /* $Id: unaligned.c,v 1.22.2.1 2001/12/21 00:52:47 davem Exp $
  2.  * unaligned.c: Unaligned load/store trap handling with special
  3.  *              cases for the kernel to do them more quickly.
  4.  *
  5.  * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
  6.  * Copyright (C) 1996 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  7.  */
  10. #include <linux/kernel.h>
  11. #include <linux/sched.h>
  12. #include <linux/mm.h>
  13. #include <asm/ptrace.h>
  14. #include <asm/processor.h>
  15. #include <asm/system.h>
  16. #include <asm/uaccess.h>
  17. #include <linux/smp.h>
  18. #include <linux/smp_lock.h>
  20. /* #define DEBUG_MNA */
  22. enum direction {
  23. load,    /* ld, ldd, ldh, ldsh */
  24. store,   /* st, std, sth, stsh */
  25. both,    /* Swap, ldstub, etc. */
  26. fpload,
  27. fpstore,
  28. invalid,
  29. };
  31. #ifdef DEBUG_MNA
  32. static char *dirstrings[] = {
  33.   "load", "store", "both", "fpload", "fpstore", "invalid"
  34. };
  35. #endif
  37. static inline enum direction decode_direction(unsigned int insn)
  38. {
  39. unsigned long tmp = (insn >> 21) & 1;
  41. if(!tmp)
  42. return load;
  43. else {
  44. if(((insn>>19)&0x3f) == 15)
  45. return both;
  46. else
  47. return store;
  48. }
  49. }
  51. /* 8 = double-word, 4 = word, 2 = half-word */
  52. static inline int decode_access_size(unsigned int insn)
  53. {
  54. insn = (insn >> 19) & 3;
  56. if(!insn)
  57. return 4;
  58. else if(insn == 3)
  59. return 8;
  60. else if(insn == 2)
  61. return 2;
  62. else {
  63. printk("Impossible unaligned trap. insn=%08xn", insn);
  64. die_if_kernel("Byte sized unaligned access?!?!", current->thread.kregs);
  65. return 4; /* just to keep gcc happy. */
  66. }
  67. }
  69. /* 0x400000 = signed, 0 = unsigned */
  70. static inline int decode_signedness(unsigned int insn)
  71. {
  72. return (insn & 0x400000);
  73. }
  75. static inline void maybe_flush_windows(unsigned int rs1, unsigned int rs2,
  76.        unsigned int rd)
  77. {
  78. if(rs2 >= 16 || rs1 >= 16 || rd >= 16) {
  79. /* Wheee... */
  80. __asm__ __volatile__("save %sp, -0x40, %spnt"
  81.      "save %sp, -0x40, %spnt"
  82.      "save %sp, -0x40, %spnt"
  83.      "save %sp, -0x40, %spnt"
  84.      "save %sp, -0x40, %spnt"
  85.      "save %sp, -0x40, %spnt"
  86.      "save %sp, -0x40, %spnt"
  87.      "restore; restore; restore; restore;nt"
  88.      "restore; restore; restore;nt");
  89. }
  90. }
  92. static inline int sign_extend_imm13(int imm)
  93. {
  94. return imm << 19 >> 19;
  95. }
  97. static inline unsigned long fetch_reg(unsigned int reg, struct pt_regs *regs)
  98. {
  99. struct reg_window *win;
  101. if(reg < 16)
  102. return (!reg ? 0 : regs->u_regs[reg]);
  104. /* Ho hum, the slightly complicated case. */
  105. win = (struct reg_window *) regs->u_regs[UREG_FP];
  106. return win->locals[reg - 16]; /* yes, I know what this does... */
  107. }
  109. static inline unsigned long safe_fetch_reg(unsigned int reg, struct pt_regs *regs)
  110. {
  111. struct reg_window *win;
  112. unsigned long ret;
  114. if(reg < 16)
  115. return (!reg ? 0 : regs->u_regs[reg]);
  117. /* Ho hum, the slightly complicated case. */
  118. win = (struct reg_window *) regs->u_regs[UREG_FP];
  120. if ((unsigned long)win & 3)
  121. return -1;
  123. if (get_user(ret, &win->locals[reg - 16]))
  124. return -1;
  126. return ret;
  127. }
  129. static inline unsigned long *fetch_reg_addr(unsigned int reg, struct pt_regs *regs)
  130. {
  131. struct reg_window *win;
  133. if(reg < 16)
  134. return &regs->u_regs[reg];
  135. win = (struct reg_window *) regs->u_regs[UREG_FP];
  136. return &win->locals[reg - 16];
  137. }
  139. static inline unsigned long compute_effective_address(struct pt_regs *regs,
  140.       unsigned int insn)
  141. {
  142. unsigned int rs1 = (insn >> 14) & 0x1f;
  143. unsigned int rs2 = insn & 0x1f;
  144. unsigned int rd = (insn >> 25) & 0x1f;
  146. if(insn & 0x2000) {
  147. maybe_flush_windows(rs1, 0, rd);
  148. return (fetch_reg(rs1, regs) + sign_extend_imm13(insn));
  149. } else {
  150. maybe_flush_windows(rs1, rs2, rd);
  151. return (fetch_reg(rs1, regs) + fetch_reg(rs2, regs));
  152. }
  153. }
  155. static inline unsigned long safe_compute_effective_address(struct pt_regs *regs,
  156.    unsigned int insn)
  157. {
  158. unsigned int rs1 = (insn >> 14) & 0x1f;
  159. unsigned int rs2 = insn & 0x1f;
  160. unsigned int rd = (insn >> 25) & 0x1f;
  162. if(insn & 0x2000) {
  163. maybe_flush_windows(rs1, 0, rd);
  164. return (safe_fetch_reg(rs1, regs) + sign_extend_imm13(insn));
  165. } else {
  166. maybe_flush_windows(rs1, rs2, rd);
  167. return (safe_fetch_reg(rs1, regs) + safe_fetch_reg(rs2, regs));
  168. }
  169. }
  171. /* This is just to make gcc think panic does return... */
  172. static void unaligned_panic(char *str)
  173. {
  174. panic(str);
  175. }
  177. #define do_integer_load(dest_reg, size, saddr, is_signed, errh) ({
  178. __asm__ __volatile__ (
  179. "cmp %1, 8nt"
  180. "be 9fnt"
  181. " cmp %1, 4nt"
  182. "be 6fn"
  183. "4:t" " ldub [%2], %%l1n"
  184. "5:t" "ldub [%2 + 1], %%l2nt"
  185. "sll %%l1, 8, %%l1nt"
  186. "tst %3nt"
  187. "be 3fnt"
  188. " add %%l1, %%l2, %%l1nt"
  189. "sll %%l1, 16, %%l1nt"
  190. "sra %%l1, 16, %%l1n"
  191. "3:t" "b 0fnt"
  192. " st %%l1, [%0]n"
  193. "6:t" "ldub [%2 + 1], %%l2nt"
  194. "sll %%l1, 24, %%l1n"
  195. "7:t" "ldub [%2 + 2], %%g7nt"
  196. "sll %%l2, 16, %%l2n"
  197. "8:t" "ldub [%2 + 3], %%g1nt"
  198. "sll %%g7, 8, %%g7nt"
  199. "or %%l1, %%l2, %%l1nt"
  200. "or %%g7, %%g1, %%g7nt"
  201. "or %%l1, %%g7, %%l1nt"
  202. "b 0fnt"
  203. " st %%l1, [%0]n"
  204. "9:t" "ldub [%2], %%l1n"
  205. "10:t" "ldub [%2 + 1], %%l2nt"
  206. "sll %%l1, 24, %%l1n"
  207. "11:t" "ldub [%2 + 2], %%g7nt"
  208. "sll %%l2, 16, %%l2n"
  209. "12:t" "ldub [%2 + 3], %%g1nt"
  210. "sll %%g7, 8, %%g7nt"
  211. "or %%l1, %%l2, %%l1nt"
  212. "or %%g7, %%g1, %%g7nt"
  213. "or %%l1, %%g7, %%g7n"
  214. "13:t" "ldub [%2 + 4], %%l1nt"
  215. "st %%g7, [%0]n"
  216. "14:t" "ldub [%2 + 5], %%l2nt"
  217. "sll %%l1, 24, %%l1n"
  218. "15:t" "ldub [%2 + 6], %%g7nt"
  219. "sll %%l2, 16, %%l2n"
  220. "16:t" "ldub [%2 + 7], %%g1nt"
  221. "sll %%g7, 8, %%g7nt"
  222. "or %%l1, %%l2, %%l1nt"
  223. "or %%g7, %%g1, %%g7nt"
  224. "or %%l1, %%g7, %%g7nt"
  225. "st %%g7, [%0 + 4]n"
  226. "0:nnt"
  227. ".section __ex_table,#allocnt"
  228. ".word 4b, " #errh "nt"
  229. ".word 5b, " #errh "nt"
  230. ".word 6b, " #errh "nt"
  231. ".word 7b, " #errh "nt"
  232. ".word 8b, " #errh "nt"
  233. ".word 9b, " #errh "nt"
  234. ".word 10b, " #errh "nt"
  235. ".word 11b, " #errh "nt"
  236. ".word 12b, " #errh "nt"
  237. ".word 13b, " #errh "nt"
  238. ".word 14b, " #errh "nt"
  239. ".word 15b, " #errh "nt"
  240. ".word 16b, " #errh "nnt"
  241. ".previousnt"
  242. : : "r" (dest_reg), "r" (size), "r" (saddr), "r" (is_signed)
  243. : "l1", "l2", "g7", "g1", "cc");
  244. })
  246. #define store_common(dst_addr, size, src_val, errh) ({
  247. __asm__ __volatile__ (
  248. "ld [%2], %%l1n"
  249. "cmp %1, 2nt"
  250. "be 2fnt"
  251. " cmp %1, 4nt"
  252. "be 1fnt"
  253. " srl %%l1, 24, %%l2nt"
  254. "srl %%l1, 16, %%g7n"
  255. "4:t" "stb %%l2, [%0]nt"
  256. "srl %%l1, 8, %%l2n"
  257. "5:t" "stb %%g7, [%0 + 1]nt"
  258. "ld [%2 + 4], %%g7n"
  259. "6:t" "stb %%l2, [%0 + 2]nt"
  260. "srl %%g7, 24, %%l2n"
  261. "7:t" "stb %%l1, [%0 + 3]nt"
  262. "srl %%g7, 16, %%l1n"
  263. "8:t" "stb %%l2, [%0 + 4]nt"
  264. "srl %%g7, 8, %%l2n"
  265. "9:t" "stb %%l1, [%0 + 5]n"
  266. "10:t" "stb %%l2, [%0 + 6]nt"
  267. "b 0fn"
  268. "11:t" " stb %%g7, [%0 + 7]n"
  269. "1:t" "srl %%l1, 16, %%g7n"
  270. "12:t" "stb %%l2, [%0]nt"
  271. "srl %%l1, 8, %%l2n"
  272. "13:t" "stb %%g7, [%0 + 1]n"
  273. "14:t" "stb %%l2, [%0 + 2]nt"
  274. "b 0fn"
  275. "15:t" " stb %%l1, [%0 + 3]n"
  276. "2:t" "srl %%l1, 8, %%l2n"
  277. "16:t" "stb %%l2, [%0]n"
  278. "17:t" "stb %%l1, [%0 + 1]n"
  279. "0:nnt"
  280. ".section __ex_table,#allocnt"
  281. ".word 4b, " #errh "nt"
  282. ".word 5b, " #errh "nt"
  283. ".word 6b, " #errh "nt"
  284. ".word 7b, " #errh "nt"
  285. ".word 8b, " #errh "nt"
  286. ".word 9b, " #errh "nt"
  287. ".word 10b, " #errh "nt"
  288. ".word 11b, " #errh "nt"
  289. ".word 12b, " #errh "nt"
  290. ".word 13b, " #errh "nt"
  291. ".word 14b, " #errh "nt"
  292. ".word 15b, " #errh "nt"
  293. ".word 16b, " #errh "nt"
  294. ".word 17b, " #errh "nnt"
  295. ".previousnt"
  296. : : "r" (dst_addr), "r" (size), "r" (src_val)
  297. : "l1", "l2", "g7", "g1", "cc");
  298. })
  300. #define do_integer_store(reg_num, size, dst_addr, regs, errh) ({
  301. unsigned long *src_val;
  302. static unsigned long zero[2] = { 0, };
  304. if (reg_num) src_val = fetch_reg_addr(reg_num, regs);
  305. else {
  306. src_val = &zero[0];
  307. if (size == 8)
  308. zero[1] = fetch_reg(1, regs);
  309. }
  310. store_common(dst_addr, size, src_val, errh);
  311. })
  313. /* XXX Need to capture/release other cpu's for SMP around this. */
  314. #define do_atomic(srcdest_reg, mem, errh) ({
  315. unsigned long flags, tmp;
  317. save_and_cli(flags);
  318. tmp = *srcdest_reg;
  319. do_integer_load(srcdest_reg, 4, mem, 0, errh);
  320. store_common(mem, 4, &tmp, errh);
  321. restore_flags(flags);
  322. })
  324. static inline void advance(struct pt_regs *regs)
  325. {
  326. regs->pc   = regs->npc;
  327. regs->npc += 4;
  328. }
  330. static inline int floating_point_load_or_store_p(unsigned int insn)
  331. {
  332. return (insn >> 24) & 1;
  333. }
  335. static inline int ok_for_kernel(unsigned int insn)
  336. {
  337. return !floating_point_load_or_store_p(insn);
  338. }
  340. void kernel_mna_trap_fault(struct pt_regs *regs, unsigned int insn) __asm__ ("kernel_mna_trap_fault");
  342. void kernel_mna_trap_fault(struct pt_regs *regs, unsigned int insn)
  343. {
  344. unsigned long g2 = regs->u_regs [UREG_G2];
  345. unsigned long fixup = search_exception_table (regs->pc, &g2);
  347. if (!fixup) {
  348. unsigned long address = compute_effective_address(regs, insn);
  349.          if(address < PAGE_SIZE) {
  350.                  printk(KERN_ALERT "Unable to handle kernel NULL pointer dereference in mna handler");
  351.          } else
  352.                  printk(KERN_ALERT "Unable to handle kernel paging request in mna handler");
  353.         printk(KERN_ALERT " at virtual address %08lxn",address);
  354. printk(KERN_ALERT "current->{mm,active_mm}->context = %08lxn",
  355. (current->mm ? current->mm->context :
  356. current->active_mm->context));
  357. printk(KERN_ALERT "current->{mm,active_mm}->pgd = %08lxn",
  358. (current->mm ? (unsigned long) current->mm->pgd :
  359. (unsigned long) current->active_mm->pgd));
  360.         die_if_kernel("Oops", regs);
  361. /* Not reached */
  362. }
  363. regs->pc = fixup;
  364. regs->npc = regs->pc + 4;
  365. regs->u_regs [UREG_G2] = g2;
  366. }
  368. asmlinkage void kernel_unaligned_trap(struct pt_regs *regs, unsigned int insn)
  369. {
  370. enum direction dir = decode_direction(insn);
  371. int size = decode_access_size(insn);
  373. if(!ok_for_kernel(insn) || dir == both) {
  374. printk("Unsupported unaligned load/store trap for kernel at <%08lx>.n",
  375.        regs->pc);
  376. unaligned_panic("Wheee. Kernel does fpu/atomic unaligned load/store.");
  378. __asm__ __volatile__ ("n"
  379. "kernel_unaligned_trap_fault:nt"
  380. "mov %0, %%o0nt"
  381. "call kernel_mna_trap_faultnt"
  382. " mov %1, %%o1nt"
  383. :
  384. : "r" (regs), "r" (insn)
  385. : "o0", "o1", "o2", "o3", "o4", "o5", "o7",
  386.   "g1", "g2", "g3", "g4", "g5", "g7", "cc");
  387. } else {
  388. unsigned long addr = compute_effective_address(regs, insn);
  390. #ifdef DEBUG_MNA
  391. printk("KMNA: pc=%08lx [dir=%s addr=%08lx size=%d] retpc[%08lx]n",
  392.        regs->pc, dirstrings[dir], addr, size, regs->u_regs[UREG_RETPC]);
  393. #endif
  394. switch(dir) {
  395. case load:
  396. do_integer_load(fetch_reg_addr(((insn>>25)&0x1f), regs),
  397. size, (unsigned long *) addr,
  398. decode_signedness(insn),
  399. kernel_unaligned_trap_fault);
  400. break;
  402. case store:
  403. do_integer_store(((insn>>25)&0x1f), size,
  404.  (unsigned long *) addr, regs,
  405.  kernel_unaligned_trap_fault);
  406. break;
  407. #if 0 /* unsupported */
  408. case both:
  409. do_atomic(fetch_reg_addr(((insn>>25)&0x1f), regs),
  410.   (unsigned long *) addr,
  411.   kernel_unaligned_trap_fault);
  412. break;
  413. #endif
  414. default:
  415. panic("Impossible kernel unaligned trap.");
  416. /* Not reached... */
  417. }
  418. advance(regs);
  419. }
  420. }
  422. static inline int ok_for_user(struct pt_regs *regs, unsigned int insn,
  423.       enum direction dir)
  424. {
  425. unsigned int reg;
  426. int retval, check = (dir == load) ? VERIFY_READ : VERIFY_WRITE;
  427. int size = ((insn >> 19) & 3) == 3 ? 8 : 4;
  429. if((regs->pc | regs->npc) & 3)
  430. return 0;
  432. /* Must verify_area() in all the necessary places. */
  433. #define WINREG_ADDR(regnum) ((void *)(((unsigned long *)regs->u_regs[UREG_FP])+(regnum)))
  434. retval = 0;
  435. reg = (insn >> 25) & 0x1f;
  436. if(reg >= 16) {
  437. retval = verify_area(check, WINREG_ADDR(reg - 16), size);
  438. if(retval)
  439. return retval;
  440. }
  441. reg = (insn >> 14) & 0x1f;
  442. if(reg >= 16) {
  443. retval = verify_area(check, WINREG_ADDR(reg - 16), size);
  444. if(retval)
  445. return retval;
  446. }
  447. if(!(insn & 0x2000)) {
  448. reg = (insn & 0x1f);
  449. if(reg >= 16) {
  450. retval = verify_area(check, WINREG_ADDR(reg - 16), size);
  451. if(retval)
  452. return retval;
  453. }
  454. }
  455. return retval;
  456. #undef WINREG_ADDR
  457. }
  459. void user_mna_trap_fault(struct pt_regs *regs, unsigned int insn) __asm__ ("user_mna_trap_fault");
  461. void user_mna_trap_fault(struct pt_regs *regs, unsigned int insn)
  462. {
  463. siginfo_t info;
  465. info.si_signo = SIGBUS;
  466. info.si_errno = 0;
  467. info.si_code = BUS_ADRALN;
  468. info.si_addr = (void *)safe_compute_effective_address(regs, insn);
  469. info.si_trapno = 0;
  470. send_sig_info(SIGBUS, &info, current);
  471. }
  473. asmlinkage void user_unaligned_trap(struct pt_regs *regs, unsigned int insn)
  474. {
  475. enum direction dir;
  477. lock_kernel();
  478. if(!(current->thread.flags & SPARC_FLAG_UNALIGNED) ||
  479.    (((insn >> 30) & 3) != 3))
  480. goto kill_user;
  481. dir = decode_direction(insn);
  482. if(!ok_for_user(regs, insn, dir)) {
  483. goto kill_user;
  484. } else {
  485. int size = decode_access_size(insn);
  486. unsigned long addr;
  488. if(floating_point_load_or_store_p(insn)) {
  489. printk("User FPU load/store unaligned unsupported.n");
  490. goto kill_user;
  491. }
  493. addr = compute_effective_address(regs, insn);
  494. switch(dir) {
  495. case load:
  496. do_integer_load(fetch_reg_addr(((insn>>25)&0x1f), regs),
  497. size, (unsigned long *) addr,
  498. decode_signedness(insn),
  499. user_unaligned_trap_fault);
  500. break;
  502. case store:
  503. do_integer_store(((insn>>25)&0x1f), size,
  504.  (unsigned long *) addr, regs,
  505.  user_unaligned_trap_fault);
  506. break;
  508. case both:
  509. do_atomic(fetch_reg_addr(((insn>>25)&0x1f), regs),
  510.   (unsigned long *) addr,
  511.   user_unaligned_trap_fault);
  512. break;
  514. default:
  515. unaligned_panic("Impossible user unaligned trap.");
  517. __asm__ __volatile__ ("n"
  518. "user_unaligned_trap_fault:nt"
  519. "mov %0, %%o0nt"
  520. "call user_mna_trap_faultnt"
  521. " mov %1, %%o1nt"
  522. :
  523. : "r" (regs), "r" (insn)
  524. : "o0", "o1", "o2", "o3", "o4", "o5", "o7",
  525.   "g1", "g2", "g3", "g4", "g5", "g7", "cc");
  526. goto out;
  527. }
  528. advance(regs);
  529. goto out;
  530. }
  532. kill_user:
  533. user_mna_trap_fault(regs, insn);
  534. out:
  535. unlock_kernel();
  536. }