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         __le16 *disk_info;
  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         disk_info = (__le16 *) si->si_bh[0]->b_data;
  93
  94         for (i = 0; i < si->si_num_slots; i++) {
  95                 if (le16_to_cpu(disk_info[i]) == (u16)OCFS2_INVALID_SLOT)
  96                         ocfs2_invalidate_slot(si, i);
  97                 else
  98                         ocfs2_set_slot(si, i, le16_to_cpu(disk_info[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         __le16 *disk_info = (__le16 *) si->si_bh[0]->b_data;
 139
 140         spin_lock(&osb->osb_lock);
 141         for (i = 0; i < si->si_num_slots; i++) {
 142                 if (si->si_slots[i].sl_valid)
 143                         disk_info[i] =
 144                                 cpu_to_le16(si->si_slots[i].sl_node_num);
 145                 else
 146                         disk_info[i] = cpu_to_le16(OCFS2_INVALID_SLOT);
 147         }
 148         spin_unlock(&osb->osb_lock);
 149
 150         status = ocfs2_write_block(osb, si->si_bh[0], si->si_inode);
 151         if (status < 0)
 152                 mlog_errno(status);
 153
 154         return status;
 155 }
 156
 157 /*
 158  * Calculate how many bytes are needed by the slot map.  Returns
 159  * an error if the slot map file is too small.
 160  */
 161 static int ocfs2_slot_map_physical_size(struct ocfs2_super *osb,
 162                                         struct inode *inode,
 163                                         unsigned long long *bytes)
 164 {
 165         unsigned long long bytes_needed;
 166
 167         bytes_needed = osb->max_slots * sizeof(__le16);
 168         if (bytes_needed > i_size_read(inode)) {
 169                 mlog(ML_ERROR,
 170                      "Slot map file is too small!  (size %llu, needed %llu)\n",
 171                      i_size_read(inode), bytes_needed);
 172                 return -ENOSPC;
 173         }
 174
 175         *bytes = bytes_needed;
 176         return 0;
 177 }
 178
 179 /* try to find global node in the slot info. Returns -ENOENT
 180  * if nothing is found. */
 181 static int __ocfs2_node_num_to_slot(struct ocfs2_slot_info *si,
 182                                     unsigned int node_num)
 183 {
 184         int i, ret = -ENOENT;
 185
 186         for(i = 0; i < si->si_num_slots; i++) {
 187                 if (si->si_slots[i].sl_valid &&
 188                     (node_num == si->si_slots[i].sl_node_num)) {
 189                         ret = i;
 190                         break;
 191                 }
 192         }
 193
 194         return ret;
 195 }
 196
 197 static int __ocfs2_find_empty_slot(struct ocfs2_slot_info *si,
 198                                    int preferred)
 199 {
 200         int i, ret = -ENOSPC;
 201
 202         if ((preferred >= 0) && (preferred < si->si_num_slots)) {
 203                 if (!si->si_slots[preferred].sl_valid) {
 204                         ret = preferred;
 205                         goto out;
 206                 }
 207         }
 208
 209         for(i = 0; i < si->si_num_slots; i++) {
 210                 if (!si->si_slots[i].sl_valid) {
 211                         ret = i;
 212                         break;
 213                 }
 214         }
 215 out:
 216         return ret;
 217 }
 218
 219 int ocfs2_node_num_to_slot(struct ocfs2_super *osb, unsigned int node_num)
 220 {
 221         int slot;
 222         struct ocfs2_slot_info *si = osb->slot_info;
 223
 224         spin_lock(&osb->osb_lock);
 225         slot = __ocfs2_node_num_to_slot(si, node_num);
 226         spin_unlock(&osb->osb_lock);
 227
 228         return slot;
 229 }
 230
 231 int ocfs2_slot_to_node_num_locked(struct ocfs2_super *osb, int slot_num,
 232                                   unsigned int *node_num)
 233 {
 234         struct ocfs2_slot_info *si = osb->slot_info;
 235
 236         assert_spin_locked(&osb->osb_lock);
 237
 238         BUG_ON(slot_num < 0);
 239         BUG_ON(slot_num > osb->max_slots);
 240
 241         if (!si->si_slots[slot_num].sl_valid)
 242                 return -ENOENT;
 243
 244         *node_num = si->si_slots[slot_num].sl_node_num;
 245         return 0;
 246 }
 247
 248 static void __ocfs2_free_slot_info(struct ocfs2_slot_info *si)
 249 {
 250         unsigned int i;
 251
 252         if (si == NULL)
 253                 return;
 254
 255         if (si->si_inode)
 256                 iput(si->si_inode);
 257         if (si->si_bh) {
 258                 for (i = 0; i < si->si_blocks; i++) {
 259                         if (si->si_bh[i]) {
 260                                 brelse(si->si_bh[i]);
 261                                 si->si_bh[i] = NULL;
 262                         }
 263                 }
 264                 kfree(si->si_bh);
 265         }
 266
 267         kfree(si);
 268 }
 269
 270 int ocfs2_clear_slot(struct ocfs2_super *osb, int slot_num)
 271 {
 272         struct ocfs2_slot_info *si = osb->slot_info;
 273
 274         if (si == NULL)
 275                 return 0;
 276
 277         spin_lock(&osb->osb_lock);
 278         ocfs2_invalidate_slot(si, slot_num);
 279         spin_unlock(&osb->osb_lock);
 280
 281         return ocfs2_update_disk_slots(osb, osb->slot_info);
 282 }
 283
 284 static int ocfs2_map_slot_buffers(struct ocfs2_super *osb,
 285                                   struct ocfs2_slot_info *si)
 286 {
 287         int status = 0;
 288         u64 blkno;
 289         unsigned long long blocks, bytes;
 290         unsigned int i;
 291         struct buffer_head *bh;
 292
 293         status = ocfs2_slot_map_physical_size(osb, si->si_inode, &bytes);
 294         if (status)
 295                 goto bail;
 296
 297         blocks = ocfs2_blocks_for_bytes(si->si_inode->i_sb, bytes);
 298         BUG_ON(blocks > UINT_MAX);
 299         si->si_blocks = blocks;
 300         if (!si->si_blocks)
 301                 goto bail;
 302
 303         mlog(0, "Slot map needs %u buffers for %llu bytes\n",
 304              si->si_blocks, bytes);
 305
 306         si->si_bh = kzalloc(sizeof(struct buffer_head *) * si->si_blocks,
 307                             GFP_KERNEL);
 308         if (!si->si_bh) {
 309                 status = -ENOMEM;
 310                 mlog_errno(status);
 311                 goto bail;
 312         }
 313
 314         for (i = 0; i < si->si_blocks; i++) {
 315                 status = ocfs2_extent_map_get_blocks(si->si_inode, i,
 316                                                      &blkno, NULL, NULL);
 317                 if (status < 0) {
 318                         mlog_errno(status);
 319                         goto bail;
 320                 }
 321
 322                 mlog(0, "Reading slot map block %u at %llu\n", i,
 323                      (unsigned long long)blkno);
 324
 325                 bh = NULL;  /* Acquire a fresh bh */
 326                 status = ocfs2_read_block(osb, blkno, &bh, 0, si->si_inode);
 327                 if (status < 0) {
 328                         mlog_errno(status);
 329                         goto bail;
 330                 }
 331
 332                 si->si_bh[i] = bh;
 333         }
 334
 335 bail:
 336         return status;
 337 }
 338
 339 int ocfs2_init_slot_info(struct ocfs2_super *osb)
 340 {
 341         int status;
 342         struct inode *inode = NULL;
 343         struct ocfs2_slot_info *si;
 344
 345         si = kzalloc(sizeof(struct ocfs2_slot_info) +
 346                      (sizeof(struct ocfs2_slot) * osb->max_slots),
 347                      GFP_KERNEL);
 348         if (!si) {
 349                 status = -ENOMEM;
 350                 mlog_errno(status);
 351                 goto bail;
 352         }
 353
 354         si->si_num_slots = osb->max_slots;
 355         si->si_slots = (struct ocfs2_slot *)((char *)si +
 356                                              sizeof(struct ocfs2_slot_info));
 357
 358         inode = ocfs2_get_system_file_inode(osb, SLOT_MAP_SYSTEM_INODE,
 359                                             OCFS2_INVALID_SLOT);
 360         if (!inode) {
 361                 status = -EINVAL;
 362                 mlog_errno(status);
 363                 goto bail;
 364         }
 365
 366         si->si_inode = inode;
 367         status = ocfs2_map_slot_buffers(osb, si);
 368         if (status < 0) {
 369                 mlog_errno(status);
 370                 goto bail;
 371         }
 372
 373         osb->slot_info = (struct ocfs2_slot_info *)si;
 374 bail:
 375         if (status < 0 && si)
 376                 __ocfs2_free_slot_info(si);
 377
 378         return status;
 379 }
 380
 381 void ocfs2_free_slot_info(struct ocfs2_super *osb)
 382 {
 383         struct ocfs2_slot_info *si = osb->slot_info;
 384
 385         osb->slot_info = NULL;
 386         __ocfs2_free_slot_info(si);
 387 }
 388
 389 int ocfs2_find_slot(struct ocfs2_super *osb)
 390 {
 391         int status;
 392         int slot;
 393         struct ocfs2_slot_info *si;
 394
 395         mlog_entry_void();
 396
 397         si = osb->slot_info;
 398
 399         spin_lock(&osb->osb_lock);
 400         ocfs2_update_slot_info(si);
 401
 402         /* search for ourselves first and take the slot if it already
 403          * exists. Perhaps we need to mark this in a variable for our
 404          * own journal recovery? Possibly not, though we certainly
 405          * need to warn to the user */
 406         slot = __ocfs2_node_num_to_slot(si, osb->node_num);
 407         if (slot < 0) {
 408                 /* if no slot yet, then just take 1st available
 409                  * one. */
 410                 slot = __ocfs2_find_empty_slot(si, osb->preferred_slot);
 411                 if (slot < 0) {
 412                         spin_unlock(&osb->osb_lock);
 413                         mlog(ML_ERROR, "no free slots available!\n");
 414                         status = -EINVAL;
 415                         goto bail;
 416                 }
 417         } else
 418                 mlog(ML_NOTICE, "slot %d is already allocated to this node!\n",
 419                      slot);
 420
 421         ocfs2_set_slot(si, slot, osb->node_num);
 422         osb->slot_num = slot;
 423         spin_unlock(&osb->osb_lock);
 424
 425         mlog(0, "taking node slot %d\n", osb->slot_num);
 426
 427         status = ocfs2_update_disk_slots(osb, si);
 428         if (status < 0)
 429                 mlog_errno(status);
 430
 431 bail:
 432         mlog_exit(status);
 433         return status;
 434 }
 435
 436 void ocfs2_put_slot(struct ocfs2_super *osb)
 437 {
 438         int status;
 439         struct ocfs2_slot_info *si = osb->slot_info;
 440
 441         if (!si)
 442                 return;
 443
 444         spin_lock(&osb->osb_lock);
 445         ocfs2_update_slot_info(si);
 446
 447         ocfs2_invalidate_slot(si, osb->slot_num);
 448         osb->slot_num = OCFS2_INVALID_SLOT;
 449         spin_unlock(&osb->osb_lock);
 450
 451         status = ocfs2_update_disk_slots(osb, si);
 452         if (status < 0) {
 453                 mlog_errno(status);
 454                 goto bail;
 455         }
 456
 457 bail:
 458         ocfs2_free_slot_info(osb);
 459 }
 460