]> sourceware.org Git - lvm2.git/blame - tools/lvresize.c
Use new dmeventd_lvm2_command function in dmeventd plugins.
[lvm2.git] / tools / lvresize.c
CommitLineData
03a8a07d 1/*
1832f310 2 * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
daa10ad0 3 * Copyright (C) 2004-2011 Red Hat, Inc. All rights reserved.
03a8a07d 4 *
6606c3ae 5 * This file is part of LVM2.
03a8a07d 6 *
6606c3ae
AK
7 * This copyrighted material is made available to anyone wishing to use,
8 * modify, copy, or redistribute it subject to the terms and conditions
be684599 9 * of the GNU Lesser General Public License v.2.1.
03a8a07d 10 *
be684599 11 * You should have received a copy of the GNU Lesser General Public License
6606c3ae
AK
12 * along with this program; if not, write to the Free Software Foundation,
13 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
03a8a07d
AK
14 */
15
16#include "tools.h"
17
1a9ea74d
AK
18#define SIZE_BUF 128
19
241913fe 20struct lvresize_params {
8ef2b021 21 const char *vg_name;
241913fe
AK
22 const char *lv_name;
23
24 uint32_t stripes;
25 uint32_t stripe_size;
ffb0e538 26 uint32_t mirrors;
241913fe 27
72b2cb61 28 const struct segment_type *segtype;
241913fe 29
241913fe
AK
30 /* size */
31 uint32_t extents;
32 uint64_t size;
33 sign_t sign;
8191fe4f 34 percent_type_t percent;
03a8a07d
AK
35
36 enum {
37 LV_ANY = 0,
38 LV_REDUCE = 1,
39 LV_EXTEND = 2
241913fe
AK
40 } resize;
41
1a9ea74d
AK
42 int resizefs;
43 int nofsck;
44
241913fe
AK
45 int argc;
46 char **argv;
47};
48
bc175d28
AK
49static int _validate_stripesize(struct cmd_context *cmd,
50 const struct volume_group *vg,
51 struct lvresize_params *lp)
406a9754
DW
52{
53 if (arg_sign_value(cmd, stripesize_ARG, 0) == SIGN_MINUS) {
54 log_error("Stripesize may not be negative.");
55 return 0;
56 }
57
301c2b88 58 if (arg_uint64_value(cmd, stripesize_ARG, 0) > STRIPE_SIZE_LIMIT * 2) {
406a9754
DW
59 log_error("Stripe size cannot be larger than %s",
60 display_size(cmd, (uint64_t) STRIPE_SIZE_LIMIT));
61 return 0;
62 }
63
64 if (!(vg->fid->fmt->features & FMT_SEGMENTS))
65 log_warn("Varied stripesize not supported. Ignoring.");
204a12e5 66 else if (arg_uint_value(cmd, stripesize_ARG, 0) > vg->extent_size * 2) {
406a9754
DW
67 log_error("Reducing stripe size %s to maximum, "
68 "physical extent size %s",
69 display_size(cmd,
204a12e5 70 (uint64_t) arg_uint_value(cmd, stripesize_ARG, 0)),
406a9754
DW
71 display_size(cmd, (uint64_t) vg->extent_size));
72 lp->stripe_size = vg->extent_size;
73 } else
204a12e5 74 lp->stripe_size = arg_uint_value(cmd, stripesize_ARG, 0);
406a9754 75
406a9754
DW
76 if (lp->stripe_size & (lp->stripe_size - 1)) {
77 log_error("Stripe size must be power of 2");
78 return 0;
79 }
80
81 return 1;
82}
83
bc175d28
AK
84static int _request_confirmation(struct cmd_context *cmd,
85 const struct volume_group *vg,
86 const struct logical_volume *lv,
87 const struct lvresize_params *lp)
406a9754
DW
88{
89 struct lvinfo info;
90
91 memset(&info, 0, sizeof(info));
92
2d6fcbf6 93 if (!lv_info(cmd, lv, 0, &info, 1, 0) && driver_version(NULL, 0)) {
406a9754
DW
94 log_error("lv_info failed: aborting");
95 return 0;
96 }
97
bc175d28
AK
98 if (lp->resizefs) {
99 if (!info.exists) {
100 log_error("Logical volume %s must be activated "
101 "before resizing filesystem", lp->lv_name);
102 return 0;
103 }
104 return 1;
406a9754
DW
105 }
106
bc175d28
AK
107 if (!info.exists)
108 return 1;
406a9754 109
bc175d28
AK
110 log_warn("WARNING: Reducing active%s logical volume to %s",
111 info.open_count ? " and open" : "",
112 display_size(cmd, (uint64_t) lp->extents * vg->extent_size));
406a9754 113
bc175d28
AK
114 log_warn("THIS MAY DESTROY YOUR DATA (filesystem etc.)");
115
116 if (!arg_count(cmd, force_ARG)) {
117 if (yes_no_prompt("Do you really want to reduce %s? [y/n]: ",
118 lp->lv_name) == 'n') {
fec4de95 119 log_error("Logical volume %s NOT reduced", lp->lv_name);
bc175d28 120 return 0;
406a9754 121 }
bc175d28
AK
122 if (sigint_caught())
123 return 0;
406a9754
DW
124 }
125
126 return 1;
127}
128
c8669f6b 129enum fsadm_cmd_e { FSADM_CMD_CHECK, FSADM_CMD_RESIZE };
bc175d28
AK
130#define FSADM_CMD "fsadm"
131#define FSADM_CMD_MAX_ARGS 6
2955b913 132#define FSADM_CHECK_FAILS_FOR_MOUNTED 3 /* shell exist status code */
c8669f6b 133
bc175d28
AK
134/*
135 * FSADM_CMD --dry-run --verbose --force check lv_path
136 * FSADM_CMD --dry-run --verbose --force resize lv_path size
137 */
ed82bfd2 138static int _fsadm_cmd(struct cmd_context *cmd,
bc175d28
AK
139 const struct volume_group *vg,
140 const struct lvresize_params *lp,
2955b913
ZK
141 enum fsadm_cmd_e fcmd,
142 int *status)
406a9754
DW
143{
144 char lv_path[PATH_MAX];
145 char size_buf[SIZE_BUF];
bc175d28
AK
146 const char *argv[FSADM_CMD_MAX_ARGS + 2];
147 unsigned i = 0;
c8669f6b 148
bc175d28 149 argv[i++] = FSADM_CMD;
c8669f6b
ZK
150
151 if (test_mode())
152 argv[i++] = "--dry-run";
153
bc175d28 154 if (verbose_level() >= _LOG_NOTICE)
c8669f6b
ZK
155 argv[i++] = "--verbose";
156
157 if (arg_count(cmd, force_ARG))
158 argv[i++] = "--force";
159
160 argv[i++] = (fcmd == FSADM_CMD_RESIZE) ? "resize" : "check";
406a9754 161
bc175d28
AK
162 if (dm_snprintf(lv_path, PATH_MAX, "%s%s/%s", cmd->dev_dir, lp->vg_name,
163 lp->lv_name) < 0) {
164 log_error("Couldn't create LV path for %s", lp->lv_name);
406a9754
DW
165 return 0;
166 }
167
c8669f6b 168 argv[i++] = lv_path;
406a9754 169
c8669f6b
ZK
170 if (fcmd == FSADM_CMD_RESIZE) {
171 if (dm_snprintf(size_buf, SIZE_BUF, "%" PRIu64 "K",
172 (uint64_t) lp->extents * vg->extent_size / 2) < 0) {
173 log_error("Couldn't generate new LV size string");
174 return 0;
175 }
406a9754 176
c8669f6b
ZK
177 argv[i++] = size_buf;
178 }
406a9754 179
c8669f6b
ZK
180 argv[i] = NULL;
181
b1b38215 182 return exec_cmd(cmd, argv, status, 1);
406a9754
DW
183}
184
8a2fc586
AK
185static int _lvresize_params(struct cmd_context *cmd, int argc, char **argv,
186 struct lvresize_params *lp)
241913fe
AK
187{
188 const char *cmd_name;
189 char *st;
17dd04ca 190 unsigned dev_dir_found = 0;
a341cab7 191 int use_policy = arg_count(cmd, use_policies_ARG);
241913fe
AK
192
193 lp->sign = SIGN_NONE;
194 lp->resize = LV_ANY;
03a8a07d 195
60274aba 196 cmd_name = command_name(cmd);
03a8a07d 197 if (!strcmp(cmd_name, "lvreduce"))
241913fe 198 lp->resize = LV_REDUCE;
03a8a07d 199 if (!strcmp(cmd_name, "lvextend"))
241913fe 200 lp->resize = LV_EXTEND;
03a8a07d 201
a341cab7
PR
202 if (use_policy) {
203 /* do nothing; _lvresize will handle --use-policies itself */
204 lp->extents = 0;
dfef7f69 205 lp->sign = SIGN_PLUS;
a341cab7
PR
206 lp->percent = PERCENT_LV;
207 } else {
208 /*
209 * Allow omission of extents and size if the user has given us
210 * one or more PVs. Most likely, the intent was "resize this
211 * LV the best you can with these PVs"
212 */
213 if ((arg_count(cmd, extents_ARG) + arg_count(cmd, size_ARG) == 0) &&
214 (argc >= 2)) {
215 lp->extents = 100;
216 lp->percent = PERCENT_PVS;
217 lp->sign = SIGN_PLUS;
218 } else if ((arg_count(cmd, extents_ARG) +
219 arg_count(cmd, size_ARG) != 1)) {
220 log_error("Please specify either size or extents but not "
221 "both.");
222 return 0;
223 }
03a8a07d 224
a341cab7
PR
225 if (arg_count(cmd, extents_ARG)) {
226 lp->extents = arg_uint_value(cmd, extents_ARG, 0);
227 lp->sign = arg_sign_value(cmd, extents_ARG, SIGN_NONE);
228 lp->percent = arg_percent_value(cmd, extents_ARG, PERCENT_NONE);
229 }
03a8a07d 230
a341cab7
PR
231 /* Size returned in kilobyte units; held in sectors */
232 if (arg_count(cmd, size_ARG)) {
233 lp->size = arg_uint64_value(cmd, size_ARG, 0);
234 lp->sign = arg_sign_value(cmd, size_ARG, SIGN_NONE);
235 lp->percent = PERCENT_NONE;
236 }
03a8a07d
AK
237 }
238
241913fe 239 if (lp->resize == LV_EXTEND && lp->sign == SIGN_MINUS) {
03a8a07d 240 log_error("Negative argument not permitted - use lvreduce");
241913fe 241 return 0;
03a8a07d
AK
242 }
243
241913fe 244 if (lp->resize == LV_REDUCE && lp->sign == SIGN_PLUS) {
03a8a07d 245 log_error("Positive sign not permitted - use lvextend");
241913fe 246 return 0;
03a8a07d
AK
247 }
248
a8fb89ad
AK
249 lp->resizefs = arg_is_set(cmd, resizefs_ARG);
250 lp->nofsck = arg_is_set(cmd, nofsck_ARG);
1a9ea74d 251
03a8a07d
AK
252 if (!argc) {
253 log_error("Please provide the logical volume name");
241913fe 254 return 0;
03a8a07d
AK
255 }
256
241913fe 257 lp->lv_name = argv[0];
03a8a07d
AK
258 argv++;
259 argc--;
260
3a370b73
AK
261 if (!(lp->lv_name = skip_dev_dir(cmd, lp->lv_name, &dev_dir_found)) ||
262 !(lp->vg_name = extract_vgname(cmd, lp->lv_name))) {
03a8a07d 263 log_error("Please provide a volume group name");
241913fe 264 return 0;
03a8a07d 265 }
17dd04ca 266
d38bf361
AK
267 if (!validate_name(lp->vg_name)) {
268 log_error("Volume group name %s has invalid characters",
269 lp->vg_name);
6c3dc203 270 return 0;
d38bf361 271 }
03a8a07d 272
241913fe
AK
273 if ((st = strrchr(lp->lv_name, '/')))
274 lp->lv_name = st + 1;
03a8a07d 275
241913fe
AK
276 lp->argc = argc;
277 lp->argv = argv;
278
279 return 1;
280}
7d0e6e80 281
a341cab7
PR
282static int _adjust_policy_params(struct cmd_context *cmd,
283 struct logical_volume *lv, struct lvresize_params *lp)
284{
8191fe4f 285 percent_t percent;
a341cab7
PR
286 int policy_threshold, policy_amount;
287
0e0f706f
ZK
288 if (lv_is_thin_pool(lv)) {
289 policy_threshold =
290 find_config_tree_int(cmd, "activation/thin_pool_autoextend_threshold",
291 DEFAULT_THIN_POOL_AUTOEXTEND_THRESHOLD) * PERCENT_1;
292 policy_amount =
293 find_config_tree_int(cmd, "activation/thin_pool_autoextend_percent",
294 DEFAULT_THIN_POOL_AUTOEXTEND_PERCENT);
295 } else {
296 policy_threshold =
297 find_config_tree_int(cmd, "activation/snapshot_autoextend_threshold",
298 DEFAULT_SNAPSHOT_AUTOEXTEND_THRESHOLD) * PERCENT_1;
299 policy_amount =
300 find_config_tree_int(cmd, "activation/snapshot_autoextend_percent",
301 DEFAULT_SNAPSHOT_AUTOEXTEND_PERCENT);
302 }
a341cab7 303
8191fe4f 304 if (policy_threshold >= PERCENT_100)
a341cab7
PR
305 return 1; /* nothing to do */
306
0e0f706f
ZK
307 if (lv_is_thin_pool(lv)) {
308 if (!lv_thin_pool_percent(lv, &percent))
309 return_0;
310 if (!(PERCENT_0 < percent && percent <= PERCENT_100) ||
311 percent <= policy_threshold)
312 return 1; /* nothing to do */
313 } else {
314 if (!lv_snapshot_percent(lv, &percent))
315 return_0;
316 if (!(PERCENT_0 < percent && percent < PERCENT_100) || percent <= policy_threshold)
317 return 1; /* nothing to do */
318 }
a341cab7
PR
319
320 lp->extents = policy_amount;
0e0f706f 321
a341cab7
PR
322 return 1;
323}
324
f4ba9c5d
MB
325static uint32_t lvseg_get_stripes(struct lv_segment *seg, uint32_t *stripesize)
326{
327 uint32_t s;
328 struct lv_segment *seg_mirr;
329
330 /* If segment mirrored, check if images are striped */
331 if (seg_is_mirrored(seg))
332 for (s = 0; s < seg->area_count; s++) {
333 if (seg_type(seg, s) != AREA_LV)
334 continue;
335 seg_mirr = first_seg(seg_lv(seg, s));
336
337 if (seg_is_striped(seg_mirr)) {
338 seg = seg_mirr;
339 break;
340 }
341 }
342
343
344 if (seg_is_striped(seg)) {
345 *stripesize = seg->stripe_size;
346 return seg->area_count;
347 }
348
349 *stripesize = 0;
350 return 0;
351}
352
e5f7352b
AK
353static int _lvresize(struct cmd_context *cmd, struct volume_group *vg,
354 struct lvresize_params *lp)
241913fe 355{
241913fe 356 struct logical_volume *lv;
241913fe
AK
357 struct lvinfo info;
358 uint32_t stripesize_extents = 0;
359 uint32_t seg_stripes = 0, seg_stripesize = 0, seg_size = 0;
ffb0e538 360 uint32_t seg_mirrors = 0;
241913fe
AK
361 uint32_t extents_used = 0;
362 uint32_t size_rest;
dfef7f69 363 uint32_t pv_extent_count = 0;
a0a23eff 364 alloc_policy_t alloc;
0fb173aa 365 struct logical_volume *lock_lv;
241913fe 366 struct lv_list *lvl;
1485ce69 367 struct lv_segment *seg, *uninitialized_var(mirr_seg);
241913fe
AK
368 uint32_t seg_extents;
369 uint32_t sz, str;
2955b913 370 int status;
2c44337b 371 struct dm_list *pvh = NULL;
a341cab7 372 int use_policy = arg_count(cmd, use_policies_ARG);
241913fe 373
03a8a07d 374 /* does LV exist? */
241913fe 375 if (!(lvl = find_lv_in_vg(vg, lp->lv_name))) {
03a8a07d 376 log_error("Logical volume %s not found in volume group %s",
241913fe 377 lp->lv_name, lp->vg_name);
7f0dc9c4 378 return ECMD_FAILED;
03a8a07d
AK
379 }
380
d34991ed
JEB
381 if (lvl->lv->status & (RAID_IMAGE | RAID_META)) {
382 log_error("Cannot resize a RAID %s directly",
383 (lvl->lv->status & RAID_IMAGE) ? "image" :
384 "metadata area");
385 return ECMD_FAILED;
386 }
387
388 if (lv_is_raid_with_tracking(lvl->lv)) {
389 log_error("Cannot resize %s while it is tracking a split image",
390 lvl->lv->name);
391 return ECMD_FAILED;
392 }
393
25b73380
AK
394 if (arg_count(cmd, stripes_ARG)) {
395 if (vg->fid->fmt->features & FMT_SEGMENTS)
241913fe 396 lp->stripes = arg_uint_value(cmd, stripes_ARG, 1);
25b73380 397 else
e7ddf416 398 log_warn("Varied striping not supported. Ignoring.");
25b73380
AK
399 }
400
ffb0e538
AK
401 if (arg_count(cmd, mirrors_ARG)) {
402 if (vg->fid->fmt->features & FMT_SEGMENTS)
403 lp->mirrors = arg_uint_value(cmd, mirrors_ARG, 1) + 1;
404 else
e7ddf416 405 log_warn("Mirrors not supported. Ignoring.");
7424de5b
AK
406 if (arg_sign_value(cmd, mirrors_ARG, 0) == SIGN_MINUS) {
407 log_error("Mirrors argument may not be negative");
406a9754 408 return EINVALID_CMD_LINE;
7424de5b 409 }
ffb0e538
AK
410 }
411
bc175d28
AK
412 if (arg_count(cmd, stripesize_ARG) &&
413 !_validate_stripesize(cmd, vg, lp))
414 return EINVALID_CMD_LINE;
25b73380 415
f868d635 416 lv = lvl->lv;
03a8a07d 417
a341cab7 418 if (use_policy) {
0e0f706f
ZK
419 if (!lv_is_cow(lv) &&
420 !lv_is_thin_pool(lv)) {
421 log_error("Policy-based resize is supported only for snapshot and thin pool volumes.");
a341cab7
PR
422 return ECMD_FAILED;
423 }
424 _adjust_policy_params(cmd, lv, lp);
425 }
426
fd817ff3
MS
427 if (!lv_is_visible(lv)) {
428 log_error("Can't resize internal logical volume %s", lv->name);
429 return ECMD_FAILED;
430 }
431
6e03b44c
AK
432 if (lv->status & LOCKED) {
433 log_error("Can't resize locked LV %s", lv->name);
7f0dc9c4 434 return ECMD_FAILED;
6e03b44c
AK
435 }
436
08b481bb
AK
437 if (lv->status & CONVERTING) {
438 log_error("Can't resize %s while lvconvert in progress", lv->name);
439 return ECMD_FAILED;
440 }
441
72b2cb61 442 alloc = arg_uint_value(cmd, alloc_ARG, lv->alloc);
7f0dc9c4 443
241913fe
AK
444 if (lp->size) {
445 if (lp->size % vg->extent_size) {
446 if (lp->sign == SIGN_MINUS)
447 lp->size -= lp->size % vg->extent_size;
03a8a07d 448 else
241913fe
AK
449 lp->size += vg->extent_size -
450 (lp->size % vg->extent_size);
03a8a07d
AK
451
452 log_print("Rounding up size to full physical extent %s",
72b2cb61 453 display_size(cmd, (uint64_t) lp->size));
03a8a07d
AK
454 }
455
241913fe 456 lp->extents = lp->size / vg->extent_size;
03a8a07d
AK
457 }
458
dfef7f69
DW
459 if (!(pvh = lp->argc ? create_pv_list(cmd->mem, vg, lp->argc,
460 lp->argv, 1) : &vg->pvs)) {
461 stack;
462 return ECMD_FAILED;
463 }
464
34fadac4
AK
465 switch(lp->percent) {
466 case PERCENT_VG:
b18e1fd5 467 lp->extents = percent_of_extents(lp->extents, vg->extent_count);
34fadac4
AK
468 break;
469 case PERCENT_FREE:
b18e1fd5 470 lp->extents = percent_of_extents(lp->extents, vg->free_count);
34fadac4
AK
471 break;
472 case PERCENT_LV:
b18e1fd5 473 lp->extents = percent_of_extents(lp->extents, lv->le_count);
34fadac4 474 break;
dfef7f69 475 case PERCENT_PVS:
ba3851fd
MB
476 if (lp->argc) {
477 pv_extent_count = pv_list_extents_free(pvh);
b18e1fd5 478 lp->extents = percent_of_extents(lp->extents, pv_extent_count);
ba3851fd 479 } else
b18e1fd5 480 lp->extents = percent_of_extents(lp->extents, vg->extent_count);
dfef7f69 481 break;
5bc2af26
MS
482 case PERCENT_ORIGIN:
483 if (!lv_is_cow(lv)) {
484 log_error("Specified LV does not have an origin LV.");
485 return EINVALID_CMD_LINE;
486 }
b18e1fd5 487 lp->extents = percent_of_extents(lp->extents, origin_from_cow(lv)->le_count);
5bc2af26 488 break;
34fadac4
AK
489 case PERCENT_NONE:
490 break;
491 }
492
4079a8f2
ZK
493 if (lp->sign == SIGN_PLUS) {
494 if (lp->extents >= (MAX_EXTENT_COUNT - lv->le_count)) {
495 log_error("Unable to extend %s by %u extents, exceeds limit (%u).",
496 lp->lv_name, lv->le_count, MAX_EXTENT_COUNT);
497 return EINVALID_CMD_LINE;
498 }
241913fe 499 lp->extents += lv->le_count;
4079a8f2 500 }
03a8a07d 501
241913fe
AK
502 if (lp->sign == SIGN_MINUS) {
503 if (lp->extents >= lv->le_count) {
03a8a07d 504 log_error("Unable to reduce %s below 1 extent",
241913fe 505 lp->lv_name);
7f0dc9c4 506 return EINVALID_CMD_LINE;
03a8a07d
AK
507 }
508
241913fe 509 lp->extents = lv->le_count - lp->extents;
03a8a07d
AK
510 }
511
241913fe 512 if (!lp->extents) {
03a8a07d 513 log_error("New size of 0 not permitted");
7f0dc9c4 514 return EINVALID_CMD_LINE;
03a8a07d
AK
515 }
516
241913fe 517 if (lp->extents == lv->le_count) {
a341cab7
PR
518 if (use_policy)
519 return ECMD_PROCESSED; /* Nothing to do. */
c8669f6b
ZK
520 if (!lp->resizefs) {
521 log_error("New size (%d extents) matches existing size "
522 "(%d extents)", lp->extents, lv->le_count);
523 return EINVALID_CMD_LINE;
524 }
525 lp->resize = LV_EXTEND; /* lets pretend zero size extension */
03a8a07d
AK
526 }
527
241913fe 528 seg_size = lp->extents - lv->le_count;
25b73380 529
1832f310 530 /* Use segment type of last segment */
2c44337b 531 dm_list_iterate_items(seg, &lv->segments) {
241913fe 532 lp->segtype = seg->segtype;
1832f310
AK
533 }
534
535 /* FIXME Support LVs with mixed segment types */
54d7741a
AK
536 if (lp->segtype != get_segtype_from_string(cmd, arg_str_value(cmd, type_ARG,
537 lp->segtype->name))) {
241913fe 538 log_error("VolumeType does not match (%s)", lp->segtype->name);
7f0dc9c4 539 return EINVALID_CMD_LINE;
1832f310
AK
540 }
541
1485ce69
AK
542 /* If extending, find mirrors of last segment */
543 if ((lp->extents > lv->le_count)) {
a80192b6
JEB
544 /*
545 * Has the user specified that they would like the additional
546 * extents of a mirror not to have an initial sync?
547 */
548 if (seg_is_mirrored(first_seg(lv)) && arg_count(cmd, nosync_ARG))
549 lv->status |= LV_NOTSYNCED;
550
1485ce69
AK
551 dm_list_iterate_back_items(mirr_seg, &lv->segments) {
552 if (seg_is_mirrored(mirr_seg))
553 seg_mirrors = lv_mirror_count(mirr_seg->lv);
554 else
555 seg_mirrors = 0;
556 break;
557 }
558 if (!arg_count(cmd, mirrors_ARG) && seg_mirrors) {
559 log_print("Extending %" PRIu32 " mirror images.",
560 seg_mirrors);
561 lp->mirrors = seg_mirrors;
562 }
563 if ((arg_count(cmd, mirrors_ARG) || seg_mirrors) &&
564 (lp->mirrors != seg_mirrors)) {
565 log_error("Cannot vary number of mirrors in LV yet.");
566 return EINVALID_CMD_LINE;
567 }
568 }
569
52dc2139 570 /* If extending, find stripes, stripesize & size of last segment */
241913fe
AK
571 if ((lp->extents > lv->le_count) &&
572 !(lp->stripes == 1 || (lp->stripes > 1 && lp->stripe_size))) {
1485ce69
AK
573 /* FIXME Don't assume mirror seg will always be AREA_LV */
574 dm_list_iterate_items(seg, seg_mirrors ? &seg_lv(mirr_seg, 0)->segments : &lv->segments) {
32469fb2 575 if (!seg_is_striped(seg))
1832f310 576 continue;
b8c919b4 577
579944d3 578 sz = seg->stripe_size;
b8c919b4 579 str = seg->area_count;
52dc2139 580
bc175d28 581 if ((seg_stripesize && seg_stripesize != sz &&
1485ce69 582 sz && !lp->stripe_size) ||
241913fe 583 (seg_stripes && seg_stripes != str && !lp->stripes)) {
52dc2139
AK
584 log_error("Please specify number of "
585 "stripes (-i) and stripesize (-I)");
7f0dc9c4 586 return EINVALID_CMD_LINE;
52dc2139
AK
587 }
588
589 seg_stripesize = sz;
590 seg_stripes = str;
591 }
592
241913fe
AK
593 if (!lp->stripes)
594 lp->stripes = seg_stripes;
52dc2139 595
241913fe 596 if (!lp->stripe_size && lp->stripes > 1) {
25b73380 597 if (seg_stripesize) {
12de747d 598 log_print("Using stripesize of last segment %s",
72b2cb61 599 display_size(cmd, (uint64_t) seg_stripesize));
241913fe 600 lp->stripe_size = seg_stripesize;
25b73380 601 } else {
7f0dc9c4 602 lp->stripe_size =
2293567c 603 find_config_tree_int(cmd,
8ef2b021 604 "metadata/stripesize",
8ef2b021 605 DEFAULT_STRIPESIZE) * 2;
12de747d 606 log_print("Using default stripesize %s",
72b2cb61 607 display_size(cmd, (uint64_t) lp->stripe_size));
25b73380
AK
608 }
609 }
52dc2139
AK
610 }
611
612 /* If reducing, find stripes, stripesize & size of last segment */
241913fe 613 if (lp->extents < lv->le_count) {
25b73380 614 extents_used = 0;
52dc2139 615
ffb0e538
AK
616 if (lp->stripes || lp->stripe_size || lp->mirrors)
617 log_error("Ignoring stripes, stripesize and mirrors "
618 "arguments when reducing");
52dc2139 619
2c44337b 620 dm_list_iterate_items(seg, &lv->segments) {
579944d3
AK
621 seg_extents = seg->len;
622
f4ba9c5d
MB
623 /* Check for underlying stripe sizes */
624 seg_stripes = lvseg_get_stripes(seg, &seg_stripesize);
52dc2139 625
ffb0e538 626 if (seg_is_mirrored(seg))
31e9db26 627 seg_mirrors = lv_mirror_count(seg->lv);
ffb0e538
AK
628 else
629 seg_mirrors = 0;
630
241913fe 631 if (lp->extents <= extents_used + seg_extents)
52dc2139
AK
632 break;
633
634 extents_used += seg_extents;
635 }
636
241913fe
AK
637 seg_size = lp->extents - extents_used;
638 lp->stripe_size = seg_stripesize;
639 lp->stripes = seg_stripes;
ffb0e538 640 lp->mirrors = seg_mirrors;
52dc2139
AK
641 }
642
241913fe 643 if (lp->stripes > 1 && !lp->stripe_size) {
25b73380 644 log_error("Stripesize for striped segment should not be 0!");
7f0dc9c4 645 return EINVALID_CMD_LINE;
d4e5f63e 646 }
5a52dca9 647
851b1a96 648 if (lp->stripes > 1) {
241913fe 649 if (!(stripesize_extents = lp->stripe_size / vg->extent_size))
d4e5f63e
AK
650 stripesize_extents = 1;
651
851b1a96 652 size_rest = seg_size % (lp->stripes * stripesize_extents);
44dfb51f
PR
653 /* Round toward the original size. */
654 if (size_rest && lp->extents < lv->le_count) {
851b1a96
MB
655 log_print("Rounding size (%d extents) up to stripe "
656 "boundary size for segment (%d extents)",
6f14cd22
MB
657 lp->extents, lp->extents - size_rest +
658 (lp->stripes * stripesize_extents));
659 lp->extents = lp->extents - size_rest +
660 (lp->stripes * stripesize_extents);
851b1a96 661 } else if (size_rest) {
d4e5f63e
AK
662 log_print("Rounding size (%d extents) down to stripe "
663 "boundary size for segment (%d extents)",
241913fe
AK
664 lp->extents, lp->extents - size_rest);
665 lp->extents = lp->extents - size_rest;
d4e5f63e 666 }
12de747d
AK
667
668 if (lp->stripe_size < STRIPE_SIZE_MIN) {
669 log_error("Invalid stripe size %s",
72b2cb61 670 display_size(cmd, (uint64_t) lp->stripe_size));
406a9754 671 return EINVALID_CMD_LINE;
12de747d 672 }
da4e57f2 673 }
52dc2139 674
241913fe
AK
675 if (lp->extents < lv->le_count) {
676 if (lp->resize == LV_EXTEND) {
03a8a07d
AK
677 log_error("New size given (%d extents) not larger "
678 "than existing size (%d extents)",
241913fe 679 lp->extents, lv->le_count);
7f0dc9c4 680 return EINVALID_CMD_LINE;
c8669f6b
ZK
681 }
682 lp->resize = LV_REDUCE;
683 } else if (lp->extents > lv->le_count) {
241913fe 684 if (lp->resize == LV_REDUCE) {
03a8a07d 685 log_error("New size given (%d extents) not less than "
241913fe 686 "existing size (%d extents)", lp->extents,
03a8a07d 687 lv->le_count);
7f0dc9c4 688 return EINVALID_CMD_LINE;
c8669f6b
ZK
689 }
690 lp->resize = LV_EXTEND;
03a8a07d
AK
691 }
692
864de9ce
AK
693 if (lv_is_origin(lv)) {
694 if (lp->resize == LV_REDUCE) {
695 log_error("Snapshot origin volumes cannot be reduced "
696 "in size yet.");
697 return ECMD_FAILED;
698 }
699
700 memset(&info, 0, sizeof(info));
701
2d6fcbf6 702 if (lv_info(cmd, lv, 0, &info, 0, 0) && info.exists) {
864de9ce
AK
703 log_error("Snapshot origin volumes can be resized "
704 "only while inactive: try lvchange -an");
705 return ECMD_FAILED;
706 }
707 }
708
daa10ad0
ZK
709 if (lv_is_thin_pool(lv)) {
710 if (lp->resize == LV_REDUCE) {
711 log_error("Thin pool volumes cannot be reduced in size yet.");
712 return ECMD_FAILED;
713 }
714
715 if (lp->resizefs) {
716 log_warn("Thin pool volumes do not have filesystem.");
717 lp->resizefs = 0;
718 }
719
720 if (!lp->stripes) {
721 /* Try to use the same strip settings for underlying pool data LV */
722 lp->stripes = last_seg(seg_lv(first_seg(lv), 0))->area_count;
723 if (!lp->stripe_size)
724 lp->stripe_size = last_seg(seg_lv(first_seg(lv), 0))->stripe_size;
725 }
726 }
727
bc175d28
AK
728 if ((lp->resize == LV_REDUCE) && lp->argc)
729 log_warn("Ignoring PVs on command line when reducing");
03a8a07d 730
bc175d28
AK
731 /* Request confirmation before operations that are often mistakes. */
732 if ((lp->resizefs || (lp->resize == LV_REDUCE)) &&
733 !_request_confirmation(cmd, vg, lv, lp)) {
734 stack;
2b238642 735 return ECMD_FAILED;
bc175d28 736 }
03a8a07d 737
1a9ea74d 738 if (lp->resizefs) {
bc175d28 739 if (!lp->nofsck &&
2955b913
ZK
740 !_fsadm_cmd(cmd, vg, lp, FSADM_CMD_CHECK, &status)) {
741 if (status != FSADM_CHECK_FAILS_FOR_MOUNTED) {
da1350d4 742 log_error("Filesystem check failed.");
2955b913
ZK
743 return ECMD_FAILED;
744 }
da1350d4 745 /* some filesystems supports online resize */
c8669f6b
ZK
746 }
747
bc175d28 748 if ((lp->resize == LV_REDUCE) &&
2955b913 749 !_fsadm_cmd(cmd, vg, lp, FSADM_CMD_RESIZE, NULL)) {
da1350d4 750 log_error("Filesystem resize failed.");
c8669f6b
ZK
751 return ECMD_FAILED;
752 }
1a9ea74d 753 }
614a4508 754
1a9ea74d
AK
755 if (!archive(vg)) {
756 stack;
757 return ECMD_FAILED;
758 }
03a8a07d 759
1a9ea74d
AK
760 log_print("%sing logical volume %s to %s",
761 (lp->resize == LV_REDUCE) ? "Reduc" : "Extend",
762 lp->lv_name,
72b2cb61 763 display_size(cmd, (uint64_t) lp->extents * vg->extent_size));
1a9ea74d
AK
764
765 if (lp->resize == LV_REDUCE) {
32469fb2 766 if (!lv_reduce(lv, lv->le_count - lp->extents)) {
7f0dc9c4
AK
767 stack;
768 return ECMD_FAILED;
241913fe 769 }
bc175d28 770 } else if ((lp->extents > lv->le_count) && /* Ensure we extend */
fe93c99a
JEB
771 !lv_extend(lv, lp->segtype,
772 lp->stripes, lp->stripe_size,
773 lp->mirrors, first_seg(lv)->region_size,
9ac61d2b 774 lp->extents - lv->le_count, NULL,
fe93c99a 775 pvh, alloc)) {
1a9ea74d
AK
776 stack;
777 return ECMD_FAILED;
03a8a07d
AK
778 }
779
03a8a07d 780 /* store vg on disk(s) */
25b73380 781 if (!vg_write(vg)) {
914c9723 782 stack;
7f0dc9c4 783 return ECMD_FAILED;
cc8b2cd7 784 }
03a8a07d 785
914c9723 786 /* If snapshot, must suspend all associated devices */
2cd0aa72
AK
787 if (lv_is_cow(lv))
788 lock_lv = origin_from_cow(lv);
914c9723 789 else
0fb173aa 790 lock_lv = lv;
914c9723 791
0fb173aa 792 if (!suspend_lv(cmd, lock_lv)) {
241913fe 793 log_error("Failed to suspend %s", lp->lv_name);
914c9723 794 vg_revert(vg);
8f3fd69f 795 backup(vg);
7f0dc9c4 796 return ECMD_FAILED;
914c9723
AK
797 }
798
799 if (!vg_commit(vg)) {
800 stack;
df13cf08
MS
801 if (!resume_lv(cmd, lock_lv))
802 stack;
8f3fd69f 803 backup(vg);
7f0dc9c4 804 return ECMD_FAILED;
914c9723
AK
805 }
806
0fb173aa 807 if (!resume_lv(cmd, lock_lv)) {
241913fe 808 log_error("Problem reactivating %s", lp->lv_name);
8f3fd69f 809 backup(vg);
7f0dc9c4 810 return ECMD_FAILED;
cc8b2cd7 811 }
03a8a07d 812
8f3fd69f
MB
813 backup(vg);
814
6b58c796
ZK
815 /*
816 * Update lvm pool metadata (drop messages) if the pool has been
817 * resumed and do a pool active/deactivate in other case.
818 *
819 * Note: Active thin pool can be waiting for resize.
820 *
821 * FIXME: Activate only when thin volume is active
822 */
823 if (lv_is_thin_pool(lv) &&
824 !update_pool_lv(lv, !lv_is_active(lv))) {
825 stack;
826 return ECMD_FAILED;
827 }
828
241913fe 829 log_print("Logical volume %s successfully resized", lp->lv_name);
03a8a07d 830
bc175d28 831 if (lp->resizefs && (lp->resize == LV_EXTEND) &&
2955b913 832 !_fsadm_cmd(cmd, vg, lp, FSADM_CMD_RESIZE, NULL)) {
c8669f6b
ZK
833 stack;
834 return ECMD_FAILED;
1a9ea74d
AK
835 }
836
cfb7bfc7 837 return ECMD_PROCESSED;
03a8a07d 838}
241913fe
AK
839
840int lvresize(struct cmd_context *cmd, int argc, char **argv)
841{
842 struct lvresize_params lp;
e5f7352b 843 struct volume_group *vg;
241913fe
AK
844 int r;
845
846 memset(&lp, 0, sizeof(lp));
847
8a2fc586 848 if (!_lvresize_params(cmd, argc, argv, &lp))
241913fe
AK
849 return EINVALID_CMD_LINE;
850
851 log_verbose("Finding volume group %s", lp.vg_name);
b8b3508c
DW
852 vg = vg_read_for_update(cmd, lp.vg_name, NULL, 0);
853 if (vg_read_error(vg)) {
077a6755 854 release_vg(vg);
d0bf2f3f 855 stack;
241913fe 856 return ECMD_FAILED;
d0bf2f3f 857 }
241913fe 858
e5f7352b 859 if (!(r = _lvresize(cmd, vg, &lp)))
241913fe
AK
860 stack;
861
077a6755 862 unlock_and_release_vg(cmd, vg, lp.vg_name);
241913fe
AK
863
864 return r;
865}
This page took 0.202204 seconds and 5 git commands to generate.