Showing error 1430

User: Jiri Slaby
Error type: Leaving function in locked state
Error type description: Some lock is not unlocked on all paths of a function, so it is leaked
File location: kernel/irq/autoprobe.c
Line in file: 104
Project: Linux Kernel
Project version: 2.6.28
Tools: Stanse (1.2)
Entered: 2012-05-21 20:30:05 UTC

Source: 

  1/*
  2 * linux/kernel/irq/autoprobe.c
  3 *
  4 * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
  5 *
  6 * This file contains the interrupt probing code and driver APIs.
  7 */
  8
  9#include <linux/irq.h>
 10#include <linux/module.h>
 11#include <linux/interrupt.h>
 12#include <linux/delay.h>
 13
 14#include "internals.h"
 15
 16/*
 17 * Autodetection depends on the fact that any interrupt that
 18 * comes in on to an unassigned handler will get stuck with
 19 * "IRQ_WAITING" cleared and the interrupt disabled.
 20 */
 21static DEFINE_MUTEX(probing_active);
 22
 23/**
 24 *        probe_irq_on        - begin an interrupt autodetect
 25 *
 26 *        Commence probing for an interrupt. The interrupts are scanned
 27 *        and a mask of potential interrupt lines is returned.
 28 *
 29 */
 30unsigned long probe_irq_on(void)
 31{
 32        struct irq_desc *desc;
 33        unsigned long mask = 0;
 34        unsigned int status;
 35        int i;
 36
 37        mutex_lock(&probing_active);
 38        /*
 39         * something may have generated an irq long ago and we want to
 40         * flush such a longstanding irq before considering it as spurious.
 41         */
 42        for_each_irq_desc_reverse(i, desc) {
 43                spin_lock_irq(&desc->lock);
 44                if (!desc->action && !(desc->status & IRQ_NOPROBE)) {
 45                        /*
 46                         * An old-style architecture might still have
 47                         * the handle_bad_irq handler there:
 48                         */
 49                        compat_irq_chip_set_default_handler(desc);
 50
 51                        /*
 52                         * Some chips need to know about probing in
 53                         * progress:
 54                         */
 55                        if (desc->chip->set_type)
 56                                desc->chip->set_type(i, IRQ_TYPE_PROBE);
 57                        desc->chip->startup(i);
 58                }
 59                spin_unlock_irq(&desc->lock);
 60        }
 61
 62        /* Wait for longstanding interrupts to trigger. */
 63        msleep(20);
 64
 65        /*
 66         * enable any unassigned irqs
 67         * (we must startup again here because if a longstanding irq
 68         * happened in the previous stage, it may have masked itself)
 69         */
 70        for_each_irq_desc_reverse(i, desc) {
 71                spin_lock_irq(&desc->lock);
 72                if (!desc->action && !(desc->status & IRQ_NOPROBE)) {
 73                        desc->status |= IRQ_AUTODETECT | IRQ_WAITING;
 74                        if (desc->chip->startup(i))
 75                                desc->status |= IRQ_PENDING;
 76                }
 77                spin_unlock_irq(&desc->lock);
 78        }
 79
 80        /*
 81         * Wait for spurious interrupts to trigger
 82         */
 83        msleep(100);
 84
 85        /*
 86         * Now filter out any obviously spurious interrupts
 87         */
 88        for_each_irq_desc(i, desc) {
 89                spin_lock_irq(&desc->lock);
 90                status = desc->status;
 91
 92                if (status & IRQ_AUTODETECT) {
 93                        /* It triggered already - consider it spurious. */
 94                        if (!(status & IRQ_WAITING)) {
 95                                desc->status = status & ~IRQ_AUTODETECT;
 96                                desc->chip->shutdown(i);
 97                        } else
 98                                if (i < 32)
 99                                        mask |= 1 << i;
100                }
101                spin_unlock_irq(&desc->lock);
102        }
103
104        return mask;
105}
106EXPORT_SYMBOL(probe_irq_on);
107
108/**
109 *        probe_irq_mask - scan a bitmap of interrupt lines
110 *        @val:        mask of interrupts to consider
111 *
112 *        Scan the interrupt lines and return a bitmap of active
113 *        autodetect interrupts. The interrupt probe logic state
114 *        is then returned to its previous value.
115 *
116 *        Note: we need to scan all the irq's even though we will
117 *        only return autodetect irq numbers - just so that we reset
118 *        them all to a known state.
119 */
120unsigned int probe_irq_mask(unsigned long val)
121{
122        unsigned int status, mask = 0;
123        struct irq_desc *desc;
124        int i;
125
126        for_each_irq_desc(i, desc) {
127                spin_lock_irq(&desc->lock);
128                status = desc->status;
129
130                if (status & IRQ_AUTODETECT) {
131                        if (i < 16 && !(status & IRQ_WAITING))
132                                mask |= 1 << i;
133
134                        desc->status = status & ~IRQ_AUTODETECT;
135                        desc->chip->shutdown(i);
136                }
137                spin_unlock_irq(&desc->lock);
138        }
139        mutex_unlock(&probing_active);
140
141        return mask & val;
142}
143EXPORT_SYMBOL(probe_irq_mask);
144
145/**
146 *        probe_irq_off        - end an interrupt autodetect
147 *        @val: mask of potential interrupts (unused)
148 *
149 *        Scans the unused interrupt lines and returns the line which
150 *        appears to have triggered the interrupt. If no interrupt was
151 *        found then zero is returned. If more than one interrupt is
152 *        found then minus the first candidate is returned to indicate
153 *        their is doubt.
154 *
155 *        The interrupt probe logic state is returned to its previous
156 *        value.
157 *
158 *        BUGS: When used in a module (which arguably shouldn't happen)
159 *        nothing prevents two IRQ probe callers from overlapping. The
160 *        results of this are non-optimal.
161 */
162int probe_irq_off(unsigned long val)
163{
164        int i, irq_found = 0, nr_of_irqs = 0;
165        struct irq_desc *desc;
166        unsigned int status;
167
168        for_each_irq_desc(i, desc) {
169                spin_lock_irq(&desc->lock);
170                status = desc->status;
171
172                if (status & IRQ_AUTODETECT) {
173                        if (!(status & IRQ_WAITING)) {
174                                if (!nr_of_irqs)
175                                        irq_found = i;
176                                nr_of_irqs++;
177                        }
178                        desc->status = status & ~IRQ_AUTODETECT;
179                        desc->chip->shutdown(i);
180                }
181                spin_unlock_irq(&desc->lock);
182        }
183        mutex_unlock(&probing_active);
184
185        if (nr_of_irqs > 1)
186                irq_found = -irq_found;
187
188        return irq_found;
189}
190EXPORT_SYMBOL(probe_irq_off);
191
↑