ocfs2: Simplify ocfs2_read_block()
[linux-2.6.git] / fs / ocfs2 / slot_map.c
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 #define MLOG_MASK_PREFIX ML_SUPER
31 #include <cluster/masklog.h>
32
33 #include "ocfs2.h"
34
35 #include "dlmglue.h"
36 #include "extent_map.h"
37 #include "heartbeat.h"
38 #include "inode.h"
39 #include "slot_map.h"
40 #include "super.h"
41 #include "sysfile.h"
42
43 #include "buffer_head_io.h"
44
45
46 struct ocfs2_slot {
47         int sl_valid;
48         unsigned int sl_node_num;
49 };
50
51 struct 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
62 static int __ocfs2_node_num_to_slot(struct ocfs2_slot_info *si,
63                                     unsigned int node_num);
64
65 static 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
72 static 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 */
82 static 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  */
107 static 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
122 static 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
134 int 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         mlog(0, "Refreshing slot map, reading %u block(s)\n",
146              si->si_blocks);
147
148         /*
149          * We pass -1 as blocknr because we expect all of si->si_bh to
150          * be !NULL.  Thus, ocfs2_read_blocks() will ignore blocknr.  If
151          * this is not true, the read of -1 (UINT64_MAX) will fail.
152          */
153         ret = ocfs2_read_blocks(si->si_inode, -1, si->si_blocks, si->si_bh, 0);
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. */
165 static 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
183 static 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
201 static 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, 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  */
226 static 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. */
251 static 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
267 static 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         }
285 out:
286         return ret;
287 }
288
289 int 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
301 int 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
318 static 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
340 int 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
354 static 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;
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         mlog(0, "Slot map needs %u buffers for %llu bytes\n",
384              si->si_blocks, bytes);
385
386         si->si_bh = kzalloc(sizeof(struct buffer_head *) * si->si_blocks,
387                             GFP_KERNEL);
388         if (!si->si_bh) {
389                 status = -ENOMEM;
390                 mlog_errno(status);
391                 goto bail;
392         }
393
394         for (i = 0; i < si->si_blocks; i++) {
395                 status = ocfs2_extent_map_get_blocks(si->si_inode, i,
396                                                      &blkno, NULL, NULL);
397                 if (status < 0) {
398                         mlog_errno(status);
399                         goto bail;
400                 }
401
402                 mlog(0, "Reading slot map block %u at %llu\n", i,
403                      (unsigned long long)blkno);
404
405                 bh = NULL;  /* Acquire a fresh bh */
406                 status = ocfs2_read_blocks(si->si_inode, blkno, 1, &bh, 0);
407                 if (status < 0) {
408                         mlog_errno(status);
409                         goto bail;
410                 }
411
412                 si->si_bh[i] = bh;
413         }
414
415 bail:
416         return status;
417 }
418
419 int ocfs2_init_slot_info(struct ocfs2_super *osb)
420 {
421         int status;
422         struct inode *inode = NULL;
423         struct ocfs2_slot_info *si;
424
425         si = kzalloc(sizeof(struct ocfs2_slot_info) +
426                      (sizeof(struct ocfs2_slot) * osb->max_slots),
427                      GFP_KERNEL);
428         if (!si) {
429                 status = -ENOMEM;
430                 mlog_errno(status);
431                 goto bail;
432         }
433
434         si->si_extended = ocfs2_uses_extended_slot_map(osb);
435         si->si_num_slots = osb->max_slots;
436         si->si_slots = (struct ocfs2_slot *)((char *)si +
437                                              sizeof(struct ocfs2_slot_info));
438
439         inode = ocfs2_get_system_file_inode(osb, SLOT_MAP_SYSTEM_INODE,
440                                             OCFS2_INVALID_SLOT);
441         if (!inode) {
442                 status = -EINVAL;
443                 mlog_errno(status);
444                 goto bail;
445         }
446
447         si->si_inode = inode;
448         status = ocfs2_map_slot_buffers(osb, si);
449         if (status < 0) {
450                 mlog_errno(status);
451                 goto bail;
452         }
453
454         osb->slot_info = (struct ocfs2_slot_info *)si;
455 bail:
456         if (status < 0 && si)
457                 __ocfs2_free_slot_info(si);
458
459         return status;
460 }
461
462 void ocfs2_free_slot_info(struct ocfs2_super *osb)
463 {
464         struct ocfs2_slot_info *si = osb->slot_info;
465
466         osb->slot_info = NULL;
467         __ocfs2_free_slot_info(si);
468 }
469
470 int ocfs2_find_slot(struct ocfs2_super *osb)
471 {
472         int status;
473         int slot;
474         struct ocfs2_slot_info *si;
475
476         mlog_entry_void();
477
478         si = osb->slot_info;
479
480         spin_lock(&osb->osb_lock);
481         ocfs2_update_slot_info(si);
482
483         /* search for ourselves first and take the slot if it already
484          * exists. Perhaps we need to mark this in a variable for our
485          * own journal recovery? Possibly not, though we certainly
486          * need to warn to the user */
487         slot = __ocfs2_node_num_to_slot(si, osb->node_num);
488         if (slot < 0) {
489                 /* if no slot yet, then just take 1st available
490                  * one. */
491                 slot = __ocfs2_find_empty_slot(si, osb->preferred_slot);
492                 if (slot < 0) {
493                         spin_unlock(&osb->osb_lock);
494                         mlog(ML_ERROR, "no free slots available!\n");
495                         status = -EINVAL;
496                         goto bail;
497                 }
498         } else
499                 mlog(ML_NOTICE, "slot %d is already allocated to this node!\n",
500                      slot);
501
502         ocfs2_set_slot(si, slot, osb->node_num);
503         osb->slot_num = slot;
504         spin_unlock(&osb->osb_lock);
505
506         mlog(0, "taking node slot %d\n", osb->slot_num);
507
508         status = ocfs2_update_disk_slot(osb, si, osb->slot_num);
509         if (status < 0)
510                 mlog_errno(status);
511
512 bail:
513         mlog_exit(status);
514         return status;
515 }
516
517 void ocfs2_put_slot(struct ocfs2_super *osb)
518 {
519         int status, slot_num;
520         struct ocfs2_slot_info *si = osb->slot_info;
521
522         if (!si)
523                 return;
524
525         spin_lock(&osb->osb_lock);
526         ocfs2_update_slot_info(si);
527
528         slot_num = osb->slot_num;
529         ocfs2_invalidate_slot(si, osb->slot_num);
530         osb->slot_num = OCFS2_INVALID_SLOT;
531         spin_unlock(&osb->osb_lock);
532
533         status = ocfs2_update_disk_slot(osb, si, slot_num);
534         if (status < 0) {
535                 mlog_errno(status);
536                 goto bail;
537         }
538
539 bail:
540         ocfs2_free_slot_info(osb);
541 }
542