sanlock-fix.patch

   1 From 0b01e3f5d7ce1c954aa9f3707aa645508664f7f1 Mon Sep 17 00:00:00 2001
   2 From: David Teigland <teigland@redhat.com>
   3 Date: Mon, 22 Oct 2018 15:45:23 -0500
   4 Subject: [PATCH] lvmlockd: use new sanlock sector/align interface
   5
   6 The choice about sector size and lease align size is
   7 now made by the sanlock user, in this case lvmlockd.
   8 This will allow lvmlockd to use other lease sizes in
   9 the future.  This also prevents breakage if hosts
  10 report different sector sizes, or the sector size
  11 reported by a device changes.
  12 ---
  13  daemons/lvmlockd/lvmlockd-core.c     |  21 ++-
  14  daemons/lvmlockd/lvmlockd-internal.h |   8 +-
  15  daemons/lvmlockd/lvmlockd-sanlock.c  | 311 +++++++++++++++++++++++++++++++----
  16  3 files changed, 301 insertions(+), 39 deletions(-)
  17
  18 diff --git a/daemons/lvmlockd/lvmlockd-core.c b/daemons/lvmlockd/lvmlockd-core.c
  19 index 6490b40..5bdbefe 100644
  20 --- a/daemons/lvmlockd/lvmlockd-core.c
  21 +++ b/daemons/lvmlockd/lvmlockd-core.c
  22 @@ -929,12 +929,12 @@ static void lm_rem_resource(struct lockspace *ls, struct resource *r)
  23                 lm_rem_resource_sanlock(ls, r);
  24  }
  25
  26 -static int lm_find_free_lock(struct lockspace *ls, uint64_t *free_offset)
  27 +static int lm_find_free_lock(struct lockspace *ls, uint64_t *free_offset, int *sector_size, int *align_size)
  28  {
  29         if (ls->lm_type == LD_LM_DLM)
  30                 return 0;
  31         else if (ls->lm_type == LD_LM_SANLOCK)
  32 -               return lm_find_free_lock_sanlock(ls, free_offset);
  33 +               return lm_find_free_lock_sanlock(ls, free_offset, sector_size, align_size);
  34         return -1;
  35  }
  36
  37 @@ -2427,11 +2427,16 @@ static void *lockspace_thread_main(void *arg_in)
  38
  39                         if (act->op == LD_OP_FIND_FREE_LOCK && act->rt == LD_RT_VG) {
  40                                 uint64_t free_offset = 0;
  41 +                               int sector_size = 0;
  42 +                               int align_size = 0;
  43 +
  44                                 log_debug("S %s find free lock", ls->name);
  45 -                               rv = lm_find_free_lock(ls, &free_offset);
  46 -                               log_debug("S %s find free lock %d offset %llu",
  47 -                                         ls->name, rv, (unsigned long long)free_offset);
  48 +                               rv = lm_find_free_lock(ls, &free_offset, &sector_size, &align_size);
  49 +                               log_debug("S %s find free lock %d offset %llu sector_size %d align_size %d",
  50 +                                         ls->name, rv, (unsigned long long)free_offset, sector_size, align_size);
  51                                 ls->free_lock_offset = free_offset;
  52 +                               ls->free_lock_sector_size = sector_size;
  53 +                               ls->free_lock_align_size = align_size;
  54                                 list_del(&act->list);
  55                                 act->result = rv;
  56                                 add_client_result(act);
  57 @@ -3237,6 +3242,8 @@ static int work_init_lv(struct action *act)
  58         char vg_args[MAX_ARGS+1];
  59         char lv_args[MAX_ARGS+1];
  60         uint64_t free_offset = 0;
  61 +       int sector_size = 0;
  62 +       int align_size = 0;
  63         int lm_type = 0;
  64         int rv = 0;
  65
  66 @@ -3252,6 +3259,8 @@ static int work_init_lv(struct action *act)
  67                 lm_type = ls->lm_type;
  68                 memcpy(vg_args, ls->vg_args, MAX_ARGS);
  69                 free_offset = ls->free_lock_offset;
  70 +               sector_size = ls->free_lock_sector_size;
  71 +               align_size = ls->free_lock_align_size;
  72         }
  73         pthread_mutex_unlock(&lockspaces_mutex);
  74
  75 @@ -3268,7 +3277,7 @@ static int work_init_lv(struct action *act)
  76
  77         if (lm_type == LD_LM_SANLOCK) {
  78                 rv = lm_init_lv_sanlock(ls_name, act->vg_name, act->lv_uuid,
  79 -                                       vg_args, lv_args, free_offset);
  80 +                                       vg_args, lv_args, sector_size, align_size, free_offset);
  81
  82                 memcpy(act->lv_args, lv_args, MAX_ARGS);
  83                 return rv;
  84 diff --git a/daemons/lvmlockd/lvmlockd-internal.h b/daemons/lvmlockd/lvmlockd-internal.h
  85 index a2280b8..ead3098 100644
  86 --- a/daemons/lvmlockd/lvmlockd-internal.h
  87 +++ b/daemons/lvmlockd/lvmlockd-internal.h
  88 @@ -174,7 +174,9 @@ struct lockspace {
  89         int8_t lm_type;                 /* lock manager: LM_DLM, LM_SANLOCK */
  90         void *lm_data;
  91         uint64_t host_id;
  92 -       uint64_t free_lock_offset;      /* start search for free lock here */
  93 +       uint64_t free_lock_offset;      /* for sanlock, start search for free lock here */
  94 +       int free_lock_sector_size;      /* for sanlock */
  95 +       int free_lock_align_size;       /* for sanlock */
  96
  97         uint32_t start_client_id;       /* client_id that started the lockspace */
  98         pthread_t thread;               /* makes synchronous lock requests */
  99 @@ -468,7 +470,7 @@ static inline int lm_hosts_dlm(struct lockspace *ls, int notify)
 100  #ifdef LOCKDSANLOCK_SUPPORT
 101
 102  int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_args);
 103 -int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name, char *vg_args, char *lv_args, uint64_t free_offset);
 104 +int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name, char *vg_args, char *lv_args, int sector_size, int align_size, uint64_t free_offset);
 105  int lm_free_lv_sanlock(struct lockspace *ls, struct resource *r);
 106  int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_args);
 107  int lm_prepare_lockspace_sanlock(struct lockspace *ls);
 108 @@ -488,7 +490,7 @@ int lm_gl_is_enabled(struct lockspace *ls);
 109  int lm_get_lockspaces_sanlock(struct list_head *ls_rejoin);
 110  int lm_data_size_sanlock(void);
 111  int lm_is_running_sanlock(void);
 112 -int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset);
 113 +int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset, int *sector_size, int *align_size);
 114
 115  static inline int lm_support_sanlock(void)
 116  {
 117 diff --git a/daemons/lvmlockd/lvmlockd-sanlock.c b/daemons/lvmlockd/lvmlockd-sanlock.c
 118 index d5d6864..892b446 100644
 119 --- a/daemons/lvmlockd/lvmlockd-sanlock.c
 120 +++ b/daemons/lvmlockd/lvmlockd-sanlock.c
 121 @@ -24,10 +24,29 @@
 122  #include "sanlock_admin.h"
 123  #include "sanlock_resource.h"
 124
 125 +/* FIXME: these are copied from sanlock.h only until
 126 +   an updated version of sanlock is available with them. */
 127 +#define SANLK_RES_ALIGN1M       0x00000010
 128 +#define SANLK_RES_ALIGN2M       0x00000020
 129 +#define SANLK_RES_ALIGN4M       0x00000040
 130 +#define SANLK_RES_ALIGN8M       0x00000080
 131 +#define SANLK_RES_SECTOR512     0x00000100
 132 +#define SANLK_RES_SECTOR4K      0x00000200
 133 +#define SANLK_LSF_ALIGN1M       0x00000010
 134 +#define SANLK_LSF_ALIGN2M       0x00000020
 135 +#define SANLK_LSF_ALIGN4M       0x00000040
 136 +#define SANLK_LSF_ALIGN8M       0x00000080
 137 +#define SANLK_LSF_SECTOR512     0x00000100
 138 +#define SANLK_LSF_SECTOR4K      0x00000200
 139 +
 140  #include <stddef.h>
 141  #include <poll.h>
 142  #include <errno.h>
 143  #include <syslog.h>
 144 +#include <blkid/blkid.h>
 145 +#include <linux/kdev_t.h>
 146 +
 147 +#define ONE_MB 1048576
 148
 149  /*
 150  -------------------------------------------------------------------------------
 151 @@ -139,6 +158,7 @@ release all the leases for the VG.
 152
 153  struct lm_sanlock {
 154         struct sanlk_lockspace ss;
 155 +       int sector_size;
 156         int align_size;
 157         int sock; /* sanlock daemon connection */
 158  };
 159 @@ -201,7 +221,6 @@ int lm_data_size_sanlock(void)
 160   * ...
 161   */
 162
 163 -#define LS_BEGIN 0
 164  #define GL_LOCK_BEGIN UINT64_C(65)
 165  #define VG_LOCK_BEGIN UINT64_C(66)
 166  #define LV_LOCK_BEGIN UINT64_C(67)
 167 @@ -324,6 +343,152 @@ fail:
 168         return rv;
 169  }
 170
 171 +static void _read_sysfs_size(dev_t devno, const char *name, unsigned int *val)
 172 +{
 173 +       char path[PATH_MAX];
 174 +       char buf[32];
 175 +       FILE *fp;
 176 +       size_t len;
 177 +
 178 +       snprintf(path, sizeof(path), "/sys/dev/block/%d:%d/queue/%s",
 179 +                (int)MAJOR(devno), (int)MINOR(devno), name);
 180 +
 181 +       if (!(fp = fopen(path, "r")))
 182 +               return;
 183 +
 184 +       if (!fgets(buf, sizeof(buf), fp))
 185 +               goto out;
 186 +
 187 +       if ((len = strlen(buf)) && buf[len - 1] == '\n')
 188 +               buf[--len] = '\0';
 189 +
 190 +       if (strlen(buf))
 191 +               *val = atoi(buf);
 192 +out:
 193 +       fclose(fp);
 194 +}
 195 +
 196 +/* Select sector/align size for a new VG based on what the device reports for
 197 +   sector size of the lvmlock LV. */
 198 +
 199 +static int get_sizes_device(char *path, int *sector_size, int *align_size)
 200 +{
 201 +       unsigned int physical_block_size = 0;
 202 +       unsigned int logical_block_size = 0;
 203 +       struct stat st;
 204 +       int rv;
 205 +
 206 +       rv = stat(path, &st);
 207 +       if (rv < 0) {
 208 +               log_error("Failed to stat device to get block size %s %d", path, errno);
 209 +               return -1;
 210 +       }
 211 +
 212 +       _read_sysfs_size(st.st_rdev, "physical_block_size", &physical_block_size);
 213 +       _read_sysfs_size(st.st_rdev, "logical_block_size", &logical_block_size);
 214 +
 215 +       if ((physical_block_size == 512) && (logical_block_size == 512)) {
 216 +               *sector_size = 512;
 217 +               *align_size = ONE_MB;
 218 +               return 0;
 219 +       }
 220 +
 221 +       if ((physical_block_size == 4096) && (logical_block_size == 4096)) {
 222 +               *sector_size = 4096;
 223 +               *align_size = 8 * ONE_MB;
 224 +               return 0;
 225 +       }
 226 +
 227 +       if (physical_block_size && (physical_block_size != 512) && (physical_block_size != 4096)) {
 228 +               log_warn("WARNING: invalid block sizes physical %u logical %u for %s",
 229 +                        physical_block_size, logical_block_size, path);
 230 +               physical_block_size = 0;
 231 +       }
 232 +
 233 +       if (logical_block_size && (logical_block_size != 512) && (logical_block_size != 4096)) {
 234 +               log_warn("WARNING: invalid block sizes physical %u logical %u for %s",
 235 +                        physical_block_size, logical_block_size, path);
 236 +               logical_block_size = 0;
 237 +       }
 238 +
 239 +       if (!physical_block_size && !logical_block_size) {
 240 +               log_error("Failed to get a block size for %s", path);
 241 +               return -1;
 242 +       }
 243 +
 244 +       if (!physical_block_size || !logical_block_size) {
 245 +               log_warn("WARNING: incomplete block size information physical %u logical %u for %s",
 246 +                        physical_block_size, logical_block_size, path);
 247 +               if (!physical_block_size)
 248 +                       physical_block_size = logical_block_size;
 249 +               if (!logical_block_size)
 250 +                       logical_block_size = physical_block_size;
 251 +       }
 252 +
 253 +       if ((logical_block_size == 4096) && (physical_block_size == 512)) {
 254 +               log_warn("WARNING: mixed block sizes physical %u logical %u (using 4096) for %s",
 255 +                        physical_block_size, logical_block_size, path);
 256 +               *sector_size = 4096;
 257 +               *align_size = 8 * ONE_MB;
 258 +               return 0;
 259 +       }
 260 +
 261 +       if ((physical_block_size == 4096) && (logical_block_size == 512)) {
 262 +               log_warn("WARNING: mixed block sizes physical %u logical %u (using 4096) for %s",
 263 +                        physical_block_size, logical_block_size, path);
 264 +               *sector_size = 4096;
 265 +               *align_size = 8 * ONE_MB;
 266 +               return 0;
 267 +       }
 268 +
 269 +       if (physical_block_size == 512) {
 270 +               *sector_size = 512;
 271 +               *align_size = ONE_MB;
 272 +               return 0;
 273 +       }
 274 +
 275 +       if (physical_block_size == 4096) {
 276 +               *sector_size = 4096;
 277 +               *align_size = 8 * ONE_MB;
 278 +               return 0;
 279 +       }
 280 +
 281 +       log_error("Failed to get a block size for %s", path);
 282 +       return -1;
 283 +}
 284 +
 285 +
 286 +/* Get the sector/align sizes that were used to create an existing VG.
 287 +   sanlock encoded this in the lockspace/resource structs on disk. */
 288 +
 289 +static int get_sizes_lockspace(char *path, int *sector_size, int *align_size)
 290 +{
 291 +       struct sanlk_lockspace ss;
 292 +       uint32_t io_timeout = 0;
 293 +       int rv;
 294 +
 295 +       memset(&ss, 0, sizeof(ss));
 296 +       memcpy(ss.host_id_disk.path, path, SANLK_PATH_LEN);
 297 +       ss.host_id_disk.offset = 0;
 298 +
 299 +       rv = sanlock_read_lockspace(&ss, 0, &io_timeout);
 300 +       if (rv < 0) {
 301 +               log_error("get_sizes_lockspace %s error %d", path, rv);
 302 +               return rv;
 303 +       }
 304 +
 305 +       if ((ss.flags & SANLK_LSF_SECTOR4K) && (ss.flags & SANLK_LSF_ALIGN8M)) {
 306 +               *sector_size = 4096;
 307 +               *align_size = 8 * ONE_MB;
 308 +       } else if ((ss.flags & SANLK_LSF_SECTOR512) && (ss.flags & SANLK_LSF_ALIGN1M)) {
 309 +               *sector_size = 512;
 310 +               *align_size = ONE_MB;
 311 +       }
 312 +
 313 +       log_debug("get_sizes_lockspace found %d %d", *sector_size, *align_size);
 314 +       return 0;
 315 +}
 316 +
 317  /*
 318   * vgcreate
 319   *
 320 @@ -343,7 +508,8 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 321         uint32_t daemon_version;
 322         uint32_t daemon_proto;
 323         uint64_t offset;
 324 -       int align_size;
 325 +       int sector_size = 0;
 326 +       int align_size = 0;
 327         int i, rv;
 328
 329         memset(&ss, 0, sizeof(ss));
 330 @@ -387,23 +553,25 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 331         log_debug("sanlock daemon version %08x proto %08x",
 332                   daemon_version, daemon_proto);
 333
 334 -       rv = sanlock_align(&disk);
 335 -       if (rv <= 0) {
 336 +       /* Nothing formatted on disk yet, use what the device reports. */
 337 +       rv = get_sizes_device(disk.path, &sector_size, &align_size);
 338 +       if (rv < 0) {
 339                 if (rv == -EACCES) {
 340                         log_error("S %s init_vg_san sanlock error -EACCES: no permission to access %s",
 341                                   ls_name, disk.path);
 342                         return -EDEVOPEN;
 343                 } else {
 344 -                       log_error("S %s init_vg_san sanlock error %d trying to get align size of %s",
 345 +                       log_error("S %s init_vg_san sanlock error %d trying to get sector/align size of %s",
 346                                   ls_name, rv, disk.path);
 347                         return -EARGS;
 348                 }
 349 -       } else
 350 -               align_size = rv;
 351 +       }
 352
 353         strncpy(ss.name, ls_name, SANLK_NAME_LEN);
 354         memcpy(ss.host_id_disk.path, disk.path, SANLK_PATH_LEN);
 355 -       ss.host_id_disk.offset = LS_BEGIN * align_size;
 356 +       ss.host_id_disk.offset = 0;
 357 +       ss.flags = (sector_size == 4096) ? (SANLK_LSF_SECTOR4K | SANLK_LSF_ALIGN8M) :
 358 +                                          (SANLK_LSF_SECTOR512 | SANLK_LSF_ALIGN1M);
 359
 360         rv = sanlock_write_lockspace(&ss, 0, 0, sanlock_io_timeout);
 361         if (rv < 0) {
 362 @@ -436,6 +604,8 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 363         memcpy(rd.rs.disks[0].path, disk.path, SANLK_PATH_LEN);
 364         rd.rs.disks[0].offset = align_size * GL_LOCK_BEGIN;
 365         rd.rs.num_disks = 1;
 366 +       rd.rs.flags = (sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
 367 +                                             (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 368
 369         rv = sanlock_write_resource(&rd.rs, 0, 0, 0);
 370         if (rv < 0) {
 371 @@ -449,6 +619,8 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 372         memcpy(rd.rs.disks[0].path, disk.path, SANLK_PATH_LEN);
 373         rd.rs.disks[0].offset = align_size * VG_LOCK_BEGIN;
 374         rd.rs.num_disks = 1;
 375 +       rd.rs.flags = (sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
 376 +                                             (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 377
 378         rv = sanlock_write_resource(&rd.rs, 0, 0, 0);
 379         if (rv < 0) {
 380 @@ -472,6 +644,8 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 381
 382         memset(&rd, 0, sizeof(rd));
 383         rd.rs.num_disks = 1;
 384 +       rd.rs.flags = (sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
 385 +                                             (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 386         memcpy(rd.rs.disks[0].path, disk.path, SANLK_PATH_LEN);
 387         strncpy(rd.rs.lockspace_name, ls_name, SANLK_NAME_LEN);
 388         strcpy(rd.rs.name, "#unused");
 389 @@ -510,13 +684,13 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 390   */
 391
 392  int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name,
 393 -                      char *vg_args, char *lv_args, uint64_t free_offset)
 394 +                      char *vg_args, char *lv_args,
 395 +                      int sector_size, int align_size, uint64_t free_offset)
 396  {
 397         struct sanlk_resourced rd;
 398         char lock_lv_name[MAX_ARGS+1];
 399         char lock_args_version[MAX_ARGS+1];
 400         uint64_t offset;
 401 -       int align_size;
 402         int rv;
 403
 404         memset(&rd, 0, sizeof(rd));
 405 @@ -534,7 +708,7 @@ int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name,
 406                  LV_LOCK_ARGS_MAJOR, LV_LOCK_ARGS_MINOR, LV_LOCK_ARGS_PATCH);
 407
 408         if (daemon_test) {
 409 -               align_size = 1048576;
 410 +               align_size = ONE_MB;
 411                 snprintf(lv_args, MAX_ARGS, "%s:%llu",
 412                          lock_args_version,
 413                          (unsigned long long)((align_size * LV_LOCK_BEGIN) + (align_size * daemon_test_lv_count)));
 414 @@ -547,12 +721,35 @@ int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name,
 415         if ((rv = build_dm_path(rd.rs.disks[0].path, SANLK_PATH_LEN, vg_name, lock_lv_name)))
 416                 return rv;
 417
 418 -       align_size = sanlock_align(&rd.rs.disks[0]);
 419 -       if (align_size <= 0) {
 420 -               log_error("S %s init_lv_san align error %d", ls_name, align_size);
 421 -               return -EINVAL;
 422 +       /*
 423 +        * These should not usually be zero, maybe only the first time this function is called?
 424 +        * We need to use the same sector/align sizes that are already being used.
 425 +        */
 426 +       if (!sector_size || !align_size) {
 427 +               rv = get_sizes_lockspace(rd.rs.disks[0].path, &sector_size, &align_size);
 428 +               if (rv < 0) {
 429 +                       log_error("S %s init_lv_san read_lockspace error %d %s",
 430 +                                 ls_name, rv, rd.rs.disks[0].path);
 431 +                       return rv;
 432 +               }
 433 +
 434 +               if (sector_size)
 435 +                       log_debug("S %s init_lv_san found ls sector_size %d align_size %d", ls_name, sector_size, align_size);
 436 +               else {
 437 +                       /* use the old method */
 438 +                       align_size = sanlock_align(&rd.rs.disks[0]);
 439 +                       if (align_size <= 0) {
 440 +                               log_error("S %s init_lv_san align error %d", ls_name, align_size);
 441 +                               return -EINVAL;
 442 +                       }
 443 +                       sector_size = (align_size == ONE_MB) ? 512 : 4096;
 444 +                       log_debug("S %s init_lv_san found old sector_size %d align_size %d", ls_name, sector_size, align_size);
 445 +               }
 446         }
 447
 448 +       rd.rs.flags = (sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
 449 +                                             (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 450 +
 451         if (free_offset)
 452                 offset = free_offset;
 453         else
 454 @@ -595,6 +792,8 @@ int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name,
 455                                   ls_name, lv_name, (unsigned long long)offset);
 456
 457                         strncpy(rd.rs.name, lv_name, SANLK_NAME_LEN);
 458 +                       rd.rs.flags = (sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
 459 +                                                             (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 460
 461                         rv = sanlock_write_resource(&rd.rs, 0, 0, 0);
 462                         if (!rv) {
 463 @@ -626,7 +825,8 @@ int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_
 464         char lock_lv_name[MAX_ARGS+1];
 465         uint64_t offset;
 466         uint32_t io_timeout;
 467 -       int align_size;
 468 +       int sector_size = 0;
 469 +       int align_size = 0;
 470         int i, rv;
 471
 472         memset(&disk, 0, sizeof(disk));
 473 @@ -655,20 +855,13 @@ int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_
 474         /* FIXME: device is not always ready for us here */
 475         sleep(1);
 476
 477 -       align_size = sanlock_align(&disk);
 478 -       if (align_size <= 0) {
 479 -               log_error("S %s rename_vg_san bad align size %d %s",
 480 -                         ls_name, align_size, disk.path);
 481 -               return -EINVAL;
 482 -       }
 483 -
 484         /*
 485          * Lockspace
 486          */
 487
 488         memset(&ss, 0, sizeof(ss));
 489         memcpy(ss.host_id_disk.path, disk.path, SANLK_PATH_LEN);
 490 -       ss.host_id_disk.offset = LS_BEGIN * align_size;
 491 +       ss.host_id_disk.offset = 0;
 492
 493         rv = sanlock_read_lockspace(&ss, 0, &io_timeout);
 494         if (rv < 0) {
 495 @@ -677,6 +870,26 @@ int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_
 496                 return rv;
 497         }
 498
 499 +       if ((ss.flags & SANLK_LSF_SECTOR4K) && (ss.flags & SANLK_LSF_ALIGN8M)) {
 500 +               sector_size = 4096;
 501 +               align_size = 8 * ONE_MB;
 502 +       } else if ((ss.flags & SANLK_LSF_SECTOR512) && (ss.flags & SANLK_LSF_ALIGN1M)) {
 503 +               sector_size = 512;
 504 +               align_size = ONE_MB;
 505 +       } else {
 506 +               /* use the old method */
 507 +               align_size = sanlock_align(&ss.host_id_disk);
 508 +               if (align_size <= 0) {
 509 +                       log_error("S %s rename_vg_san unknown sector/align size for %s",
 510 +                                ls_name, ss.host_id_disk.path);
 511 +                       return -1;
 512 +               }
 513 +               sector_size = (align_size == ONE_MB) ? 512 : 4096;
 514 +       }
 515 +
 516 +       if (!sector_size || !align_size)
 517 +               return -1;
 518 +
 519         strncpy(ss.name, ls_name, SANLK_NAME_LEN);
 520
 521         rv = sanlock_write_lockspace(&ss, 0, 0, sanlock_io_timeout);
 522 @@ -830,6 +1043,11 @@ int lm_ex_disable_gl_sanlock(struct lockspace *ls)
 523         rd1.rs.num_disks = 1;
 524         strncpy(rd1.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN-1);
 525         rd1.rs.disks[0].offset = lms->align_size * GL_LOCK_BEGIN;
 526 +
 527 +       rd1.rs.flags = (lms->sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
 528 +                                                   (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 529 +       rd2.rs.flags = (lms->sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
 530 +                                                   (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 531
 532         rv = sanlock_acquire(lms->sock, -1, 0, 1, &rs1, NULL);
 533         if (rv < 0) {
 534 @@ -891,6 +1109,8 @@ int lm_able_gl_sanlock(struct lockspace *ls, int enable)
 535         rd.rs.num_disks = 1;
 536         strncpy(rd.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN-1);
 537         rd.rs.disks[0].offset = lms->align_size * GL_LOCK_BEGIN;
 538 +       rd.rs.flags = (lms->sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
 539 +                                                  (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 540
 541         rv = sanlock_write_resource(&rd.rs, 0, 0, 0);
 542         if (rv < 0) {
 543 @@ -936,7 +1156,8 @@ static int gl_is_enabled(struct lockspace *ls, struct lm_sanlock *lms)
 544
 545         rv = sanlock_read_resource(&rd.rs, 0);
 546         if (rv < 0) {
 547 -               log_error("gl_is_enabled read_resource error %d", rv);
 548 +               log_error("gl_is_enabled read_resource align_size %d offset %llu error %d",
 549 +                         lms->align_size, (unsigned long long)offset, rv);
 550                 return rv;
 551         }
 552
 553 @@ -973,7 +1194,7 @@ int lm_gl_is_enabled(struct lockspace *ls)
 554   * been disabled.)
 555   */
 556
 557 -int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset)
 558 +int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset, int *sector_size, int *align_size)
 559  {
 560         struct lm_sanlock *lms = (struct lm_sanlock *)ls->lm_data;
 561         struct sanlk_resourced rd;
 562 @@ -983,15 +1204,22 @@ int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset)
 563         int round = 0;
 564
 565         if (daemon_test) {
 566 -               *free_offset = (1048576 * LV_LOCK_BEGIN) + (1048576 * (daemon_test_lv_count + 1));
 567 +               *free_offset = (ONE_MB * LV_LOCK_BEGIN) + (ONE_MB * (daemon_test_lv_count + 1));
 568 +               *sector_size = 512;
 569 +               *align_size = ONE_MB;
 570                 return 0;
 571         }
 572
 573 +       *sector_size = lms->sector_size;
 574 +       *align_size = lms->align_size;
 575 +
 576         memset(&rd, 0, sizeof(rd));
 577
 578         strncpy(rd.rs.lockspace_name, ls->name, SANLK_NAME_LEN);
 579         rd.rs.num_disks = 1;
 580         strncpy(rd.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN-1);
 581 +       rd.rs.flags = (lms->sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
 582 +                                                  (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 583
 584         if (ls->free_lock_offset)
 585                 offset = ls->free_lock_offset;
 586 @@ -1091,6 +1319,8 @@ int lm_prepare_lockspace_sanlock(struct lockspace *ls)
 587         char disk_path[SANLK_PATH_LEN];
 588         char killpath[SANLK_PATH_LEN];
 589         char killargs[SANLK_PATH_LEN];
 590 +       int sector_size = 0;
 591 +       int align_size = 0;
 592         int gl_found;
 593         int ret, rv;
 594
 595 @@ -1207,13 +1437,33 @@ int lm_prepare_lockspace_sanlock(struct lockspace *ls)
 596                 goto fail;
 597         }
 598
 599 -       lms->align_size = sanlock_align(&lms->ss.host_id_disk);
 600 -       if (lms->align_size <= 0) {
 601 -               log_error("S %s prepare_lockspace_san align error %d", lsname, lms->align_size);
 602 +       rv = get_sizes_lockspace(disk_path, &sector_size, &align_size);
 603 +       if (rv < 0) {
 604 +               log_error("S %s prepare_lockspace_san cannot get sector/align sizes %d", lsname, rv);
 605                 ret = -EMANAGER;
 606                 goto fail;
 607         }
 608
 609 +       if (!sector_size) {
 610 +               log_debug("S %s prepare_lockspace_san using old size method", lsname);
 611 +               /* use the old method */
 612 +               align_size = sanlock_align(&lms->ss.host_id_disk);
 613 +               if (align_size <= 0) {
 614 +                       log_error("S %s prepare_lockspace_san align error %d", lsname, align_size);
 615 +                       return -EINVAL;
 616 +               }
 617 +               sector_size = (align_size == ONE_MB) ? 512 : 4096;
 618 +               log_debug("S %s prepare_lockspace_san found old sector_size %d align_size %d", lsname, sector_size, align_size);
 619 +       }
 620 +
 621 +       log_debug("S %s prepare_lockspace_san sizes %d %d", lsname, sector_size, align_size);
 622 +
 623 +       lms->align_size = align_size;
 624 +       lms->sector_size = sector_size;
 625 +
 626 +       lms->ss.flags = (sector_size == 4096) ? (SANLK_LSF_SECTOR4K | SANLK_LSF_ALIGN8M) :
 627 +                                               (SANLK_LSF_SECTOR512 | SANLK_LSF_ALIGN1M);
 628 +
 629         gl_found = gl_is_enabled(ls, lms);
 630         if (gl_found < 0) {
 631                 log_error("S %s prepare_lockspace_san gl_enabled error %d", lsname, gl_found);
 632 @@ -1351,6 +1601,7 @@ static int lm_add_resource_sanlock(struct lockspace *ls, struct resource *r)
 633         strncpy(rds->rs.name, r->name, SANLK_NAME_LEN);
 634         rds->rs.num_disks = 1;
 635         memcpy(rds->rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN);
 636 +       rds->rs.flags = (lms->sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) : (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 637
 638         if (r->type == LD_RT_GL)
 639                 rds->rs.disks[0].offset = GL_LOCK_BEGIN * lms->align_size;
 640 --
 641 2.9.3
 642