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