mgmtd/mgmt_history.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2021  Vmware, Inc.
   4  *                     Pushpasis Sarkar <spushpasis@vmware.com>
   5  * Copyright (c) 2023, LabN Consulting, L.L.C.
   6  */
   7
   8 #include <zebra.h>
   9 #include "md5.h"
  10 #include "thread.h"
  11 #include "xref.h"
  12
  13 #include "mgmt_fe_client.h"
  14 #include "mgmtd/mgmt.h"
  15 #include "mgmtd/mgmt_ds.h"
  16 #include "mgmtd/mgmt_history.h"
  17
  18 struct mgmt_cmt_info_t {
  19         struct mgmt_cmt_infos_item cmts;
  20
  21         char cmtid_str[MGMTD_MD5_HASH_STR_HEX_LEN];
  22         char time_str[MGMTD_COMMIT_TIME_STR_LEN];
  23         char cmt_json_file[PATH_MAX];
  24 };
  25
  26
  27 DECLARE_DLIST(mgmt_cmt_infos, struct mgmt_cmt_info_t, cmts);
  28
  29 #define FOREACH_CMT_REC(mm, cmt_info)                                          \
  30         frr_each_safe (mgmt_cmt_infos, &mm->cmts, cmt_info)
  31
  32 /*
  33  * The only instance of VTY session that has triggered an ongoing
  34  * config rollback operation.
  35  */
  36 static struct vty *rollback_vty = NULL;
  37
  38 static bool mgmt_history_record_exists(char *file_path)
  39 {
  40         int exist;
  41
  42         exist = access(file_path, F_OK);
  43         if (exist == 0)
  44                 return true;
  45         else
  46                 return false;
  47 }
  48
  49 static void mgmt_history_remove_file(char *name)
  50 {
  51         if (remove(name) == 0)
  52                 zlog_debug("Old commit info deletion succeeded");
  53         else
  54                 zlog_err("Old commit info deletion failed");
  55 }
  56
  57 static void mgmt_history_hash(const char *input_str, char *hash)
  58 {
  59         int i;
  60         unsigned char digest[MGMTD_MD5_HASH_LEN];
  61         MD5_CTX ctx;
  62
  63         memset(&ctx, 0, sizeof(ctx));
  64         MD5Init(&ctx);
  65         MD5Update(&ctx, input_str, strlen(input_str));
  66         MD5Final(digest, &ctx);
  67
  68         for (i = 0; i < MGMTD_MD5_HASH_LEN; i++)
  69                 snprintf(&hash[i * 2], MGMTD_MD5_HASH_STR_HEX_LEN, "%02x",
  70                          (unsigned int)digest[i]);
  71 }
  72
  73 static struct mgmt_cmt_info_t *mgmt_history_create_cmt_rec(void)
  74 {
  75         struct mgmt_cmt_info_t *new;
  76         struct mgmt_cmt_info_t *cmt_info;
  77         struct mgmt_cmt_info_t *last_cmt_info = NULL;
  78         struct timeval cmt_recd_tv;
  79
  80         new = XCALLOC(MTYPE_MGMTD_CMT_INFO, sizeof(struct mgmt_cmt_info_t));
  81         gettimeofday(&cmt_recd_tv, NULL);
  82         mgmt_realtime_to_string(&cmt_recd_tv, new->time_str,
  83                                 sizeof(new->time_str));
  84         mgmt_history_hash(new->time_str, new->cmtid_str);
  85         snprintf(new->cmt_json_file, sizeof(new->cmt_json_file),
  86                  MGMTD_COMMIT_FILE_PATH, new->cmtid_str);
  87
  88         if (mgmt_cmt_infos_count(&mm->cmts) == MGMTD_MAX_COMMIT_LIST) {
  89                 FOREACH_CMT_REC (mm, cmt_info)
  90                         last_cmt_info = cmt_info;
  91
  92                 if (last_cmt_info) {
  93                         mgmt_history_remove_file(last_cmt_info->cmt_json_file);
  94                         mgmt_cmt_infos_del(&mm->cmts, last_cmt_info);
  95                         XFREE(MTYPE_MGMTD_CMT_INFO, last_cmt_info);
  96                 }
  97         }
  98
  99         mgmt_cmt_infos_add_head(&mm->cmts, new);
 100         return new;
 101 }
 102
 103 static struct mgmt_cmt_info_t *mgmt_history_find_cmt_record(const char *cmtid_str)
 104 {
 105         struct mgmt_cmt_info_t *cmt_info;
 106
 107         FOREACH_CMT_REC (mm, cmt_info) {
 108                 if (strncmp(cmt_info->cmtid_str, cmtid_str,
 109                             MGMTD_MD5_HASH_STR_HEX_LEN) == 0)
 110                         return cmt_info;
 111         }
 112
 113         return NULL;
 114 }
 115
 116 static bool mgmt_history_read_cmt_record_index(void)
 117 {
 118         FILE *fp;
 119         struct mgmt_cmt_info_t cmt_info;
 120         struct mgmt_cmt_info_t *new;
 121         int cnt = 0;
 122
 123         fp = fopen(MGMTD_COMMIT_INDEX_FILE_NAME, "rb");
 124         if (!fp) {
 125                 zlog_err("Failed to open file %s rb mode",
 126                          MGMTD_COMMIT_INDEX_FILE_NAME);
 127                 return false;
 128         }
 129
 130         while ((fread(&cmt_info, sizeof(cmt_info), 1, fp)) > 0) {
 131                 if (cnt < MGMTD_MAX_COMMIT_LIST) {
 132                         if (!mgmt_history_record_exists(cmt_info.cmt_json_file)) {
 133                                 zlog_err(
 134                                         "Commit record present in index_file, but commit file %s missing",
 135                                         cmt_info.cmt_json_file);
 136                                 continue;
 137                         }
 138
 139                         new = XCALLOC(MTYPE_MGMTD_CMT_INFO,
 140                                       sizeof(struct mgmt_cmt_info_t));
 141                         memcpy(new, &cmt_info, sizeof(struct mgmt_cmt_info_t));
 142                         mgmt_cmt_infos_add_tail(&mm->cmts, new);
 143                 } else {
 144                         zlog_err("More records found in index file %s",
 145                                  MGMTD_COMMIT_INDEX_FILE_NAME);
 146                         return false;
 147                 }
 148
 149                 cnt++;
 150         }
 151
 152         fclose(fp);
 153         return true;
 154 }
 155
 156 static bool mgmt_history_dump_cmt_record_index(void)
 157 {
 158         FILE *fp;
 159         int ret = 0;
 160         struct mgmt_cmt_info_t *cmt_info;
 161         struct mgmt_cmt_info_t cmt_info_set[10];
 162         int cnt = 0;
 163
 164         mgmt_history_remove_file((char *)MGMTD_COMMIT_INDEX_FILE_NAME);
 165         fp = fopen(MGMTD_COMMIT_INDEX_FILE_NAME, "ab");
 166         if (!fp) {
 167                 zlog_err("Failed to open file %s ab mode",
 168                          MGMTD_COMMIT_INDEX_FILE_NAME);
 169                 return false;
 170         }
 171
 172         FOREACH_CMT_REC (mm, cmt_info) {
 173                 memcpy(&cmt_info_set[cnt], cmt_info,
 174                        sizeof(struct mgmt_cmt_info_t));
 175                 cnt++;
 176         }
 177
 178         if (!cnt) {
 179                 fclose(fp);
 180                 return false;
 181         }
 182
 183         ret = fwrite(&cmt_info_set, sizeof(struct mgmt_cmt_info_t), cnt, fp);
 184         fclose(fp);
 185         if (ret != cnt) {
 186                 zlog_err("Write record failed");
 187                 return false;
 188         } else {
 189                 return true;
 190         }
 191 }
 192
 193 static int mgmt_history_rollback_to_cmt(struct vty *vty,
 194                                    struct mgmt_cmt_info_t *cmt_info,
 195                                    bool skip_file_load)
 196 {
 197         struct mgmt_ds_ctx *src_ds_ctx;
 198         struct mgmt_ds_ctx *dst_ds_ctx;
 199         int ret = 0;
 200
 201         if (rollback_vty) {
 202                 vty_out(vty, "ERROR: Rollback already in progress!\n");
 203                 return -1;
 204         }
 205
 206         src_ds_ctx = mgmt_ds_get_ctx_by_id(mm, MGMTD_DS_CANDIDATE);
 207         if (!src_ds_ctx) {
 208                 vty_out(vty, "ERROR: Couldnot access Candidate datastore!\n");
 209                 return -1;
 210         }
 211
 212         /*
 213          * Note: Write lock on src_ds is not required. This is already
 214          * taken in 'conf te'.
 215          */
 216         dst_ds_ctx = mgmt_ds_get_ctx_by_id(mm, MGMTD_DS_RUNNING);
 217         if (!dst_ds_ctx) {
 218                 vty_out(vty, "ERROR: Couldnot access Running datastore!\n");
 219                 return -1;
 220         }
 221
 222         ret = mgmt_ds_write_lock(dst_ds_ctx);
 223         if (ret != 0) {
 224                 vty_out(vty,
 225                         "Failed to lock the DS %u for rollback Reason: %s!\n",
 226                         MGMTD_DS_RUNNING, strerror(ret));
 227                 return -1;
 228         }
 229
 230         if (!skip_file_load) {
 231                 ret = mgmt_ds_load_config_from_file(
 232                         src_ds_ctx, cmt_info->cmt_json_file, false);
 233                 if (ret != 0) {
 234                         mgmt_ds_unlock(dst_ds_ctx);
 235                         vty_out(vty,
 236                                 "Error with parsing the file with error code %d\n",
 237                                 ret);
 238                         return ret;
 239                 }
 240         }
 241
 242         /* Internally trigger a commit-request. */
 243         ret = mgmt_txn_rollback_trigger_cfg_apply(src_ds_ctx, dst_ds_ctx);
 244         if (ret != 0) {
 245                 mgmt_ds_unlock(dst_ds_ctx);
 246                 vty_out(vty,
 247                         "Error with creating commit apply txn with error code %d\n",
 248                         ret);
 249                 return ret;
 250         }
 251
 252         mgmt_history_dump_cmt_record_index();
 253
 254         /*
 255          * Block the rollback command from returning till the rollback
 256          * is completed. On rollback completion mgmt_history_rollback_complete()
 257          * shall be called to resume the rollback command return to VTYSH.
 258          */
 259         vty->mgmt_req_pending = true;
 260         rollback_vty = vty;
 261         return 0;
 262 }
 263
 264 void mgmt_history_rollback_complete(bool success)
 265 {
 266         vty_mgmt_resume_response(rollback_vty, success);
 267         rollback_vty = NULL;
 268 }
 269
 270 int mgmt_history_rollback_by_id(struct vty *vty, const char *cmtid_str)
 271 {
 272         int ret = 0;
 273         struct mgmt_cmt_info_t *cmt_info;
 274
 275         if (!mgmt_cmt_infos_count(&mm->cmts) ||
 276             !mgmt_history_find_cmt_record(cmtid_str)) {
 277                 vty_out(vty, "Invalid commit Id\n");
 278                 return -1;
 279         }
 280
 281         FOREACH_CMT_REC (mm, cmt_info) {
 282                 if (strncmp(cmt_info->cmtid_str, cmtid_str,
 283                             MGMTD_MD5_HASH_STR_HEX_LEN) == 0) {
 284                         ret = mgmt_history_rollback_to_cmt(vty, cmt_info, false);
 285                         return ret;
 286                 }
 287
 288                 mgmt_history_remove_file(cmt_info->cmt_json_file);
 289                 mgmt_cmt_infos_del(&mm->cmts, cmt_info);
 290                 XFREE(MTYPE_MGMTD_CMT_INFO, cmt_info);
 291         }
 292
 293         return 0;
 294 }
 295
 296 int mgmt_history_rollback_n(struct vty *vty, int num_cmts)
 297 {
 298         int ret = 0;
 299         int cnt = 0;
 300         struct mgmt_cmt_info_t *cmt_info;
 301         size_t cmts;
 302
 303         if (!num_cmts)
 304                 num_cmts = 1;
 305
 306         cmts = mgmt_cmt_infos_count(&mm->cmts);
 307         if ((int)cmts < num_cmts) {
 308                 vty_out(vty,
 309                         "Number of commits found (%d) less than required to rollback\n",
 310                         (int)cmts);
 311                 return -1;
 312         }
 313
 314         if ((int)cmts == 1 || (int)cmts == num_cmts) {
 315                 vty_out(vty,
 316                         "Number of commits found (%d), Rollback of last commit is not supported\n",
 317                         (int)cmts);
 318                 return -1;
 319         }
 320
 321         FOREACH_CMT_REC (mm, cmt_info) {
 322                 if (cnt == num_cmts) {
 323                         ret = mgmt_history_rollback_to_cmt(vty, cmt_info, false);
 324                         return ret;
 325                 }
 326
 327                 cnt++;
 328                 mgmt_history_remove_file(cmt_info->cmt_json_file);
 329                 mgmt_cmt_infos_del(&mm->cmts, cmt_info);
 330                 XFREE(MTYPE_MGMTD_CMT_INFO, cmt_info);
 331         }
 332
 333         if (!mgmt_cmt_infos_count(&mm->cmts)) {
 334                 mgmt_ds_reset_candidate();
 335                 ret = mgmt_history_rollback_to_cmt(vty, cmt_info, true);
 336         }
 337
 338         return ret;
 339 }
 340
 341 void show_mgmt_cmt_history(struct vty *vty)
 342 {
 343         struct mgmt_cmt_info_t *cmt_info;
 344         int slno = 0;
 345
 346         vty_out(vty, "Last 10 commit history:\n");
 347         vty_out(vty, "  Sl.No\tCommit-ID(HEX)\t\t\t  Commit-Record-Time\n");
 348         FOREACH_CMT_REC (mm, cmt_info) {
 349                 vty_out(vty, "  %d\t%s  %s\n", slno, cmt_info->cmtid_str,
 350                         cmt_info->time_str);
 351                 slno++;
 352         }
 353 }
 354
 355 void mgmt_history_new_record(struct mgmt_ds_ctx *ds_ctx)
 356 {
 357         struct mgmt_cmt_info_t *cmt_info = mgmt_history_create_cmt_rec();
 358         mgmt_ds_dump_ds_to_file(cmt_info->cmt_json_file, ds_ctx);
 359         mgmt_history_dump_cmt_record_index();
 360 }
 361
 362 void mgmt_history_init(void)
 363 {
 364         /* Create commit record for previously stored commit-apply */
 365         mgmt_cmt_infos_init(&mm->cmts);
 366         mgmt_history_read_cmt_record_index();
 367 }
 368
 369 void mgmt_history_destroy(void)
 370 {
 371         struct mgmt_cmt_info_t *cmt_info;
 372
 373         FOREACH_CMT_REC(mm, cmt_info) {
 374                 mgmt_cmt_infos_del(&mm->cmts, cmt_info);
 375                 XFREE(MTYPE_MGMTD_CMT_INFO, cmt_info);
 376         }
 377
 378         mgmt_cmt_infos_fini(&mm->cmts);
 379 }