fs/ocfs2/slot_map.c

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