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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
#if TUX3_FLUSHER != TUX3_FLUSHER_ASYNC_HACK
#include "tux3.h"
static void __tux3_init_flusher(struct sb *sb)
{
#ifdef __KERNEL__
/* Disable writeback task to control inode reclaim by dirty flags */
vfs_sb(sb)->s_bdi = &noop_backing_dev_info;
#endif
}
#if TUX3_FLUSHER == TUX3_FLUSHER_ASYNC_OWN
static int flush_delta_work(void *data)
{
struct sb *sb = data;
int err;
set_freezable();
/*
* Our parent may run at a different priority, just set us to normal
*/
set_user_nice(current, 0);
while (!kthread_freezable_should_stop(NULL)) {
if (test_bit(TUX3_COMMIT_PENDING_BIT, &sb->backend_state)) {
clear_bit(TUX3_COMMIT_PENDING_BIT, &sb->backend_state);
err = flush_delta(sb);
/* FIXME: error handling */
}
set_current_state(TASK_INTERRUPTIBLE);
if (!test_bit(TUX3_COMMIT_PENDING_BIT, &sb->backend_state) &&
!kthread_should_stop())
schedule();
__set_current_state(TASK_RUNNING);
}
return 0;
}
int tux3_init_flusher(struct sb *sb)
{
struct task_struct *task;
char b[BDEVNAME_SIZE];
__tux3_init_flusher(sb);
bdevname(vfs_sb(sb)->s_bdev, b);
/* FIXME: we should use normal bdi-writeback by changing core */
task = kthread_run(flush_delta_work, sb, "tux3/%s", b);
if (IS_ERR(task))
return PTR_ERR(task);
sb->flush_task = task;
return 0;
}
void tux3_exit_flusher(struct sb *sb)
{
if (sb->flush_task) {
kthread_stop(sb->flush_task);
sb->flush_task = NULL;
}
}
static void schedule_flush_delta(struct sb *sb)
{
/* Start the flusher for pending delta */
wake_up_process(sb->flush_task);
}
#else /* TUX3_FLUSHER != TUX3_FLUSHER_ASYNC_OWN */
int tux3_init_flusher(struct sb *sb)
{
__tux3_init_flusher(sb);
return 0;
}
void tux3_exit_flusher(struct sb *sb)
{
}
static void schedule_flush_delta(struct sb *sb)
{
/* Wake up waiters for pending marshal delta */
wake_up_all(&sb->delta_event_wq);
}
static int flush_pending_delta(struct sb *sb)
{
int err = 0;
if (!test_bit(TUX3_COMMIT_PENDING_BIT, &sb->backend_state))
goto out;
if (test_and_clear_bit(TUX3_COMMIT_PENDING_BIT, &sb->backend_state))
err = flush_delta(sb);
out:
return err;
}
#endif /* TUX3_FLUSHER != TUX3_FLUSHER_ASYNC_OWN */
/* Try delta transition */
static void try_delta_transition(struct sb *sb)
{
trace("marshal %u, backend_state %lx",
sb->marshal_delta, sb->backend_state);
if (!test_and_set_bit(TUX3_COMMIT_RUNNING_BIT, &sb->backend_state))
delta_transition(sb);
}
/* Do the delta transition until specified delta */
static int try_delta_transition_until_delta(struct sb *sb, unsigned delta)
{
trace("delta %u, marshal %u, backend_state %lx",
delta, sb->marshal_delta, sb->backend_state);
/* Already delta transition was started for delta */
if (delta_after_eq(sb->marshal_delta, delta))
return 1;
if (!test_and_set_bit(TUX3_COMMIT_RUNNING_BIT, &sb->backend_state)) {
/* Recheck after grabed TUX3_COMMIT_RUNNING_BIT */
if (delta_after_eq(sb->marshal_delta, delta)) {
clear_bit(TUX3_COMMIT_RUNNING_BIT, &sb->backend_state);
return 1;
}
delta_transition(sb);
}
return delta_after_eq(sb->marshal_delta, delta);
}
/* Advance delta transition until specified delta */
static int wait_for_transition(struct sb *sb, unsigned delta)
{
return wait_event_killable(sb->delta_event_wq,
try_delta_transition_until_delta(sb, delta));
}
static int try_flush_pending_until_delta(struct sb *sb, unsigned delta)
{
trace("delta %u, committed %u, backend_state %lx",
delta, sb->committed_delta, sb->backend_state);
#if TUX3_FLUSHER == TUX3_FLUSHER_SYNC
if (!delta_after_eq(sb->committed_delta, delta))
flush_pending_delta(sb);
#endif
return delta_after_eq(sb->committed_delta, delta);
}
static int wait_for_commit(struct sb *sb, unsigned delta)
{
return wait_event_killable(sb->delta_event_wq,
try_flush_pending_until_delta(sb, delta));
}
static int sync_current_delta(struct sb *sb, enum rollup_flags rollup_flag)
{
struct delta_ref *delta_ref;
unsigned delta;
int err = 0;
#if TUX3_FLUSHER == TUX3_FLUSHER_SYNC
down_write(&sb->delta_lock);
#endif
/* Get delta that have to write */
delta_ref = delta_get(sb);
#ifdef ROLLUP_DEBUG
delta_ref->rollup_flag = rollup_flag;
#endif
delta = delta_ref->delta;
delta_put(sb, delta_ref);
trace("delta %u", delta);
/* Make sure the delta transition was done for current delta */
err = wait_for_transition(sb, delta);
if (err)
return err;
assert(delta_after_eq(sb->marshal_delta, delta));
/* Wait until committing the current delta */
err = wait_for_commit(sb, delta);
assert(err || delta_after_eq(sb->committed_delta, delta));
#if TUX3_FLUSHER == TUX3_FLUSHER_SYNC
up_write(&sb->delta_lock);
#endif
return err;
}
#endif /* TUX3_FLUSHER == TUX3_FLUSHER_ASYNC_HACK */
|
