Print this page 
botadm patch
Split Close
Expand all
Collapse all
          --- old/bootadm/bootadm.c
          +++ new/bootadm/bootadm.c
↓ open down ↓ 13 lines elided ↑ open up ↑ 
  14   14   * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15   15   * If applicable, add the following below this CDDL HEADER, with the
  16   16   * fields enclosed by brackets "[]" replaced with your own identifying
  17   17   * information: Portions Copyright [yyyy] [name of copyright owner]
  18   18   *
  19   19   * CDDL HEADER END
  20   20   */
  21   21  /*
  22   22   * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  23   23   * Copyright 2012 Milan Jurik. All rights reserved.
       24 + * Copyright 2012 Daniil Lunev. All rights reserved.
  24   25   */
  25   26  
  26   27  /*
  27   28   * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
  28   29   */
  29   30  
  30   31  /*
  31   32   * bootadm(1M) is a new utility for managing bootability of
  32   33   * Solaris *Newboot* environments. It has two primary tasks:
  33   34   *      - Allow end users to manage bootability of Newboot Solaris instances
↓ open down ↓ 77 lines elided ↑ open up ↑ 
 111  112          error_t (*handler)();
 112  113          int     unpriv;                 /* is this an unprivileged command */
 113  114  } subcmd_defn_t;
 114  115  
 115  116  #define LINE_INIT       0       /* lineNum initial value */
 116  117  #define ENTRY_INIT      -1      /* entryNum initial value */
 117  118  #define ALL_ENTRIES     -2      /* selects all boot entries */
 118  119  
 119  120  #define GRUB_DIR                "/boot/grub"
 120  121  #define GRUB_STAGE2             GRUB_DIR "/stage2"
 121      -#define GRUB_MENU               "/boot/grub/menu.lst"
 122      -#define MENU_TMP                "/boot/grub/menu.lst.tmp"
      122 +#define GRUB_MENU               "/boot/illumos.cfg"
      123 +#define MENU_TMP                "/boot/illumos.cfg.tmp"
 123  124  #define GRUB_BACKUP_MENU        "/etc/lu/GRUB_backup_menu"
 124  125  #define RAMDISK_SPECIAL         "/ramdisk"
 125  126  #define STUBBOOT                "/stubboot"
 126  127  #define MULTIBOOT               "/platform/i86pc/multiboot"
 127  128  #define GRUBSIGN_DIR            "/boot/grub/bootsign"
 128  129  #define GRUBSIGN_BACKUP         "/etc/bootsign"
 129  130  #define GRUBSIGN_UFS_PREFIX     "rootfs"
 130  131  #define GRUBSIGN_ZFS_PREFIX     "pool_"
 131  132  #define GRUBSIGN_LU_PREFIX      "BE_"
 132  133  #define UFS_SIGNATURE_LIST      "/var/run/grub_ufs_signatures"
↓ open down ↓ 38 lines elided ↑ open up ↑ 
 171  172   */
 172  173  #define DEFAULT_DEV_MODE        0644    /* default permissions */
 173  174  #define DEFAULT_DEV_UID         0       /* user root */
 174  175  #define DEFAULT_DEV_GID         3       /* group sys */
 175  176  
 176  177  /*
 177  178   * Menu related
 178  179   * menu_cmd_t and menu_cmds must be kept in sync
 179  180   */
 180  181  char *menu_cmds[] = {
 181      -        "default",      /* DEFAULT_CMD */
      182 +        "default_entry",/* DEFAULT_CMD */
 182  183          "timeout",      /* TIMEOUT_CMD */
 183      -        "title",        /* TITLE_CMD */
 184      -        "root",         /* ROOT_CMD */
 185      -        "kernel",       /* KERNEL_CMD */
 186      -        "kernel$",      /* KERNEL_DOLLAR_CMD */
 187      -        "module",       /* MODULE_CMD */
 188      -        "module$",      /* MODULE_DOLLAR_CMD */
 189      -        " ",            /* SEP_CMD */
      184 +        "entry_name",   /* TITLE_CMD */
      185 +        "pool_uuid",    /* ROOT_CMD */
      186 +        "kernel_path$", /* KERNEL_CMD */
      187 +        "kernel_path",  /* KERNEL_DOLLAR_CMD */
      188 +        "module$",      /* MODULE_CMD */
      189 +        "module",       /* MODULE_DOLLAR_CMD */
      190 +        "=",            /* SEP_CMD */
 190  191          "#",            /* COMMENT_CMD */
 191  192          "chainloader",  /* CHAINLOADER_CMD */
 192  193          "args",         /* ARGS_CMD */
 193      -        "findroot",     /* FINDROOT_CMD */
 194      -        "bootfs",       /* BOOTFS_CMD */
      194 +        "pool_label",   /* FINDROOT_CMD */
      195 +        "data_set",     /* BOOTFS_CMD */
      196 +        "kernel_options",/* KERNEL_OPTIONS_CMD */
 195  197          NULL
 196  198  };
 197  199  
 198  200  #define OPT_ENTRY_NUM   "entry"
 199  201  
 200  202  /*
 201  203   * exec_cmd related
 202  204   */
 203  205  typedef struct {
 204  206          line_t *head;
↓ open down ↓ 4478 lines elided ↑ open up ↑ 
4683 4685          char *mod_kernel,
4684 4686          char *module,
4685 4687          char *bootfs)
4686 4688  {
4687 4689          int             lineNum;
4688 4690          int             entryNum;
4689 4691          char            linebuf[BAM_MAXLINE];
4690 4692          menu_cmd_t      k_cmd;
4691 4693          menu_cmd_t      m_cmd;
4692 4694          const char      *fcn = "add_boot_entry()";
     4695 +        char * options = NULL;
4693 4696  
4694 4697          assert(mp);
4695 4698  
4696 4699          INJECT_ERROR1("ADD_BOOT_ENTRY_FINDROOT_NULL", findroot = NULL);
4697 4700          if (findroot == NULL) {
4698 4701                  bam_error(NULL_FINDROOT);
4699 4702                  return (BAM_ERROR);
4700 4703          }
4701 4704  
4702 4705          if (title == NULL) {
↓ open down ↓ 46 lines elided ↑ open up ↑ 
4749 4752              menu_cmds[FINDROOT_CMD], menu_cmds[SEP_CMD], findroot);
4750 4753          line_parser(mp, linebuf, &lineNum, &entryNum);
4751 4754          BAM_DPRINTF((D_ADD_FINDROOT_NUM, fcn, lineNum, entryNum));
4752 4755  
4753 4756          if (bootfs != NULL) {
4754 4757                  (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
4755 4758                      menu_cmds[BOOTFS_CMD], menu_cmds[SEP_CMD], bootfs);
4756 4759                  line_parser(mp, linebuf, &lineNum, &entryNum);
4757 4760          }
4758 4761  
4759      -        (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
4760      -            menu_cmds[k_cmd], menu_cmds[SEP_CMD], kernel);
     4762 +        options = strpbrk(kernel, " \t");
     4763 +        if (options)
     4764 +                ++options;
     4765 +
     4766 +        (void) snprintf(linebuf, sizeof (linebuf), "%s%s",
     4767 +            menu_cmds[k_cmd], menu_cmds[SEP_CMD]);
     4768 +        (void) strncat(linebuf, kernel, options - kernel);
4761 4769          line_parser(mp, linebuf, &lineNum, &entryNum);
4762 4770  
     4771 +        if (options) {
     4772 +                (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
     4773 +                    menu_cmds[KERNEL_OPTIONS_CMD], menu_cmds[SEP_CMD], options);
     4774 +                line_parser(mp, linebuf, &lineNum, &entryNum);
     4775 +        }
     4776 +
4763 4777          if (mod_kernel != NULL) {
4764 4778                  (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
4765 4779                      menu_cmds[m_cmd], menu_cmds[SEP_CMD], mod_kernel);
4766 4780                  line_parser(mp, linebuf, &lineNum, &entryNum);
4767 4781          }
4768 4782  
4769 4783          (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
4770 4784              menu_cmds[m_cmd], menu_cmds[SEP_CMD], module);
4771 4785          line_parser(mp, linebuf, &lineNum, &entryNum);
4772 4786
↓ open down ↓ 2332 lines elided ↑ open up ↑ 
7105 7119          INJECT_ERROR1("GET_GRUBSIGN_FDISK", fdiskpart = -1);
7106 7120          if (fdiskpart == -1) {
7107 7121                  bam_error(FDISKPART_FAIL, osdev);
7108 7122                  free(sign);
7109 7123                  return (NULL);
7110 7124          }
7111 7125  
7112 7126          slice = strrchr(osdev, 's');
7113 7127  
7114 7128          grubsign = s_calloc(1, MAXNAMELEN + 10);
7115      -        if (slice) {
     7129 +/*      if (slice) {
7116 7130                  (void) snprintf(grubsign, MAXNAMELEN + 10, "(%s,%d,%c)",
7117 7131                      sign, fdiskpart, slice[1] + 'a' - '0');
7118 7132          } else
7119 7133                  (void) snprintf(grubsign, MAXNAMELEN + 10, "(%s,%d)",
7120      -                    sign, fdiskpart);
     7134 +                    sign, fdiskpart);*/
     7135 +        grubsign = strdup(sign);
7121 7136  
7122 7137          free(sign);
7123 7138  
7124 7139          BAM_DPRINTF((D_GET_GRUBSIGN_SUCCESS, fcn, grubsign));
7125 7140  
7126      -        return (grubsign);
     7141 +        return (strchr(grubsign,'_') + 1);
7127 7142  }
7128 7143  
7129 7144  static char *
7130 7145  get_title(char *rootdir)
7131 7146  {
7132 7147          static char     title[80];
7133 7148          char            *cp = NULL;
7134 7149          char            release[PATH_MAX];
7135 7150          FILE            *fp;
7136 7151          const char      *fcn = "get_title()";
↓ open down ↓ 668 lines elided ↑ open up ↑ 
7805 7820                  } else if (lp->cmd != NULL &&
7806 7821                      strcmp(lp->cmd, menu_cmds[FINDROOT_CMD]) == 0) {
7807 7822                          INJECT_ERROR1("FIND_BOOT_ENTRY_NULL_FINDROOT",
7808 7823                              findroot = NULL);
7809 7824                          if (findroot == NULL) {
7810 7825                                  BAM_DPRINTF((D_NOMATCH_FINDROOT_NULL,
7811 7826                                      fcn, lp->arg));
7812 7827                                  continue;
7813 7828                          }
7814 7829                          /* findroot command found, try match  */
7815      -                        if (strcmp(lp->arg, findroot) != 0) {
     7830 +                        if (strncmp(lp->arg, strchr(findroot, '_') + 1, strlen(lp->arg)) != 0) {
7816 7831                                  BAM_DPRINTF((D_NOMATCH_FINDROOT,
7817 7832                                      fcn, findroot, lp->arg));
7818 7833                                  continue;
7819 7834                          }
7820 7835                          BAM_DPRINTF((D_MATCHED_FINDROOT, fcn, findroot));
7821 7836                          lp = lp->next;  /* advance to kernel line */
7822 7837                  } else if (lp->cmd != NULL &&
7823 7838                      strcmp(lp->cmd, menu_cmds[ROOT_CMD]) == 0) {
7824 7839                          INJECT_ERROR1("FIND_BOOT_ENTRY_NULL_ROOT", root = NULL);
7825 7840                          if (root == NULL) {
↓ open down ↓ 37 lines elided ↑ open up ↑ 
7863 7878  
7864 7879                  }
7865 7880                  BAM_DPRINTF((D_KERNEL_MATCH, fcn, kernel, lp->arg));
7866 7881  
7867 7882                  /*
7868 7883                   * Check for matching module entry (failsafe or normal).
7869 7884                   * If it fails to match, we go around the loop again.
7870 7885                   * For xpv entries, there are two module lines, so we
7871 7886                   * do the check twice.
7872 7887                   */
     7888 +                lp = lp->next;  /* advance to options line */
7873 7889                  lp = lp->next;  /* advance to module line */
7874 7890                  if (check_cmd(lp->cmd, MODULE_CMD, lp->arg, module) ||
7875 7891                      (((lp = lp->next) != NULL) &&
7876 7892                      check_cmd(lp->cmd, MODULE_CMD, lp->arg, module))) {
7877 7893                          /* match found */
7878 7894                          BAM_DPRINTF((D_MODULE_MATCH, fcn, module, lp->arg));
7879 7895                          break;
7880 7896                  }
7881 7897  
7882 7898                  if (strcmp(module, FAILSAFE_ARCHIVE) == 0 &&
↓ open down ↓ 21 lines elided ↑ open up ↑ 
7904 7920  update_boot_entry(menu_t *mp, char *title, char *findroot, char *root,
7905 7921      char *kernel, char *mod_kernel, char *module, int root_opt)
7906 7922  {
7907 7923          int             i;
7908 7924          int             change_kernel = 0;
7909 7925          entry_t         *ent;
7910 7926          line_t          *lp;
7911 7927          line_t          *tlp;
7912 7928          char            linebuf[BAM_MAXLINE];
7913 7929          const char      *fcn = "update_boot_entry()";
     7930 +        char            *label;
7914 7931  
7915 7932          /* note: don't match on title, it's updated on upgrade */
7916 7933          ent = find_boot_entry(mp, NULL, kernel, findroot, root, module,
7917 7934              root_opt, &i);
7918 7935          if ((ent == NULL) && (bam_direct == BAM_DIRECT_DBOOT)) {
7919 7936                  /*
7920 7937                   * We may be upgrading a kernel from multiboot to
7921 7938                   * directboot.  Look for a multiboot entry. A multiboot
7922 7939                   * entry will not have a findroot line.
7923 7940                   */
↓ open down ↓ 36 lines elided ↑ open up ↑ 
7960 7977                  if (lp->cmd != NULL)
7961 7978                          free(lp->cmd);
7962 7979  
7963 7980                  free(lp->sep);
7964 7981                  free(lp->arg);
7965 7982                  free(lp->line);
7966 7983          }
7967 7984  
7968 7985          lp->cmd = s_strdup(menu_cmds[FINDROOT_CMD]);
7969 7986          lp->sep = s_strdup(menu_cmds[SEP_CMD]);
7970      -        lp->arg = s_strdup(findroot);
     7987 +        label = s_strdup(strchr(findroot, '_') + 1);
     7988 +        *(strchr(label,',')) = 0;
     7989 +        lp->arg = s_strdup(label);
7971 7990          (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
7972      -            menu_cmds[FINDROOT_CMD], menu_cmds[SEP_CMD], findroot);
     7991 +            menu_cmds[FINDROOT_CMD], menu_cmds[SEP_CMD], label);
7973 7992          lp->line = s_strdup(linebuf);
     7993 +        free(label);
7974 7994          BAM_DPRINTF((D_ADDING_FINDROOT_LINE, fcn, findroot));
7975 7995  
7976 7996          /* kernel line */
7977 7997          lp = lp->next;
7978 7998  
7979 7999          if (ent->flags & BAM_ENTRY_UPGFSKERNEL) {
7980 8000                  char            *params = NULL;
     8001 +                char            *opts = NULL;
7981 8002  
7982      -                params = strstr(lp->line, "-s");
7983      -                if (params != NULL)
7984      -                        (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s%s",
7985      -                            menu_cmds[KERNEL_DOLLAR_CMD], menu_cmds[SEP_CMD],
7986      -                            kernel, params+2);
7987      -                else
7988      -                        (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
7989      -                            menu_cmds[KERNEL_DOLLAR_CMD], menu_cmds[SEP_CMD],
7990      -                            kernel);
     8003 +                opts = strpbrk(kernel, " \t");
     8004 +                *opts++ = '\0';
     8005 +                (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
     8006 +                    menu_cmds[KERNEL_DOLLAR_CMD], menu_cmds[SEP_CMD],
     8007 +                    kernel);
7991 8008  
7992 8009                  if (lp->cmd != NULL)
7993 8010                          free(lp->cmd);
7994 8011  
7995 8012                  free(lp->arg);
7996 8013                  free(lp->line);
7997 8014                  lp->cmd = s_strdup(menu_cmds[KERNEL_DOLLAR_CMD]);
7998 8015                  lp->arg = s_strdup(strstr(linebuf, "/"));
7999 8016                  lp->line = s_strdup(linebuf);
8000 8017                  ent->flags &= ~BAM_ENTRY_UPGFSKERNEL;
8001 8018                  BAM_DPRINTF((D_ADDING_KERNEL_DOLLAR, fcn, lp->prev->cmd));
     8019 +
     8020 +                lp = lp->next;
     8021 +                params = strstr(lp->arg, "-s");
     8022 +                free(lp->arg);
     8023 +                free(lp->line);
     8024 +                if (params)
     8025 +                        (void) snprintf(linebuf, sizeof(linebuf), "%s%s%s -s",
     8026 +                                lp->cmd, menu_cmds[SEP_CMD],opts);
     8027 +                else
     8028 +                        (void) snprintf(linebuf, sizeof(linebuf), "%s%s%s",
     8029 +                                lp->cmd, menu_cmds[SEP_CMD],opts);
     8030 +                lp->line = s_strdup(linebuf);
     8031 +                lp->arg = s_strdup(strchr(linebuf, '=') + 1);
8002 8032          }
8003 8033  
8004 8034          if (change_kernel) {
     8035 +                char            *opts = NULL;
8005 8036                  /*
8006 8037                   * We're upgrading from multiboot to directboot.
8007 8038                   */
     8039 +                opts = strpbrk(kernel, " \t");
     8040 +                *opts++ = '\0';
8008 8041                  if (lp->cmd != NULL &&
8009 8042                      strcmp(lp->cmd, menu_cmds[KERNEL_CMD]) == 0) {
8010 8043                          (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
8011 8044                              menu_cmds[KERNEL_DOLLAR_CMD], menu_cmds[SEP_CMD],
8012 8045                              kernel);
8013 8046                          free(lp->cmd);
8014 8047                          free(lp->arg);
8015 8048                          free(lp->line);
8016 8049                          lp->cmd = s_strdup(menu_cmds[KERNEL_DOLLAR_CMD]);
8017 8050                          lp->arg = s_strdup(kernel);
8018 8051                          lp->line = s_strdup(linebuf);
8019 8052                          lp = lp->next;
8020 8053                          BAM_DPRINTF((D_ADDING_KERNEL_DOLLAR, fcn, kernel));
     8054 +                        (void) snprintf(linebuf, sizeof(linebuf), "%s%s%s",
     8055 +                                lp->cmd, menu_cmds[SEP_CMD],opts);
     8056 +                        free(lp->arg);
     8057 +                        free(lp->line);
     8058 +                        lp->line = s_strdup(linebuf);
     8059 +                        lp->arg = s_strdup(strchr(linebuf, '=') + 1);
8021 8060                  }
8022 8061                  if (lp->cmd != NULL &&
8023 8062                      strcmp(lp->cmd, menu_cmds[MODULE_CMD]) == 0) {
8024 8063                          (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
8025 8064                              menu_cmds[MODULE_DOLLAR_CMD], menu_cmds[SEP_CMD],
8026 8065                              module);
8027 8066                          free(lp->cmd);
8028 8067                          free(lp->arg);
8029 8068                          free(lp->line);
8030 8069                          lp->cmd = s_strdup(menu_cmds[MODULE_DOLLAR_CMD]);
↓ open down ↓ 372 lines elided ↑ open up ↑ 
8403 8442  
8404 8443          osdev = get_special("/");
8405 8444          INJECT_ERROR1("REBOOT_SPECIAL_NULL", osdev = NULL);
8406 8445          if (osdev == NULL) {
8407 8446                  free(fstype);
8408 8447                  bam_error(REBOOT_SPECIAL_FAILED);
8409 8448                  return (BAM_ERROR);
8410 8449          }
8411 8450  
8412 8451          sign = find_existing_sign("/", osdev, fstype);
     8452 +        sign = strchr(sign, '_') + 1;
8413 8453          INJECT_ERROR1("REBOOT_SIGN_NULL", sign = NULL);
8414 8454          if (sign == NULL) {
8415 8455                  free(fstype);
8416 8456                  free(osdev);
8417 8457                  bam_error(REBOOT_SIGN_FAILED);
8418 8458                  return (BAM_ERROR);
8419 8459          }
8420 8460  
8421 8461          free(osdev);
8422 8462          (void) strlcpy(signbuf, sign, sizeof (signbuf));
↓ open down ↓ 428 lines elided ↑ open up ↑ 
8851 8891                  }
8852 8892          }
8853 8893  
8854 8894          entryp = find_boot_entry(mp, BOOTENV_RC_TITLE, NULL, NULL, NULL, NULL,
8855 8895              0, &entryNum);
8856 8896  
8857 8897          if (entryp != NULL) {
8858 8898                  for (ptr = entryp->start; ptr && ptr != entryp->end;
8859 8899                      ptr = ptr->next) {
8860 8900                          if (strncmp(ptr->cmd, menu_cmds[KERNEL_CMD],
8861      -                            sizeof (menu_cmds[KERNEL_CMD]) - 1) == 0) {
     8901 +                            sizeof (menu_cmds[KERNEL_CMD]) - 2) == 0) {
8862 8902                                  kernelp = ptr;
8863 8903                                  break;
8864 8904                          }
8865 8905                  }
8866 8906                  if (kernelp == NULL) {
8867 8907                          bam_error(NO_KERNEL, entryNum);
8868 8908                          return (BAM_ERROR);
8869 8909                  }
8870 8910  
8871 8911                  old_kernel_len = strcspn(kernelp->arg, " \t");
↓ open down ↓ 67 lines elided ↑ open up ↑ 
8939 8979  
8940 8980                  if (optnum == KERNEL_CMD) {
8941 8981                          /*
8942 8982                           * At this point, we've already checked that old_args
8943 8983                           * and entryp are valid pointers.  The "+ 2" is for
8944 8984                           * a space a the string termination character.
8945 8985                           */
8946 8986                          new_str_len = (sizeof (DIRECT_BOOT_KERNEL) - 1) +
8947 8987                              strlen(old_args) + 2;
8948 8988                          new_arg = s_calloc(1, new_str_len);
8949      -                        (void) snprintf(new_arg, new_str_len, "%s %s",
8950      -                            DIRECT_BOOT_KERNEL, old_args);
     8989 +                        (void) snprintf(new_arg, new_str_len, "%s",
     8990 +                            DIRECT_BOOT_KERNEL);
8951 8991                          free(kernelp->arg);
8952 8992                          kernelp->arg = new_arg;
8953 8993  
8954 8994                          /*
8955 8995                           * We have changed the kernel line, so we may need
8956 8996                           * to update the archive line as well.
8957 8997                           */
8958 8998                          set_archive_line(entryp, kernelp);
8959 8999                          BAM_DPRINTF((D_GET_SET_KERNEL_RESET_KERNEL_SET_ARG,
8960 9000                              fcn, kernelp->arg));
↓ open down ↓ 140 lines elided ↑ open up ↑ 
9101 9141                  kernelp->arg = new_arg;
9102 9142  
9103 9143                  /*
9104 9144                   * If we have changed the kernel line, we may need to update
9105 9145                   * the archive line as well.
9106 9146                   */
9107 9147                  set_archive_line(entryp, kernelp);
9108 9148                  BAM_DPRINTF((D_GET_SET_KERNEL_REPLACED_KERNEL_SAME_ARG, fcn,
9109 9149                      kernelp->arg));
9110 9150          } else {
9111      -                new_str_len = old_kernel_len + strlen(path) + 8;
     9151 +                kernelp = kernelp->next;
     9152 +                new_str_len = strlen(kernelp->arg) + strlen(path) + 8;
9112 9153                  new_arg = s_calloc(1, new_str_len);
9113      -                (void) strncpy(new_arg, kernelp->arg, old_kernel_len);
     9154 +                (void) strncpy(new_arg, kernelp->arg, strlen(kernelp->arg));
9114 9155                  (void) strlcat(new_arg, " ", new_str_len);
9115 9156                  (void) strlcat(new_arg, path, new_str_len);
9116 9157                  free(kernelp->arg);
9117 9158                  kernelp->arg = new_arg;
9118 9159                  BAM_DPRINTF((D_GET_SET_KERNEL_SAME_KERNEL_REPLACED_ARG, fcn,
9119 9160                      kernelp->arg));
9120 9161          }
9121 9162          rv = BAM_WRITE;
9122 9163  
9123 9164  done:
↓ open down ↓ 550 lines elided ↑ open up ↑ 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX