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
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.
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(-)
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);
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)
29 if (ls->lm_type == LD_LM_DLM)
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);
37 @@ -2427,11 +2427,16 @@ static void *lockspace_thread_main(void *arg_in)
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;
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, §or_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;
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;
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;
73 pthread_mutex_unlock(&lockspaces_mutex);
75 @@ -3268,7 +3277,7 @@ static int work_init_lv(struct action *act)
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);
82 memcpy(act->lv_args, lv_args, MAX_ARGS);
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 */
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 */
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
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);
115 static inline int lm_support_sanlock(void)
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
122 #include "sanlock_admin.h"
123 #include "sanlock_resource.h"
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
144 +#include <blkid/blkid.h>
145 +#include <linux/kdev_t.h>
147 +#define ONE_MB 1048576
150 -------------------------------------------------------------------------------
151 @@ -139,6 +158,7 @@ release all the leases for the VG.
154 struct sanlk_lockspace ss;
157 int sock; /* sanlock daemon connection */
159 @@ -201,7 +221,6 @@ int lm_data_size_sanlock(void)
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:
171 +static void _read_sysfs_size(dev_t devno, const char *name, unsigned int *val)
173 + char path[PATH_MAX];
178 + snprintf(path, sizeof(path), "/sys/dev/block/%d:%d/queue/%s",
179 + (int)MAJOR(devno), (int)MINOR(devno), name);
181 + if (!(fp = fopen(path, "r")))
184 + if (!fgets(buf, sizeof(buf), fp))
187 + if ((len = strlen(buf)) && buf[len - 1] == '\n')
196 +/* Select sector/align size for a new VG based on what the device reports for
197 + sector size of the lvmlock LV. */
199 +static int get_sizes_device(char *path, int *sector_size, int *align_size)
201 + unsigned int physical_block_size = 0;
202 + unsigned int logical_block_size = 0;
206 + rv = stat(path, &st);
208 + log_error("Failed to stat device to get block size %s %d", path, errno);
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);
215 + if ((physical_block_size == 512) && (logical_block_size == 512)) {
216 + *sector_size = 512;
217 + *align_size = ONE_MB;
221 + if ((physical_block_size == 4096) && (logical_block_size == 4096)) {
222 + *sector_size = 4096;
223 + *align_size = 8 * ONE_MB;
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;
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;
239 + if (!physical_block_size && !logical_block_size) {
240 + log_error("Failed to get a block size for %s", path);
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;
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;
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;
269 + if (physical_block_size == 512) {
270 + *sector_size = 512;
271 + *align_size = ONE_MB;
275 + if (physical_block_size == 4096) {
276 + *sector_size = 4096;
277 + *align_size = 8 * ONE_MB;
281 + log_error("Failed to get a block size for %s", path);
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. */
289 +static int get_sizes_lockspace(char *path, int *sector_size, int *align_size)
291 + struct sanlk_lockspace ss;
292 + uint32_t io_timeout = 0;
295 + memset(&ss, 0, sizeof(ss));
296 + memcpy(ss.host_id_disk.path, path, SANLK_PATH_LEN);
297 + ss.host_id_disk.offset = 0;
299 + rv = sanlock_read_lockspace(&ss, 0, &io_timeout);
301 + log_error("get_sizes_lockspace %s error %d", path, rv);
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;
313 + log_debug("get_sizes_lockspace found %d %d", *sector_size, *align_size);
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;
325 + int sector_size = 0;
326 + int align_size = 0;
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);
334 - rv = sanlock_align(&disk);
336 + /* Nothing formatted on disk yet, use what the device reports. */
337 + rv = get_sizes_device(disk.path, §or_size, &align_size);
340 log_error("S %s init_vg_san sanlock error -EACCES: no permission to access %s",
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);
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);
360 rv = sanlock_write_lockspace(&ss, 0, 0, sanlock_io_timeout);
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;
366 + rd.rs.flags = (sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
367 + (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
369 rv = sanlock_write_resource(&rd.rs, 0, 0, 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;
375 + rd.rs.flags = (sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
376 + (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
378 rv = sanlock_write_resource(&rd.rs, 0, 0, 0);
380 @@ -472,6 +644,8 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
382 memset(&rd, 0, sizeof(rd));
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
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)
397 struct sanlk_resourced rd;
398 char lock_lv_name[MAX_ARGS+1];
399 char lock_args_version[MAX_ARGS+1];
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);
409 - align_size = 1048576;
410 + align_size = ONE_MB;
411 snprintf(lv_args, MAX_ARGS, "%s:%llu",
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)))
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);
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.
426 + if (!sector_size || !align_size) {
427 + rv = get_sizes_lockspace(rd.rs.disks[0].path, §or_size, &align_size);
429 + log_error("S %s init_lv_san read_lockspace error %d %s",
430 + ls_name, rv, rd.rs.disks[0].path);
435 + log_debug("S %s init_lv_san found ls sector_size %d align_size %d", ls_name, sector_size, align_size);
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);
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);
448 + rd.rs.flags = (sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
449 + (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
452 offset = free_offset;
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);
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);
461 rv = sanlock_write_resource(&rd.rs, 0, 0, 0);
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];
468 + int sector_size = 0;
469 + int align_size = 0;
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 */
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);
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;
493 rv = sanlock_read_lockspace(&ss, 0, &io_timeout);
495 @@ -677,6 +870,26 @@ int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_
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)) {
504 + align_size = ONE_MB;
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);
513 + sector_size = (align_size == ONE_MB) ? 512 : 4096;
516 + if (!sector_size || !align_size)
519 strncpy(ss.name, ls_name, SANLK_NAME_LEN);
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;
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);
532 rv = sanlock_acquire(lms->sock, -1, 0, 1, &rs1, NULL);
534 @@ -891,6 +1109,8 @@ int lm_able_gl_sanlock(struct lockspace *ls, int enable)
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);
541 rv = sanlock_write_resource(&rd.rs, 0, 0, 0);
543 @@ -936,7 +1156,8 @@ static int gl_is_enabled(struct lockspace *ls, struct lm_sanlock *lms)
545 rv = sanlock_read_resource(&rd.rs, 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);
553 @@ -973,7 +1194,7 @@ int lm_gl_is_enabled(struct lockspace *ls)
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)
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)
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;
573 + *sector_size = lms->sector_size;
574 + *align_size = lms->align_size;
576 memset(&rd, 0, sizeof(rd));
578 strncpy(rd.rs.lockspace_name, ls->name, SANLK_NAME_LEN);
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);
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;
595 @@ -1207,13 +1437,33 @@ int lm_prepare_lockspace_sanlock(struct lockspace *ls)
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, §or_size, &align_size);
604 + log_error("S %s prepare_lockspace_san cannot get sector/align sizes %d", lsname, rv);
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);
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);
621 + log_debug("S %s prepare_lockspace_san sizes %d %d", lsname, sector_size, align_size);
623 + lms->align_size = align_size;
624 + lms->sector_size = sector_size;
626 + lms->ss.flags = (sector_size == 4096) ? (SANLK_LSF_SECTOR4K | SANLK_LSF_ALIGN8M) :
627 + (SANLK_LSF_SECTOR512 | SANLK_LSF_ALIGN1M);
629 gl_found = gl_is_enabled(ls, lms);
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);
638 if (r->type == LD_RT_GL)
639 rds->rs.disks[0].offset = GL_LOCK_BEGIN * lms->align_size;