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