cubefs

1
// Copyright 2014 The Go Authors. All rights reserved.
2
// Use of this source code is governed by a BSD-style
3
// license that can be found in the LICENSE file.
4

5
// Defensive debug-only utility to track that functions run on the
6
// goroutine that they're supposed to.
7

8
package http2
9

10
import (
11
	"bytes"
12
	"errors"
13
	"fmt"
14
	"os"
15
	"runtime"
16
	"strconv"
17
	"sync"
18
)
19

20
var DebugGoroutines = os.Getenv("DEBUG_HTTP2_GOROUTINES") == "1"
21

22
type goroutineLock uint64
23

24
func newGoroutineLock() goroutineLock {
25
	if !DebugGoroutines {
26
		return 0
27
	}
28
	return goroutineLock(curGoroutineID())
29
}
30

31
func (g goroutineLock) check() {
32
	if !DebugGoroutines {
33
		return
34
	}
35
	if curGoroutineID() != uint64(g) {
36
		panic("running on the wrong goroutine")
37
	}
38
}
39

40
func (g goroutineLock) checkNotOn() {
41
	if !DebugGoroutines {
42
		return
43
	}
44
	if curGoroutineID() == uint64(g) {
45
		panic("running on the wrong goroutine")
46
	}
47
}
48

49
var goroutineSpace = []byte("goroutine ")
50

51
func curGoroutineID() uint64 {
52
	bp := littleBuf.Get().(*[]byte)
53
	defer littleBuf.Put(bp)
54
	b := *bp
55
	b = b[:runtime.Stack(b, false)]
56
	// Parse the 4707 out of "goroutine 4707 ["
57
	b = bytes.TrimPrefix(b, goroutineSpace)
58
	i := bytes.IndexByte(b, ' ')
59
	if i < 0 {
60
		panic(fmt.Sprintf("No space found in %q", b))
61
	}
62
	b = b[:i]
63
	n, err := parseUintBytes(b, 10, 64)
64
	if err != nil {
65
		panic(fmt.Sprintf("Failed to parse goroutine ID out of %q: %v", b, err))
66
	}
67
	return n
68
}
69

70
var littleBuf = sync.Pool{
71
	New: func() interface{} {
72
		buf := make([]byte, 64)
73
		return &buf
74
	},
75
}
76

77
// parseUintBytes is like strconv.ParseUint, but using a []byte.
78
func parseUintBytes(s []byte, base int, bitSize int) (n uint64, err error) {
79
	var cutoff, maxVal uint64
80

81
	if bitSize == 0 {
82
		bitSize = int(strconv.IntSize)
83
	}
84

85
	s0 := s
86
	switch {
87
	case len(s) < 1:
88
		err = strconv.ErrSyntax
89
		goto Error
90

91
	case 2 <= base && base <= 36:
92
		// valid base; nothing to do
93

94
	case base == 0:
95
		// Look for octal, hex prefix.
96
		switch {
97
		case s[0] == '0' && len(s) > 1 && (s[1] == 'x' || s[1] == 'X'):
98
			base = 16
99
			s = s[2:]
100
			if len(s) < 1 {
101
				err = strconv.ErrSyntax
102
				goto Error
103
			}
104
		case s[0] == '0':
105
			base = 8
106
		default:
107
			base = 10
108
		}
109

110
	default:
111
		err = errors.New("invalid base " + strconv.Itoa(base))
112
		goto Error
113
	}
114

115
	n = 0
116
	cutoff = cutoff64(base)
117
	maxVal = 1<<uint(bitSize) - 1
118

119
	for i := 0; i < len(s); i++ {
120
		var v byte
121
		d := s[i]
122
		switch {
123
		case '0' <= d && d <= '9':
124
			v = d - '0'
125
		case 'a' <= d && d <= 'z':
126
			v = d - 'a' + 10
127
		case 'A' <= d && d <= 'Z':
128
			v = d - 'A' + 10
129
		default:
130
			n = 0
131
			err = strconv.ErrSyntax
132
			goto Error
133
		}
134
		if int(v) >= base {
135
			n = 0
136
			err = strconv.ErrSyntax
137
			goto Error
138
		}
139

140
		if n >= cutoff {
141
			// n*base overflows
142
			n = 1<<64 - 1
143
			err = strconv.ErrRange
144
			goto Error
145
		}
146
		n *= uint64(base)
147

148
		n1 := n + uint64(v)
149
		if n1 < n || n1 > maxVal {
150
			// n+v overflows
151
			n = 1<<64 - 1
152
			err = strconv.ErrRange
153
			goto Error
154
		}
155
		n = n1
156
	}
157

158
	return n, nil
159

160
Error:
161
	return n, &strconv.NumError{Func: "ParseUint", Num: string(s0), Err: err}
162
}
163

164
// Return the first number n such that n*base >= 1<<64.
165
func cutoff64(base int) uint64 {
166
	if base < 2 {
167
		return 0
168
	}
169
	return (1<<64-1)/uint64(base) + 1
170
}
171