usr.sbin/memswitch/methods.c

   1 /*      $NetBSD: methods.c,v 1.5 2002/06/08 17:24:09 yamt Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1999 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Minoura Makoto.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <err.h>
  35 #include <sys/types.h>
  36
  37 #include "memswitch.h"
  38 #include "methods.h"
  39
  40 int
  41 atoi_ (p)
  42          const char **p;
  43 {
  44         const char *p1 = *p;
  45         int v = 0;
  46         int first = 1;
  47
  48         while (*p1 == ' ' || *p1 == '\t')
  49                 p1++;
  50
  51         if (*p1 == 0) {
  52                 *p = 0;
  53                 return 0;
  54         }
  55         if (strlen (p1) >= 2 && strncasecmp ("0x", p1, 2) == 0) {
  56                 p1 += 2;
  57                 while (1) {
  58                         if (*p1 >= '0' && *p1 <= '9') {
  59                                 v *= 16;
  60                                 v += *p1 - '0';
  61                                 first = 0;
  62                         } else if (*p1 >= 'A' && *p1 <= 'F') {
  63                                 v *= 16;
  64                                 v += *p1 - 'A' + 10;
  65                                 first = 0;
  66                         } else if (*p1 >= 'a' && *p1 <= 'f') {
  67                                 v *= 16;
  68                                 v += *p1 - 'a' + 10;
  69                                 first = 0;
  70                         } else {
  71                                 break;
  72                         }
  73                         p1++;
  74                 }
  75         } else {
  76                 while (1) {
  77                         if (*p1 >= '0' && *p1 <= '9') {
  78                                 v *= 10;
  79                                 v += *p1 - '0';
  80                                 first = 0;
  81                         } else {
  82                                 break;
  83                         }
  84                         p1++;
  85                 }
  86         }
  87
  88         if (first) {
  89                 *p = 0;
  90                 return 0;
  91         }
  92
  93         while (*p1 == ' ' || *p1 == '\t') p1++;
  94         *p = p1;
  95         return v;
  96 }
  97
  98 int
  99 fill_uchar (prop)
 100         struct property *prop;
 101 {
 102         if (current_values == 0)
 103                 alloc_current_values ();
 104
 105         prop->current_value.byte[0] = current_values[prop->offset];
 106         prop->current_value.byte[1] = 0;
 107         prop->current_value.byte[2] = 0;
 108         prop->current_value.byte[3] = 0;
 109         prop->value_valid = 1;
 110
 111         return 0;
 112 }
 113
 114 int
 115 fill_ushort (prop)
 116         struct property *prop;
 117 {
 118         if (current_values == 0)
 119                 alloc_current_values ();
 120
 121         prop->current_value.byte[0] = current_values[prop->offset];
 122         prop->current_value.byte[1] = current_values[prop->offset+1];
 123         prop->current_value.byte[2] = 0;
 124         prop->current_value.byte[3] = 0;
 125         prop->value_valid = 1;
 126
 127         return 0;
 128 }
 129
 130 int
 131 fill_ulong (prop)
 132         struct property *prop;
 133 {
 134         if (current_values == 0)
 135                 alloc_current_values ();
 136
 137         prop->current_value.byte[0] = current_values[prop->offset];
 138         prop->current_value.byte[1] = current_values[prop->offset+1];
 139         prop->current_value.byte[2] = current_values[prop->offset+2];
 140         prop->current_value.byte[3] = current_values[prop->offset+3];
 141         prop->value_valid = 1;
 142
 143         return 0;
 144 }
 145
 146 int
 147 flush_uchar (prop)
 148         struct property *prop;
 149 {
 150         if (!prop->modified)
 151                 return 0;
 152
 153         if (modified_values == 0)
 154                 alloc_modified_values ();
 155
 156         modified_values[prop->offset] = prop->modified_value.byte[0];
 157
 158         return 0;
 159 }
 160
 161 int
 162 flush_ushort (prop)
 163         struct property *prop;
 164 {
 165         if (!prop->modified)
 166                 return 0;
 167
 168         if (modified_values == 0)
 169                 alloc_modified_values ();
 170
 171         modified_values[prop->offset] = prop->modified_value.byte[0];
 172         modified_values[prop->offset+1] = prop->modified_value.byte[1];
 173
 174         return 0;
 175 }
 176
 177 int
 178 flush_ulong (prop)
 179         struct property *prop;
 180 {
 181         if (!prop->modified)
 182                 return 0;
 183
 184         if (modified_values == 0)
 185                 alloc_modified_values ();
 186
 187         modified_values[prop->offset] = prop->modified_value.byte[0];
 188         modified_values[prop->offset+1] = prop->modified_value.byte[1];
 189         modified_values[prop->offset+2] = prop->modified_value.byte[2];
 190         modified_values[prop->offset+3] = prop->modified_value.byte[3];
 191
 192         return 0;
 193 }
 194
 195 int
 196 flush_dummy (prop)
 197         struct property *prop;
 198 {
 199         return 0;
 200 }
 201
 202 int
 203 parse_dummy (prop, value)
 204         struct property *prop;
 205         const char *value;
 206 {
 207         warnx ("Cannot modify %s.%s", prop->class, prop->node);
 208
 209         return -1;
 210 }
 211
 212 int
 213 parse_byte (prop, value)
 214         struct property *prop;
 215         const char *value;
 216 {
 217         const char *p = value;
 218         int v;
 219
 220         v = atoi_ (&p);
 221         if (p == 0) {
 222                 warnx ("%s: Invalid value", value);
 223                 return -1;
 224         }
 225
 226         if (strcasecmp ("MB", p) == 0)
 227                 v *= 1024 * 1024;
 228         else if (strcasecmp ("KB", p) == 0)
 229                 v *= 1024;
 230         else if (*p != 0 &&
 231                  strcasecmp ("B", p) != 0) {
 232                 warnx ("%s: Invalid value", value);
 233                 return -1;
 234         }
 235
 236         if (v < prop->min) {
 237                 warnx ("%s: Too small", value);
 238                 return -1;
 239         } else if (v > prop->max) {
 240                 warnx ("%s: Too large", value);
 241                 return -1;
 242         }
 243
 244         prop->modified = 1;
 245         prop->modified_value.longword = v;
 246
 247         return 0;
 248 }
 249
 250 int
 251 parse_uchar (prop, value)
 252         struct property *prop;
 253         const char *value;
 254 {
 255         const char *p = value;
 256         int v;
 257
 258         v = atoi_ (&p);
 259         if (p == 0) {
 260                 warnx ("%s: Invalid value", value);
 261                 return -1;
 262         }
 263
 264         if (v < prop->min) {
 265                 warnx ("%s: Too small", value);
 266                 return -1;
 267         } else if (v > prop->max) {
 268                 warnx ("%s: Too large", value);
 269                 return -1;
 270         }
 271
 272         prop->modified = 1;
 273         prop->modified_value.byte[0] = v;
 274
 275         return 0;
 276 }
 277
 278 int
 279 parse_ulong (prop, value)
 280         struct property *prop;
 281         const char *value;
 282 {
 283         const char *p = value;
 284         int v;
 285
 286         v = atoi_ (&p);
 287         if (p == 0) {
 288                 warnx ("%s: Invalid value", value);
 289                 return -1;
 290         }
 291
 292         if (v < prop->min) {
 293                 warnx ("%s: Too small", value);
 294                 return -1;
 295         } else if (v > prop->max) {
 296                 warnx ("%s: Too large", value);
 297                 return -1;
 298         }
 299
 300         prop->modified = 1;
 301         prop->modified_value.longword = v;
 302
 303         return 0;
 304 }
 305
 306 int
 307 parse_ushort (prop, value)
 308         struct property *prop;
 309         const char *value;
 310 {
 311         const char *p = value;
 312         int v;
 313
 314         v = atoi_ (&p);
 315         if (p == 0) {
 316                 warnx ("%s: Invalid value", value);
 317                 return -1;
 318         }
 319
 320         if (v < prop->min) {
 321                 warnx ("%s: Too small", value);
 322                 return -1;
 323         } else if (v > prop->max) {
 324                 warnx ("%s: Too large", value);
 325                 return -1;
 326         }
 327
 328         prop->modified = 1;
 329         prop->modified_value.word[0] = v;
 330
 331         return 0;
 332 }
 333
 334 int
 335 parse_time (prop, value)
 336         struct property *prop;
 337         const char *value;
 338 {
 339         const char *p = value;
 340         int v;
 341
 342         while (*p == ' ' || *p == '\t') p++;
 343         if (*p == '-') {
 344                 p++;
 345                 v = -atoi_ (&p);
 346         } else
 347                 v = atoi_ (&p);
 348         if (p == 0) {
 349                 warnx ("%s: Invalid value", value);
 350                 return -1;
 351         }
 352
 353         if (strcasecmp ("hours", p) == 0 || strcasecmp ("hour", p) == 0)
 354                 v *= 60 * 60;
 355         else if (strcasecmp ("minutes", p) == 0 ||
 356                  strcasecmp ("minute", p) == 0)
 357                 v *= 60;
 358         else if (*p != 0 &&
 359                  strcasecmp ("second", p) != 0 &&
 360                  strcasecmp ("seconds", p) != 0) {
 361                 warnx ("%s: Invalid value", value);
 362                 return -1;
 363         }
 364
 365         if (v < prop->min) {
 366                 warnx ("%s: Too small", value);
 367                 return -1;
 368         } else if (v > prop->max) {
 369                 warnx ("%s: Too large", value);
 370                 return -1;
 371         }
 372
 373         prop->modified = 1;
 374         prop->modified_value.longword = v;
 375
 376         return 0;
 377 }
 378
 379 int
 380 parse_bootdev (prop, value)
 381         struct property *prop;
 382         const char *value;
 383 {
 384         const char *p = value;
 385         int v;
 386         char expr_scsi[32];
 387
 388         while (*p == ' ' || *p == '\t') p++;
 389
 390         if (strcasecmp ("STD", p) == 0)
 391                 v = 0;
 392         else if (strcasecmp ("ROM", p) == 0)
 393                 v = 0xa000;
 394         else if (strcasecmp ("RAM", p) == 0)
 395                 v = 0xb000;
 396         else if (strncasecmp ("HD", p, 2) == 0) {
 397                 p += 2;
 398                 v = atoi_ (&p);
 399                 if (p == 0 || v < 0 || v > 15) {
 400                         warnx ("%s: Invalid value", value);
 401                         return -1;
 402                 }
 403                 v *= 0x0100;
 404                 v += 0x8000;
 405         } else if (strncasecmp ("FD", p, 2) == 0) {
 406                 p += 2;
 407                 v = atoi_ (&p);
 408                 if (p == 0 || v < 0 || v > 3) {
 409                         warnx ("%s: Invalid value", value);
 410                         return -1;
 411                 }
 412                 v *= 0x0100;
 413                 v += 0x9070;
 414         } else if (strncasecmp ("INSCSI", p, 6) == 0 ||
 415                    strncasecmp ("EXSCSI", p, 6) == 0) {
 416                 int isin = strncasecmp ("EXSCSI", p, 6);
 417
 418                 p += 6;
 419                 v = atoi_ (&p);
 420                 if (p == 0 || v < 0 || v > 7) {
 421                         warnx ("%s: Invalid value", value);
 422                         return -1;
 423                 }
 424
 425                 /* change boot.romaddr */
 426                 sprintf(expr_scsi, "boot.romaddr=0x%06x",
 427                         (isin ? 0xfc0000 : 0xea0020) + v * 4);
 428                 modify_single(expr_scsi);
 429
 430                 /* boot.device again */
 431                 v = 0xa000;
 432         } else {
 433                 warnx ("%s: Invalid value", value);
 434                 return -1;
 435         }
 436
 437         prop->modified = 1;
 438         prop->modified_value.word[0] = v;
 439
 440         return 0;
 441 }
 442
 443 int
 444 parse_serial (prop, value)
 445         struct property *prop;
 446         const char *value;
 447 #define NEXTSPEC        while (*p == ' ' || *p == '\t') p++;            \
 448                         if (*p++ != ',') {                              \
 449                                 warnx ("%s: Invalid value", value);     \
 450                                 return -1;                              \
 451                         }                                               \
 452                         while (*p == ' ' || *p == '\t') p++;
 453 {
 454         const char *p = value;
 455         const char *q;
 456         int baud, bit, parity, stop, flow;
 457         static const int bauds[] = {75, 150, 300, 600, 1200, 2400, 4800, 9600,
 458             17361, 0};
 459         static const char parities[] = "noe";
 460         int i;
 461
 462         while (*p == ' ' || *p == '\t') p++;
 463
 464         /* speed */
 465         baud = atoi_ (&p);
 466         if (p == 0) {
 467                 warnx ("%s: Invalid value", value);
 468                 return -1;
 469         }
 470         for (i = 0; bauds[i]; i++)
 471                 if (baud == bauds[i])
 472                         break;
 473         if (bauds[i] == 0) {
 474                 warnx ("%d: Invalid speed", baud);
 475                 return -1;
 476         }
 477         baud = i;
 478
 479         NEXTSPEC;
 480
 481         /* bit size */
 482         if (*p < '5' || *p > '8') {
 483                 warnx ("%c: Invalid bit size", *p);
 484                 return -1;
 485         }
 486         bit = *p++ - '5';
 487
 488         NEXTSPEC;
 489
 490         /* parity */
 491         q = strchr(parities, *p++);
 492         if (q == 0) {
 493                 warnx ("%c: Invalid parity spec", *p);
 494                 return -1;
 495         }
 496         parity = q - parities;
 497
 498         NEXTSPEC;
 499
 500         /* stop bit */
 501         if (strncmp (p, "1.5", 3) == 0) {
 502                 stop = 2;
 503                 p += 3;
 504         } else if (strncmp (p, "2", 1) == 0) {
 505                 stop = 0;
 506                 p++;
 507         } else if (strncmp (p, "1", 1) == 0) {
 508                 stop = 1;
 509                 p++;
 510         } else {
 511                 warnx ("%s: Invalid value", value);
 512                 return -1;
 513         }
 514
 515         NEXTSPEC;
 516
 517         /* flow */
 518         if (*p == '-')
 519                 flow = 0;
 520         else if (*p == 's')
 521                 flow = 1;
 522         else {
 523                 warnx ("%s: Invalid value", value);
 524                 return -1;
 525         }
 526
 527         p++;
 528         while (*p == ' ' || *p == '\t') p++;
 529         if (*p != 0) {
 530                 warnx ("%s: Invalid value", value);
 531                 return -1;
 532         }
 533
 534         prop->modified = 1;
 535         prop->modified_value.word[0] = ((stop << 14) +
 536                                         (parity << 12) +
 537                                         (bit << 10) +
 538                                         (flow << 9) +
 539                                         baud);
 540
 541         return 0;
 542 }
 543 #undef NEXTSPEC
 544
 545 int
 546 parse_srammode (prop, value)
 547         struct property *prop;
 548         const char *value;
 549 {
 550         static const char *const sramstrs[] = {"unused", "SRAMDISK", "program"};
 551         int i;
 552
 553         for (i = 0; i <= 2; i++) {
 554                 if (strcasecmp (value, sramstrs[i]) == 0)
 555                         break;
 556         }
 557         if (i > 2) {
 558                 warnx ("%s: Invalid value", value);
 559                 return -1;
 560         }
 561
 562         prop->modified = 1;
 563         prop->modified_value.byte[0] = i;
 564
 565         return 0;
 566 }
 567
 568 int
 569 print_uchar (prop, str)
 570         struct property *prop;
 571         char *str;
 572 {
 573         if (prop->modified)
 574                 snprintf (str, MAXVALUELEN,
 575                           "%d", prop->modified_value.byte[0]);
 576         else {
 577                 if (!prop->value_valid)
 578                         prop->fill (prop);
 579                 snprintf (str, MAXVALUELEN, "%d",
 580                           prop->current_value.byte[0]);
 581         }
 582
 583         return 0;
 584 }
 585
 586 int
 587 print_ucharh (prop, str)
 588         struct property *prop;
 589         char *str;
 590 {
 591         if (prop->modified)
 592                 snprintf (str, MAXVALUELEN,
 593                           "0x%4.4x", prop->modified_value.byte[0]);
 594         else {
 595                 if (!prop->value_valid)
 596                         prop->fill (prop);
 597                 snprintf (str, MAXVALUELEN,
 598                           "0x%4.4x", prop->current_value.byte[0]);
 599         }
 600
 601         return 0;
 602 }
 603
 604 int
 605 print_ushorth (prop, str)
 606         struct property *prop;
 607         char *str;
 608 {
 609         if (prop->modified)
 610                 snprintf (str, MAXVALUELEN,
 611                           "0x%4.4x", prop->modified_value.word[0]);
 612         else {
 613                 if (!prop->value_valid)
 614                         prop->fill (prop);
 615                 snprintf (str, MAXVALUELEN,
 616                           "0x%4.4x", prop->current_value.word[0]);
 617         }
 618
 619         return 0;
 620 }
 621
 622 int
 623 print_ulong (prop, str)
 624         struct property *prop;
 625         char *str;
 626 {
 627         if (prop->modified)
 628                 snprintf (str, MAXVALUELEN,
 629                           "%ld", prop->modified_value.longword);
 630         else {
 631                 if (!prop->value_valid)
 632                         prop->fill (prop);
 633                 snprintf (str, MAXVALUELEN,
 634                           "%ld", prop->current_value.longword);
 635         }
 636
 637         return 0;
 638 }
 639
 640 int
 641 print_ulongh (prop, str)
 642         struct property *prop;
 643         char *str;
 644 {
 645         if (prop->modified)
 646                 snprintf (str, MAXVALUELEN,
 647                           "0x%8.8lx", prop->modified_value.longword);
 648         else {
 649                 if (!prop->value_valid)
 650                         prop->fill (prop);
 651                 snprintf (str, MAXVALUELEN,
 652                           "0x%8.8lx", prop->current_value.longword);
 653         }
 654
 655         return 0;
 656 }
 657
 658 int
 659 print_magic (prop, str)
 660         struct property *prop;
 661         char *str;
 662 {
 663         if (!prop->value_valid)
 664                 prop->fill (prop);
 665         snprintf (str, MAXVALUELEN, "%c%c%c%c",
 666                   prop->current_value.byte[0],
 667                   prop->current_value.byte[1],
 668                   prop->current_value.byte[2],
 669                   prop->current_value.byte[3]);
 670
 671         return 0;
 672 }
 673
 674 int
 675 print_timesec (prop, str)
 676         struct property *prop;
 677         char *str;
 678 {
 679         if (prop->modified)
 680                 snprintf (str, MAXVALUELEN,
 681                           "%ld second", prop->modified_value.longword);
 682         else {
 683                 if (!prop->value_valid)
 684                         prop->fill (prop);
 685                 snprintf (str, MAXVALUELEN,
 686                           "%ld second", prop->current_value.longword);
 687         }
 688
 689         return 0;
 690 }
 691
 692 int
 693 print_bootdev (prop, str)
 694         struct property *prop;
 695         char *str;
 696 {
 697         unsigned int v;
 698
 699         if (prop->modified)
 700                 v = prop->modified_value.word[0];
 701         else {
 702                 if (!prop->value_valid)
 703                         prop->fill (prop);
 704                 v = prop->current_value.word[0];
 705         }
 706
 707         if (v == 0)
 708                 strcpy (str, "STD");
 709         else if (v == 0xa000)
 710                 strcpy (str, "ROM");
 711         else if (v == 0xb000)
 712                 strcpy (str, "RAM");
 713         else if (v >= 0x8000 && v < 0x9000)
 714                 snprintf (str, MAXVALUELEN, "HD%d", (v & 0x0f00) >> 8);
 715         else if (v >= 0x9000 && v < 0xa000)
 716                 snprintf (str, MAXVALUELEN, "FD%d", (v & 0x0f00) >> 8);
 717         else
 718                 snprintf (str, MAXVALUELEN, "%8.8x", v);
 719
 720         return 0;
 721 }
 722
 723 int
 724 print_serial (prop, str)
 725         struct property *prop;
 726         char *str;
 727 {
 728         unsigned int v;
 729         const char *baud, *stop;
 730         char bit, parity, flow;
 731         static const char *const bauds[] = {"75", "150", "300", "600", "1200",
 732                                "2400", "4800", "9600", "17361"};
 733         static const char bits[] = "5678";
 734         static const char parities[] = "noen";
 735         static const char *const stops[] = {"2", "1", "1.5", "2"};
 736         static const char flows[] = "-s";
 737
 738         if (prop->modified)
 739                 v = prop->modified_value.word[0];
 740         else {
 741                 if (!prop->value_valid)
 742                         prop->fill (prop);
 743                 v = prop->current_value.word[0];
 744         }
 745
 746         baud = bauds[v & 0x000f];
 747         bit = bits[(v & 0x0c00) >> 10];
 748         parity = parities[(v & 0x3000) >> 12];
 749         stop = stops[(v & 0xe000) >> 14];
 750         flow = flows[(v & 0x0200) >> 9];
 751         sprintf (str, "%s,%c,%c,%s,%c", baud, bit, parity, stop, flow);
 752
 753         return 0;
 754 }
 755
 756 int
 757 print_srammode (prop, str)
 758         struct property *prop;
 759         char *str;
 760 {
 761         int v;
 762         static const char *const sramstrs[] = {"unused", "SRAMDISK", "program"};
 763
 764         if (prop->modified)
 765                 v = prop->modified_value.byte[0];
 766         else {
 767                 if (!prop->value_valid)
 768                         prop->fill (prop);
 769                 v = prop->current_value.byte[0];
 770         }
 771
 772         if (v < 0 || v > 2)
 773                 strcpy (str, "INVALID");
 774         else
 775                 strcpy (str, sramstrs[v]);
 776
 777         return 0;
 778 }