kernel -- Slight changes to refcount_wait/_wakeup.
[dragonfly.git] / sys / kern / kern_refcount.c
1 /*
2  * Copyright (c) 2011 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34 /*
35  * Implement helper routines for the refcount inlines in sys/refcount.h.
36  *
37  * These helpers implement the refcount_release_wakeup() and refcount_wait()
38  * APIs for the non-trivial or race case.  The trivial non-race case is
39  * handled by the inline in sys/refcount.h
40  */
41
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/kernel.h>
45 #include <sys/sysctl.h>
46 #include <sys/thread.h>
47 #include <sys/refcount.h>
48
49 #include <machine/cpufunc.h>
50
51 #include <sys/thread2.h>
52
53 /*
54  * Helper function to wait for a reference count to become zero.
55  * We set REFCNTF_WAITING and sleep if the reference count is not zero.
56  *
57  * In the case where REFCNTF_WAITING is already set the atomic op validates
58  * that it is still set after the tsleep_interlock() call.
59  *
60  * Users of this waiting API must use refcount_release_wakeup() to release
61  * refs instead of refcount_release().  refcount_release() will not wake
62  * up waiters.
63  */
64 void
65 _refcount_wait(volatile u_int *countp, const char *wstr)
66 {
67         u_int n;
68         int loops = 0;
69         int threshold = 5;
70
71         for (;;) {
72                 n = *countp;
73                 if (n == 0)
74                         break;
75                 if (loops > threshold) {
76                         kprintf("refcount_wait %s long wait\n", wstr);
77                         loops = 0;
78                 }
79                 KKASSERT(n != REFCNTF_WAITING); /* impossible state */
80                 tsleep_interlock(countp, 0);
81                 if (atomic_cmpset_int(countp, n, n | REFCNTF_WAITING))
82                         tsleep(countp, PINTERLOCKED, wstr, hz*10);
83                 loops++;
84         }
85 }
86
87 /*
88  * This helper function implements the release-with-wakeup API.  It is
89  * executed for the non-trivial case or if the atomic op races.
90  *
91  * On the 1->0 transition is REFCNTF_WAITING is set it will be cleared
92  * and a wakeup() will be issued.
93  *
94  * On any other transition we simply subtract 1 and leave the REFCNTF_WAITING
95  * flag intact.
96  *
97  * This function returns TRUE(1) on the last release, whether a wakeup
98  * occured or not, and FALSE(0) otherwise.
99  */
100 int
101 _refcount_release_wakeup(volatile u_int *countp)
102 {
103         u_int n;
104
105         for (;;) {
106                 n = *countp;
107                 if (n == (REFCNTF_WAITING | 1)) {
108                         if (atomic_cmpset_int(countp, n, 0)) {
109                                 wakeup(countp);
110                                 n = 1;
111                                 break;
112                         }
113                 } else {
114                         KKASSERT(n != REFCNTF_WAITING); /* illegal state */
115                         if (atomic_cmpset_int(countp, n, n - 1))
116                                 break;
117                 }
118         }
119         return (n == 1);
120 }