geom_vinum_create.c revision 190513
1/*- 2 * Copyright (c) 2007 Lukas Ertl 3 * Copyright (c) 2007, 2009 Ulf Lilleengen 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28#include <sys/cdefs.h> 29__FBSDID("$FreeBSD: head/sys/geom/vinum/geom_vinum_create.c 190513 2009-03-28 21:06:59Z lulf $"); 30 31#include <sys/param.h> 32#include <sys/bio.h> 33#include <sys/conf.h> 34#include <sys/kernel.h> 35#include <sys/malloc.h> 36#include <sys/systm.h> 37#include <sys/vimage.h> 38 39#include <geom/geom.h> 40#include <geom/vinum/geom_vinum_var.h> 41#include <geom/vinum/geom_vinum.h> 42 43#define DEFAULT_STRIPESIZE 262144 44 45/* 46 * Create a new drive object, either by user request, during taste of the drive 47 * itself, or because it was referenced by a subdisk during taste. 48 */ 49int 50gv_create_drive(struct gv_softc *sc, struct gv_drive *d) 51{ 52 struct g_geom *gp; 53 struct g_provider *pp; 54 struct g_consumer *cp, *cp2; 55 struct gv_drive *d2; 56 struct gv_hdr *hdr; 57 struct gv_freelist *fl; 58 59 KASSERT(d != NULL, ("gv_create_drive: NULL d")); 60 61 gp = sc->geom; 62 63 pp = NULL; 64 cp = cp2 = NULL; 65 66 /* The drive already has a consumer if it was tasted before. */ 67 if (d->consumer != NULL) { 68 cp = d->consumer; 69 cp->private = d; 70 pp = cp->provider; 71 } else if (!(d->flags & GV_DRIVE_REFERENCED)) { 72 if (gv_find_drive(sc, d->name) != NULL) { 73 G_VINUM_DEBUG(0, "drive '%s' already exists", d->name); 74 g_free(d); 75 return (GV_ERR_CREATE); 76 } 77 78 if (gv_find_drive_device(sc, d->device) != NULL) { 79 G_VINUM_DEBUG(0, "provider '%s' already in use by " 80 "gvinum", d->device); 81 return (GV_ERR_CREATE); 82 } 83 84 pp = g_provider_by_name(d->device); 85 if (pp == NULL) { 86 G_VINUM_DEBUG(0, "create '%s': device '%s' disappeared", 87 d->name, d->device); 88 g_free(d); 89 return (GV_ERR_CREATE); 90 } 91 92 g_topology_lock(); 93 cp = g_new_consumer(gp); 94 if (g_attach(cp, pp) != 0) { 95 g_destroy_consumer(cp); 96 g_topology_unlock(); 97 G_VINUM_DEBUG(0, "create drive '%s': couldn't attach", 98 d->name); 99 g_free(d); 100 return (GV_ERR_CREATE); 101 } 102 g_topology_unlock(); 103 104 d->consumer = cp; 105 cp->private = d; 106 } 107 108 /* 109 * If this was just a "referenced" drive, we're almost finished, but 110 * insert this drive not on the head of the drives list, as 111 * gv_drive_is_newer() expects a "real" drive from LIST_FIRST(). 112 */ 113 if (d->flags & GV_DRIVE_REFERENCED) { 114 snprintf(d->device, sizeof(d->device), "???"); 115 d2 = LIST_FIRST(&sc->drives); 116 if (d2 == NULL) 117 LIST_INSERT_HEAD(&sc->drives, d, drive); 118 else 119 LIST_INSERT_AFTER(d2, d, drive); 120 return (0); 121 } 122 123 /* 124 * Update access counts of the new drive to those of an already 125 * existing drive. 126 */ 127 LIST_FOREACH(d2, &sc->drives, drive) { 128 if ((d == d2) || (d2->consumer == NULL)) 129 continue; 130 131 cp2 = d2->consumer; 132 g_topology_lock(); 133 if ((cp2->acr || cp2->acw || cp2->ace) && 134 (g_access(cp, cp2->acr, cp2->acw, cp2->ace) != 0)) { 135 g_detach(cp); 136 g_destroy_consumer(cp); 137 g_topology_unlock(); 138 G_VINUM_DEBUG(0, "create drive '%s': couldn't update " 139 "access counts", d->name); 140 if (d->hdr != NULL) 141 g_free(d->hdr); 142 g_free(d); 143 return (GV_ERR_CREATE); 144 } 145 g_topology_unlock(); 146 break; 147 } 148 149 d->size = pp->mediasize - GV_DATA_START; 150 d->avail = d->size; 151 d->vinumconf = sc; 152 LIST_INIT(&d->subdisks); 153 LIST_INIT(&d->freelist); 154 155 /* The header might have been set during taste. */ 156 if (d->hdr == NULL) { 157 hdr = g_malloc(sizeof(*hdr), M_WAITOK | M_ZERO); 158 hdr->magic = GV_MAGIC; 159 hdr->config_length = GV_CFG_LEN; 160 mtx_lock(&hostname_mtx); 161 bcopy(G_hostname, hdr->label.sysname, GV_HOSTNAME_LEN); 162 mtx_unlock(&hostname_mtx); 163 strlcpy(hdr->label.name, d->name, sizeof(hdr->label.name)); 164 microtime(&hdr->label.date_of_birth); 165 d->hdr = hdr; 166 } 167 168 /* We also need a freelist entry. */ 169 fl = g_malloc(sizeof(struct gv_freelist), M_WAITOK | M_ZERO); 170 fl->offset = GV_DATA_START; 171 fl->size = d->avail; 172 LIST_INSERT_HEAD(&d->freelist, fl, freelist); 173 d->freelist_entries = 1; 174 175 if (gv_find_drive(sc, d->name) == NULL) 176 LIST_INSERT_HEAD(&sc->drives, d, drive); 177 178 gv_set_drive_state(d, GV_DRIVE_UP, 0); 179 return (0); 180} 181 182int 183gv_create_volume(struct gv_softc *sc, struct gv_volume *v) 184{ 185 KASSERT(v != NULL, ("gv_create_volume: NULL v")); 186 187 v->vinumconf = sc; 188 v->flags |= GV_VOL_NEWBORN; 189 LIST_INIT(&v->plexes); 190 LIST_INSERT_HEAD(&sc->volumes, v, volume); 191 v->wqueue = g_malloc(sizeof(struct bio_queue_head), M_WAITOK | M_ZERO); 192 bioq_init(v->wqueue); 193 return (0); 194} 195 196int 197gv_create_plex(struct gv_softc *sc, struct gv_plex *p) 198{ 199 struct gv_volume *v; 200 201 KASSERT(p != NULL, ("gv_create_plex: NULL p")); 202 203 /* Find the volume this plex should be attached to. */ 204 v = gv_find_vol(sc, p->volume); 205 if (v == NULL) { 206 G_VINUM_DEBUG(0, "create plex '%s': volume '%s' not found", 207 p->name, p->volume); 208 g_free(p); 209 return (GV_ERR_CREATE); 210 } 211 if (!(v->flags & GV_VOL_NEWBORN)) 212 p->flags |= GV_PLEX_ADDED; 213 p->vol_sc = v; 214 v->plexcount++; 215 p->vinumconf = sc; 216 p->synced = 0; 217 p->flags |= GV_PLEX_NEWBORN; 218 LIST_INSERT_HEAD(&v->plexes, p, in_volume); 219 LIST_INIT(&p->subdisks); 220 TAILQ_INIT(&p->packets); 221 LIST_INSERT_HEAD(&sc->plexes, p, plex); 222 p->bqueue = g_malloc(sizeof(struct bio_queue_head), M_WAITOK | M_ZERO); 223 bioq_init(p->bqueue); 224 p->wqueue = g_malloc(sizeof(struct bio_queue_head), M_WAITOK | M_ZERO); 225 bioq_init(p->wqueue); 226 p->rqueue = g_malloc(sizeof(struct bio_queue_head), M_WAITOK | M_ZERO); 227 bioq_init(p->rqueue); 228 return (0); 229} 230 231int 232gv_create_sd(struct gv_softc *sc, struct gv_sd *s) 233{ 234 struct gv_plex *p; 235 struct gv_drive *d; 236 237 KASSERT(s != NULL, ("gv_create_sd: NULL s")); 238 239 /* Find the drive where this subdisk should be put on. */ 240 d = gv_find_drive(sc, s->drive); 241 if (d == NULL) { 242 /* 243 * It's possible that the subdisk references a drive that 244 * doesn't exist yet (during the taste process), so create a 245 * practically empty "referenced" drive. 246 */ 247 if (s->flags & GV_SD_TASTED) { 248 d = g_malloc(sizeof(struct gv_drive), 249 M_WAITOK | M_ZERO); 250 d->flags |= GV_DRIVE_REFERENCED; 251 strlcpy(d->name, s->drive, sizeof(d->name)); 252 gv_create_drive(sc, d); 253 } else { 254 G_VINUM_DEBUG(0, "create sd '%s': drive '%s' not found", 255 s->name, s->drive); 256 g_free(s); 257 return (GV_ERR_CREATE); 258 } 259 } 260 261 /* Find the plex where this subdisk belongs to. */ 262 p = gv_find_plex(sc, s->plex); 263 if (p == NULL) { 264 G_VINUM_DEBUG(0, "create sd '%s': plex '%s' not found", 265 s->name, s->plex); 266 g_free(s); 267 return (GV_ERR_CREATE); 268 } 269 270 /* 271 * First we give the subdisk to the drive, to handle autosized 272 * values ... 273 */ 274 if (gv_sd_to_drive(s, d) != 0) { 275 g_free(s); 276 return (GV_ERR_CREATE); 277 } 278 279 /* 280 * Then, we give the subdisk to the plex; we check if the 281 * given values are correct and maybe adjust them. 282 */ 283 if (gv_sd_to_plex(s, p) != 0) { 284 G_VINUM_DEBUG(0, "unable to give sd '%s' to plex '%s'", 285 s->name, p->name); 286 if (s->drive_sc && !(s->drive_sc->flags & GV_DRIVE_REFERENCED)) 287 LIST_REMOVE(s, from_drive); 288 gv_free_sd(s); 289 g_free(s); 290 /* 291 * If this subdisk can't be created, we won't create 292 * the attached plex either, if it is also a new one. 293 */ 294 if (!(p->flags & GV_PLEX_NEWBORN)) 295 return (GV_ERR_CREATE); 296 gv_rm_plex(sc, p); 297 return (GV_ERR_CREATE); 298 } 299 s->flags |= GV_SD_NEWBORN; 300 301 s->vinumconf = sc; 302 LIST_INSERT_HEAD(&sc->subdisks, s, sd); 303 304 return (0); 305} 306 307/* 308 * Create a concatenated volume from specified drives or drivegroups. 309 */ 310void 311gv_concat(struct g_geom *gp, struct gctl_req *req) 312{ 313 struct gv_drive *d; 314 struct gv_sd *s; 315 struct gv_volume *v; 316 struct gv_plex *p; 317 struct gv_softc *sc; 318 char *drive, buf[30], *vol; 319 int *drives, *flags, dcount; 320 321 sc = gp->softc; 322 dcount = 0; 323 vol = gctl_get_param(req, "name", NULL); 324 if (vol == NULL) { 325 gctl_error(req, "volume names not given"); 326 return; 327 } 328 329 flags = gctl_get_paraml(req, "flags", sizeof(*flags)); 330 drives = gctl_get_paraml(req, "drives", sizeof(*drives)); 331 332 if (drives == NULL) { 333 gctl_error(req, "drive names not given"); 334 return; 335 } 336 337 /* First we create the volume. */ 338 v = g_malloc(sizeof(*v), M_WAITOK | M_ZERO); 339 strlcpy(v->name, vol, sizeof(v->name)); 340 v->state = GV_VOL_UP; 341 gv_post_event(sc, GV_EVENT_CREATE_VOLUME, v, NULL, 0, 0); 342 343 /* Then we create the plex. */ 344 p = g_malloc(sizeof(*p), M_WAITOK | M_ZERO); 345 snprintf(p->name, sizeof(p->name), "%s.p%d", v->name, v->plexcount); 346 strlcpy(p->volume, v->name, sizeof(p->volume)); 347 p->org = GV_PLEX_CONCAT; 348 p->stripesize = 0; 349 gv_post_event(sc, GV_EVENT_CREATE_PLEX, p, NULL, 0, 0); 350 351 /* Drives are first (right now) priority */ 352 for (dcount = 0; dcount < *drives; dcount++) { 353 snprintf(buf, sizeof(buf), "drive%d", dcount); 354 drive = gctl_get_param(req, buf, NULL); 355 d = gv_find_drive(sc, drive); 356 if (d == NULL) { 357 gctl_error(req, "No such drive '%s'", drive); 358 continue; 359 } 360 s = g_malloc(sizeof(*s), M_WAITOK | M_ZERO); 361 snprintf(s->name, sizeof(s->name), "%s.s%d", p->name, dcount); 362 strlcpy(s->plex, p->name, sizeof(s->plex)); 363 strlcpy(s->drive, drive, sizeof(s->drive)); 364 s->plex_offset = -1; 365 s->drive_offset = -1; 366 s->size = -1; 367 gv_post_event(sc, GV_EVENT_CREATE_SD, s, NULL, 0, 0); 368 } 369 gv_post_event(sc, GV_EVENT_SETUP_OBJECTS, sc, NULL, 0, 0); 370 gv_post_event(sc, GV_EVENT_SAVE_CONFIG, sc, NULL, 0, 0); 371} 372 373/* 374 * Create a mirrored volume from specified drives or drivegroups. 375 */ 376void 377gv_mirror(struct g_geom *gp, struct gctl_req *req) 378{ 379 struct gv_drive *d; 380 struct gv_sd *s; 381 struct gv_volume *v; 382 struct gv_plex *p; 383 struct gv_softc *sc; 384 char *drive, buf[30], *vol; 385 int *drives, *flags, dcount, pcount, scount; 386 387 sc = gp->softc; 388 dcount = 0; 389 scount = 0; 390 pcount = 0; 391 vol = gctl_get_param(req, "name", NULL); 392 if (vol == NULL) { 393 gctl_error(req, "volume's not given"); 394 return; 395 } 396 397 flags = gctl_get_paraml(req, "flags", sizeof(*flags)); 398 drives = gctl_get_paraml(req, "drives", sizeof(*drives)); 399 400 if (drives == NULL) { 401 gctl_error(req, "drives not given"); 402 return; 403 } 404 405 /* We must have an even number of drives. */ 406 if (*drives % 2 != 0) { 407 gctl_error(req, "mirror organization must have an even number " 408 "of drives"); 409 return; 410 } 411 if (*flags & GV_FLAG_S && *drives < 4) { 412 gctl_error(req, "must have at least 4 drives for striped plex"); 413 return; 414 } 415 416 /* First we create the volume. */ 417 v = g_malloc(sizeof(*v), M_WAITOK | M_ZERO); 418 strlcpy(v->name, vol, sizeof(v->name)); 419 v->state = GV_VOL_UP; 420 gv_post_event(sc, GV_EVENT_CREATE_VOLUME, v, NULL, 0, 0); 421 422 /* Then we create the plexes. */ 423 for (pcount = 0; pcount < 2; pcount++) { 424 p = g_malloc(sizeof(*p), M_WAITOK | M_ZERO); 425 snprintf(p->name, sizeof(p->name), "%s.p%d", v->name, 426 pcount); 427 strlcpy(p->volume, v->name, sizeof(p->volume)); 428 if (*flags & GV_FLAG_S) { 429 p->org = GV_PLEX_STRIPED; 430 p->stripesize = DEFAULT_STRIPESIZE; 431 } else { 432 p->org = GV_PLEX_CONCAT; 433 p->stripesize = -1; 434 } 435 gv_post_event(sc, GV_EVENT_CREATE_PLEX, p, NULL, 0, 0); 436 437 /* 438 * We just gives each even drive to plex one, and each odd to 439 * plex two. 440 */ 441 scount = 0; 442 for (dcount = pcount; dcount < *drives; dcount += 2) { 443 snprintf(buf, sizeof(buf), "drive%d", dcount); 444 drive = gctl_get_param(req, buf, NULL); 445 d = gv_find_drive(sc, drive); 446 if (d == NULL) { 447 gctl_error(req, "No such drive '%s', aborting", 448 drive); 449 scount++; 450 break; 451 } 452 s = g_malloc(sizeof(*s), M_WAITOK | M_ZERO); 453 snprintf(s->name, sizeof(s->name), "%s.s%d", p->name, 454 scount); 455 strlcpy(s->plex, p->name, sizeof(s->plex)); 456 strlcpy(s->drive, drive, sizeof(s->drive)); 457 s->plex_offset = -1; 458 s->drive_offset = -1; 459 s->size = -1; 460 gv_post_event(sc, GV_EVENT_CREATE_SD, s, NULL, 0, 0); 461 scount++; 462 } 463 } 464 gv_post_event(sc, GV_EVENT_SETUP_OBJECTS, sc, NULL, 0, 0); 465 gv_post_event(sc, GV_EVENT_SAVE_CONFIG, sc, NULL, 0, 0); 466} 467 468void 469gv_raid5(struct g_geom *gp, struct gctl_req *req) 470{ 471 struct gv_softc *sc; 472 struct gv_drive *d; 473 struct gv_volume *v; 474 struct gv_plex *p; 475 struct gv_sd *s; 476 int *drives, *flags, dcount; 477 char *vol, *drive, buf[30]; 478 off_t *stripesize; 479 480 dcount = 0; 481 sc = gp->softc; 482 483 vol = gctl_get_param(req, "name", NULL); 484 if (vol == NULL) { 485 gctl_error(req, "volume's not given"); 486 return; 487 } 488 flags = gctl_get_paraml(req, "flags", sizeof(*flags)); 489 drives = gctl_get_paraml(req, "drives", sizeof(*drives)); 490 stripesize = gctl_get_paraml(req, "stripesize", sizeof(*stripesize)); 491 492 if (stripesize == NULL) { 493 gctl_error(req, "no stripesize given"); 494 return; 495 } 496 497 if (drives == NULL) { 498 gctl_error(req, "drives not given"); 499 return; 500 } 501 502 /* We must have at least three drives. */ 503 if (*drives < 3) { 504 gctl_error(req, "must have at least three drives for this " 505 "plex organisation"); 506 return; 507 } 508 /* First we create the volume. */ 509 v = g_malloc(sizeof(*v), M_WAITOK | M_ZERO); 510 strlcpy(v->name, vol, sizeof(v->name)); 511 v->state = GV_VOL_UP; 512 gv_post_event(sc, GV_EVENT_CREATE_VOLUME, v, NULL, 0, 0); 513 514 /* Then we create the plex. */ 515 p = g_malloc(sizeof(*p), M_WAITOK | M_ZERO); 516 snprintf(p->name, sizeof(p->name), "%s.p%d", v->name, v->plexcount); 517 strlcpy(p->volume, v->name, sizeof(p->volume)); 518 p->org = GV_PLEX_RAID5; 519 p->stripesize = *stripesize; 520 gv_post_event(sc, GV_EVENT_CREATE_PLEX, p, NULL, 0, 0); 521 522 /* Create subdisks on drives. */ 523 for (dcount = 0; dcount < *drives; dcount++) { 524 snprintf(buf, sizeof(buf), "drive%d", dcount); 525 drive = gctl_get_param(req, buf, NULL); 526 d = gv_find_drive(sc, drive); 527 if (d == NULL) { 528 gctl_error(req, "No such drive '%s'", drive); 529 continue; 530 } 531 s = g_malloc(sizeof(*s), M_WAITOK | M_ZERO); 532 snprintf(s->name, sizeof(s->name), "%s.s%d", p->name, dcount); 533 strlcpy(s->plex, p->name, sizeof(s->plex)); 534 strlcpy(s->drive, drive, sizeof(s->drive)); 535 s->plex_offset = -1; 536 s->drive_offset = -1; 537 s->size = -1; 538 gv_post_event(sc, GV_EVENT_CREATE_SD, s, NULL, 0, 0); 539 } 540 gv_post_event(sc, GV_EVENT_SETUP_OBJECTS, sc, NULL, 0, 0); 541 gv_post_event(sc, GV_EVENT_SAVE_CONFIG, sc, NULL, 0, 0); 542} 543 544/* 545 * Create a striped volume from specified drives or drivegroups. 546 */ 547void 548gv_stripe(struct g_geom *gp, struct gctl_req *req) 549{ 550 struct gv_drive *d; 551 struct gv_sd *s; 552 struct gv_volume *v; 553 struct gv_plex *p; 554 struct gv_softc *sc; 555 char *drive, buf[30], *vol; 556 int *drives, *flags, dcount, pcount; 557 558 sc = gp->softc; 559 dcount = 0; 560 pcount = 0; 561 vol = gctl_get_param(req, "name", NULL); 562 if (vol == NULL) { 563 gctl_error(req, "volume's not given"); 564 return; 565 } 566 flags = gctl_get_paraml(req, "flags", sizeof(*flags)); 567 drives = gctl_get_paraml(req, "drives", sizeof(*drives)); 568 569 if (drives == NULL) { 570 gctl_error(req, "drives not given"); 571 return; 572 } 573 574 /* We must have at least two drives. */ 575 if (*drives < 2) { 576 gctl_error(req, "must have at least 2 drives"); 577 return; 578 } 579 580 /* First we create the volume. */ 581 v = g_malloc(sizeof(*v), M_WAITOK | M_ZERO); 582 strlcpy(v->name, vol, sizeof(v->name)); 583 v->state = GV_VOL_UP; 584 gv_post_event(sc, GV_EVENT_CREATE_VOLUME, v, NULL, 0, 0); 585 586 /* Then we create the plex. */ 587 p = g_malloc(sizeof(*p), M_WAITOK | M_ZERO); 588 snprintf(p->name, sizeof(p->name), "%s.p%d", v->name, v->plexcount); 589 strlcpy(p->volume, v->name, sizeof(p->volume)); 590 p->org = GV_PLEX_STRIPED; 591 p->stripesize = 262144; 592 gv_post_event(sc, GV_EVENT_CREATE_PLEX, p, NULL, 0, 0); 593 594 /* Create subdisks on drives. */ 595 for (dcount = 0; dcount < *drives; dcount++) { 596 snprintf(buf, sizeof(buf), "drive%d", dcount); 597 drive = gctl_get_param(req, buf, NULL); 598 d = gv_find_drive(sc, drive); 599 if (d == NULL) { 600 gctl_error(req, "No such drive '%s'", drive); 601 continue; 602 } 603 s = g_malloc(sizeof(*s), M_WAITOK | M_ZERO); 604 snprintf(s->name, sizeof(s->name), "%s.s%d", p->name, dcount); 605 strlcpy(s->plex, p->name, sizeof(s->plex)); 606 strlcpy(s->drive, drive, sizeof(s->drive)); 607 s->plex_offset = -1; 608 s->drive_offset = -1; 609 s->size = -1; 610 gv_post_event(sc, GV_EVENT_CREATE_SD, s, NULL, 0, 0); 611 } 612 gv_post_event(sc, GV_EVENT_SETUP_OBJECTS, sc, NULL, 0, 0); 613 gv_post_event(sc, GV_EVENT_SAVE_CONFIG, sc, NULL, 0, 0); 614} 615