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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
unwind.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：56k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

unwind.c：源码内容
  1. /*
  2.  * Copyright (C) 1999-2002 Hewlett-Packard Co
  3.  * David Mosberger-Tang <davidm@hpl.hp.com>
  4.  */
  5. /*
  6.  * This file implements call frame unwind support for the Linux
  7.  * kernel.  Parsing and processing the unwind information is
  8.  * time-consuming, so this implementation translates the unwind
  9.  * descriptors into unwind scripts.  These scripts are very simple
  10.  * (basically a sequence of assignments) and efficient to execute.
  11.  * They are cached for later re-use.  Each script is specific for a
  12.  * given instruction pointer address and the set of predicate values
  13.  * that the script depends on (most unwind descriptors are
  14.  * unconditional and scripts often do not depend on predicates at
  15.  * all).  This code is based on the unwind conventions described in
  16.  * the "IA-64 Software Conventions and Runtime Architecture" manual.
  17.  *
  18.  * SMP conventions:
  19.  * o updates to the global unwind data (in structure "unw") are serialized
  20.  *   by the unw.lock spinlock
  21.  * o each unwind script has its own read-write lock; a thread must acquire
  22.  *   a read lock before executing a script and must acquire a write lock
  23.  *   before modifying a script
  24.  * o if both the unw.lock spinlock and a script's read-write lock must be
  25.  *   acquired, then the read-write lock must be acquired first.
  26.  */
  27. #include <linux/bootmem.h>
  28. #include <linux/kernel.h>
  29. #include <linux/sched.h>
  30. #include <linux/slab.h>
  32. #include <asm/unwind.h>
  34. #include <asm/delay.h>
  35. #include <asm/page.h>
  36. #include <asm/ptrace.h>
  37. #include <asm/ptrace_offsets.h>
  38. #include <asm/rse.h>
  39. #include <asm/system.h>
  40. #include <asm/uaccess.h>
  42. #include "entry.h"
  43. #include "unwind_i.h"
  45. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  46. #define p5 5
  48. #define UNW_LOG_CACHE_SIZE 7 /* each unw_script is ~256 bytes in size */
  49. #define UNW_CACHE_SIZE (1 << UNW_LOG_CACHE_SIZE)
  51. #define UNW_LOG_HASH_SIZE (UNW_LOG_CACHE_SIZE + 1)
  52. #define UNW_HASH_SIZE (1 << UNW_LOG_HASH_SIZE)
  54. #define UNW_DEBUG 0
  55. #define UNW_STATS 0 /* WARNING: this disabled interrupts for long time-spans!! */
  57. #if UNW_DEBUG
  58.   static long unw_debug_level = 255;
  59. # define debug(level,format...) if (unw_debug_level > level) printk(format)
  60. # define dprintk(format...) printk(format)
  61. # define inline
  62. #else
  63. # define debug(level,format...)
  64. # define dprintk(format...)
  65. #endif
  67. #if UNW_STATS
  68. # define STAT(x...) x
  69. #else
  70. # define STAT(x...)
  71. #endif
  73. #define alloc_reg_state() kmalloc(sizeof(struct unw_state_record), GFP_ATOMIC)
  74. #define free_reg_state(usr) kfree(usr)
  75. #define alloc_labeled_state() kmalloc(sizeof(struct unw_labeled_state), GFP_ATOMIC)
  76. #define free_labeled_state(usr) kfree(usr)
  78. typedef unsigned long unw_word;
  79. typedef unsigned char unw_hash_index_t;
  81. #define struct_offset(str,fld) ((char *)&((str *)NULL)->fld - (char *) 0)
  83. static struct {
  84. spinlock_t lock; /* spinlock for unwind data */
  86. /* list of unwind tables (one per load-module) */
  87. struct unw_table *tables;
  89. /* table of registers that prologues can save (and order in which they're saved): */
  90. const unsigned char save_order[8];
  92. /* maps a preserved register index (preg_index) to corresponding switch_stack offset: */
  93. unsigned short sw_off[sizeof(struct unw_frame_info) / 8];
  95. unsigned short lru_head; /* index of lead-recently used script */
  96. unsigned short lru_tail; /* index of most-recently used script */
  98. /* index into unw_frame_info for preserved register i */
  99. unsigned short preg_index[UNW_NUM_REGS];
  101. /* unwind table for the kernel: */
  102. struct unw_table kernel_table;
  104. /* unwind table describing the gate page (kernel code that is mapped into user space): */
  105. size_t gate_table_size;
  106. unsigned long *gate_table;
  108. /* hash table that maps instruction pointer to script index: */
  109. unsigned short hash[UNW_HASH_SIZE];
  111. /* script cache: */
  112. struct unw_script cache[UNW_CACHE_SIZE];
  114. # if UNW_DEBUG
  115. const char *preg_name[UNW_NUM_REGS];
  116. # endif
  117. # if UNW_STATS
  118. struct {
  119. struct {
  120. int lookups;
  121. int hinted_hits;
  122. int normal_hits;
  123. int collision_chain_traversals;
  124. } cache;
  125. struct {
  126. unsigned long build_time;
  127. unsigned long run_time;
  128. unsigned long parse_time;
  129. int builds;
  130. int news;
  131. int collisions;
  132. int runs;
  133. } script;
  134. struct {
  135. unsigned long init_time;
  136. unsigned long unwind_time;
  137. int inits;
  138. int unwinds;
  139. } api;
  140. } stat;
  141. # endif
  142. } unw = {
  143. tables: &unw.kernel_table,
  144. lock: SPIN_LOCK_UNLOCKED,
  145. save_order: {
  146. UNW_REG_RP, UNW_REG_PFS, UNW_REG_PSP, UNW_REG_PR,
  147. UNW_REG_UNAT, UNW_REG_LC, UNW_REG_FPSR, UNW_REG_PRI_UNAT_GR
  148. },
  149. preg_index: {
  150. struct_offset(struct unw_frame_info, pri_unat_loc)/8, /* PRI_UNAT_GR */
  151. struct_offset(struct unw_frame_info, pri_unat_loc)/8, /* PRI_UNAT_MEM */
  152. struct_offset(struct unw_frame_info, bsp_loc)/8,
  153. struct_offset(struct unw_frame_info, bspstore_loc)/8,
  154. struct_offset(struct unw_frame_info, pfs_loc)/8,
  155. struct_offset(struct unw_frame_info, rnat_loc)/8,
  156. struct_offset(struct unw_frame_info, psp)/8,
  157. struct_offset(struct unw_frame_info, rp_loc)/8,
  158. struct_offset(struct unw_frame_info, r4)/8,
  159. struct_offset(struct unw_frame_info, r5)/8,
  160. struct_offset(struct unw_frame_info, r6)/8,
  161. struct_offset(struct unw_frame_info, r7)/8,
  162. struct_offset(struct unw_frame_info, unat_loc)/8,
  163. struct_offset(struct unw_frame_info, pr_loc)/8,
  164. struct_offset(struct unw_frame_info, lc_loc)/8,
  165. struct_offset(struct unw_frame_info, fpsr_loc)/8,
  166. struct_offset(struct unw_frame_info, b1_loc)/8,
  167. struct_offset(struct unw_frame_info, b2_loc)/8,
  168. struct_offset(struct unw_frame_info, b3_loc)/8,
  169. struct_offset(struct unw_frame_info, b4_loc)/8,
  170. struct_offset(struct unw_frame_info, b5_loc)/8,
  171. struct_offset(struct unw_frame_info, f2_loc)/8,
  172. struct_offset(struct unw_frame_info, f3_loc)/8,
  173. struct_offset(struct unw_frame_info, f4_loc)/8,
  174. struct_offset(struct unw_frame_info, f5_loc)/8,
  175. struct_offset(struct unw_frame_info, fr_loc[16 - 16])/8,
  176. struct_offset(struct unw_frame_info, fr_loc[17 - 16])/8,
  177. struct_offset(struct unw_frame_info, fr_loc[18 - 16])/8,
  178. struct_offset(struct unw_frame_info, fr_loc[19 - 16])/8,
  179. struct_offset(struct unw_frame_info, fr_loc[20 - 16])/8,
  180. struct_offset(struct unw_frame_info, fr_loc[21 - 16])/8,
  181. struct_offset(struct unw_frame_info, fr_loc[22 - 16])/8,
  182. struct_offset(struct unw_frame_info, fr_loc[23 - 16])/8,
  183. struct_offset(struct unw_frame_info, fr_loc[24 - 16])/8,
  184. struct_offset(struct unw_frame_info, fr_loc[25 - 16])/8,
  185. struct_offset(struct unw_frame_info, fr_loc[26 - 16])/8,
  186. struct_offset(struct unw_frame_info, fr_loc[27 - 16])/8,
  187. struct_offset(struct unw_frame_info, fr_loc[28 - 16])/8,
  188. struct_offset(struct unw_frame_info, fr_loc[29 - 16])/8,
  189. struct_offset(struct unw_frame_info, fr_loc[30 - 16])/8,
  190. struct_offset(struct unw_frame_info, fr_loc[31 - 16])/8,
  191. },
  192. hash : { [0 ... UNW_HASH_SIZE - 1] = -1 },
  193. #if UNW_DEBUG
  194. preg_name: {
  195. "pri_unat_gr", "pri_unat_mem", "bsp", "bspstore", "ar.pfs", "ar.rnat", "psp", "rp",
  196. "r4", "r5", "r6", "r7",
  197. "ar.unat", "pr", "ar.lc", "ar.fpsr",
  198. "b1", "b2", "b3", "b4", "b5",
  199. "f2", "f3", "f4", "f5",
  200. "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
  201. "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31"
  202. }
  203. #endif
  204. };
  207. /* Unwind accessors.  */
  209. /*
  210.  * Returns offset of rREG in struct pt_regs.
  211.  */
  212. static inline unsigned long
  213. pt_regs_off (unsigned long reg)
  214. {
  215. unsigned long off =0;
  217. if (reg >= 1 && reg <= 3)
  218. off = struct_offset(struct pt_regs, r1) + 8*(reg - 1);
  219. else if (reg <= 11)
  220. off = struct_offset(struct pt_regs, r8) + 8*(reg - 8);
  221. else if (reg <= 15)
  222. off = struct_offset(struct pt_regs, r12) + 8*(reg - 12);
  223. else if (reg <= 31)
  224. off = struct_offset(struct pt_regs, r16) + 8*(reg - 16);
  225. else
  226. dprintk("unwind: bad scratch reg r%lun", reg);
  227. return off;
  228. }
  230. int
  231. unw_access_gr (struct unw_frame_info *info, int regnum, unsigned long *val, char *nat, int write)
  232. {
  233. unsigned long *addr, *nat_addr, nat_mask = 0, dummy_nat;
  234. struct unw_ireg *ireg;
  235. struct pt_regs *pt;
  237. if ((unsigned) regnum - 1 >= 127) {
  238. dprintk("unwind: trying to access non-existent r%un", regnum);
  239. return -1;
  240. }
  242. if (regnum < 32) {
  243. if (regnum >= 4 && regnum <= 7) {
  244. /* access a preserved register */
  245. ireg = &info->r4 + (regnum - 4);
  246. addr = ireg->loc;
  247. if (addr) {
  248. nat_addr = addr + ireg->nat.off;
  249. switch (ireg->nat.type) {
  250.       case UNW_NAT_VAL:
  251. /* simulate getf.sig/setf.sig */
  252. if (write) {
  253. if (*nat) {
  254. /* write NaTVal and be done with it */
  255. addr[0] = 0;
  256. addr[1] = 0x1fffe;
  257. return 0;
  258. }
  259. addr[1] = 0x1003e;
  260. } else {
  261. if (addr[0] == 0 && addr[1] == 0x1ffe) {
  262. /* return NaT and be done with it */
  263. *val = 0;
  264. *nat = 1;
  265. return 0;
  266. }
  267. }
  268. /* fall through */
  269.       case UNW_NAT_NONE:
  270. dummy_nat = 0;
  271. nat_addr = &dummy_nat;
  272. break;
  274.       case UNW_NAT_MEMSTK:
  275. nat_mask = (1UL << ((long) addr & 0x1f8)/8);
  276. break;
  278.       case UNW_NAT_REGSTK:
  279. nat_addr = ia64_rse_rnat_addr(addr);
  280. if ((unsigned long) addr < info->regstk.limit
  281.     || (unsigned long) addr >= info->regstk.top)
  282. {
  283. dprintk("unwind: %p outside of regstk "
  284. "[0x%lx-0x%lx)n", (void *) addr,
  285. info->regstk.limit,
  286. info->regstk.top);
  287. return -1;
  288. }
  289. if ((unsigned long) nat_addr >= info->regstk.top)
  290. nat_addr = &info->sw->ar_rnat;
  291. nat_mask = (1UL << ia64_rse_slot_num(addr));
  292. break;
  293. }
  294. } else {
  295. addr = &info->sw->r4 + (regnum - 4);
  296. nat_addr = &info->sw->ar_unat;
  297. nat_mask = (1UL << ((long) addr & 0x1f8)/8);
  298. }
  299. } else {
  300. /* access a scratch register */
  301. if (info->flags & UNW_FLAG_INTERRUPT_FRAME)
  302. pt = (struct pt_regs *) info->psp - 1;
  303. else
  304. pt = (struct pt_regs *) info->sp - 1;
  305. addr = (unsigned long *) ((long) pt + pt_regs_off(regnum));
  306. if (info->pri_unat_loc)
  307. nat_addr = info->pri_unat_loc;
  308. else
  309. nat_addr = &info->sw->ar_unat;
  310. nat_mask = (1UL << ((long) addr & 0x1f8)/8);
  311. }
  312. } else {
  313. /* access a stacked register */
  314. addr = ia64_rse_skip_regs((unsigned long *) info->bsp, regnum - 32);
  315. nat_addr = ia64_rse_rnat_addr(addr);
  316. if ((unsigned long) addr < info->regstk.limit
  317.     || (unsigned long) addr >= info->regstk.top)
  318. {
  319. dprintk("unwind: ignoring attempt to access register outside of rbsn");
  320. return -1;
  321. }
  322. if ((unsigned long) nat_addr >= info->regstk.top)
  323. nat_addr = &info->sw->ar_rnat;
  324. nat_mask = (1UL << ia64_rse_slot_num(addr));
  325. }
  327. if (write) {
  328. *addr = *val;
  329. if (*nat)
  330. *nat_addr |= nat_mask;
  331. else
  332. *nat_addr &= ~nat_mask;
  333. } else {
  334. if ((*nat_addr & nat_mask) == 0) {
  335. *val = *addr;
  336. *nat = 0;
  337. } else {
  338. *val = 0; /* if register is a NaT, *addr may contain kernel data! */
  339. *nat = 1;
  340. }
  341. }
  342. return 0;
  343. }
  345. int
  346. unw_access_br (struct unw_frame_info *info, int regnum, unsigned long *val, int write)
  347. {
  348. unsigned long *addr;
  349. struct pt_regs *pt;
  351. if (info->flags & UNW_FLAG_INTERRUPT_FRAME)
  352. pt = (struct pt_regs *) info->psp - 1;
  353. else
  354. pt = (struct pt_regs *) info->sp - 1;
  355. switch (regnum) {
  356. /* scratch: */
  357.       case 0: addr = &pt->b0; break;
  358.       case 6: addr = &pt->b6; break;
  359.       case 7: addr = &pt->b7; break;
  361. /* preserved: */
  362.       case 1: case 2: case 3: case 4: case 5:
  363. addr = *(&info->b1_loc + (regnum - 1));
  364. if (!addr)
  365. addr = &info->sw->b1 + (regnum - 1);
  366. break;
  368.       default:
  369. dprintk("unwind: trying to access non-existent b%un", regnum);
  370. return -1;
  371. }
  372. if (write)
  373. *addr = *val;
  374. else
  375. *val = *addr;
  376. return 0;
  377. }
  379. int
  380. unw_access_fr (struct unw_frame_info *info, int regnum, struct ia64_fpreg *val, int write)
  381. {
  382. struct ia64_fpreg *addr = 0;
  383. struct pt_regs *pt;
  385. if ((unsigned) (regnum - 2) >= 126) {
  386. dprintk("unwind: trying to access non-existent f%un", regnum);
  387. return -1;
  388. }
  390. if (info->flags & UNW_FLAG_INTERRUPT_FRAME)
  391. pt = (struct pt_regs *) info->psp - 1;
  392. else
  393. pt = (struct pt_regs *) info->sp - 1;
  395. if (regnum <= 5) {
  396. addr = *(&info->f2_loc + (regnum - 2));
  397. if (!addr)
  398. addr = &info->sw->f2 + (regnum - 2);
  399. } else if (regnum <= 15) {
  400. if (regnum <= 9)
  401. addr = &pt->f6  + (regnum - 6);
  402. else
  403. addr = &info->sw->f10 + (regnum - 10);
  404. } else if (regnum <= 31) {
  405. addr = info->fr_loc[regnum - 16];
  406. if (!addr)
  407. addr = &info->sw->f16 + (regnum - 16);
  408. } else {
  409. struct task_struct *t = info->task;
  411. if (write)
  412. ia64_sync_fph(t);
  413. else
  414. ia64_flush_fph(t);
  415. addr = t->thread.fph + (regnum - 32);
  416. }
  418. if (write)
  419. *addr = *val;
  420. else
  421. *val = *addr;
  422. return 0;
  423. }
  425. int
  426. unw_access_ar (struct unw_frame_info *info, int regnum, unsigned long *val, int write)
  427. {
  428. unsigned long *addr;
  429. struct pt_regs *pt;
  431. if (info->flags & UNW_FLAG_INTERRUPT_FRAME)
  432. pt = (struct pt_regs *) info->psp - 1;
  433. else
  434. pt = (struct pt_regs *) info->sp - 1;
  436. switch (regnum) {
  437.       case UNW_AR_BSP:
  438. addr = info->bsp_loc;
  439. if (!addr)
  440. addr = &info->sw->ar_bspstore;
  441. break;
  443.       case UNW_AR_BSPSTORE:
  444. addr = info->bspstore_loc;
  445. if (!addr)
  446. addr = &info->sw->ar_bspstore;
  447. break;
  449.       case UNW_AR_PFS:
  450. addr = info->pfs_loc;
  451. if (!addr)
  452. addr = &info->sw->ar_pfs;
  453. break;
  455.       case UNW_AR_RNAT:
  456. addr = info->rnat_loc;
  457. if (!addr)
  458. addr = &info->sw->ar_rnat;
  459. break;
  461.       case UNW_AR_UNAT:
  462. addr = info->unat_loc;
  463. if (!addr)
  464. addr = &info->sw->ar_unat;
  465. break;
  467.       case UNW_AR_LC:
  468. addr = info->lc_loc;
  469. if (!addr)
  470. addr = &info->sw->ar_lc;
  471. break;
  473.       case UNW_AR_EC:
  474. if (!info->cfm_loc)
  475. return -1;
  476. if (write)
  477. *info->cfm_loc =
  478. (*info->cfm_loc & ~(0x3fUL << 52)) | ((*val & 0x3f) << 52);
  479. else
  480. *val = (*info->cfm_loc >> 52) & 0x3f;
  481. return 0;
  483.       case UNW_AR_FPSR:
  484. addr = info->fpsr_loc;
  485. if (!addr)
  486. addr = &info->sw->ar_fpsr;
  487. break;
  489.       case UNW_AR_RSC:
  490. addr = &pt->ar_rsc;
  491. break;
  493.       case UNW_AR_CCV:
  494. addr = &pt->ar_ccv;
  495. break;
  497.       default:
  498. dprintk("unwind: trying to access non-existent ar%un", regnum);
  499. return -1;
  500. }
  502. if (write)
  503. *addr = *val;
  504. else
  505. *val = *addr;
  506. return 0;
  507. }
  509. int
  510. unw_access_pr (struct unw_frame_info *info, unsigned long *val, int write)
  511. {
  512. unsigned long *addr;
  514. addr = info->pr_loc;
  515. if (!addr)
  516. addr = &info->sw->pr;
  518. if (write)
  519. *addr = *val;
  520. else
  521. *val = *addr;
  522. return 0;
  523. }
  526. /* Routines to manipulate the state stack.  */
  528. static inline void
  529. push (struct unw_state_record *sr)
  530. {
  531. struct unw_reg_state *rs;
  533. rs = alloc_reg_state();
  534. if (!rs) {
  535. printk("unwind: cannot stack reg state!n");
  536. return;
  537. }
  538. memcpy(rs, &sr->curr, sizeof(*rs));
  539. sr->curr.next = rs;
  540. }
  542. static void
  543. pop (struct unw_state_record *sr)
  544. {
  545. struct unw_reg_state *rs = sr->curr.next;
  547. if (!rs) {
  548. printk("unwind: stack underflow!n");
  549. return;
  550. }
  551. memcpy(&sr->curr, rs, sizeof(*rs));
  552. free_reg_state(rs);
  553. }
  555. /* Make a copy of the state stack.  Non-recursive to avoid stack overflows.  */
  556. static struct unw_reg_state *
  557. dup_state_stack (struct unw_reg_state *rs)
  558. {
  559. struct unw_reg_state *copy, *prev = NULL, *first = NULL;
  561. while (rs) {
  562. copy = alloc_reg_state();
  563. if (!copy) {
  564. printk ("unwind.dup_state_stack: out of memoryn");
  565. return NULL;
  566. }
  567. memcpy(copy, rs, sizeof(*copy));
  568. if (first)
  569. prev->next = copy;
  570. else
  571. first = copy;
  572. rs = rs->next;
  573. prev = copy;
  574. }
  575. return first;
  576. }
  578. /* Free all stacked register states (but not RS itself).  */
  579. static void
  580. free_state_stack (struct unw_reg_state *rs)
  581. {
  582. struct unw_reg_state *p, *next;
  584. for (p = rs->next; p != NULL; p = next) {
  585. next = p->next;
  586. free_reg_state(p);
  587. }
  588. rs->next = NULL;
  589. }
  591. /* Unwind decoder routines */
  593. static enum unw_register_index __attribute__((const))
  594. decode_abreg (unsigned char abreg, int memory)
  595. {
  596. switch (abreg) {
  597.       case 0x04 ... 0x07: return UNW_REG_R4 + (abreg - 0x04);
  598.       case 0x22 ... 0x25: return UNW_REG_F2 + (abreg - 0x22);
  599.       case 0x30 ... 0x3f: return UNW_REG_F16 + (abreg - 0x30);
  600.       case 0x41 ... 0x45: return UNW_REG_B1 + (abreg - 0x41);
  601.       case 0x60: return UNW_REG_PR;
  602.       case 0x61: return UNW_REG_PSP;
  603.       case 0x62: return memory ? UNW_REG_PRI_UNAT_MEM : UNW_REG_PRI_UNAT_GR;
  604.       case 0x63: return UNW_REG_RP;
  605.       case 0x64: return UNW_REG_BSP;
  606.       case 0x65: return UNW_REG_BSPSTORE;
  607.       case 0x66: return UNW_REG_RNAT;
  608.       case 0x67: return UNW_REG_UNAT;
  609.       case 0x68: return UNW_REG_FPSR;
  610.       case 0x69: return UNW_REG_PFS;
  611.       case 0x6a: return UNW_REG_LC;
  612.       default:
  613. break;
  614. }
  615. dprintk("unwind: bad abreg=0x%xn", abreg);
  616. return UNW_REG_LC;
  617. }
  619. static void
  620. set_reg (struct unw_reg_info *reg, enum unw_where where, int when, unsigned long val)
  621. {
  622. reg->val = val;
  623. reg->where = where;
  624. if (reg->when == UNW_WHEN_NEVER)
  625. reg->when = when;
  626. }
  628. static void
  629. alloc_spill_area (unsigned long *offp, unsigned long regsize,
  630.   struct unw_reg_info *lo, struct unw_reg_info *hi)
  631. {
  632. struct unw_reg_info *reg;
  634. for (reg = hi; reg >= lo; --reg) {
  635. if (reg->where == UNW_WHERE_SPILL_HOME) {
  636. reg->where = UNW_WHERE_PSPREL;
  637. *offp -= regsize;
  638. reg->val = *offp;
  639. }
  640. }
  641. }
  643. static inline void
  644. spill_next_when (struct unw_reg_info **regp, struct unw_reg_info *lim, unw_word t)
  645. {
  646. struct unw_reg_info *reg;
  648. for (reg = *regp; reg <= lim; ++reg) {
  649. if (reg->where == UNW_WHERE_SPILL_HOME) {
  650. reg->when = t;
  651. *regp = reg + 1;
  652. return;
  653. }
  654. }
  655. dprintk("unwind: excess spill!n");
  656. }
  658. static inline void
  659. finish_prologue (struct unw_state_record *sr)
  660. {
  661. struct unw_reg_info *reg;
  662. unsigned long off;
  663. int i;
  665. /*
  666.  * First, resolve implicit register save locations (see Section "11.4.2.3 Rules
  667.  * for Using Unwind Descriptors", rule 3):
  668.  */
  669. for (i = 0; i < (int) sizeof(unw.save_order)/sizeof(unw.save_order[0]); ++i) {
  670. reg = sr->curr.reg + unw.save_order[i];
  671. if (reg->where == UNW_WHERE_GR_SAVE) {
  672. reg->where = UNW_WHERE_GR;
  673. reg->val = sr->gr_save_loc++;
  674. }
  675. }
  677. /*
  678.  * Next, compute when the fp, general, and branch registers get
  679.  * saved.  This must come before alloc_spill_area() because
  680.  * we need to know which registers are spilled to their home
  681.  * locations.
  682.  */
  683. if (sr->imask) {
  684. unsigned char kind, mask = 0, *cp = sr->imask;
  685. unsigned long t;
  686. static const unsigned char limit[3] = {
  687. UNW_REG_F31, UNW_REG_R7, UNW_REG_B5
  688. };
  689. struct unw_reg_info *(regs[3]);
  691. regs[0] = sr->curr.reg + UNW_REG_F2;
  692. regs[1] = sr->curr.reg + UNW_REG_R4;
  693. regs[2] = sr->curr.reg + UNW_REG_B1;
  695. for (t = 0; t < sr->region_len; ++t) {
  696. if ((t & 3) == 0)
  697. mask = *cp++;
  698. kind = (mask >> 2*(3-(t & 3))) & 3;
  699. if (kind > 0)
  700. spill_next_when(&regs[kind - 1], sr->curr.reg + limit[kind - 1],
  701. sr->region_start + t);
  702. }
  703. }
  704. /*
  705.  * Next, lay out the memory stack spill area:
  706.  */
  707. if (sr->any_spills) {
  708. off = sr->spill_offset;
  709. alloc_spill_area(&off, 16, sr->curr.reg + UNW_REG_F2, sr->curr.reg + UNW_REG_F31);
  710. alloc_spill_area(&off,  8, sr->curr.reg + UNW_REG_B1, sr->curr.reg + UNW_REG_B5);
  711. alloc_spill_area(&off,  8, sr->curr.reg + UNW_REG_R4, sr->curr.reg + UNW_REG_R7);
  712. }
  713. }
  715. /*
  716.  * Region header descriptors.
  717.  */
  719. static void
  720. desc_prologue (int body, unw_word rlen, unsigned char mask, unsigned char grsave,
  721.        struct unw_state_record *sr)
  722. {
  723. int i;
  725. if (!(sr->in_body || sr->first_region))
  726. finish_prologue(sr);
  727. sr->first_region = 0;
  729. /* check if we're done: */
  730. if (sr->when_target < sr->region_start + sr->region_len) {
  731. sr->done = 1;
  732. return;
  733. }
  735. for (i = 0; i < sr->epilogue_count; ++i)
  736. pop(sr);
  737. sr->epilogue_count = 0;
  738. sr->epilogue_start = UNW_WHEN_NEVER;
  740. if (!body)
  741. push(sr);
  743. sr->region_start += sr->region_len;
  744. sr->region_len = rlen;
  745. sr->in_body = body;
  747. if (!body) {
  748. for (i = 0; i < 4; ++i) {
  749. if (mask & 0x8)
  750. set_reg(sr->curr.reg + unw.save_order[i], UNW_WHERE_GR,
  751. sr->region_start + sr->region_len - 1, grsave++);
  752. mask <<= 1;
  753. }
  754. sr->gr_save_loc = grsave;
  755. sr->any_spills = 0;
  756. sr->imask = 0;
  757. sr->spill_offset = 0x10; /* default to psp+16 */
  758. }
  759. }
  761. /*
  762.  * Prologue descriptors.
  763.  */
  765. static inline void
  766. desc_abi (unsigned char abi, unsigned char context, struct unw_state_record *sr)
  767. {
  768. if (abi == 0 && context == 'i')
  769. sr->flags |= UNW_FLAG_INTERRUPT_FRAME;
  770. else
  771. dprintk("unwind: ignoring unwabi(abi=0x%x,context=0x%x)n", abi, context);
  772. }
  774. static inline void
  775. desc_br_gr (unsigned char brmask, unsigned char gr, struct unw_state_record *sr)
  776. {
  777. int i;
  779. for (i = 0; i < 5; ++i) {
  780. if (brmask & 1)
  781. set_reg(sr->curr.reg + UNW_REG_B1 + i, UNW_WHERE_GR,
  782. sr->region_start + sr->region_len - 1, gr++);
  783. brmask >>= 1;
  784. }
  785. }
  787. static inline void
  788. desc_br_mem (unsigned char brmask, struct unw_state_record *sr)
  789. {
  790. int i;
  792. for (i = 0; i < 5; ++i) {
  793. if (brmask & 1) {
  794. set_reg(sr->curr.reg + UNW_REG_B1 + i, UNW_WHERE_SPILL_HOME,
  795. sr->region_start + sr->region_len - 1, 0);
  796. sr->any_spills = 1;
  797. }
  798. brmask >>= 1;
  799. }
  800. }
  802. static inline void
  803. desc_frgr_mem (unsigned char grmask, unw_word frmask, struct unw_state_record *sr)
  804. {
  805. int i;
  807. for (i = 0; i < 4; ++i) {
  808. if ((grmask & 1) != 0) {
  809. set_reg(sr->curr.reg + UNW_REG_R4 + i, UNW_WHERE_SPILL_HOME,
  810. sr->region_start + sr->region_len - 1, 0);
  811. sr->any_spills = 1;
  812. }
  813. grmask >>= 1;
  814. }
  815. for (i = 0; i < 20; ++i) {
  816. if ((frmask & 1) != 0) {
  817. int base = (i < 4) ? UNW_REG_F2 : UNW_REG_F16 - 4;
  818. set_reg(sr->curr.reg + base + i, UNW_WHERE_SPILL_HOME,
  819. sr->region_start + sr->region_len - 1, 0);
  820. sr->any_spills = 1;
  821. }
  822. frmask >>= 1;
  823. }
  824. }
  826. static inline void
  827. desc_fr_mem (unsigned char frmask, struct unw_state_record *sr)
  828. {
  829. int i;
  831. for (i = 0; i < 4; ++i) {
  832. if ((frmask & 1) != 0) {
  833. set_reg(sr->curr.reg + UNW_REG_F2 + i, UNW_WHERE_SPILL_HOME,
  834. sr->region_start + sr->region_len - 1, 0);
  835. sr->any_spills = 1;
  836. }
  837. frmask >>= 1;
  838. }
  839. }
  841. static inline void
  842. desc_gr_gr (unsigned char grmask, unsigned char gr, struct unw_state_record *sr)
  843. {
  844. int i;
  846. for (i = 0; i < 4; ++i) {
  847. if ((grmask & 1) != 0)
  848. set_reg(sr->curr.reg + UNW_REG_R4 + i, UNW_WHERE_GR,
  849. sr->region_start + sr->region_len - 1, gr++);
  850. grmask >>= 1;
  851. }
  852. }
  854. static inline void
  855. desc_gr_mem (unsigned char grmask, struct unw_state_record *sr)
  856. {
  857. int i;
  859. for (i = 0; i < 4; ++i) {
  860. if ((grmask & 1) != 0) {
  861. set_reg(sr->curr.reg + UNW_REG_R4 + i, UNW_WHERE_SPILL_HOME,
  862. sr->region_start + sr->region_len - 1, 0);
  863. sr->any_spills = 1;
  864. }
  865. grmask >>= 1;
  866. }
  867. }
  869. static inline void
  870. desc_mem_stack_f (unw_word t, unw_word size, struct unw_state_record *sr)
  871. {
  872. set_reg(sr->curr.reg + UNW_REG_PSP, UNW_WHERE_NONE,
  873. sr->region_start + MIN((int)t, sr->region_len - 1), 16*size);
  874. }
  876. static inline void
  877. desc_mem_stack_v (unw_word t, struct unw_state_record *sr)
  878. {
  879. sr->curr.reg[UNW_REG_PSP].when = sr->region_start + MIN((int)t, sr->region_len - 1);
  880. }
  882. static inline void
  883. desc_reg_gr (unsigned char reg, unsigned char dst, struct unw_state_record *sr)
  884. {
  885. set_reg(sr->curr.reg + reg, UNW_WHERE_GR, sr->region_start + sr->region_len - 1, dst);
  886. }
  888. static inline void
  889. desc_reg_psprel (unsigned char reg, unw_word pspoff, struct unw_state_record *sr)
  890. {
  891. set_reg(sr->curr.reg + reg, UNW_WHERE_PSPREL, sr->region_start + sr->region_len - 1,
  892. 0x10 - 4*pspoff);
  893. }
  895. static inline void
  896. desc_reg_sprel (unsigned char reg, unw_word spoff, struct unw_state_record *sr)
  897. {
  898. set_reg(sr->curr.reg + reg, UNW_WHERE_SPREL, sr->region_start + sr->region_len - 1,
  899. 4*spoff);
  900. }
  902. static inline void
  903. desc_rp_br (unsigned char dst, struct unw_state_record *sr)
  904. {
  905. sr->return_link_reg = dst;
  906. }
  908. static inline void
  909. desc_reg_when (unsigned char regnum, unw_word t, struct unw_state_record *sr)
  910. {
  911. struct unw_reg_info *reg = sr->curr.reg + regnum;
  913. if (reg->where == UNW_WHERE_NONE)
  914. reg->where = UNW_WHERE_GR_SAVE;
  915. reg->when = sr->region_start + MIN((int)t, sr->region_len - 1);
  916. }
  918. static inline void
  919. desc_spill_base (unw_word pspoff, struct unw_state_record *sr)
  920. {
  921. sr->spill_offset = 0x10 - 4*pspoff;
  922. }
  924. static inline unsigned char *
  925. desc_spill_mask (unsigned char *imaskp, struct unw_state_record *sr)
  926. {
  927. sr->imask = imaskp;
  928. return imaskp + (2*sr->region_len + 7)/8;
  929. }
  931. /*
  932.  * Body descriptors.
  933.  */
  934. static inline void
  935. desc_epilogue (unw_word t, unw_word ecount, struct unw_state_record *sr)
  936. {
  937. sr->epilogue_start = sr->region_start + sr->region_len - 1 - t;
  938. sr->epilogue_count = ecount + 1;
  939. }
  941. static inline void
  942. desc_copy_state (unw_word label, struct unw_state_record *sr)
  943. {
  944. struct unw_labeled_state *ls;
  946. for (ls = sr->labeled_states; ls; ls = ls->next) {
  947. if (ls->label == label) {
  948. free_state_stack(&sr->curr);
  949. memcpy(&sr->curr, &ls->saved_state, sizeof(sr->curr));
  950. sr->curr.next = dup_state_stack(ls->saved_state.next);
  951. return;
  952. }
  953. }
  954. printk("unwind: failed to find state labeled 0x%lxn", label);
  955. }
  957. static inline void
  958. desc_label_state (unw_word label, struct unw_state_record *sr)
  959. {
  960. struct unw_labeled_state *ls;
  962. ls = alloc_labeled_state();
  963. if (!ls) {
  964. printk("unwind.desc_label_state(): out of memoryn");
  965. return;
  966. }
  967. ls->label = label;
  968. memcpy(&ls->saved_state, &sr->curr, sizeof(ls->saved_state));
  969. ls->saved_state.next = dup_state_stack(sr->curr.next);
  971. /* insert into list of labeled states: */
  972. ls->next = sr->labeled_states;
  973. sr->labeled_states = ls;
  974. }
  976. /*
  977.  * General descriptors.
  978.  */
  980. static inline int
  981. desc_is_active (unsigned char qp, unw_word t, struct unw_state_record *sr)
  982. {
  983. if (sr->when_target <= sr->region_start + MIN((int)t, sr->region_len - 1))
  984. return 0;
  985. if (qp > 0) {
  986. if ((sr->pr_val & (1UL << qp)) == 0)
  987. return 0;
  988. sr->pr_mask |= (1UL << qp);
  989. }
  990. return 1;
  991. }
  993. static inline void
  994. desc_restore_p (unsigned char qp, unw_word t, unsigned char abreg, struct unw_state_record *sr)
  995. {
  996. struct unw_reg_info *r;
  998. if (!desc_is_active(qp, t, sr))
  999. return;
  1001. r = sr->curr.reg + decode_abreg(abreg, 0);
  1002. r->where = UNW_WHERE_NONE;
  1003. r->when = UNW_WHEN_NEVER;
  1004. r->val = 0;
  1005. }
  1007. static inline void
  1008. desc_spill_reg_p (unsigned char qp, unw_word t, unsigned char abreg, unsigned char x,
  1009.      unsigned char ytreg, struct unw_state_record *sr)
  1010. {
  1011. enum unw_where where = UNW_WHERE_GR;
  1012. struct unw_reg_info *r;
  1014. if (!desc_is_active(qp, t, sr))
  1015. return;
  1017. if (x)
  1018. where = UNW_WHERE_BR;
  1019. else if (ytreg & 0x80)
  1020. where = UNW_WHERE_FR;
  1022. r = sr->curr.reg + decode_abreg(abreg, 0);
  1023. r->where = where;
  1024. r->when = sr->region_start + MIN((int)t, sr->region_len - 1);
  1025. r->val = (ytreg & 0x7f);
  1026. }
  1028. static inline void
  1029. desc_spill_psprel_p (unsigned char qp, unw_word t, unsigned char abreg, unw_word pspoff,
  1030.      struct unw_state_record *sr)
  1031. {
  1032. struct unw_reg_info *r;
  1034. if (!desc_is_active(qp, t, sr))
  1035. return;
  1037. r = sr->curr.reg + decode_abreg(abreg, 1);
  1038. r->where = UNW_WHERE_PSPREL;
  1039. r->when = sr->region_start + MIN((int)t, sr->region_len - 1);
  1040. r->val = 0x10 - 4*pspoff;
  1041. }
  1043. static inline void
  1044. desc_spill_sprel_p (unsigned char qp, unw_word t, unsigned char abreg, unw_word spoff,
  1045.        struct unw_state_record *sr)
  1046. {
  1047. struct unw_reg_info *r;
  1049. if (!desc_is_active(qp, t, sr))
  1050. return;
  1052. r = sr->curr.reg + decode_abreg(abreg, 1);
  1053. r->where = UNW_WHERE_SPREL;
  1054. r->when = sr->region_start + MIN((int)t, sr->region_len - 1);
  1055. r->val = 4*spoff;
  1056. }
  1058. #define UNW_DEC_BAD_CODE(code) printk("unwind: unknown code 0x%02xn", code);
  1060. /*
  1061.  * region headers:
  1062.  */
  1063. #define UNW_DEC_PROLOGUE_GR(fmt,r,m,gr,arg) desc_prologue(0,r,m,gr,arg)
  1064. #define UNW_DEC_PROLOGUE(fmt,b,r,arg) desc_prologue(b,r,0,32,arg)
  1065. /*
  1066.  * prologue descriptors:
  1067.  */
  1068. #define UNW_DEC_ABI(fmt,a,c,arg) desc_abi(a,c,arg)
  1069. #define UNW_DEC_BR_GR(fmt,b,g,arg) desc_br_gr(b,g,arg)
  1070. #define UNW_DEC_BR_MEM(fmt,b,arg) desc_br_mem(b,arg)
  1071. #define UNW_DEC_FRGR_MEM(fmt,g,f,arg) desc_frgr_mem(g,f,arg)
  1072. #define UNW_DEC_FR_MEM(fmt,f,arg) desc_fr_mem(f,arg)
  1073. #define UNW_DEC_GR_GR(fmt,m,g,arg) desc_gr_gr(m,g,arg)
  1074. #define UNW_DEC_GR_MEM(fmt,m,arg) desc_gr_mem(m,arg)
  1075. #define UNW_DEC_MEM_STACK_F(fmt,t,s,arg) desc_mem_stack_f(t,s,arg)
  1076. #define UNW_DEC_MEM_STACK_V(fmt,t,arg) desc_mem_stack_v(t,arg)
  1077. #define UNW_DEC_REG_GR(fmt,r,d,arg) desc_reg_gr(r,d,arg)
  1078. #define UNW_DEC_REG_PSPREL(fmt,r,o,arg) desc_reg_psprel(r,o,arg)
  1079. #define UNW_DEC_REG_SPREL(fmt,r,o,arg) desc_reg_sprel(r,o,arg)
  1080. #define UNW_DEC_REG_WHEN(fmt,r,t,arg) desc_reg_when(r,t,arg)
  1081. #define UNW_DEC_PRIUNAT_WHEN_GR(fmt,t,arg) desc_reg_when(UNW_REG_PRI_UNAT_GR,t,arg)
  1082. #define UNW_DEC_PRIUNAT_WHEN_MEM(fmt,t,arg) desc_reg_when(UNW_REG_PRI_UNAT_MEM,t,arg)
  1083. #define UNW_DEC_PRIUNAT_GR(fmt,r,arg) desc_reg_gr(UNW_REG_PRI_UNAT_GR,r,arg)
  1084. #define UNW_DEC_PRIUNAT_PSPREL(fmt,o,arg) desc_reg_psprel(UNW_REG_PRI_UNAT_MEM,o,arg)
  1085. #define UNW_DEC_PRIUNAT_SPREL(fmt,o,arg) desc_reg_sprel(UNW_REG_PRI_UNAT_MEM,o,arg)
  1086. #define UNW_DEC_RP_BR(fmt,d,arg) desc_rp_br(d,arg)
  1087. #define UNW_DEC_SPILL_BASE(fmt,o,arg) desc_spill_base(o,arg)
  1088. #define UNW_DEC_SPILL_MASK(fmt,m,arg) (m = desc_spill_mask(m,arg))
  1089. /*
  1090.  * body descriptors:
  1091.  */
  1092. #define UNW_DEC_EPILOGUE(fmt,t,c,arg) desc_epilogue(t,c,arg)
  1093. #define UNW_DEC_COPY_STATE(fmt,l,arg) desc_copy_state(l,arg)
  1094. #define UNW_DEC_LABEL_STATE(fmt,l,arg) desc_label_state(l,arg)
  1095. /*
  1096.  * general unwind descriptors:
  1097.  */
  1098. #define UNW_DEC_SPILL_REG_P(f,p,t,a,x,y,arg) desc_spill_reg_p(p,t,a,x,y,arg)
  1099. #define UNW_DEC_SPILL_REG(f,t,a,x,y,arg) desc_spill_reg_p(0,t,a,x,y,arg)
  1100. #define UNW_DEC_SPILL_PSPREL_P(f,p,t,a,o,arg) desc_spill_psprel_p(p,t,a,o,arg)
  1101. #define UNW_DEC_SPILL_PSPREL(f,t,a,o,arg) desc_spill_psprel_p(0,t,a,o,arg)
  1102. #define UNW_DEC_SPILL_SPREL_P(f,p,t,a,o,arg) desc_spill_sprel_p(p,t,a,o,arg)
  1103. #define UNW_DEC_SPILL_SPREL(f,t,a,o,arg) desc_spill_sprel_p(0,t,a,o,arg)
  1104. #define UNW_DEC_RESTORE_P(f,p,t,a,arg) desc_restore_p(p,t,a,arg)
  1105. #define UNW_DEC_RESTORE(f,t,a,arg) desc_restore_p(0,t,a,arg)
  1107. #include "unwind_decoder.c"
  1110. /* Unwind scripts. */
  1112. static inline unw_hash_index_t
  1113. hash (unsigned long ip)
  1114. {
  1115. # define magic 0x9e3779b97f4a7c16 /* based on (sqrt(5)/2-1)*2^64 */
  1117. return (ip >> 4)*magic >> (64 - UNW_LOG_HASH_SIZE);
  1118. }
  1120. static inline long
  1121. cache_match (struct unw_script *script, unsigned long ip, unsigned long pr)
  1122. {
  1123. read_lock(&script->lock);
  1124. if (ip == script->ip && ((pr ^ script->pr_val) & script->pr_mask) == 0)
  1125. /* keep the read lock... */
  1126. return 1;
  1127. read_unlock(&script->lock);
  1128. return 0;
  1129. }
  1131. static inline struct unw_script *
  1132. script_lookup (struct unw_frame_info *info)
  1133. {
  1134. struct unw_script *script = unw.cache + info->hint;
  1135. unsigned short index;
  1136. unsigned long ip, pr;
  1138. STAT(++unw.stat.cache.lookups);
  1140. ip = info->ip;
  1141. pr = info->pr;
  1143. if (cache_match(script, ip, pr)) {
  1144. STAT(++unw.stat.cache.hinted_hits);
  1145. return script;
  1146. }
  1148. index = unw.hash[hash(ip)];
  1149. if (index >= UNW_CACHE_SIZE)
  1150. return 0;
  1152. script = unw.cache + index;
  1153. while (1) {
  1154. if (cache_match(script, ip, pr)) {
  1155. /* update hint; no locking required as single-word writes are atomic */
  1156. STAT(++unw.stat.cache.normal_hits);
  1157. unw.cache[info->prev_script].hint = script - unw.cache;
  1158. return script;
  1159. }
  1160. if (script->coll_chain >= UNW_HASH_SIZE)
  1161. return 0;
  1162. script = unw.cache + script->coll_chain;
  1163. STAT(++unw.stat.cache.collision_chain_traversals);
  1164. }
  1165. }
  1167. /*
  1168.  * On returning, a write lock for the SCRIPT is still being held.
  1169.  */
  1170. static inline struct unw_script *
  1171. script_new (unsigned long ip)
  1172. {
  1173. struct unw_script *script, *prev, *tmp;
  1174. unw_hash_index_t index;
  1175. unsigned long flags;
  1176. unsigned short head;
  1178. STAT(++unw.stat.script.news);
  1180. /*
  1181.  * Can't (easily) use cmpxchg() here because of ABA problem
  1182.  * that is intrinsic in cmpxchg()...
  1183.  */
  1184. spin_lock_irqsave(&unw.lock, flags);
  1185. {
  1186. head = unw.lru_head;
  1187. script = unw.cache + head;
  1188. unw.lru_head = script->lru_chain;
  1189. }
  1190. spin_unlock(&unw.lock);
  1192. /*
  1193.  * XXX We'll deadlock here if we interrupt a thread that is
  1194.  * holding a read lock on script->lock.  A try_write_lock()
  1195.  * might be mighty handy here...  Alternatively, we could
  1196.  * disable interrupts whenever we hold a read-lock, but that
  1197.  * seems silly.
  1198.  */
  1199. write_lock(&script->lock);
  1201. spin_lock(&unw.lock);
  1202. {
  1203. /* re-insert script at the tail of the LRU chain: */
  1204. unw.cache[unw.lru_tail].lru_chain = head;
  1205. unw.lru_tail = head;
  1207. /* remove the old script from the hash table (if it's there): */
  1208. if (script->ip) {
  1209. index = hash(script->ip);
  1210. tmp = unw.cache + unw.hash[index];
  1211. prev = 0;
  1212. while (1) {
  1213. if (tmp == script) {
  1214. if (prev)
  1215. prev->coll_chain = tmp->coll_chain;
  1216. else
  1217. unw.hash[index] = tmp->coll_chain;
  1218. break;
  1219. } else
  1220. prev = tmp;
  1221. if (tmp->coll_chain >= UNW_CACHE_SIZE)
  1222. /* old script wasn't in the hash-table */
  1223. break;
  1224. tmp = unw.cache + tmp->coll_chain;
  1225. }
  1226. }
  1228. /* enter new script in the hash table */
  1229. index = hash(ip);
  1230. script->coll_chain = unw.hash[index];
  1231. unw.hash[index] = script - unw.cache;
  1233. script->ip = ip; /* set new IP while we're holding the locks */
  1235. STAT(if (script->coll_chain < UNW_CACHE_SIZE) ++unw.stat.script.collisions);
  1236. }
  1237. spin_unlock_irqrestore(&unw.lock, flags);
  1239. script->flags = 0;
  1240. script->hint = 0;
  1241. script->count = 0;
  1242. return script;
  1243. }
  1245. static void
  1246. script_finalize (struct unw_script *script, struct unw_state_record *sr)
  1247. {
  1248. script->pr_mask = sr->pr_mask;
  1249. script->pr_val = sr->pr_val;
  1250. /*
  1251.  * We could down-grade our write-lock on script->lock here but
  1252.  * the rwlock API doesn't offer atomic lock downgrading, so
  1253.  * we'll just keep the write-lock and release it later when
  1254.  * we're done using the script.
  1255.  */
  1256. }
  1258. static inline void
  1259. script_emit (struct unw_script *script, struct unw_insn insn)
  1260. {
  1261. if (script->count >= UNW_MAX_SCRIPT_LEN) {
  1262. dprintk("unwind: script exceeds maximum size of %u instructions!n",
  1263. UNW_MAX_SCRIPT_LEN);
  1264. return;
  1265. }
  1266. script->insn[script->count++] = insn;
  1267. }
  1269. static inline void
  1270. emit_nat_info (struct unw_state_record *sr, int i, struct unw_script *script)
  1271. {
  1272. struct unw_reg_info *r = sr->curr.reg + i;
  1273. enum unw_insn_opcode opc;
  1274. struct unw_insn insn;
  1275. unsigned long val = 0;
  1277. switch (r->where) {
  1278.       case UNW_WHERE_GR:
  1279. if (r->val >= 32) {
  1280. /* register got spilled to a stacked register */
  1281. opc = UNW_INSN_SETNAT_TYPE;
  1282. val = UNW_NAT_REGSTK;
  1283. } else
  1284. /* register got spilled to a scratch register */
  1285. opc = UNW_INSN_SETNAT_MEMSTK;
  1286. break;
  1288.       case UNW_WHERE_FR:
  1289. opc = UNW_INSN_SETNAT_TYPE;
  1290. val = UNW_NAT_VAL;
  1291. break;
  1293.       case UNW_WHERE_BR:
  1294. opc = UNW_INSN_SETNAT_TYPE;
  1295. val = UNW_NAT_NONE;
  1296. break;
  1298.       case UNW_WHERE_PSPREL:
  1299.       case UNW_WHERE_SPREL:
  1300. opc = UNW_INSN_SETNAT_MEMSTK;
  1301. break;
  1303.       default:
  1304. dprintk("unwind: don't know how to emit nat info for where = %un", r->where);
  1305. return;
  1306. }
  1307. insn.opc = opc;
  1308. insn.dst = unw.preg_index[i];
  1309. insn.val = val;
  1310. script_emit(script, insn);
  1311. }
  1313. static void
  1314. compile_reg (struct unw_state_record *sr, int i, struct unw_script *script)
  1315. {
  1316. struct unw_reg_info *r = sr->curr.reg + i;
  1317. enum unw_insn_opcode opc;
  1318. unsigned long val, rval;
  1319. struct unw_insn insn;
  1320. long need_nat_info;
  1322. if (r->where == UNW_WHERE_NONE || r->when >= sr->when_target)
  1323. return;
  1325. opc = UNW_INSN_MOVE;
  1326. val = rval = r->val;
  1327. need_nat_info = (i >= UNW_REG_R4 && i <= UNW_REG_R7);
  1329. switch (r->where) {
  1330.       case UNW_WHERE_GR:
  1331. if (rval >= 32) {
  1332. opc = UNW_INSN_MOVE_STACKED;
  1333. val = rval - 32;
  1334. } else if (rval >= 4 && rval <= 7) {
  1335. if (need_nat_info) {
  1336. opc = UNW_INSN_MOVE2;
  1337. need_nat_info = 0;
  1338. }
  1339. val = unw.preg_index[UNW_REG_R4 + (rval - 4)];
  1340. } else {
  1341. opc = UNW_INSN_ADD_SP;
  1342. val = -sizeof(struct pt_regs) + pt_regs_off(rval);
  1343. }
  1344. break;
  1346.       case UNW_WHERE_FR:
  1347. if (rval <= 5)
  1348. val = unw.preg_index[UNW_REG_F2  + (rval -  1)];
  1349. else if (rval >= 16 && rval <= 31)
  1350. val = unw.preg_index[UNW_REG_F16 + (rval - 16)];
  1351. else {
  1352. opc = UNW_INSN_ADD_SP;
  1353. val = -sizeof(struct pt_regs);
  1354. if (rval <= 9)
  1355. val += struct_offset(struct pt_regs, f6) + 16*(rval - 6);
  1356. else
  1357. dprintk("unwind: kernel may not touch f%lun", rval);
  1358. }
  1359. break;
  1361.       case UNW_WHERE_BR:
  1362. if (rval >= 1 && rval <= 5)
  1363. val = unw.preg_index[UNW_REG_B1 + (rval - 1)];
  1364. else {
  1365. opc = UNW_INSN_ADD_SP;
  1366. val = -sizeof(struct pt_regs);
  1367. if (rval == 0)
  1368. val += struct_offset(struct pt_regs, b0);
  1369. else if (rval == 6)
  1370. val += struct_offset(struct pt_regs, b6);
  1371. else
  1372. val += struct_offset(struct pt_regs, b7);
  1373. }
  1374. break;
  1376.       case UNW_WHERE_SPREL:
  1377. opc = UNW_INSN_ADD_SP;
  1378. break;
  1380.       case UNW_WHERE_PSPREL:
  1381. opc = UNW_INSN_ADD_PSP;
  1382. break;
  1384.       default:
  1385. dprintk("unwind: register %u has unexpected `where' value of %un", i, r->where);
  1386. break;
  1387. }
  1388. insn.opc = opc;
  1389. insn.dst = unw.preg_index[i];
  1390. insn.val = val;
  1391. script_emit(script, insn);
  1392. if (need_nat_info)
  1393. emit_nat_info(sr, i, script);
  1395. if (i == UNW_REG_PSP) {
  1396. /*
  1397.  * info->psp must contain the _value_ of the previous
  1398.  * sp, not it's save location.  We get this by
  1399.  * dereferencing the value we just stored in
  1400.  * info->psp:
  1401.  */
  1402. insn.opc = UNW_INSN_LOAD;
  1403. insn.dst = insn.val = unw.preg_index[UNW_REG_PSP];
  1404. script_emit(script, insn);
  1405. }
  1406. }
  1408. static inline const struct unw_table_entry *
  1409. lookup (struct unw_table *table, unsigned long rel_ip)
  1410. {
  1411. const struct unw_table_entry *e = 0;
  1412. unsigned long lo, hi, mid;
  1414. /* do a binary search for right entry: */
  1415. for (lo = 0, hi = table->length; lo < hi; ) {
  1416. mid = (lo + hi) / 2;
  1417. e = &table->array[mid];
  1418. if (rel_ip < e->start_offset)
  1419. hi = mid;
  1420. else if (rel_ip >= e->end_offset)
  1421. lo = mid + 1;
  1422. else
  1423. break;
  1424. }
  1425. if (rel_ip < e->start_offset || rel_ip >= e->end_offset)
  1426. return NULL;
  1427. return e;
  1428. }
  1430. /*
  1431.  * Build an unwind script that unwinds from state OLD_STATE to the
  1432.  * entrypoint of the function that called OLD_STATE.
  1433.  */
  1434. static inline struct unw_script *
  1435. build_script (struct unw_frame_info *info)
  1436. {
  1437. const struct unw_table_entry *e = 0;
  1438. struct unw_script *script = 0;
  1439. struct unw_labeled_state *ls, *next;
  1440. unsigned long ip = info->ip;
  1441. struct unw_state_record sr;
  1442. struct unw_table *table;
  1443. struct unw_reg_info *r;
  1444. struct unw_insn insn;
  1445. u8 *dp, *desc_end;
  1446. u64 hdr;
  1447. int i;
  1448. STAT(unsigned long start, parse_start;)
  1450. STAT(++unw.stat.script.builds; start = ia64_get_itc());
  1452. /* build state record */
  1453. memset(&sr, 0, sizeof(sr));
  1454. for (r = sr.curr.reg; r < sr.curr.reg + UNW_NUM_REGS; ++r)
  1455. r->when = UNW_WHEN_NEVER;
  1456. sr.pr_val = info->pr;
  1458. script = script_new(ip);
  1459. if (!script) {
  1460. dprintk("unwind: failed to create unwind scriptn");
  1461. STAT(unw.stat.script.build_time += ia64_get_itc() - start);
  1462. return 0;
  1463. }
  1464. unw.cache[info->prev_script].hint = script - unw.cache;
  1466. /* search the kernels and the modules' unwind tables for IP: */
  1468. STAT(parse_start = ia64_get_itc());
  1470. for (table = unw.tables; table; table = table->next) {
  1471. if (ip >= table->start && ip < table->end) {
  1472. e = lookup(table, ip - table->segment_base);
  1473. break;
  1474. }
  1475. }
  1476. if (!e) {
  1477. /* no info, return default unwinder (leaf proc, no mem stack, no saved regs)  */
  1478. dprintk("unwind: no unwind info for ip=0x%lx (prev ip=0x%lx)n", ip,
  1479. unw.cache[info->prev_script].ip);
  1480. sr.curr.reg[UNW_REG_RP].where = UNW_WHERE_BR;
  1481. sr.curr.reg[UNW_REG_RP].when = -1;
  1482. sr.curr.reg[UNW_REG_RP].val = 0;
  1483. compile_reg(&sr, UNW_REG_RP, script);
  1484. script_finalize(script, &sr);
  1485. STAT(unw.stat.script.parse_time += ia64_get_itc() - parse_start);
  1486. STAT(unw.stat.script.build_time += ia64_get_itc() - start);
  1487. return script;
  1488. }
  1490. sr.when_target = (3*((ip & ~0xfUL) - (table->segment_base + e->start_offset))/16
  1491.   + (ip & 0xfUL));
  1492. hdr = *(u64 *) (table->segment_base + e->info_offset);
  1493. dp =   (u8 *)  (table->segment_base + e->info_offset + 8);
  1494. desc_end = dp + 8*UNW_LENGTH(hdr);
  1496. while (!sr.done && dp < desc_end)
  1497. dp = unw_decode(dp, sr.in_body, &sr);
  1499. if (sr.when_target > sr.epilogue_start) {
  1500. /*
  1501.  * sp has been restored and all values on the memory stack below
  1502.  * psp also have been restored.
  1503.  */
  1504. sr.curr.reg[UNW_REG_PSP].val = 0;
  1505. sr.curr.reg[UNW_REG_PSP].where = UNW_WHERE_NONE;
  1506. sr.curr.reg[UNW_REG_PSP].when = UNW_WHEN_NEVER;
  1507. for (r = sr.curr.reg; r < sr.curr.reg + UNW_NUM_REGS; ++r)
  1508. if ((r->where == UNW_WHERE_PSPREL && r->val <= 0x10)
  1509.     || r->where == UNW_WHERE_SPREL)
  1510. {
  1511. r->val = 0;
  1512. r->where = UNW_WHERE_NONE;
  1513. r->when = UNW_WHEN_NEVER;
  1514. }
  1515. }
  1517. script->flags = sr.flags;
  1519. /*
  1520.  * If RP did't get saved, generate entry for the return link
  1521.  * register.
  1522.  */
  1523. if (sr.curr.reg[UNW_REG_RP].when >= sr.when_target) {
  1524. sr.curr.reg[UNW_REG_RP].where = UNW_WHERE_BR;
  1525. sr.curr.reg[UNW_REG_RP].when = -1;
  1526. sr.curr.reg[UNW_REG_RP].val = sr.return_link_reg;
  1527. }
  1529. #if UNW_DEBUG
  1530. printk("unwind: state record for func 0x%lx, t=%u:n",
  1531.        table->segment_base + e->start_offset, sr.when_target);
  1532. for (r = sr.curr.reg; r < sr.curr.reg + UNW_NUM_REGS; ++r) {
  1533. if (r->where != UNW_WHERE_NONE || r->when != UNW_WHEN_NEVER) {
  1534. printk("  %s <- ", unw.preg_name[r - sr.curr.reg]);
  1535. switch (r->where) {
  1536.       case UNW_WHERE_GR:     printk("r%lu", r->val); break;
  1537.       case UNW_WHERE_FR:     printk("f%lu", r->val); break;
  1538.       case UNW_WHERE_BR:     printk("b%lu", r->val); break;
  1539.       case UNW_WHERE_SPREL:  printk("[sp+0x%lx]", r->val); break;
  1540.       case UNW_WHERE_PSPREL: printk("[psp+0x%lx]", r->val); break;
  1541.       case UNW_WHERE_NONE:
  1542. printk("%s+0x%lx", unw.preg_name[r - sr.curr.reg], r->val);
  1543. break;
  1544.       default:      printk("BADWHERE(%d)", r->where); break;
  1545. }
  1546. printk("tt%dn", r->when);
  1547. }
  1548. }
  1549. #endif
  1551. STAT(unw.stat.script.parse_time += ia64_get_itc() - parse_start);
  1553. /* translate state record into unwinder instructions: */
  1555. /*
  1556.  * First, set psp if we're dealing with a fixed-size frame;
  1557.  * subsequent instructions may depend on this value.
  1558.  */
  1559. if (sr.when_target > sr.curr.reg[UNW_REG_PSP].when
  1560.     && (sr.curr.reg[UNW_REG_PSP].where == UNW_WHERE_NONE)
  1561.     && sr.curr.reg[UNW_REG_PSP].val != 0) {
  1562. /* new psp is sp plus frame size */
  1563. insn.opc = UNW_INSN_ADD;
  1564. insn.dst = struct_offset(struct unw_frame_info, psp)/8;
  1565. insn.val = sr.curr.reg[UNW_REG_PSP].val; /* frame size */
  1566. script_emit(script, insn);
  1567. }
  1569. /* determine where the primary UNaT is: */
  1570. if (sr.when_target < sr.curr.reg[UNW_REG_PRI_UNAT_GR].when)
  1571. i = UNW_REG_PRI_UNAT_MEM;
  1572. else if (sr.when_target < sr.curr.reg[UNW_REG_PRI_UNAT_MEM].when)
  1573. i = UNW_REG_PRI_UNAT_GR;
  1574. else if (sr.curr.reg[UNW_REG_PRI_UNAT_MEM].when > sr.curr.reg[UNW_REG_PRI_UNAT_GR].when)
  1575. i = UNW_REG_PRI_UNAT_MEM;
  1576. else
  1577. i = UNW_REG_PRI_UNAT_GR;
  1579. compile_reg(&sr, i, script);
  1581. for (i = UNW_REG_BSP; i < UNW_NUM_REGS; ++i)
  1582. compile_reg(&sr, i, script);
  1584. /* free labeled register states & stack: */
  1586. STAT(parse_start = ia64_get_itc());
  1587. for (ls = sr.labeled_states; ls; ls = next) {
  1588. next = ls->next;
  1589. free_state_stack(&ls->saved_state);
  1590. free_labeled_state(ls);
  1591. }
  1592. free_state_stack(&sr.curr);
  1593. STAT(unw.stat.script.parse_time += ia64_get_itc() - parse_start);
  1595. script_finalize(script, &sr);
  1596. STAT(unw.stat.script.build_time += ia64_get_itc() - start);
  1597. return script;
  1598. }
  1600. /*
  1601.  * Apply the unwinding actions represented by OPS and update SR to
  1602.  * reflect the state that existed upon entry to the function that this
  1603.  * unwinder represents.
  1604.  */
  1605. static inline void
  1606. run_script (struct unw_script *script, struct unw_frame_info *state)
  1607. {
  1608. struct unw_insn *ip, *limit, next_insn;
  1609. unsigned long opc, dst, val, off;
  1610. unsigned long *s = (unsigned long *) state;
  1611. STAT(unsigned long start;)
  1613. STAT(++unw.stat.script.runs; start = ia64_get_itc());
  1614. state->flags = script->flags;
  1615. ip = script->insn;
  1616. limit = script->insn + script->count;
  1617. next_insn = *ip;
  1619. while (ip++ < limit) {
  1620. opc = next_insn.opc;
  1621. dst = next_insn.dst;
  1622. val = next_insn.val;
  1623. next_insn = *ip;
  1625.   redo:
  1626. switch (opc) {
  1627.       case UNW_INSN_ADD:
  1628. s[dst] += val;
  1629. break;
  1631.       case UNW_INSN_MOVE2:
  1632. if (!s[val])
  1633. goto lazy_init;
  1634. s[dst+1] = s[val+1];
  1635. s[dst] = s[val];
  1636. break;
  1638.       case UNW_INSN_MOVE:
  1639. if (!s[val])
  1640. goto lazy_init;
  1641. s[dst] = s[val];
  1642. break;
  1644.       case UNW_INSN_MOVE_STACKED:
  1645. s[dst] = (unsigned long) ia64_rse_skip_regs((unsigned long *)state->bsp,
  1646.     val);
  1647. break;
  1649.       case UNW_INSN_ADD_PSP:
  1650. s[dst] = state->psp + val;
  1651. break;
  1653.       case UNW_INSN_ADD_SP:
  1654. s[dst] = state->sp + val;
  1655. break;
  1657.       case UNW_INSN_SETNAT_MEMSTK:
  1658. if (!state->pri_unat_loc)
  1659. state->pri_unat_loc = &state->sw->ar_unat;
  1660. /* register off. is a multiple of 8, so the least 3 bits (type) are 0 */
  1661. s[dst+1] = (*state->pri_unat_loc - s[dst]) | UNW_NAT_MEMSTK;
  1662. break;
  1664.       case UNW_INSN_SETNAT_TYPE:
  1665. s[dst+1] = val;
  1666. break;
  1668.       case UNW_INSN_LOAD:
  1669. #if UNW_DEBUG
  1670. if ((s[val] & (local_cpu_data->unimpl_va_mask | 0x7)) != 0
  1671.     || s[val] < TASK_SIZE)
  1672. {
  1673. debug(1, "unwind: rejecting bad psp=0x%lxn", s[val]);
  1674. break;
  1675. }
  1676. #endif
  1677. s[dst] = *(unsigned long *) s[val];
  1678. break;
  1679. }
  1680. }
  1681. STAT(unw.stat.script.run_time += ia64_get_itc() - start);
  1682. return;
  1684.   lazy_init:
  1685. off = unw.sw_off[val];
  1686. s[val] = (unsigned long) state->sw + off;
  1687. if (off >= struct_offset(struct switch_stack, r4)
  1688.     && off <= struct_offset(struct switch_stack, r7))
  1689. /*
  1690.  * We're initializing a general register: init NaT info, too.  Note that
  1691.  * the offset is a multiple of 8 which gives us the 3 bits needed for
  1692.  * the type field.
  1693.  */
  1694. s[val+1] = (struct_offset(struct switch_stack, ar_unat) - off) | UNW_NAT_MEMSTK;
  1695. goto redo;
  1696. }
  1698. static int
  1699. find_save_locs (struct unw_frame_info *info)
  1700. {
  1701. int have_write_lock = 0;
  1702. struct unw_script *scr;
  1704. if ((info->ip & (local_cpu_data->unimpl_va_mask | 0xf)) || info->ip < TASK_SIZE) {
  1705. /* don't let obviously bad addresses pollute the cache */
  1706. debug(1, "unwind: rejecting bad ip=0x%lxn", info->ip);
  1707. info->rp_loc = 0;
  1708. return -1;
  1709. }
  1711. scr = script_lookup(info);
  1712. if (!scr) {
  1713. scr = build_script(info);
  1714. if (!scr) {
  1715. dprintk("unwind: failed to locate/build unwind script for ip %lxn",
  1716. info->ip);
  1717. return -1;
  1718. }
  1719. have_write_lock = 1;
  1720. }
  1721. info->hint = scr->hint;
  1722. info->prev_script = scr - unw.cache;
  1724. run_script(scr, info);
  1726. if (have_write_lock)
  1727. write_unlock(&scr->lock);
  1728. else
  1729. read_unlock(&scr->lock);
  1730. return 0;
  1731. }
  1733. int
  1734. unw_unwind (struct unw_frame_info *info)
  1735. {
  1736. unsigned long prev_ip, prev_sp, prev_bsp;
  1737. unsigned long ip, pr, num_regs;
  1738. STAT(unsigned long start, flags;)
  1739. int retval;
  1741. STAT(local_irq_save(flags); ++unw.stat.api.unwinds; start = ia64_get_itc());
  1743. prev_ip = info->ip;
  1744. prev_sp = info->sp;
  1745. prev_bsp = info->bsp;
  1747. /* restore the ip */
  1748. if (!info->rp_loc) {
  1749. debug(1, "unwind: failed to locate return link (ip=0x%lx)!n", info->ip);
  1750. STAT(unw.stat.api.unwind_time += ia64_get_itc() - start; local_irq_restore(flags));
  1751. return -1;
  1752. }
  1753. ip = info->ip = *info->rp_loc;
  1754. if (ip < GATE_ADDR + PAGE_SIZE) {
  1755. /*
  1756.  * We don't have unwind info for the gate page, so we consider that part
  1757.  * of user-space for the purpose of unwinding.
  1758.  */
  1759. debug(1, "unwind: reached user-space (ip=0x%lx)n", ip);
  1760. STAT(unw.stat.api.unwind_time += ia64_get_itc() - start; local_irq_restore(flags));
  1761. return -1;
  1762. }
  1764. /* restore the cfm: */
  1765. if (!info->pfs_loc) {
  1766. dprintk("unwind: failed to locate ar.pfs!n");
  1767. STAT(unw.stat.api.unwind_time += ia64_get_itc() - start; local_irq_restore(flags));
  1768. return -1;
  1769. }
  1770. info->cfm_loc = info->pfs_loc;
  1772. /* restore the bsp: */
  1773. pr = info->pr;
  1774. num_regs = 0;
  1775. if ((info->flags & UNW_FLAG_INTERRUPT_FRAME)) {
  1776. if ((pr & (1UL << pNonSys)) != 0)
  1777. num_regs = *info->cfm_loc & 0x7f; /* size of frame */
  1778. info->pfs_loc =
  1779. (unsigned long *) (info->sp + 16 + struct_offset(struct pt_regs, ar_pfs));
  1780. } else
  1781. num_regs = (*info->cfm_loc >> 7) & 0x7f; /* size of locals */
  1782. info->bsp = (unsigned long) ia64_rse_skip_regs((unsigned long *) info->bsp, -num_regs);
  1783. if (info->bsp < info->regstk.limit || info->bsp > info->regstk.top) {
  1784. dprintk("unwind: bsp (0x%lx) out of range [0x%lx-0x%lx]n",
  1785. info->bsp, info->regstk.limit, info->regstk.top);
  1786. STAT(unw.stat.api.unwind_time += ia64_get_itc() - start; local_irq_restore(flags));
  1787. return -1;
  1788. }
  1790. /* restore the sp: */
  1791. info->sp = info->psp;
  1792. if (info->sp < info->memstk.top || info->sp > info->memstk.limit) {
  1793. dprintk("unwind: sp (0x%lx) out of range [0x%lx-0x%lx]n",
  1794. info->sp, info->memstk.top, info->memstk.limit);
  1795. STAT(unw.stat.api.unwind_time += ia64_get_itc() - start; local_irq_restore(flags));
  1796. return -1;
  1797. }
  1799. if (info->ip == prev_ip && info->sp == prev_sp && info->bsp == prev_bsp) {
  1800. dprintk("unwind: ip, sp, bsp remain unchanged; stopping here (ip=0x%lx)n", ip);
  1801. STAT(unw.stat.api.unwind_time += ia64_get_itc() - start; local_irq_restore(flags));
  1802. return -1;
  1803. }
  1805. /* as we unwind, the saved ar.unat becomes the primary unat: */
  1806. info->pri_unat_loc = info->unat_loc;
  1808. /* finally, restore the predicates: */
  1809. unw_get_pr(info, &info->pr);
  1811. retval = find_save_locs(info);
  1812. STAT(unw.stat.api.unwind_time += ia64_get_itc() - start; local_irq_restore(flags));
  1813. return retval;
  1814. }
  1816. int
  1817. unw_unwind_to_user (struct unw_frame_info *info)
  1818. {
  1819. unsigned long ip;
  1821. while (unw_unwind(info) >= 0) {
  1822. if (unw_get_rp(info, &ip) < 0) {
  1823. unw_get_ip(info, &ip);
  1824. dprintk("unwind: failed to read return pointer (ip=0x%lx)n", ip);
  1825. return -1;
  1826. }
  1827. /*
  1828.  * We don't have unwind info for the gate page, so we consider that part
  1829.  * of user-space for the purpose of unwinding.
  1830.  */
  1831. if (ip < GATE_ADDR + PAGE_SIZE)
  1832. return 0;
  1833. }
  1834. unw_get_ip(info, &ip);
  1835. dprintk("unwind: failed to unwind to user-level (ip=0x%lx)n", ip);
  1836. return -1;
  1837. }
  1839. void
  1840. unw_init_frame_info (struct unw_frame_info *info, struct task_struct *t, struct switch_stack *sw)
  1841. {
  1842. unsigned long rbslimit, rbstop, stklimit, stktop, sol;
  1843. STAT(unsigned long start, flags;)
  1845. STAT(local_irq_save(flags); ++unw.stat.api.inits; start = ia64_get_itc());
  1847. /*
  1848.  * Subtle stuff here: we _could_ unwind through the
  1849.  * switch_stack frame but we don't want to do that because it
  1850.  * would be slow as each preserved register would have to be
  1851.  * processed.  Instead, what we do here is zero out the frame
  1852.  * info and start the unwind process at the function that
  1853.  * created the switch_stack frame.  When a preserved value in
  1854.  * switch_stack needs to be accessed, run_script() will
  1855.  * initialize the appropriate pointer on demand.
  1856.  */
  1857. memset(info, 0, sizeof(*info));
  1859. rbslimit = (unsigned long) t + IA64_RBS_OFFSET;
  1860. rbstop   = sw->ar_bspstore;
  1861. if (rbstop - (unsigned long) t >= IA64_STK_OFFSET)
  1862. rbstop = rbslimit;
  1864. stklimit = (unsigned long) t + IA64_STK_OFFSET;
  1865. stktop   = (unsigned long) sw - 16;
  1866. if (stktop <= rbstop)
  1867. stktop = rbstop;
  1869. info->regstk.limit = rbslimit;
  1870. info->regstk.top   = rbstop;
  1871. info->memstk.limit = stklimit;
  1872. info->memstk.top   = stktop;
  1873. info->task = t;
  1874. info->sw  = sw;
  1875. info->sp = info->psp = (unsigned long) (sw + 1) - 16;
  1876. info->cfm_loc = &sw->ar_pfs;
  1877. sol = (*info->cfm_loc >> 7) & 0x7f;
  1878. info->bsp = (unsigned long) ia64_rse_skip_regs((unsigned long *) info->regstk.top, -sol);
  1879. info->ip = sw->b0;
  1880. info->pr = sw->pr;
  1882. find_save_locs(info);
  1883. STAT(unw.stat.api.init_time += ia64_get_itc() - start; local_irq_restore(flags));
  1884. }
  1886. void
  1887. unw_init_from_blocked_task (struct unw_frame_info *info, struct task_struct *t)
  1888. {
  1889. struct switch_stack *sw = (struct switch_stack *) (t->thread.ksp + 16);
  1891. unw_init_frame_info(info, t, sw);
  1892. }
  1894. static void
  1895. init_unwind_table (struct unw_table *table, const char *name, unsigned long segment_base,
  1896.    unsigned long gp, const void *table_start, const void *table_end)
  1897. {
  1898. const struct unw_table_entry *start = table_start, *end = table_end;
  1900. table->name = name;
  1901. table->segment_base = segment_base;
  1902. table->gp = gp;
  1903. table->start = segment_base + start[0].start_offset;
  1904. table->end = segment_base + end[-1].end_offset;
  1905. table->array = start;
  1906. table->length = end - start;
  1907. }
  1909. void *
  1910. unw_add_unwind_table (const char *name, unsigned long segment_base, unsigned long gp,
  1911.       const void *table_start, const void *table_end)
  1912. {
  1913. const struct unw_table_entry *start = table_start, *end = table_end;
  1914. struct unw_table *table;
  1915. unsigned long flags;
  1917. if (end - start <= 0) {
  1918. dprintk("unwind: ignoring attempt to insert empty unwind tablen");
  1919. return 0;
  1920. }
  1922. table = kmalloc(sizeof(*table), GFP_USER);
  1923. if (!table)
  1924. return 0;
  1926. init_unwind_table(table, name, segment_base, gp, table_start, table_end);
  1928. spin_lock_irqsave(&unw.lock, flags);
  1929. {
  1930. /* keep kernel unwind table at the front (it's searched most commonly): */
  1931. table->next = unw.tables->next;
  1932. unw.tables->next = table;
  1933. }
  1934. spin_unlock_irqrestore(&unw.lock, flags);
  1936. return table;
  1937. }
  1939. void
  1940. unw_remove_unwind_table (void *handle)
  1941. {
  1942. struct unw_table *table, *prev;
  1943. struct unw_script *tmp;
  1944. unsigned long flags;
  1945. long index;
  1947. if (!handle) {
  1948. dprintk("unwind: ignoring attempt to remove non-existent unwind tablen");
  1949. return;
  1950. }
  1952. table = handle;
  1953. if (table == &unw.kernel_table) {
  1954. dprintk("unwind: sorry, freeing the kernel's unwind table is a no-can-do!n");
  1955. return;
  1956. }
  1958. spin_lock_irqsave(&unw.lock, flags);
  1959. {
  1960. /* first, delete the table: */
  1962. for (prev = (struct unw_table *) &unw.tables; prev; prev = prev->next)
  1963. if (prev->next == table)
  1964. break;
  1965. if (!prev) {
  1966. dprintk("unwind: failed to find unwind table %pn", (void *) table);
  1967. spin_unlock_irqrestore(&unw.lock, flags);
  1968. return;
  1969. }
  1970. prev->next = table->next;
  1971. }
  1972. spin_unlock_irqrestore(&unw.lock, flags);
  1974. /* next, remove hash table entries for this table */
  1976. for (index = 0; index <= UNW_HASH_SIZE; ++index) {
  1977. tmp = unw.cache + unw.hash[index];
  1978. if (unw.hash[index] >= UNW_CACHE_SIZE
  1979.     || tmp->ip < table->start || tmp->ip >= table->end)
  1980. continue;
  1982. write_lock(&tmp->lock);
  1983. {
  1984. if (tmp->ip >= table->start && tmp->ip < table->end) {
  1985. unw.hash[index] = tmp->coll_chain;
  1986. tmp->ip = 0;
  1987. }
  1988. }
  1989. write_unlock(&tmp->lock);
  1990. }
  1992. kfree(table);
  1993. }
  1995. void
  1996. unw_create_gate_table (void)
  1997. {
  1998. extern char __start_gate_section[], __stop_gate_section[];
  1999. unsigned long *lp, start, end, segbase = unw.kernel_table.segment_base;
  2000. const struct unw_table_entry *entry, *first;
  2001. size_t info_size, size;
  2002. char *info;
  2004. start = (unsigned long) __start_gate_section - segbase;
  2005. end   = (unsigned long) __stop_gate_section - segbase;
  2006. size  = 0;
  2007. first = lookup(&unw.kernel_table, start);
  2009. for (entry = first; entry->start_offset < end; ++entry)
  2010. size += 3*8 + 8 + 8*UNW_LENGTH(*(u64 *) (segbase + entry->info_offset));
  2011. size += 8; /* reserve space for "end of table" marker */
  2013. unw.gate_table = alloc_bootmem(size);
  2014. if (!unw.gate_table) {
  2015. unw.gate_table_size = 0;
  2016. printk("unwind: unable to create unwind data for gate page!n");
  2017. return;
  2018. }
  2019. unw.gate_table_size = size;
  2021. lp = unw.gate_table;
  2022. info = (char *) unw.gate_table + size;
  2024. for (entry = first; entry->start_offset < end; ++entry, lp += 3) {
  2025. info_size = 8 + 8*UNW_LENGTH(*(u64 *) (segbase + entry->info_offset));
  2026. info -= info_size;
  2027. memcpy(info, (char *) segbase + entry->info_offset, info_size);
  2029. lp[0] = entry->start_offset - start + GATE_ADDR; /* start */
  2030. lp[1] = entry->end_offset - start + GATE_ADDR; /* end */
  2031. lp[2] = info - (char *) unw.gate_table; /* info */
  2032. }
  2033. *lp = 0; /* end-of-table marker */
  2034. }
  2036. void
  2037. unw_init (void)
  2038. {
  2039. extern int ia64_unw_start, ia64_unw_end, __gp;
  2040. extern void unw_hash_index_t_is_too_narrow (void);
  2041. long i, off;
  2043. if (8*sizeof(unw_hash_index_t) < UNW_LOG_HASH_SIZE)
  2044. unw_hash_index_t_is_too_narrow();
  2046. unw.sw_off[unw.preg_index[UNW_REG_PRI_UNAT_GR]] = SW(AR_UNAT);
  2047. unw.sw_off[unw.preg_index[UNW_REG_BSPSTORE]] = SW(AR_BSPSTORE);
  2048. unw.sw_off[unw.preg_index[UNW_REG_PFS]] = SW(AR_UNAT);
  2049. unw.sw_off[unw.preg_index[UNW_REG_RP]] = SW(B0);
  2050. unw.sw_off[unw.preg_index[UNW_REG_UNAT]] = SW(AR_UNAT);
  2051. unw.sw_off[unw.preg_index[UNW_REG_PR]] = SW(PR);
  2052. unw.sw_off[unw.preg_index[UNW_REG_LC]] = SW(AR_LC);
  2053. unw.sw_off[unw.preg_index[UNW_REG_FPSR]] = SW(AR_FPSR);
  2054. for (i = UNW_REG_R4, off = SW(R4); i <= UNW_REG_R7; ++i, off += 8)
  2055. unw.sw_off[unw.preg_index[i]] = off;
  2056. for (i = UNW_REG_B1, off = SW(B1); i <= UNW_REG_B5; ++i, off += 8)
  2057. unw.sw_off[unw.preg_index[i]] = off;
  2058. for (i = UNW_REG_F2, off = SW(F2); i <= UNW_REG_F5; ++i, off += 16)
  2059. unw.sw_off[unw.preg_index[i]] = off;
  2060. for (i = UNW_REG_F16, off = SW(F16); i <= UNW_REG_F31; ++i, off += 16)
  2061. unw.sw_off[unw.preg_index[i]] = off;
  2063. for (i = 0; i < UNW_CACHE_SIZE; ++i) {
  2064. if (i > 0)
  2065. unw.cache[i].lru_chain = (i - 1);
  2066. unw.cache[i].coll_chain = -1;
  2067. unw.cache[i].lock = RW_LOCK_UNLOCKED;
  2068. }
  2069. unw.lru_head = UNW_CACHE_SIZE - 1;
  2070. unw.lru_tail = 0;
  2072. init_unwind_table(&unw.kernel_table, "kernel", KERNEL_START, (unsigned long) &__gp,
  2073.   &ia64_unw_start, &ia64_unw_end);
  2074. }
  2076. /*
  2077.  * This system call copies the unwind data into the buffer pointed to by BUF and returns
  2078.  * the size of the unwind data.  If BUF_SIZE is smaller than the size of the unwind data
  2079.  * or if BUF is NULL, nothing is copied, but the system call still returns the size of the
  2080.  * unwind data.
  2081.  *
  2082.  * The first portion of the unwind data contains an unwind table and rest contains the
  2083.  * associated unwind info (in no particular order).  The unwind table consists of a table
  2084.  * of entries of the form:
  2085.  *
  2086.  * u64 start; (64-bit address of start of function)
  2087.  * u64 end; (64-bit address of start of function)
  2088.  * u64 info; (BUF-relative offset to unwind info)
  2089.  *
  2090.  * The end of the unwind table is indicated by an entry with a START address of zero.
  2091.  *
  2092.  * Please see the IA-64 Software Conventions and Runtime Architecture manual for details
  2093.  * on the format of the unwind info.
  2094.  *
  2095.  * ERRORS
  2096.  * EFAULT BUF points outside your accessible address space.
  2097.  */
  2098. asmlinkage long
  2099. sys_getunwind (void *buf, size_t buf_size)
  2100. {
  2101. if (buf && buf_size >= unw.gate_table_size)
  2102. if (copy_to_user(buf, unw.gate_table, unw.gate_table_size) != 0)
  2103. return -EFAULT;
  2104. return unw.gate_table_size;
  2105. }