]>
Commit | Line | Data |
---|---|---|
2522fe45 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
e7fd4179 DT |
2 | /****************************************************************************** |
3 | ******************************************************************************* | |
4 | ** | |
c36258b5 | 5 | ** Copyright (C) 2005-2007 Red Hat, Inc. All rights reserved. |
e7fd4179 | 6 | ** |
e7fd4179 DT |
7 | ** |
8 | ******************************************************************************* | |
9 | ******************************************************************************/ | |
10 | ||
11 | #include "dlm_internal.h" | |
12 | #include "member.h" | |
13 | #include "lock.h" | |
14 | #include "dir.h" | |
15 | #include "config.h" | |
16 | #include "requestqueue.h" | |
17 | ||
18 | struct rq_entry { | |
19 | struct list_head list; | |
6d40c4a7 | 20 | uint32_t recover_seq; |
e7fd4179 | 21 | int nodeid; |
8b0d8e03 | 22 | struct dlm_message request; |
e7fd4179 DT |
23 | }; |
24 | ||
25 | /* | |
26 | * Requests received while the lockspace is in recovery get added to the | |
27 | * request queue and processed when recovery is complete. This happens when | |
28 | * the lockspace is suspended on some nodes before it is on others, or the | |
29 | * lockspace is enabled on some while still suspended on others. | |
30 | */ | |
31 | ||
8b0d8e03 | 32 | void dlm_add_requestqueue(struct dlm_ls *ls, int nodeid, struct dlm_message *ms) |
e7fd4179 DT |
33 | { |
34 | struct rq_entry *e; | |
8b0d8e03 | 35 | int length = ms->m_header.h_length - sizeof(struct dlm_message); |
e7fd4179 | 36 | |
573c24c4 | 37 | e = kmalloc(sizeof(struct rq_entry) + length, GFP_NOFS); |
e7fd4179 | 38 | if (!e) { |
c36258b5 DT |
39 | log_print("dlm_add_requestqueue: out of memory len %d", length); |
40 | return; | |
e7fd4179 DT |
41 | } |
42 | ||
6d40c4a7 | 43 | e->recover_seq = ls->ls_recover_seq & 0xFFFFFFFF; |
e7fd4179 | 44 | e->nodeid = nodeid; |
8b0d8e03 | 45 | memcpy(&e->request, ms, ms->m_header.h_length); |
e7fd4179 | 46 | |
90135925 | 47 | mutex_lock(&ls->ls_requestqueue_mutex); |
c36258b5 | 48 | list_add_tail(&e->list, &ls->ls_requestqueue); |
90135925 | 49 | mutex_unlock(&ls->ls_requestqueue_mutex); |
e7fd4179 DT |
50 | } |
51 | ||
c36258b5 DT |
52 | /* |
53 | * Called by dlm_recoverd to process normal messages saved while recovery was | |
54 | * happening. Normal locking has been enabled before this is called. dlm_recv | |
55 | * upon receiving a message, will wait for all saved messages to be drained | |
56 | * here before processing the message it got. If a new dlm_ls_stop() arrives | |
57 | * while we're processing these saved messages, it may block trying to suspend | |
58 | * dlm_recv if dlm_recv is waiting for us in dlm_wait_requestqueue. In that | |
59 | * case, we don't abort since locking_stopped is still 0. If dlm_recv is not | |
60 | * waiting for us, then this processing may be aborted due to locking_stopped. | |
61 | */ | |
62 | ||
e7fd4179 DT |
63 | int dlm_process_requestqueue(struct dlm_ls *ls) |
64 | { | |
65 | struct rq_entry *e; | |
4875647a | 66 | struct dlm_message *ms; |
e7fd4179 DT |
67 | int error = 0; |
68 | ||
90135925 | 69 | mutex_lock(&ls->ls_requestqueue_mutex); |
e7fd4179 DT |
70 | |
71 | for (;;) { | |
72 | if (list_empty(&ls->ls_requestqueue)) { | |
90135925 | 73 | mutex_unlock(&ls->ls_requestqueue_mutex); |
e7fd4179 DT |
74 | error = 0; |
75 | break; | |
76 | } | |
77 | e = list_entry(ls->ls_requestqueue.next, struct rq_entry, list); | |
90135925 | 78 | mutex_unlock(&ls->ls_requestqueue_mutex); |
e7fd4179 | 79 | |
4875647a DT |
80 | ms = &e->request; |
81 | ||
82 | log_limit(ls, "dlm_process_requestqueue msg %d from %d " | |
83 | "lkid %x remid %x result %d seq %u", | |
84 | ms->m_type, ms->m_header.h_nodeid, | |
85 | ms->m_lkid, ms->m_remid, ms->m_result, | |
86 | e->recover_seq); | |
87 | ||
6d40c4a7 | 88 | dlm_receive_message_saved(ls, &e->request, e->recover_seq); |
e7fd4179 | 89 | |
90135925 | 90 | mutex_lock(&ls->ls_requestqueue_mutex); |
e7fd4179 DT |
91 | list_del(&e->list); |
92 | kfree(e); | |
93 | ||
94 | if (dlm_locking_stopped(ls)) { | |
95 | log_debug(ls, "process_requestqueue abort running"); | |
90135925 | 96 | mutex_unlock(&ls->ls_requestqueue_mutex); |
e7fd4179 DT |
97 | error = -EINTR; |
98 | break; | |
99 | } | |
100 | schedule(); | |
101 | } | |
102 | ||
103 | return error; | |
104 | } | |
105 | ||
106 | /* | |
107 | * After recovery is done, locking is resumed and dlm_recoverd takes all the | |
c36258b5 DT |
108 | * saved requests and processes them as they would have been by dlm_recv. At |
109 | * the same time, dlm_recv will start receiving new requests from remote nodes. | |
110 | * We want to delay dlm_recv processing new requests until dlm_recoverd has | |
111 | * finished processing the old saved requests. We don't check for locking | |
112 | * stopped here because dlm_ls_stop won't stop locking until it's suspended us | |
113 | * (dlm_recv). | |
e7fd4179 DT |
114 | */ |
115 | ||
116 | void dlm_wait_requestqueue(struct dlm_ls *ls) | |
117 | { | |
118 | for (;;) { | |
90135925 | 119 | mutex_lock(&ls->ls_requestqueue_mutex); |
e7fd4179 DT |
120 | if (list_empty(&ls->ls_requestqueue)) |
121 | break; | |
90135925 | 122 | mutex_unlock(&ls->ls_requestqueue_mutex); |
e7fd4179 DT |
123 | schedule(); |
124 | } | |
90135925 | 125 | mutex_unlock(&ls->ls_requestqueue_mutex); |
e7fd4179 DT |
126 | } |
127 | ||
128 | static int purge_request(struct dlm_ls *ls, struct dlm_message *ms, int nodeid) | |
129 | { | |
130 | uint32_t type = ms->m_type; | |
131 | ||
2896ee37 DT |
132 | /* the ls is being cleaned up and freed by release_lockspace */ |
133 | if (!ls->ls_count) | |
134 | return 1; | |
135 | ||
e7fd4179 DT |
136 | if (dlm_is_removed(ls, nodeid)) |
137 | return 1; | |
138 | ||
139 | /* directory operations are always purged because the directory is | |
140 | always rebuilt during recovery and the lookups resent */ | |
141 | ||
142 | if (type == DLM_MSG_REMOVE || | |
143 | type == DLM_MSG_LOOKUP || | |
144 | type == DLM_MSG_LOOKUP_REPLY) | |
145 | return 1; | |
146 | ||
147 | if (!dlm_no_directory(ls)) | |
148 | return 0; | |
149 | ||
4875647a | 150 | return 1; |
e7fd4179 DT |
151 | } |
152 | ||
153 | void dlm_purge_requestqueue(struct dlm_ls *ls) | |
154 | { | |
155 | struct dlm_message *ms; | |
156 | struct rq_entry *e, *safe; | |
157 | ||
90135925 | 158 | mutex_lock(&ls->ls_requestqueue_mutex); |
e7fd4179 | 159 | list_for_each_entry_safe(e, safe, &ls->ls_requestqueue, list) { |
8b0d8e03 | 160 | ms = &e->request; |
e7fd4179 DT |
161 | |
162 | if (purge_request(ls, ms, e->nodeid)) { | |
163 | list_del(&e->list); | |
164 | kfree(e); | |
165 | } | |
166 | } | |
90135925 | 167 | mutex_unlock(&ls->ls_requestqueue_mutex); |
e7fd4179 DT |
168 | } |
169 |