1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
// SPDX-License-Identifier: GPL-2.0
/*
* GPL HEADER START
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 only,
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License version 2 for more details (a copy is included
* in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU General Public License
* version 2 along with this program; If not, see http://www.gnu.org/licenses
*
* GPL HEADER END
*/
/*
* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
* Copyright (c) 2011, 2015, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
* Lustre is a trademark of Oracle Corporation, Inc.
*/
#include <linux/libcfs/libcfs.h>
unsigned long cfs_fail_loc;
EXPORT_SYMBOL(cfs_fail_loc);
unsigned int cfs_fail_val;
EXPORT_SYMBOL(cfs_fail_val);
int cfs_fail_err;
EXPORT_SYMBOL(cfs_fail_err);
DECLARE_WAIT_QUEUE_HEAD(cfs_race_waitq);
EXPORT_SYMBOL(cfs_race_waitq);
int cfs_race_state;
EXPORT_SYMBOL(cfs_race_state);
int __cfs_fail_check_set(u32 id, u32 value, int set)
{
static atomic_t cfs_fail_count = ATOMIC_INIT(0);
LASSERT(!(id & CFS_FAIL_ONCE));
if ((cfs_fail_loc & (CFS_FAILED | CFS_FAIL_ONCE)) ==
(CFS_FAILED | CFS_FAIL_ONCE)) {
atomic_set(&cfs_fail_count, 0); /* paranoia */
return 0;
}
/* Fail 1/cfs_fail_val times */
if (cfs_fail_loc & CFS_FAIL_RAND) {
if (cfs_fail_val < 2 || prandom_u32_max(cfs_fail_val) > 0)
return 0;
}
/* Skip the first cfs_fail_val, then fail */
if (cfs_fail_loc & CFS_FAIL_SKIP) {
if (atomic_inc_return(&cfs_fail_count) <= cfs_fail_val)
return 0;
}
/* check cfs_fail_val... */
if (set == CFS_FAIL_LOC_VALUE) {
if (cfs_fail_val != -1 && cfs_fail_val != value)
return 0;
}
/* Fail cfs_fail_val times, overridden by FAIL_ONCE */
if (cfs_fail_loc & CFS_FAIL_SOME &&
(!(cfs_fail_loc & CFS_FAIL_ONCE) || cfs_fail_val <= 1)) {
int count = atomic_inc_return(&cfs_fail_count);
if (count >= cfs_fail_val) {
set_bit(CFS_FAIL_ONCE_BIT, &cfs_fail_loc);
atomic_set(&cfs_fail_count, 0);
/* we are lost race to increase */
if (count > cfs_fail_val)
return 0;
}
}
/* Take into account the current call for FAIL_ONCE for ORSET only,
* as RESET is a new fail_loc, it does not change the current call
*/
if ((set == CFS_FAIL_LOC_ORSET) && (value & CFS_FAIL_ONCE))
set_bit(CFS_FAIL_ONCE_BIT, &cfs_fail_loc);
/* Lost race to set CFS_FAILED_BIT. */
if (test_and_set_bit(CFS_FAILED_BIT, &cfs_fail_loc)) {
/* If CFS_FAIL_ONCE is valid, only one process can fail,
* otherwise multi-process can fail at the same time.
*/
if (cfs_fail_loc & CFS_FAIL_ONCE)
return 0;
}
switch (set) {
case CFS_FAIL_LOC_NOSET:
case CFS_FAIL_LOC_VALUE:
break;
case CFS_FAIL_LOC_ORSET:
cfs_fail_loc |= value & ~(CFS_FAILED | CFS_FAIL_ONCE);
break;
case CFS_FAIL_LOC_RESET:
cfs_fail_loc = value;
atomic_set(&cfs_fail_count, 0);
break;
default:
LASSERTF(0, "called with bad set %u\n", set);
break;
}
return 1;
}
EXPORT_SYMBOL(__cfs_fail_check_set);
int __cfs_fail_timeout_set(u32 id, u32 value, int ms, int set)
{
int ret;
ret = __cfs_fail_check_set(id, value, set);
if (ret && likely(ms > 0)) {
CERROR("cfs_fail_timeout id %x sleeping for %dms\n",
id, ms);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout(ms * HZ / 1000);
CERROR("cfs_fail_timeout id %x awake\n", id);
}
return ret;
}
EXPORT_SYMBOL(__cfs_fail_timeout_set);
|
