Lines Matching defs:curr
411 static void lockdep_print_held_locks(struct task_struct *curr)
413 int i, depth = curr->lockdep_depth;
416 printk("no locks held by %s/%d.\n", curr->comm, curr->pid);
420 depth, depth > 1 ? "s" : "", curr->comm, curr->pid);
424 print_lock(curr->held_locks + i);
550 struct task_struct *curr = current;
560 curr->comm, curr->pid);
574 struct task_struct *curr = current;
587 lockdep_print_held_locks(curr);
733 print_bad_irq_dependency(struct task_struct *curr,
749 curr->comm, curr->pid,
750 curr->hardirq_context, hardirq_count() >> HARDIRQ_SHIFT,
751 curr->softirq_context, softirq_count() >> SOFTIRQ_SHIFT,
752 curr->hardirqs_enabled,
753 curr->softirqs_enabled);
779 lockdep_print_held_locks(curr);
794 check_usage(struct task_struct *curr, struct held_lock *prev,
811 return print_bad_irq_dependency(curr, prev, next,
818 print_deadlock_bug(struct task_struct *curr, struct held_lock *prev,
829 curr->comm, curr->pid);
835 lockdep_print_held_locks(curr);
852 check_deadlock(struct task_struct *curr, struct held_lock *next,
858 for (i = 0; i < curr->lockdep_depth; i++) {
859 prev = curr->held_locks + i;
868 return print_deadlock_bug(curr, prev, next);
896 check_prev_add(struct task_struct *curr, struct held_lock *prev,
923 if (!check_usage(curr, prev, next, LOCK_USED_IN_HARDIRQ,
933 if (!check_usage(curr, prev, next, LOCK_USED_IN_HARDIRQ_READ,
943 if (!check_usage(curr, prev, next, LOCK_USED_IN_SOFTIRQ,
952 if (!check_usage(curr, prev, next, LOCK_USED_IN_SOFTIRQ_READ,
1015 * The ones that are relevant are (in increasing distance from curr):
1020 check_prevs_add(struct task_struct *curr, struct held_lock *next)
1022 int depth = curr->lockdep_depth;
1036 if (curr->held_locks[depth].irq_context !=
1037 curr->held_locks[depth-1].irq_context)
1041 int distance = curr->lockdep_depth - depth + 1;
1042 hlock = curr->held_locks + depth-1;
1048 if (!check_prev_add(curr, hlock, next, distance))
1068 if (curr->held_locks[depth].irq_context !=
1069 curr->held_locks[depth-1].irq_context)
1380 static void check_chain_key(struct task_struct *curr)
1387 for (i = 0; i < curr->lockdep_depth; i++) {
1388 hlock = curr->held_locks + i;
1392 curr->lockdep_depth, i,
1408 if (chain_key != curr->curr_chain_key) {
1411 curr->lockdep_depth, i,
1413 (unsigned long long)curr->curr_chain_key);
1425 print_irq_inversion_bug(struct task_struct *curr, struct lock_class *other,
1437 curr->comm, curr->pid);
1447 lockdep_print_held_locks(curr);
1466 check_usage_forwards(struct task_struct *curr, struct held_lock *this,
1477 return print_irq_inversion_bug(curr, forwards_match, this, 1, irqclass);
1485 check_usage_backwards(struct task_struct *curr, struct held_lock *this,
1496 return print_irq_inversion_bug(curr, backwards_match, this, 0, irqclass);
1499 void print_irqtrace_events(struct task_struct *curr)
1501 printk("irq event stamp: %u\n", curr->irq_events);
1502 printk("hardirqs last enabled at (%u): ", curr->hardirq_enable_event);
1503 print_ip_sym(curr->hardirq_enable_ip);
1504 printk("hardirqs last disabled at (%u): ", curr->hardirq_disable_event);
1505 print_ip_sym(curr->hardirq_disable_ip);
1506 printk("softirqs last enabled at (%u): ", curr->softirq_enable_event);
1507 print_ip_sym(curr->softirq_enable_ip);
1508 printk("softirqs last disabled at (%u): ", curr->softirq_disable_event);
1509 print_ip_sym(curr->softirq_disable_ip);
1515 print_usage_bug(struct task_struct *curr, struct held_lock *this,
1530 curr->comm, curr->pid,
1531 trace_hardirq_context(curr), hardirq_count() >> HARDIRQ_SHIFT,
1532 trace_softirq_context(curr), softirq_count() >> SOFTIRQ_SHIFT,
1533 trace_hardirqs_enabled(curr),
1534 trace_softirqs_enabled(curr));
1540 print_irqtrace_events(curr);
1542 lockdep_print_held_locks(curr);
1554 valid_state(struct task_struct *curr, struct held_lock *this,
1558 return print_usage_bug(curr, this, bad_bit, new_bit);
1567 static int mark_lock(struct task_struct *curr, struct held_lock *this,
1597 if (!valid_state(curr, this, new_bit, LOCK_ENABLED_HARDIRQS))
1599 if (!valid_state(curr, this, new_bit,
1606 if (!check_usage_forwards(curr, this,
1614 if (!check_usage_forwards(curr, this,
1622 if (!valid_state(curr, this, new_bit, LOCK_ENABLED_SOFTIRQS))
1624 if (!valid_state(curr, this, new_bit,
1631 if (!check_usage_forwards(curr, this,
1639 if (!check_usage_forwards(curr, this,
1647 if (!valid_state(curr, this, new_bit, LOCK_ENABLED_HARDIRQS))
1653 if (!check_usage_forwards(curr, this,
1660 if (!valid_state(curr, this, new_bit, LOCK_ENABLED_SOFTIRQS))
1666 if (!check_usage_forwards(curr, this,
1673 if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ))
1675 if (!valid_state(curr, this, new_bit,
1682 if (!check_usage_backwards(curr, this,
1691 if (!check_usage_backwards(curr, this,
1699 if (!valid_state(curr, this, new_bit, LOCK_USED_IN_SOFTIRQ))
1701 if (!valid_state(curr, this, new_bit,
1708 if (!check_usage_backwards(curr, this,
1717 if (!check_usage_backwards(curr, this,
1725 if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ))
1732 if (!check_usage_backwards(curr, this,
1740 if (!valid_state(curr, this, new_bit, LOCK_USED_IN_SOFTIRQ))
1747 if (!check_usage_backwards(curr, this,
1777 print_irqtrace_events(curr);
1789 mark_held_locks(struct task_struct *curr, int hardirq)
1795 for (i = 0; i < curr->lockdep_depth; i++) {
1796 hlock = curr->held_locks + i;
1809 if (!mark_lock(curr, hlock, usage_bit))
1837 struct task_struct *curr = current;
1846 if (unlikely(curr->hardirqs_enabled)) {
1851 curr->hardirqs_enabled = 1;
1862 if (!mark_held_locks(curr, 1))
1869 if (curr->softirqs_enabled)
1870 if (!mark_held_locks(curr, 0))
1873 curr->hardirq_enable_ip = ip;
1874 curr->hardirq_enable_event = ++curr->irq_events;
1885 struct task_struct *curr = current;
1893 if (curr->hardirqs_enabled) {
1897 curr->hardirqs_enabled = 0;
1898 curr->hardirq_disable_ip = _RET_IP_;
1899 curr->hardirq_disable_event = ++curr->irq_events;
1912 struct task_struct *curr = current;
1920 if (curr->softirqs_enabled) {
1928 curr->softirqs_enabled = 1;
1929 curr->softirq_enable_ip = ip;
1930 curr->softirq_enable_event = ++curr->irq_events;
1937 if (curr->hardirqs_enabled)
1938 mark_held_locks(curr, 0);
1946 struct task_struct *curr = current;
1954 if (curr->softirqs_enabled) {
1958 curr->softirqs_enabled = 0;
1959 curr->softirq_disable_ip = ip;
1960 curr->softirq_disable_event = ++curr->irq_events;
2007 struct task_struct *curr = current;
2051 depth = curr->lockdep_depth;
2055 hlock = curr->held_locks + depth;
2074 if (curr->hardirq_context)
2075 if (!mark_lock(curr, hlock,
2078 if (curr->softirq_context)
2079 if (!mark_lock(curr, hlock,
2083 if (curr->hardirq_context)
2084 if (!mark_lock(curr, hlock, LOCK_USED_IN_HARDIRQ))
2086 if (curr->softirq_context)
2087 if (!mark_lock(curr, hlock, LOCK_USED_IN_SOFTIRQ))
2093 if (!mark_lock(curr, hlock,
2096 if (curr->softirqs_enabled)
2097 if (!mark_lock(curr, hlock,
2101 if (!mark_lock(curr, hlock,
2104 if (curr->softirqs_enabled)
2105 if (!mark_lock(curr, hlock,
2112 if (!mark_lock(curr, hlock, LOCK_USED))
2129 chain_key = curr->curr_chain_key;
2142 hlock->irq_context = 2*(curr->hardirq_context ? 1 : 0) +
2143 curr->softirq_context;
2147 prev_hlock = curr->held_locks + depth-1;
2160 curr->curr_chain_key = chain_key;
2185 int ret = check_deadlock(curr, hlock, lock, read);
2201 if (!check_prevs_add(curr, hlock))
2209 curr->lockdep_depth++;
2210 check_chain_key(curr);
2215 if (unlikely(curr->lockdep_depth >= MAX_LOCK_DEPTH)) {
2222 if (unlikely(curr->lockdep_depth > max_lockdep_depth))
2223 max_lockdep_depth = curr->lockdep_depth;
2229 print_unlock_inbalance_bug(struct task_struct *curr, struct lockdep_map *lock,
2241 curr->comm, curr->pid);
2247 lockdep_print_held_locks(curr);
2258 static int check_unlock(struct task_struct *curr, struct lockdep_map *lock,
2266 if (curr->lockdep_depth <= 0)
2267 return print_unlock_inbalance_bug(curr, lock, ip);
2279 lock_release_non_nested(struct task_struct *curr,
2290 depth = curr->lockdep_depth;
2296 hlock = curr->held_locks + i;
2306 return print_unlock_inbalance_bug(curr, lock, ip);
2314 curr->lockdep_depth = i;
2315 curr->curr_chain_key = hlock->prev_chain_key;
2318 hlock = curr->held_locks + i;
2326 if (DEBUG_LOCKS_WARN_ON(curr->lockdep_depth != depth - 1))
2337 static int lock_release_nested(struct task_struct *curr,
2346 depth = curr->lockdep_depth - 1;
2347 hlock = curr->held_locks + depth;
2353 return lock_release_non_nested(curr, lock, ip);
2354 curr->lockdep_depth--;
2359 curr->curr_chain_key = hlock->prev_chain_key;
2379 struct task_struct *curr = current;
2381 if (!check_unlock(curr, lock, ip))
2385 if (!lock_release_nested(curr, lock, ip))
2388 if (!lock_release_non_nested(curr, lock, ip))
2392 check_chain_key(curr);
2641 print_freed_lock_bug(struct task_struct *curr, const void *mem_from,
2653 curr->comm, curr->pid, mem_from, mem_to-1);
2655 lockdep_print_held_locks(curr);
2669 struct task_struct *curr = current;
2678 for (i = 0; i < curr->lockdep_depth; i++) {
2679 hlock = curr->held_locks + i;
2688 print_freed_lock_bug(curr, mem_from, mem_to, hlock);
2695 static void print_held_locks_bug(struct task_struct *curr)
2706 curr->comm, curr->pid);
2707 lockdep_print_held_locks(curr);