Commit | Line | Data |
---|---|---|
328970de | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
ccd979bd MF |
2 | /* -*- mode: c; c-basic-offset: 8; -*- |
3 | * vim: noexpandtab sw=8 ts=8 sts=0: | |
4 | * | |
5 | * slot_map.c | |
6 | * | |
ccd979bd | 7 | * Copyright (C) 2002, 2004 Oracle. All rights reserved. |
ccd979bd MF |
8 | */ |
9 | ||
10 | #include <linux/types.h> | |
11 | #include <linux/slab.h> | |
12 | #include <linux/highmem.h> | |
ccd979bd | 13 | |
ccd979bd MF |
14 | #include <cluster/masklog.h> |
15 | ||
16 | #include "ocfs2.h" | |
17 | ||
18 | #include "dlmglue.h" | |
19 | #include "extent_map.h" | |
20 | #include "heartbeat.h" | |
21 | #include "inode.h" | |
22 | #include "slot_map.h" | |
23 | #include "super.h" | |
24 | #include "sysfile.h" | |
a8731086 | 25 | #include "ocfs2_trace.h" |
ccd979bd MF |
26 | |
27 | #include "buffer_head_io.h" | |
28 | ||
fc881fa0 JB |
29 | |
30 | struct ocfs2_slot { | |
31 | int sl_valid; | |
32 | unsigned int sl_node_num; | |
33 | }; | |
34 | ||
d85b20e4 | 35 | struct ocfs2_slot_info { |
386a2ef8 JB |
36 | int si_extended; |
37 | int si_slots_per_block; | |
d85b20e4 | 38 | struct inode *si_inode; |
1c8d9a6a JB |
39 | unsigned int si_blocks; |
40 | struct buffer_head **si_bh; | |
d85b20e4 | 41 | unsigned int si_num_slots; |
f402cf03 | 42 | struct ocfs2_slot si_slots[]; |
d85b20e4 JB |
43 | }; |
44 | ||
45 | ||
fc881fa0 JB |
46 | static int __ocfs2_node_num_to_slot(struct ocfs2_slot_info *si, |
47 | unsigned int node_num); | |
48 | ||
49 | static void ocfs2_invalidate_slot(struct ocfs2_slot_info *si, | |
50 | int slot_num) | |
51 | { | |
52 | BUG_ON((slot_num < 0) || (slot_num >= si->si_num_slots)); | |
53 | si->si_slots[slot_num].sl_valid = 0; | |
54 | } | |
55 | ||
56 | static void ocfs2_set_slot(struct ocfs2_slot_info *si, | |
57 | int slot_num, unsigned int node_num) | |
58 | { | |
59 | BUG_ON((slot_num < 0) || (slot_num >= si->si_num_slots)); | |
fc881fa0 JB |
60 | |
61 | si->si_slots[slot_num].sl_valid = 1; | |
62 | si->si_slots[slot_num].sl_node_num = node_num; | |
63 | } | |
ccd979bd | 64 | |
386a2ef8 JB |
65 | /* This version is for the extended slot map */ |
66 | static void ocfs2_update_slot_info_extended(struct ocfs2_slot_info *si) | |
67 | { | |
68 | int b, i, slotno; | |
69 | struct ocfs2_slot_map_extended *se; | |
70 | ||
71 | slotno = 0; | |
72 | for (b = 0; b < si->si_blocks; b++) { | |
73 | se = (struct ocfs2_slot_map_extended *)si->si_bh[b]->b_data; | |
74 | for (i = 0; | |
75 | (i < si->si_slots_per_block) && | |
76 | (slotno < si->si_num_slots); | |
77 | i++, slotno++) { | |
78 | if (se->se_slots[i].es_valid) | |
79 | ocfs2_set_slot(si, slotno, | |
80 | le32_to_cpu(se->se_slots[i].es_node_num)); | |
81 | else | |
82 | ocfs2_invalidate_slot(si, slotno); | |
83 | } | |
84 | } | |
85 | } | |
86 | ||
d85b20e4 JB |
87 | /* |
88 | * Post the slot information on disk into our slot_info struct. | |
89 | * Must be protected by osb_lock. | |
90 | */ | |
386a2ef8 | 91 | static void ocfs2_update_slot_info_old(struct ocfs2_slot_info *si) |
ccd979bd MF |
92 | { |
93 | int i; | |
fb86b1f0 | 94 | struct ocfs2_slot_map *sm; |
ccd979bd | 95 | |
fb86b1f0 | 96 | sm = (struct ocfs2_slot_map *)si->si_bh[0]->b_data; |
ccd979bd | 97 | |
fc881fa0 | 98 | for (i = 0; i < si->si_num_slots; i++) { |
fb86b1f0 | 99 | if (le16_to_cpu(sm->sm_slots[i]) == (u16)OCFS2_INVALID_SLOT) |
fc881fa0 JB |
100 | ocfs2_invalidate_slot(si, i); |
101 | else | |
fb86b1f0 | 102 | ocfs2_set_slot(si, i, le16_to_cpu(sm->sm_slots[i])); |
fc881fa0 | 103 | } |
ccd979bd MF |
104 | } |
105 | ||
386a2ef8 JB |
106 | static void ocfs2_update_slot_info(struct ocfs2_slot_info *si) |
107 | { | |
108 | /* | |
109 | * The slot data will have been refreshed when ocfs2_super_lock | |
110 | * was taken. | |
111 | */ | |
112 | if (si->si_extended) | |
113 | ocfs2_update_slot_info_extended(si); | |
114 | else | |
115 | ocfs2_update_slot_info_old(si); | |
116 | } | |
117 | ||
8e8a4603 MF |
118 | int ocfs2_refresh_slot_info(struct ocfs2_super *osb) |
119 | { | |
120 | int ret; | |
121 | struct ocfs2_slot_info *si = osb->slot_info; | |
8e8a4603 MF |
122 | |
123 | if (si == NULL) | |
124 | return 0; | |
125 | ||
1c8d9a6a JB |
126 | BUG_ON(si->si_blocks == 0); |
127 | BUG_ON(si->si_bh == NULL); | |
128 | ||
a8731086 | 129 | trace_ocfs2_refresh_slot_info(si->si_blocks); |
1c8d9a6a JB |
130 | |
131 | /* | |
132 | * We pass -1 as blocknr because we expect all of si->si_bh to | |
133 | * be !NULL. Thus, ocfs2_read_blocks() will ignore blocknr. If | |
134 | * this is not true, the read of -1 (UINT64_MAX) will fail. | |
135 | */ | |
8cb471e8 JB |
136 | ret = ocfs2_read_blocks(INODE_CACHE(si->si_inode), -1, si->si_blocks, |
137 | si->si_bh, OCFS2_BH_IGNORE_CACHE, NULL); | |
d85b20e4 JB |
138 | if (ret == 0) { |
139 | spin_lock(&osb->osb_lock); | |
8e8a4603 | 140 | ocfs2_update_slot_info(si); |
d85b20e4 JB |
141 | spin_unlock(&osb->osb_lock); |
142 | } | |
8e8a4603 MF |
143 | |
144 | return ret; | |
145 | } | |
146 | ||
ccd979bd MF |
147 | /* post the our slot info stuff into it's destination bh and write it |
148 | * out. */ | |
386a2ef8 JB |
149 | static void ocfs2_update_disk_slot_extended(struct ocfs2_slot_info *si, |
150 | int slot_num, | |
151 | struct buffer_head **bh) | |
152 | { | |
153 | int blkind = slot_num / si->si_slots_per_block; | |
154 | int slotno = slot_num % si->si_slots_per_block; | |
155 | struct ocfs2_slot_map_extended *se; | |
156 | ||
157 | BUG_ON(blkind >= si->si_blocks); | |
158 | ||
159 | se = (struct ocfs2_slot_map_extended *)si->si_bh[blkind]->b_data; | |
160 | se->se_slots[slotno].es_valid = si->si_slots[slot_num].sl_valid; | |
161 | if (si->si_slots[slot_num].sl_valid) | |
162 | se->se_slots[slotno].es_node_num = | |
163 | cpu_to_le32(si->si_slots[slot_num].sl_node_num); | |
164 | *bh = si->si_bh[blkind]; | |
165 | } | |
166 | ||
167 | static void ocfs2_update_disk_slot_old(struct ocfs2_slot_info *si, | |
168 | int slot_num, | |
169 | struct buffer_head **bh) | |
ccd979bd | 170 | { |
386a2ef8 | 171 | int i; |
fb86b1f0 | 172 | struct ocfs2_slot_map *sm; |
ccd979bd | 173 | |
fb86b1f0 | 174 | sm = (struct ocfs2_slot_map *)si->si_bh[0]->b_data; |
fc881fa0 JB |
175 | for (i = 0; i < si->si_num_slots; i++) { |
176 | if (si->si_slots[i].sl_valid) | |
fb86b1f0 | 177 | sm->sm_slots[i] = |
fc881fa0 JB |
178 | cpu_to_le16(si->si_slots[i].sl_node_num); |
179 | else | |
fb86b1f0 | 180 | sm->sm_slots[i] = cpu_to_le16(OCFS2_INVALID_SLOT); |
fc881fa0 | 181 | } |
386a2ef8 JB |
182 | *bh = si->si_bh[0]; |
183 | } | |
184 | ||
185 | static int ocfs2_update_disk_slot(struct ocfs2_super *osb, | |
186 | struct ocfs2_slot_info *si, | |
187 | int slot_num) | |
188 | { | |
189 | int status; | |
190 | struct buffer_head *bh; | |
191 | ||
192 | spin_lock(&osb->osb_lock); | |
193 | if (si->si_extended) | |
194 | ocfs2_update_disk_slot_extended(si, slot_num, &bh); | |
195 | else | |
196 | ocfs2_update_disk_slot_old(si, slot_num, &bh); | |
d85b20e4 | 197 | spin_unlock(&osb->osb_lock); |
ccd979bd | 198 | |
8cb471e8 | 199 | status = ocfs2_write_block(osb, bh, INODE_CACHE(si->si_inode)); |
ccd979bd MF |
200 | if (status < 0) |
201 | mlog_errno(status); | |
202 | ||
203 | return status; | |
204 | } | |
205 | ||
1c8d9a6a JB |
206 | /* |
207 | * Calculate how many bytes are needed by the slot map. Returns | |
208 | * an error if the slot map file is too small. | |
209 | */ | |
210 | static int ocfs2_slot_map_physical_size(struct ocfs2_super *osb, | |
211 | struct inode *inode, | |
212 | unsigned long long *bytes) | |
213 | { | |
214 | unsigned long long bytes_needed; | |
215 | ||
386a2ef8 JB |
216 | if (ocfs2_uses_extended_slot_map(osb)) { |
217 | bytes_needed = osb->max_slots * | |
218 | sizeof(struct ocfs2_extended_slot); | |
219 | } else { | |
220 | bytes_needed = osb->max_slots * sizeof(__le16); | |
221 | } | |
1c8d9a6a JB |
222 | if (bytes_needed > i_size_read(inode)) { |
223 | mlog(ML_ERROR, | |
224 | "Slot map file is too small! (size %llu, needed %llu)\n", | |
225 | i_size_read(inode), bytes_needed); | |
226 | return -ENOSPC; | |
227 | } | |
228 | ||
229 | *bytes = bytes_needed; | |
230 | return 0; | |
231 | } | |
232 | ||
fc881fa0 JB |
233 | /* try to find global node in the slot info. Returns -ENOENT |
234 | * if nothing is found. */ | |
235 | static int __ocfs2_node_num_to_slot(struct ocfs2_slot_info *si, | |
236 | unsigned int node_num) | |
ccd979bd | 237 | { |
fc881fa0 | 238 | int i, ret = -ENOENT; |
ccd979bd MF |
239 | |
240 | for(i = 0; i < si->si_num_slots; i++) { | |
fc881fa0 JB |
241 | if (si->si_slots[i].sl_valid && |
242 | (node_num == si->si_slots[i].sl_node_num)) { | |
243 | ret = i; | |
ccd979bd MF |
244 | break; |
245 | } | |
246 | } | |
fc881fa0 | 247 | |
ccd979bd MF |
248 | return ret; |
249 | } | |
250 | ||
fc881fa0 JB |
251 | static int __ocfs2_find_empty_slot(struct ocfs2_slot_info *si, |
252 | int preferred) | |
ccd979bd | 253 | { |
fc881fa0 | 254 | int i, ret = -ENOSPC; |
ccd979bd | 255 | |
fc881fa0 JB |
256 | if ((preferred >= 0) && (preferred < si->si_num_slots)) { |
257 | if (!si->si_slots[preferred].sl_valid) { | |
baf4661a SM |
258 | ret = preferred; |
259 | goto out; | |
260 | } | |
261 | } | |
262 | ||
ccd979bd | 263 | for(i = 0; i < si->si_num_slots; i++) { |
fc881fa0 JB |
264 | if (!si->si_slots[i].sl_valid) { |
265 | ret = i; | |
ccd979bd MF |
266 | break; |
267 | } | |
268 | } | |
baf4661a | 269 | out: |
ccd979bd MF |
270 | return ret; |
271 | } | |
272 | ||
d85b20e4 | 273 | int ocfs2_node_num_to_slot(struct ocfs2_super *osb, unsigned int node_num) |
ccd979bd | 274 | { |
fc881fa0 | 275 | int slot; |
d85b20e4 | 276 | struct ocfs2_slot_info *si = osb->slot_info; |
ccd979bd | 277 | |
d85b20e4 JB |
278 | spin_lock(&osb->osb_lock); |
279 | slot = __ocfs2_node_num_to_slot(si, node_num); | |
280 | spin_unlock(&osb->osb_lock); | |
281 | ||
d85b20e4 JB |
282 | return slot; |
283 | } | |
284 | ||
285 | int ocfs2_slot_to_node_num_locked(struct ocfs2_super *osb, int slot_num, | |
286 | unsigned int *node_num) | |
287 | { | |
288 | struct ocfs2_slot_info *si = osb->slot_info; | |
289 | ||
290 | assert_spin_locked(&osb->osb_lock); | |
291 | ||
292 | BUG_ON(slot_num < 0); | |
519a2861 | 293 | BUG_ON(slot_num >= osb->max_slots); |
d85b20e4 | 294 | |
fc881fa0 | 295 | if (!si->si_slots[slot_num].sl_valid) |
d85b20e4 JB |
296 | return -ENOENT; |
297 | ||
fc881fa0 | 298 | *node_num = si->si_slots[slot_num].sl_node_num; |
d85b20e4 | 299 | return 0; |
ccd979bd MF |
300 | } |
301 | ||
8e8a4603 MF |
302 | static void __ocfs2_free_slot_info(struct ocfs2_slot_info *si) |
303 | { | |
1c8d9a6a JB |
304 | unsigned int i; |
305 | ||
8e8a4603 MF |
306 | if (si == NULL) |
307 | return; | |
308 | ||
72865d92 | 309 | iput(si->si_inode); |
1c8d9a6a JB |
310 | if (si->si_bh) { |
311 | for (i = 0; i < si->si_blocks; i++) { | |
312 | if (si->si_bh[i]) { | |
313 | brelse(si->si_bh[i]); | |
314 | si->si_bh[i] = NULL; | |
315 | } | |
316 | } | |
317 | kfree(si->si_bh); | |
318 | } | |
8e8a4603 MF |
319 | |
320 | kfree(si); | |
321 | } | |
322 | ||
fc881fa0 | 323 | int ocfs2_clear_slot(struct ocfs2_super *osb, int slot_num) |
ccd979bd | 324 | { |
8e8a4603 MF |
325 | struct ocfs2_slot_info *si = osb->slot_info; |
326 | ||
327 | if (si == NULL) | |
328 | return 0; | |
329 | ||
d85b20e4 | 330 | spin_lock(&osb->osb_lock); |
fc881fa0 | 331 | ocfs2_invalidate_slot(si, slot_num); |
d85b20e4 | 332 | spin_unlock(&osb->osb_lock); |
8e8a4603 | 333 | |
386a2ef8 | 334 | return ocfs2_update_disk_slot(osb, osb->slot_info, slot_num); |
ccd979bd MF |
335 | } |
336 | ||
1c8d9a6a JB |
337 | static int ocfs2_map_slot_buffers(struct ocfs2_super *osb, |
338 | struct ocfs2_slot_info *si) | |
339 | { | |
340 | int status = 0; | |
341 | u64 blkno; | |
f30d44f3 | 342 | unsigned long long blocks, bytes = 0; |
1c8d9a6a JB |
343 | unsigned int i; |
344 | struct buffer_head *bh; | |
345 | ||
346 | status = ocfs2_slot_map_physical_size(osb, si->si_inode, &bytes); | |
347 | if (status) | |
348 | goto bail; | |
349 | ||
350 | blocks = ocfs2_blocks_for_bytes(si->si_inode->i_sb, bytes); | |
351 | BUG_ON(blocks > UINT_MAX); | |
352 | si->si_blocks = blocks; | |
353 | if (!si->si_blocks) | |
354 | goto bail; | |
355 | ||
386a2ef8 JB |
356 | if (si->si_extended) |
357 | si->si_slots_per_block = | |
358 | (osb->sb->s_blocksize / | |
359 | sizeof(struct ocfs2_extended_slot)); | |
360 | else | |
361 | si->si_slots_per_block = osb->sb->s_blocksize / sizeof(__le16); | |
362 | ||
363 | /* The size checks above should ensure this */ | |
364 | BUG_ON((osb->max_slots / si->si_slots_per_block) > blocks); | |
365 | ||
a8731086 | 366 | trace_ocfs2_map_slot_buffers(bytes, si->si_blocks); |
1c8d9a6a | 367 | |
1b7f8ba6 | 368 | si->si_bh = kcalloc(si->si_blocks, sizeof(struct buffer_head *), |
1c8d9a6a JB |
369 | GFP_KERNEL); |
370 | if (!si->si_bh) { | |
371 | status = -ENOMEM; | |
372 | mlog_errno(status); | |
373 | goto bail; | |
374 | } | |
375 | ||
376 | for (i = 0; i < si->si_blocks; i++) { | |
377 | status = ocfs2_extent_map_get_blocks(si->si_inode, i, | |
378 | &blkno, NULL, NULL); | |
379 | if (status < 0) { | |
380 | mlog_errno(status); | |
381 | goto bail; | |
382 | } | |
383 | ||
a8731086 | 384 | trace_ocfs2_map_slot_buffers_block((unsigned long long)blkno, i); |
1c8d9a6a JB |
385 | |
386 | bh = NULL; /* Acquire a fresh bh */ | |
8cb471e8 JB |
387 | status = ocfs2_read_blocks(INODE_CACHE(si->si_inode), blkno, |
388 | 1, &bh, OCFS2_BH_IGNORE_CACHE, NULL); | |
1c8d9a6a JB |
389 | if (status < 0) { |
390 | mlog_errno(status); | |
391 | goto bail; | |
392 | } | |
393 | ||
394 | si->si_bh[i] = bh; | |
395 | } | |
396 | ||
397 | bail: | |
398 | return status; | |
399 | } | |
400 | ||
ccd979bd MF |
401 | int ocfs2_init_slot_info(struct ocfs2_super *osb) |
402 | { | |
fc881fa0 | 403 | int status; |
ccd979bd | 404 | struct inode *inode = NULL; |
ccd979bd MF |
405 | struct ocfs2_slot_info *si; |
406 | ||
f402cf03 | 407 | si = kzalloc(struct_size(si, si_slots, osb->max_slots), GFP_KERNEL); |
ccd979bd MF |
408 | if (!si) { |
409 | status = -ENOMEM; | |
410 | mlog_errno(status); | |
bb34ed21 | 411 | return status; |
ccd979bd MF |
412 | } |
413 | ||
386a2ef8 | 414 | si->si_extended = ocfs2_uses_extended_slot_map(osb); |
ccd979bd | 415 | si->si_num_slots = osb->max_slots; |
ccd979bd MF |
416 | |
417 | inode = ocfs2_get_system_file_inode(osb, SLOT_MAP_SYSTEM_INODE, | |
418 | OCFS2_INVALID_SLOT); | |
419 | if (!inode) { | |
420 | status = -EINVAL; | |
421 | mlog_errno(status); | |
422 | goto bail; | |
423 | } | |
424 | ||
1c8d9a6a JB |
425 | si->si_inode = inode; |
426 | status = ocfs2_map_slot_buffers(osb, si); | |
ccd979bd MF |
427 | if (status < 0) { |
428 | mlog_errno(status); | |
429 | goto bail; | |
430 | } | |
431 | ||
d85b20e4 | 432 | osb->slot_info = (struct ocfs2_slot_info *)si; |
ccd979bd | 433 | bail: |
fd90d4df | 434 | if (status < 0) |
8e8a4603 | 435 | __ocfs2_free_slot_info(si); |
ccd979bd MF |
436 | |
437 | return status; | |
438 | } | |
439 | ||
8e8a4603 | 440 | void ocfs2_free_slot_info(struct ocfs2_super *osb) |
ccd979bd | 441 | { |
8e8a4603 MF |
442 | struct ocfs2_slot_info *si = osb->slot_info; |
443 | ||
444 | osb->slot_info = NULL; | |
445 | __ocfs2_free_slot_info(si); | |
ccd979bd MF |
446 | } |
447 | ||
448 | int ocfs2_find_slot(struct ocfs2_super *osb) | |
449 | { | |
450 | int status; | |
fc881fa0 | 451 | int slot; |
ccd979bd MF |
452 | struct ocfs2_slot_info *si; |
453 | ||
ccd979bd MF |
454 | si = osb->slot_info; |
455 | ||
d85b20e4 | 456 | spin_lock(&osb->osb_lock); |
ccd979bd MF |
457 | ocfs2_update_slot_info(si); |
458 | ||
ccd979bd MF |
459 | /* search for ourselves first and take the slot if it already |
460 | * exists. Perhaps we need to mark this in a variable for our | |
461 | * own journal recovery? Possibly not, though we certainly | |
462 | * need to warn to the user */ | |
463 | slot = __ocfs2_node_num_to_slot(si, osb->node_num); | |
fc881fa0 | 464 | if (slot < 0) { |
ccd979bd MF |
465 | /* if no slot yet, then just take 1st available |
466 | * one. */ | |
baf4661a | 467 | slot = __ocfs2_find_empty_slot(si, osb->preferred_slot); |
fc881fa0 | 468 | if (slot < 0) { |
d85b20e4 | 469 | spin_unlock(&osb->osb_lock); |
ccd979bd MF |
470 | mlog(ML_ERROR, "no free slots available!\n"); |
471 | status = -EINVAL; | |
472 | goto bail; | |
473 | } | |
474 | } else | |
619c200d SM |
475 | printk(KERN_INFO "ocfs2: Slot %d on device (%s) was already " |
476 | "allocated to this node!\n", slot, osb->dev_str); | |
ccd979bd | 477 | |
fc881fa0 | 478 | ocfs2_set_slot(si, slot, osb->node_num); |
ccd979bd | 479 | osb->slot_num = slot; |
d85b20e4 | 480 | spin_unlock(&osb->osb_lock); |
ccd979bd | 481 | |
a8731086 | 482 | trace_ocfs2_find_slot(osb->slot_num); |
ccd979bd | 483 | |
386a2ef8 | 484 | status = ocfs2_update_disk_slot(osb, si, osb->slot_num); |
1247017f | 485 | if (status < 0) { |
ccd979bd | 486 | mlog_errno(status); |
1247017f | 487 | /* |
488 | * if write block failed, invalidate slot to avoid overwrite | |
489 | * slot during dismount in case another node rightly has mounted | |
490 | */ | |
491 | spin_lock(&osb->osb_lock); | |
492 | ocfs2_invalidate_slot(si, osb->slot_num); | |
493 | osb->slot_num = OCFS2_INVALID_SLOT; | |
494 | spin_unlock(&osb->osb_lock); | |
495 | } | |
ccd979bd MF |
496 | |
497 | bail: | |
ccd979bd MF |
498 | return status; |
499 | } | |
500 | ||
501 | void ocfs2_put_slot(struct ocfs2_super *osb) | |
502 | { | |
386a2ef8 | 503 | int status, slot_num; |
ccd979bd MF |
504 | struct ocfs2_slot_info *si = osb->slot_info; |
505 | ||
506 | if (!si) | |
507 | return; | |
508 | ||
d85b20e4 | 509 | spin_lock(&osb->osb_lock); |
ccd979bd MF |
510 | ocfs2_update_slot_info(si); |
511 | ||
386a2ef8 | 512 | slot_num = osb->slot_num; |
fc881fa0 | 513 | ocfs2_invalidate_slot(si, osb->slot_num); |
ccd979bd | 514 | osb->slot_num = OCFS2_INVALID_SLOT; |
d85b20e4 | 515 | spin_unlock(&osb->osb_lock); |
ccd979bd | 516 | |
386a2ef8 | 517 | status = ocfs2_update_disk_slot(osb, si, slot_num); |
8f9b1802 | 518 | if (status < 0) |
ccd979bd | 519 | mlog_errno(status); |
ccd979bd | 520 | |
8e8a4603 | 521 | ocfs2_free_slot_info(osb); |
ccd979bd | 522 | } |