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
28struct ocfs2_slot {
29	int sl_valid;
30	unsigned int sl_node_num;
31};
32
33struct 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
44static int __ocfs2_node_num_to_slot(struct ocfs2_slot_info *si,
45				    unsigned int node_num);
46
47static 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
54static 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 */
64static 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 */
89static 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
104static 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
116int 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. */
147static 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
165static 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
183static 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 */
208static 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. */
233static 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
249static 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	}
267out:
268	return ret;
269}
270
271int 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
283int 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
300static 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
321int 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
335static 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
395bail:
396	return status;
397}
398
399int 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;
431bail:
432	if (status < 0)
433		__ocfs2_free_slot_info(si);
434
435	return status;
436}
437
438void 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
446int 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
495bail:
496	return status;
497}
498
499void 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