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         struct inode *si_inode;
  53         unsigned int si_blocks;
  54         struct buffer_head **si_bh;
  55         unsigned int si_num_slots;
  56         struct ocfs2_slot *si_slots;
  57 };
  58
  59
  60 static int __ocfs2_node_num_to_slot(struct ocfs2_slot_info *si,
  61                                     unsigned int node_num);
  62
  63 static void ocfs2_invalidate_slot(struct ocfs2_slot_info *si,
  64                                   int slot_num)
  65 {
  66         BUG_ON((slot_num < 0) || (slot_num >= si->si_num_slots));
  67         si->si_slots[slot_num].sl_valid = 0;
  68 }
  69
  70 static void ocfs2_set_slot(struct ocfs2_slot_info *si,
  71                            int slot_num, unsigned int node_num)
  72 {
  73         BUG_ON((slot_num < 0) || (slot_num >= si->si_num_slots));
  74         BUG_ON((node_num == O2NM_INVALID_NODE_NUM) ||
  75                (node_num >= O2NM_MAX_NODES));
  76
  77         si->si_slots[slot_num].sl_valid = 1;
  78         si->si_slots[slot_num].sl_node_num = node_num;
  79 }
  80
  81 /*
  82  * Post the slot information on disk into our slot_info struct.
  83  * Must be protected by osb_lock.
  84  */
  85 static void ocfs2_update_slot_info(struct ocfs2_slot_info *si)
  86 {
  87         int i;
  88         struct ocfs2_slot_map *sm;
  89
  90         /* we don't read the slot block here as ocfs2_super_lock
  91          * should've made sure we have the most recent copy. */
  92         sm = (struct ocfs2_slot_map *)si->si_bh[0]->b_data;
  93
  94         for (i = 0; i < si->si_num_slots; i++) {
  95                 if (le16_to_cpu(sm->sm_slots[i]) == (u16)OCFS2_INVALID_SLOT)
  96                         ocfs2_invalidate_slot(si, i);
  97                 else
  98                         ocfs2_set_slot(si, i, le16_to_cpu(sm->sm_slots[i]));
  99         }
 100 }
 101
 102 int ocfs2_refresh_slot_info(struct ocfs2_super *osb)
 103 {
 104         int ret;
 105         struct ocfs2_slot_info *si = osb->slot_info;
 106
 107         if (si == NULL)
 108                 return 0;
 109
 110         BUG_ON(si->si_blocks == 0);
 111         BUG_ON(si->si_bh == NULL);
 112
 113         mlog(0, "Refreshing slot map, reading %u block(s)\n",
 114              si->si_blocks);
 115
 116         /*
 117          * We pass -1 as blocknr because we expect all of si->si_bh to
 118          * be !NULL.  Thus, ocfs2_read_blocks() will ignore blocknr.  If
 119          * this is not true, the read of -1 (UINT64_MAX) will fail.
 120          */
 121         ret = ocfs2_read_blocks(osb, -1, si->si_blocks, si->si_bh, 0,
 122                                 si->si_inode);
 123         if (ret == 0) {
 124                 spin_lock(&osb->osb_lock);
 125                 ocfs2_update_slot_info(si);
 126                 spin_unlock(&osb->osb_lock);
 127         }
 128
 129         return ret;
 130 }
 131
 132 /* post the our slot info stuff into it's destination bh and write it
 133  * out. */
 134 static int ocfs2_update_disk_slots(struct ocfs2_super *osb,
 135                                    struct ocfs2_slot_info *si)
 136 {
 137         int status, i;
 138         struct ocfs2_slot_map *sm;
 139
 140         spin_lock(&osb->osb_lock);
 141         sm = (struct ocfs2_slot_map *)si->si_bh[0]->b_data;
 142         for (i = 0; i < si->si_num_slots; i++) {
 143                 if (si->si_slots[i].sl_valid)
 144                         sm->sm_slots[i] =
 145                                 cpu_to_le16(si->si_slots[i].sl_node_num);
 146                 else
 147                         sm->sm_slots[i] = cpu_to_le16(OCFS2_INVALID_SLOT);
 148         }
 149         spin_unlock(&osb->osb_lock);
 150
 151         status = ocfs2_write_block(osb, si->si_bh[0], si->si_inode);
 152         if (status < 0)
 153                 mlog_errno(status);
 154
 155         return status;
 156 }
 157
 158 /*
 159  * Calculate how many bytes are needed by the slot map.  Returns
 160  * an error if the slot map file is too small.
 161  */
 162 static int ocfs2_slot_map_physical_size(struct ocfs2_super *osb,
 163                                         struct inode *inode,
 164                                         unsigned long long *bytes)
 165 {
 166         unsigned long long bytes_needed;
 167
 168         bytes_needed = osb->max_slots * sizeof(__le16);
 169         if (bytes_needed > i_size_read(inode)) {
 170                 mlog(ML_ERROR,
 171                      "Slot map file is too small!  (size %llu, needed %llu)\n",
 172                      i_size_read(inode), bytes_needed);
 173                 return -ENOSPC;
 174         }
 175
 176         *bytes = bytes_needed;
 177         return 0;
 178 }
 179
 180 /* try to find global node in the slot info. Returns -ENOENT
 181  * if nothing is found. */
 182 static int __ocfs2_node_num_to_slot(struct ocfs2_slot_info *si,
 183                                     unsigned int node_num)
 184 {
 185         int i, ret = -ENOENT;
 186
 187         for(i = 0; i < si->si_num_slots; i++) {
 188                 if (si->si_slots[i].sl_valid &&
 189                     (node_num == si->si_slots[i].sl_node_num)) {
 190                         ret = i;
 191                         break;
 192                 }
 193         }
 194
 195         return ret;
 196 }
 197
 198 static int __ocfs2_find_empty_slot(struct ocfs2_slot_info *si,
 199                                    int preferred)
 200 {
 201         int i, ret = -ENOSPC;
 202
 203         if ((preferred >= 0) && (preferred < si->si_num_slots)) {
 204                 if (!si->si_slots[preferred].sl_valid) {
 205                         ret = preferred;
 206                         goto out;
 207                 }
 208         }
 209
 210         for(i = 0; i < si->si_num_slots; i++) {
 211                 if (!si->si_slots[i].sl_valid) {
 212                         ret = i;
 213                         break;
 214                 }
 215         }
 216 out:
 217         return ret;
 218 }
 219
 220 int ocfs2_node_num_to_slot(struct ocfs2_super *osb, unsigned int node_num)
 221 {
 222         int slot;
 223         struct ocfs2_slot_info *si = osb->slot_info;
 224
 225         spin_lock(&osb->osb_lock);
 226         slot = __ocfs2_node_num_to_slot(si, node_num);
 227         spin_unlock(&osb->osb_lock);
 228
 229         return slot;
 230 }
 231
 232 int ocfs2_slot_to_node_num_locked(struct ocfs2_super *osb, int slot_num,
 233                                   unsigned int *node_num)
 234 {
 235         struct ocfs2_slot_info *si = osb->slot_info;
 236
 237         assert_spin_locked(&osb->osb_lock);
 238
 239         BUG_ON(slot_num < 0);
 240         BUG_ON(slot_num > osb->max_slots);
 241
 242         if (!si->si_slots[slot_num].sl_valid)
 243                 return -ENOENT;
 244
 245         *node_num = si->si_slots[slot_num].sl_node_num;
 246         return 0;
 247 }
 248
 249 static void __ocfs2_free_slot_info(struct ocfs2_slot_info *si)
 250 {
 251         unsigned int i;
 252
 253         if (si == NULL)
 254                 return;
 255
 256         if (si->si_inode)
 257                 iput(si->si_inode);
 258         if (si->si_bh) {
 259                 for (i = 0; i < si->si_blocks; i++) {
 260                         if (si->si_bh[i]) {
 261                                 brelse(si->si_bh[i]);
 262                                 si->si_bh[i] = NULL;
 263                         }
 264                 }
 265                 kfree(si->si_bh);
 266         }
 267
 268         kfree(si);
 269 }
 270
 271 int ocfs2_clear_slot(struct ocfs2_super *osb, int slot_num)
 272 {
 273         struct ocfs2_slot_info *si = osb->slot_info;
 274
 275         if (si == NULL)
 276                 return 0;
 277
 278         spin_lock(&osb->osb_lock);
 279         ocfs2_invalidate_slot(si, slot_num);
 280         spin_unlock(&osb->osb_lock);
 281
 282         return ocfs2_update_disk_slots(osb, osb->slot_info);
 283 }
 284
 285 static int ocfs2_map_slot_buffers(struct ocfs2_super *osb,
 286                                   struct ocfs2_slot_info *si)
 287 {
 288         int status = 0;
 289         u64 blkno;
 290         unsigned long long blocks, bytes;
 291         unsigned int i;
 292         struct buffer_head *bh;
 293
 294         status = ocfs2_slot_map_physical_size(osb, si->si_inode, &bytes);
 295         if (status)
 296                 goto bail;
 297
 298         blocks = ocfs2_blocks_for_bytes(si->si_inode->i_sb, bytes);
 299         BUG_ON(blocks > UINT_MAX);
 300         si->si_blocks = blocks;
 301         if (!si->si_blocks)
 302                 goto bail;
 303
 304         mlog(0, "Slot map needs %u buffers for %llu bytes\n",
 305              si->si_blocks, bytes);
 306
 307         si->si_bh = kzalloc(sizeof(struct buffer_head *) * si->si_blocks,
 308                             GFP_KERNEL);
 309         if (!si->si_bh) {
 310                 status = -ENOMEM;
 311                 mlog_errno(status);
 312                 goto bail;
 313         }
 314
 315         for (i = 0; i < si->si_blocks; i++) {
 316                 status = ocfs2_extent_map_get_blocks(si->si_inode, i,
 317                                                      &blkno, NULL, NULL);
 318                 if (status < 0) {
 319                         mlog_errno(status);
 320                         goto bail;
 321                 }
 322
 323                 mlog(0, "Reading slot map block %u at %llu\n", i,
 324                      (unsigned long long)blkno);
 325
 326                 bh = NULL;  /* Acquire a fresh bh */
 327                 status = ocfs2_read_block(osb, blkno, &bh, 0, si->si_inode);
 328                 if (status < 0) {
 329                         mlog_errno(status);
 330                         goto bail;
 331                 }
 332
 333                 si->si_bh[i] = bh;
 334         }
 335
 336 bail:
 337         return status;
 338 }
 339
 340 int ocfs2_init_slot_info(struct ocfs2_super *osb)
 341 {
 342         int status;
 343         struct inode *inode = NULL;
 344         struct ocfs2_slot_info *si;
 345
 346         si = kzalloc(sizeof(struct ocfs2_slot_info) +
 347                      (sizeof(struct ocfs2_slot) * osb->max_slots),
 348                      GFP_KERNEL);
 349         if (!si) {
 350                 status = -ENOMEM;
 351                 mlog_errno(status);
 352                 goto bail;
 353         }
 354
 355         si->si_num_slots = osb->max_slots;
 356         si->si_slots = (struct ocfs2_slot *)((char *)si +
 357                                              sizeof(struct ocfs2_slot_info));
 358
 359         inode = ocfs2_get_system_file_inode(osb, SLOT_MAP_SYSTEM_INODE,
 360                                             OCFS2_INVALID_SLOT);
 361         if (!inode) {
 362                 status = -EINVAL;
 363                 mlog_errno(status);
 364                 goto bail;
 365         }
 366
 367         si->si_inode = inode;
 368         status = ocfs2_map_slot_buffers(osb, si);
 369         if (status < 0) {
 370                 mlog_errno(status);
 371                 goto bail;
 372         }
 373
 374         osb->slot_info = (struct ocfs2_slot_info *)si;
 375 bail:
 376         if (status < 0 && si)
 377                 __ocfs2_free_slot_info(si);
 378
 379         return status;
 380 }
 381
 382 void ocfs2_free_slot_info(struct ocfs2_super *osb)
 383 {
 384         struct ocfs2_slot_info *si = osb->slot_info;
 385
 386         osb->slot_info = NULL;
 387         __ocfs2_free_slot_info(si);
 388 }
 389
 390 int ocfs2_find_slot(struct ocfs2_super *osb)
 391 {
 392         int status;
 393         int slot;
 394         struct ocfs2_slot_info *si;
 395
 396         mlog_entry_void();
 397
 398         si = osb->slot_info;
 399
 400         spin_lock(&osb->osb_lock);
 401         ocfs2_update_slot_info(si);
 402
 403         /* search for ourselves first and take the slot if it already
 404          * exists. Perhaps we need to mark this in a variable for our
 405          * own journal recovery? Possibly not, though we certainly
 406          * need to warn to the user */
 407         slot = __ocfs2_node_num_to_slot(si, osb->node_num);
 408         if (slot < 0) {
 409                 /* if no slot yet, then just take 1st available
 410                  * one. */
 411                 slot = __ocfs2_find_empty_slot(si, osb->preferred_slot);
 412                 if (slot < 0) {
 413                         spin_unlock(&osb->osb_lock);
 414                         mlog(ML_ERROR, "no free slots available!\n");
 415                         status = -EINVAL;
 416                         goto bail;
 417                 }
 418         } else
 419                 mlog(ML_NOTICE, "slot %d is already allocated to this node!\n",
 420                      slot);
 421
 422         ocfs2_set_slot(si, slot, osb->node_num);
 423         osb->slot_num = slot;
 424         spin_unlock(&osb->osb_lock);
 425
 426         mlog(0, "taking node slot %d\n", osb->slot_num);
 427
 428         status = ocfs2_update_disk_slots(osb, si);
 429         if (status < 0)
 430                 mlog_errno(status);
 431
 432 bail:
 433         mlog_exit(status);
 434         return status;
 435 }
 436
 437 void ocfs2_put_slot(struct ocfs2_super *osb)
 438 {
 439         int status;
 440         struct ocfs2_slot_info *si = osb->slot_info;
 441
 442         if (!si)
 443                 return;
 444
 445         spin_lock(&osb->osb_lock);
 446         ocfs2_update_slot_info(si);
 447
 448         ocfs2_invalidate_slot(si, osb->slot_num);
 449         osb->slot_num = OCFS2_INVALID_SLOT;
 450         spin_unlock(&osb->osb_lock);
 451
 452         status = ocfs2_update_disk_slots(osb, si);
 453         if (status < 0) {
 454                 mlog_errno(status);
 455                 goto bail;
 456         }
 457
 458 bail:
 459         ocfs2_free_slot_info(osb);
 460 }
 461