Print this page
patch tsoome-feedback

Split Close
Expand all
Collapse all
          --- old/usr/src/lib/libbe/common/be_create.c
          +++ new/usr/src/lib/libbe/common/be_create.c
↓ open down ↓ 344 lines elided ↑ open up ↑
 345  345                                  ret = zfs_err_to_be_err(g_zfs);
 346  346                                  nvlist_free(props);
 347  347                                  goto done;
 348  348                          }
 349  349                  }
 350  350  
 351  351                  nvlist_free(props);
 352  352          }
 353  353  
 354  354  done:
 355      -        if (bt.nbe_zfs_props != NULL)
 356      -                nvlist_free(bt.nbe_zfs_props);
      355 +        nvlist_free(bt.nbe_zfs_props);
 357  356  
 358  357          be_zfs_fini();
 359  358  
 360  359          return (ret);
 361  360  }
 362  361  
 363  362  /*
 364  363   * Function:    be_destroy
 365  364   * Description: Destroy a BE and all of its children datasets, snapshots and
 366  365   *              zones that belong to the parent BE.
↓ open down ↓ 793 lines elided ↑ open up ↑
1160 1159                                  be_print_err(gettext("be_copy: failed to "
1161 1160                                      "add snap name to be_attrs\n"));
1162 1161                          }
1163 1162                  }
1164 1163          }
1165 1164  
1166 1165  done:
1167 1166          ZFS_CLOSE(zhp);
1168 1167          be_free_fs_list(&fld);
1169 1168  
1170      -        if (bt.nbe_zfs_props != NULL)
1171      -                nvlist_free(bt.nbe_zfs_props);
     1169 +        nvlist_free(bt.nbe_zfs_props);
1172 1170  
1173 1171          free(bt.obe_altroot);
1174 1172          free(new_mp);
1175 1173  
1176 1174          /*
1177 1175           * If a failure occurred and we already created the datasets for
1178 1176           * the new boot environment, destroy them.
1179 1177           */
1180 1178          if (ret != BE_SUCCESS && be_created) {
1181 1179                  be_destroy_data_t       cdd = { 0 };
↓ open down ↓ 901 lines elided ↑ open up ↑
2083 2081                   * The call to be_clone_fs_callback always closes the
2084 2082                   * zfs_handle so there's no need to close z_zhp.
2085 2083                   */
2086 2084                  if ((iret = be_clone_fs_callback(z_zhp, &bt)) != 0) {
2087 2085                          z_zhp = NULL;
2088 2086                          if (iret != BE_ERR_BE_EXISTS) {
2089 2087                                  be_print_err(gettext("be_copy_zones: "
2090 2088                                      "failed to create zone BE clone for new "
2091 2089                                      "zone BE %s\n"), new_zone_be_name);
2092 2090                                  ret = iret;
2093      -                                if (bt.nbe_zfs_props != NULL)
2094      -                                        nvlist_free(bt.nbe_zfs_props);
     2091 +                                nvlist_free(bt.nbe_zfs_props);
2095 2092                                  goto done;
2096 2093                          }
2097 2094                          /*
2098 2095                           * We failed to create the new zone BE because a zone
2099 2096                           * BE with the auto-name we generated above has since
2100 2097                           * come into existence. Regenerate a new auto-name
2101 2098                           * and retry.
2102 2099                           */
2103 2100                          for (num_retries = 1;
2104 2101                              num_retries < BE_AUTO_NAME_MAX_TRY;
↓ open down ↓ 4 lines elided ↑ open up ↑
2109 2106  
2110 2107                                  /* Generate new auto zone BE name */
2111 2108                                  free(new_zone_be_name);
2112 2109                                  if ((new_zone_be_name = be_auto_zone_be_name(
2113 2110                                      zone_container_ds,
2114 2111                                      zone_be_name)) == NULL) {
2115 2112                                          be_print_err(gettext("be_copy_zones: "
2116 2113                                              "failed to generate auto name "
2117 2114                                              "for zone BE.\n"));
2118 2115                                          ret = BE_ERR_AUTONAME;
2119      -                                        if (bt.nbe_zfs_props != NULL)
2120      -                                                nvlist_free(bt.nbe_zfs_props);
     2116 +                                        nvlist_free(bt.nbe_zfs_props);
2121 2117                                          goto done;
2122 2118                                  }
2123 2119  
2124 2120                                  (void) snprintf(new_zoneroot_ds,
2125 2121                                      sizeof (new_zoneroot_ds),
2126 2122                                      "%s/%s", zone_container_ds,
2127 2123                                      new_zone_be_name);
2128 2124                                  bt.nbe_name = new_zone_be_name;
2129 2125                                  bt.nbe_root_ds = new_zoneroot_ds;
2130 2126  
↓ open down ↓ 2 lines elided ↑ open up ↑
2133 2129                                   * dataset.
2134 2130                                   */
2135 2131                                  if ((z_zhp = zfs_open(g_zfs, zoneroot_ds,
2136 2132                                      ZFS_TYPE_FILESYSTEM)) == NULL) {
2137 2133                                          be_print_err(gettext("be_copy_zones: "
2138 2134                                              "failed to open zone root "
2139 2135                                              "dataset (%s): %s\n"),
2140 2136                                              zoneroot_ds,
2141 2137                                              libzfs_error_description(g_zfs));
2142 2138                                          ret = zfs_err_to_be_err(g_zfs);
2143      -                                        if (bt.nbe_zfs_props != NULL)
2144      -                                                nvlist_free(bt.nbe_zfs_props);
     2139 +                                        nvlist_free(bt.nbe_zfs_props);
2145 2140                                          goto done;
2146 2141                                  }
2147 2142  
2148 2143                                  /*
2149 2144                                   * Try to clone the zone BE again. This
2150 2145                                   * call will end up closing the zfs
2151 2146                                   * handle passed in whether it
2152 2147                                   * succeeds or fails.
2153 2148                                   */
2154 2149                                  iret = be_clone_fs_callback(z_zhp, &bt);
2155 2150                                  z_zhp = NULL;
2156 2151                                  if (iret == 0) {
2157 2152                                          break;
2158 2153                                  } else if (iret != BE_ERR_BE_EXISTS) {
2159 2154                                          be_print_err(gettext("be_copy_zones: "
2160 2155                                              "failed to create zone BE clone "
2161 2156                                              "for new zone BE %s\n"),
2162 2157                                              new_zone_be_name);
2163 2158                                          ret = iret;
2164      -                                        if (bt.nbe_zfs_props != NULL)
2165      -                                                nvlist_free(bt.nbe_zfs_props);
     2159 +                                        nvlist_free(bt.nbe_zfs_props);
2166 2160                                          goto done;
2167 2161                                  }
2168 2162                          }
2169 2163                          /*
2170 2164                           * If we've exhausted the maximum number of
2171 2165                           * tries, free the auto zone BE name and return
2172 2166                           * error.
2173 2167                           */
2174 2168                          if (num_retries == BE_AUTO_NAME_MAX_TRY) {
2175 2169                                  be_print_err(gettext("be_copy_zones: failed "
2176 2170                                      "to create a unique auto zone BE name\n"));
2177 2171                                  free(bt.nbe_name);
2178 2172                                  bt.nbe_name = NULL;
2179 2173                                  ret = BE_ERR_AUTONAME;
2180      -                                if (bt.nbe_zfs_props != NULL)
2181      -                                        nvlist_free(bt.nbe_zfs_props);
     2174 +                                nvlist_free(bt.nbe_zfs_props);
2182 2175                                  goto done;
2183 2176                          }
2184 2177                  }
2185 2178  
2186      -                if (bt.nbe_zfs_props != NULL)
2187      -                        nvlist_free(bt.nbe_zfs_props);
     2179 +                nvlist_free(bt.nbe_zfs_props);
2188 2180  
2189 2181                  z_zhp = NULL;
2190 2182  
2191 2183                  if ((z_zhp = zfs_open(g_zfs, new_zoneroot_ds,
2192 2184                      ZFS_TYPE_FILESYSTEM)) == NULL) {
2193 2185                          be_print_err(gettext("be_copy_zones: "
2194 2186                              "failed to open the new zone BE root dataset "
2195 2187                              "(%s): %s\n"), new_zoneroot_ds,
2196 2188                              libzfs_error_description(g_zfs));
2197 2189                          ret = zfs_err_to_be_err(g_zfs);
↓ open down ↓ 901 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX