src/vpp/api/api.c

   1 /*
   2  *------------------------------------------------------------------
   3  * api.c - message handler registration
   4  *
   5  * Copyright (c) 2010-2018 Cisco and/or its affiliates.
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *------------------------------------------------------------------
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <sys/types.h>
  24 #include <sys/mman.h>
  25 #include <sys/stat.h>
  26 #include <netinet/in.h>
  27 #include <signal.h>
  28 #include <pthread.h>
  29 #include <unistd.h>
  30 #include <time.h>
  31 #include <fcntl.h>
  32 #include <string.h>
  33 #include <pwd.h>
  34 #include <grp.h>
  35
  36 #include <vppinfra/clib.h>
  37 #include <vppinfra/vec.h>
  38 #include <vppinfra/hash.h>
  39 #include <vppinfra/bitmap.h>
  40 #include <vppinfra/fifo.h>
  41 #include <vppinfra/time.h>
  42 #include <vppinfra/heap.h>
  43 #include <vppinfra/pool.h>
  44 #include <vppinfra/format.h>
  45 #include <vppinfra/error.h>
  46
  47 #include <vnet/api_errno.h>
  48 #include <vnet/vnet.h>
  49
  50 #include <vlib/log.h>
  51 #include <vlib/vlib.h>
  52 #include <vlib/unix/unix.h>
  53 #include <vlibapi/api.h>
  54 #include <vlibmemory/api.h>
  55
  56 #undef BIHASH_TYPE
  57 #undef __included_bihash_template_h__
  58
  59 #include <vnet/ip/format.h>
  60
  61 #include <vpp/api/vpe_msg_enum.h>
  62 #include <vpp/api/types.h>
  63 #include <vnet/classify/classify.api_enum.h>
  64 #include <vnet/ip/ip.api_enum.h>
  65
  66 #define vl_typedefs             /* define message structures */
  67 #include <vpp/api/vpe_all_api_h.h>
  68 #undef vl_typedefs
  69 #define vl_endianfun            /* define message structures */
  70 #include <vpp/api/vpe_all_api_h.h>
  71 #undef vl_endianfun
  72 /* instantiate all the print functions we know about */
  73 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  74 #define vl_printfun
  75 #include <vpp/api/vpe_all_api_h.h>
  76 #undef vl_printfun
  77 #include <vlibapi/api_helper_macros.h>
  78
  79 #define foreach_vpe_api_msg                                             \
  80 _(CONTROL_PING, control_ping)                                           \
  81 _(CLI, cli)                                                             \
  82 _(CLI_INBAND, cli_inband)                                                                       \
  83 _(GET_NODE_INDEX, get_node_index)                                       \
  84 _(ADD_NODE_NEXT, add_node_next)                                                             \
  85 _(SHOW_VERSION, show_version)                                                               \
  86 _(SHOW_THREADS, show_threads)                                                               \
  87 _(GET_NODE_GRAPH, get_node_graph)                                       \
  88 _(GET_NEXT_INDEX, get_next_index)                                       \
  89 _(LOG_DUMP, log_dump)                                                   \
  90 _(SHOW_VPE_SYSTEM_TIME, show_vpe_system_time)                           \
  91 _(GET_F64_ENDIAN_VALUE, get_f64_endian_value)                                                   \
  92 _(GET_F64_INCREMENT_BY_ONE, get_f64_increment_by_one)                                   \
  93
  94 #define QUOTE_(x) #x
  95 #define QUOTE(x) QUOTE_(x)
  96
  97 typedef enum
  98 {
  99   RESOLVE_IP4_ADD_DEL_ROUTE = 1,
 100   RESOLVE_IP6_ADD_DEL_ROUTE,
 101 } resolve_t;
 102
 103 extern vpe_api_main_t vpe_api_main;
 104
 105 /* Clean up all registrations belonging to the indicated client */
 106 static clib_error_t *
 107 memclnt_delete_callback (u32 client_index)
 108 {
 109   vpe_api_main_t *vam = &vpe_api_main;
 110   vpe_client_registration_t *rp;
 111   uword *p;
 112
 113 #define _(a)                                                    \
 114     p = hash_get (vam->a##_registration_hash, client_index);    \
 115     if (p) {                                                    \
 116         rp = pool_elt_at_index (vam->a##_registrations, p[0]);  \
 117         pool_put (vam->a##_registrations, rp);                  \
 118         hash_unset (vam->a##_registration_hash, client_index);  \
 119     }
 120   foreach_registration_hash;
 121 #undef _
 122   return 0;
 123 }
 124
 125 VL_MSG_API_REAPER_FUNCTION (memclnt_delete_callback);
 126
 127 static void
 128 vl_api_control_ping_t_handler (vl_api_control_ping_t * mp)
 129 {
 130   vl_api_control_ping_reply_t *rmp;
 131   int rv = 0;
 132
 133   /* *INDENT-OFF* */
 134   REPLY_MACRO2(VL_API_CONTROL_PING_REPLY,
 135   ({
 136     rmp->vpe_pid = ntohl (getpid());
 137   }));
 138   /* *INDENT-ON* */
 139 }
 140
 141 static void
 142 shmem_cli_output (uword arg, u8 * buffer, uword buffer_bytes)
 143 {
 144   u8 **shmem_vecp = (u8 **) arg;
 145   u8 *shmem_vec;
 146   void *oldheap;
 147   u32 offset;
 148
 149   shmem_vec = *shmem_vecp;
 150
 151   offset = vec_len (shmem_vec);
 152
 153   oldheap = vl_msg_push_heap ();
 154
 155   vec_validate (shmem_vec, offset + buffer_bytes - 1);
 156
 157   clib_memcpy (shmem_vec + offset, buffer, buffer_bytes);
 158
 159   vl_msg_pop_heap (oldheap);
 160
 161   *shmem_vecp = shmem_vec;
 162 }
 163
 164
 165 static void
 166 vl_api_cli_t_handler (vl_api_cli_t * mp)
 167 {
 168   vl_api_cli_reply_t *rp;
 169   vl_api_registration_t *reg;
 170   vlib_main_t *vm = vlib_get_main ();
 171   unformat_input_t input;
 172   u8 *shmem_vec = 0;
 173   void *oldheap;
 174
 175   reg = vl_api_client_index_to_registration (mp->client_index);
 176   if (!reg)
 177     return;;
 178
 179   rp = vl_msg_api_alloc (sizeof (*rp));
 180   rp->_vl_msg_id = ntohs (VL_API_CLI_REPLY);
 181   rp->context = mp->context;
 182
 183   unformat_init_vector (&input, (u8 *) (uword) mp->cmd_in_shmem);
 184
 185   vlib_cli_input (vm, &input, shmem_cli_output, (uword) & shmem_vec);
 186
 187   oldheap = vl_msg_push_heap ();
 188   vec_add1 (shmem_vec, 0);
 189   vl_msg_pop_heap (oldheap);
 190
 191   rp->reply_in_shmem = (uword) shmem_vec;
 192
 193   vl_api_send_msg (reg, (u8 *) rp);
 194 }
 195
 196 static void
 197 inband_cli_output (uword arg, u8 * buffer, uword buffer_bytes)
 198 {
 199   u8 **mem_vecp = (u8 **) arg;
 200   u8 *mem_vec = *mem_vecp;
 201   u32 offset = vec_len (mem_vec);
 202
 203   vec_validate (mem_vec, offset + buffer_bytes - 1);
 204   clib_memcpy (mem_vec + offset, buffer, buffer_bytes);
 205   *mem_vecp = mem_vec;
 206 }
 207
 208 static void
 209 vl_api_cli_inband_t_handler (vl_api_cli_inband_t * mp)
 210 {
 211   vl_api_cli_inband_reply_t *rmp;
 212   int rv = 0;
 213   vlib_main_t *vm = vlib_get_main ();
 214   unformat_input_t input;
 215   u8 *out_vec = 0;
 216   u8 *cmd_vec = 0;
 217
 218   if (vl_msg_api_get_msg_length (mp) <
 219       vl_api_string_len (&mp->cmd) + sizeof (*mp))
 220     {
 221       rv = -1;
 222       goto error;
 223     }
 224
 225   cmd_vec = vl_api_from_api_to_new_vec (mp, &mp->cmd);
 226
 227   unformat_init_string (&input, (char *) cmd_vec,
 228                         vl_api_string_len (&mp->cmd));
 229   rv = vlib_cli_input (vm, &input, inband_cli_output, (uword) & out_vec);
 230   unformat_free (&input);
 231
 232 error:
 233   /* *INDENT-OFF* */
 234   REPLY_MACRO3(VL_API_CLI_INBAND_REPLY, vec_len (out_vec),
 235   ({
 236     vl_api_vec_to_api_string(out_vec, &rmp->reply);
 237   }));
 238   /* *INDENT-ON* */
 239   vec_free (out_vec);
 240   vec_free (cmd_vec);
 241 }
 242
 243 static void
 244 vl_api_show_version_t_handler (vl_api_show_version_t * mp)
 245 {
 246   vl_api_show_version_reply_t *rmp;
 247   int rv = 0;
 248   char *vpe_api_get_build_directory (void);
 249   char *vpe_api_get_version (void);
 250   char *vpe_api_get_build_date (void);
 251
 252   /* *INDENT-OFF* */
 253   REPLY_MACRO2(VL_API_SHOW_VERSION_REPLY,
 254   ({
 255     strncpy ((char *) rmp->program, "vpe", ARRAY_LEN(rmp->program)-1);
 256     strncpy ((char *) rmp->build_directory, vpe_api_get_build_directory(),
 257              ARRAY_LEN(rmp->build_directory)-1);
 258     strncpy ((char *) rmp->version, vpe_api_get_version(),
 259              ARRAY_LEN(rmp->version)-1);
 260     strncpy ((char *) rmp->build_date, vpe_api_get_build_date(),
 261              ARRAY_LEN(rmp->build_date)-1);
 262   }));
 263   /* *INDENT-ON* */
 264 }
 265
 266 static void
 267 get_thread_data (vl_api_thread_data_t * td, int index)
 268 {
 269   vlib_worker_thread_t *w = vlib_worker_threads + index;
 270   td->id = htonl (index);
 271   if (w->name)
 272     strncpy ((char *) td->name, (char *) w->name, ARRAY_LEN (td->name) - 1);
 273   if (w->registration)
 274     strncpy ((char *) td->type, (char *) w->registration->name,
 275              ARRAY_LEN (td->type) - 1);
 276   td->pid = htonl (w->lwp);
 277   td->cpu_id = htonl (w->cpu_id);
 278   td->core = htonl (w->core_id);
 279   td->cpu_socket = htonl (w->numa_id);
 280 }
 281
 282 static void
 283 vl_api_show_threads_t_handler (vl_api_show_threads_t * mp)
 284 {
 285   int count = 0;
 286
 287 #if !defined(__powerpc64__)
 288   vl_api_registration_t *reg;
 289   vl_api_show_threads_reply_t *rmp;
 290   vl_api_thread_data_t *td;
 291   int i, msg_size = 0;
 292   count = vec_len (vlib_worker_threads);
 293   if (!count)
 294     return;
 295
 296   msg_size = sizeof (*rmp) + sizeof (rmp->thread_data[0]) * count;
 297   reg = vl_api_client_index_to_registration (mp->client_index);
 298   if (!reg)
 299     return;
 300
 301   rmp = vl_msg_api_alloc (msg_size);
 302   clib_memset (rmp, 0, msg_size);
 303   rmp->_vl_msg_id = htons (VL_API_SHOW_THREADS_REPLY);
 304   rmp->context = mp->context;
 305   rmp->count = htonl (count);
 306   td = rmp->thread_data;
 307
 308   for (i = 0; i < count; i++)
 309     {
 310       get_thread_data (&td[i], i);
 311     }
 312
 313   vl_api_send_msg (reg, (u8 *) rmp);
 314 #else
 315
 316   /* unimplemented support */
 317   rv = -9;
 318   clib_warning ("power pc does not support show threads api");
 319   /* *INDENT-OFF* */
 320   REPLY_MACRO2(VL_API_SHOW_THREADS_REPLY,
 321   ({
 322     rmp->count = htonl(count);
 323   }));
 324   /* *INDENT-ON* */
 325 #endif
 326 }
 327
 328 static void
 329 vl_api_get_node_index_t_handler (vl_api_get_node_index_t * mp)
 330 {
 331   vlib_main_t *vm = vlib_get_main ();
 332   vl_api_get_node_index_reply_t *rmp;
 333   vlib_node_t *n;
 334   int rv = 0;
 335   u32 node_index = ~0;
 336
 337   n = vlib_get_node_by_name (vm, mp->node_name);
 338
 339   if (n == 0)
 340     rv = VNET_API_ERROR_NO_SUCH_NODE;
 341   else
 342     node_index = n->index;
 343
 344   /* *INDENT-OFF* */
 345   REPLY_MACRO2(VL_API_GET_NODE_INDEX_REPLY,
 346   ({
 347     rmp->node_index = htonl(node_index);
 348   }));
 349   /* *INDENT-ON* */
 350 }
 351
 352 static void
 353 vl_api_get_next_index_t_handler (vl_api_get_next_index_t * mp)
 354 {
 355   vlib_main_t *vm = vlib_get_main ();
 356   vl_api_get_next_index_reply_t *rmp;
 357   vlib_node_t *node, *next_node;
 358   int rv = 0;
 359   u32 next_node_index = ~0, next_index = ~0;
 360   uword *p;
 361
 362   node = vlib_get_node_by_name (vm, mp->node_name);
 363
 364   if (node == 0)
 365     {
 366       rv = VNET_API_ERROR_NO_SUCH_NODE;
 367       goto out;
 368     }
 369
 370   next_node = vlib_get_node_by_name (vm, mp->next_name);
 371
 372   if (next_node == 0)
 373     {
 374       rv = VNET_API_ERROR_NO_SUCH_NODE2;
 375       goto out;
 376     }
 377   else
 378     next_node_index = next_node->index;
 379
 380   p = hash_get (node->next_slot_by_node, next_node_index);
 381
 382   if (p == 0)
 383     {
 384       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
 385       goto out;
 386     }
 387   else
 388     next_index = p[0];
 389
 390 out:
 391   /* *INDENT-OFF* */
 392   REPLY_MACRO2(VL_API_GET_NEXT_INDEX_REPLY,
 393   ({
 394     rmp->next_index = htonl(next_index);
 395   }));
 396   /* *INDENT-ON* */
 397 }
 398
 399 static void
 400 vl_api_add_node_next_t_handler (vl_api_add_node_next_t * mp)
 401 {
 402   vlib_main_t *vm = vlib_get_main ();
 403   vl_api_add_node_next_reply_t *rmp;
 404   vlib_node_t *n, *next;
 405   int rv = 0;
 406   u32 next_index = ~0;
 407
 408   n = vlib_get_node_by_name (vm, mp->node_name);
 409
 410   if (n == 0)
 411     {
 412       rv = VNET_API_ERROR_NO_SUCH_NODE;
 413       goto out;
 414     }
 415
 416   next = vlib_get_node_by_name (vm, mp->next_name);
 417
 418   if (next == 0)
 419     rv = VNET_API_ERROR_NO_SUCH_NODE2;
 420   else
 421     next_index = vlib_node_add_next (vm, n->index, next->index);
 422
 423 out:
 424   /* *INDENT-OFF* */
 425   REPLY_MACRO2(VL_API_ADD_NODE_NEXT_REPLY,
 426   ({
 427     rmp->next_index = htonl(next_index);
 428   }));
 429   /* *INDENT-ON* */
 430 }
 431
 432 static void
 433 vl_api_get_node_graph_t_handler (vl_api_get_node_graph_t * mp)
 434 {
 435   int rv = 0;
 436   u8 *vector = 0;
 437   vlib_main_t *vm = vlib_get_main ();
 438   void *oldheap;
 439   vl_api_get_node_graph_reply_t *rmp;
 440   static vlib_node_t ***node_dups;
 441   static vlib_main_t **stat_vms;
 442
 443   oldheap = vl_msg_push_heap ();
 444
 445   /*
 446    * Keep the number of memcpy ops to a minimum (e.g. 1).
 447    */
 448   vec_validate (vector, 16384);
 449   vec_reset_length (vector);
 450
 451   vlib_node_get_nodes (vm, 0 /* main threads */ ,
 452                        0 /* include stats */ ,
 453                        1 /* barrier sync */ ,
 454                        &node_dups, &stat_vms);
 455   vector = vlib_node_serialize (vm, node_dups, vector, 1 /* include nexts */ ,
 456                                 1 /* include stats */ );
 457
 458   vl_msg_pop_heap (oldheap);
 459
 460   /* *INDENT-OFF* */
 461   REPLY_MACRO2(VL_API_GET_NODE_GRAPH_REPLY,
 462   ({
 463     rmp->reply_in_shmem = (uword) vector;
 464   }));
 465   /* *INDENT-ON* */
 466 }
 467
 468 static void
 469 show_log_details (vl_api_registration_t * reg, u32 context,
 470                   f64 timestamp,
 471                   vl_api_log_level_t * level, u8 * msg_class, u8 * message)
 472 {
 473   u32 msg_size;
 474
 475   vl_api_log_details_t *rmp;
 476   int class_len =
 477     clib_min (vec_len (msg_class) + 1, ARRAY_LEN (rmp->msg_class));
 478   int message_len =
 479     clib_min (vec_len (message) + 1, ARRAY_LEN (rmp->message));
 480   msg_size = sizeof (*rmp) + class_len + message_len;
 481
 482   rmp = vl_msg_api_alloc (msg_size);
 483   clib_memset (rmp, 0, msg_size);
 484   rmp->_vl_msg_id = ntohs (VL_API_LOG_DETAILS);
 485
 486   rmp->context = context;
 487   rmp->timestamp = clib_host_to_net_f64 (timestamp);
 488   rmp->level = htonl (*level);
 489
 490   memcpy (rmp->msg_class, msg_class, class_len - 1);
 491   memcpy (rmp->message, message, message_len - 1);
 492   /* enforced by memset() above */
 493   ASSERT (0 == rmp->msg_class[class_len - 1]);
 494   ASSERT (0 == rmp->message[message_len - 1]);
 495
 496   vl_api_send_msg (reg, (u8 *) rmp);
 497 }
 498
 499 static void
 500 vl_api_log_dump_t_handler (vl_api_log_dump_t * mp)
 501 {
 502
 503   /* from log.c */
 504   vlib_log_main_t *lm = &log_main;
 505   vlib_log_entry_t *e;
 506   int i = last_log_entry ();
 507   int count = lm->count;
 508   f64 time_offset, start_time;
 509   vl_api_registration_t *reg;
 510
 511   reg = vl_api_client_index_to_registration (mp->client_index);
 512   if (reg == 0)
 513     return;
 514
 515   start_time = clib_net_to_host_f64 (mp->start_timestamp);
 516
 517   time_offset = (f64) lm->time_zero_timeval.tv_sec
 518     + (((f64) lm->time_zero_timeval.tv_usec) * 1e-6) - lm->time_zero;
 519
 520   while (count--)
 521     {
 522       e = vec_elt_at_index (lm->entries, i);
 523       if (start_time <= e->timestamp + time_offset)
 524         show_log_details (reg, mp->context, e->timestamp + time_offset,
 525                           (vl_api_log_level_t *) & e->level,
 526                           format (0, "%U", format_vlib_log_class, e->class),
 527                           e->string);
 528       i = (i + 1) % lm->size;
 529     }
 530
 531 }
 532
 533 static void
 534 vl_api_show_vpe_system_time_t_handler (vl_api_show_vpe_system_time_t * mp)
 535 {
 536   int rv = 0;
 537   vl_api_show_vpe_system_time_reply_t *rmp;
 538   /* *INDENT-OFF* */
 539   REPLY_MACRO2(VL_API_SHOW_VPE_SYSTEM_TIME_REPLY,
 540   ({
 541     rmp->vpe_system_time = clib_host_to_net_f64 (unix_time_now ());
 542   }));
 543   /* *INDENT-ON* */
 544 }
 545
 546 static void
 547 vl_api_get_f64_endian_value_t_handler (vl_api_get_f64_endian_value_t * mp)
 548 {
 549   int rv = 0;
 550   f64 one = 1.0;
 551   vl_api_get_f64_endian_value_reply_t *rmp;
 552   if (1.0 != clib_net_to_host_f64 (mp->f64_one))
 553     rv = VNET_API_ERROR_API_ENDIAN_FAILED;
 554
 555   /* *INDENT-OFF* */
 556   REPLY_MACRO2(VL_API_GET_F64_ENDIAN_VALUE_REPLY,
 557   ({
 558     rmp->f64_one_result = clib_host_to_net_f64 (one);
 559   }));
 560   /* *INDENT-ON* */
 561 }
 562
 563 static void
 564 vl_api_get_f64_increment_by_one_t_handler (vl_api_get_f64_increment_by_one_t *
 565                                            mp)
 566 {
 567   int rv = 0;
 568   vl_api_get_f64_increment_by_one_reply_t *rmp;
 569
 570   /* *INDENT-OFF* */
 571   REPLY_MACRO2(VL_API_GET_F64_INCREMENT_BY_ONE_REPLY,
 572   ({
 573     rmp->f64_value = clib_host_to_net_f64 (clib_net_to_host_f64(mp->f64_value) + 1.0);
 574   }));
 575   /* *INDENT-ON* */
 576 }
 577
 578 #define BOUNCE_HANDLER(nn)                                              \
 579 static void vl_api_##nn##_t_handler (                                   \
 580     vl_api_##nn##_t *mp)                                                \
 581 {                                                                       \
 582     vpe_client_registration_t *reg;                                     \
 583     vpe_api_main_t * vam = &vpe_api_main;                               \
 584     svm_queue_t * q;                                     \
 585                                                                         \
 586     /* One registration only... */                                      \
 587     pool_foreach (reg, vam->nn##_registrations)                          \
 588     ({                                                                  \
 589         q = vl_api_client_index_to_input_queue (reg->client_index);     \
 590         if (q) {                                                        \
 591             /*                                                          \
 592              * If the queue is stuffed, turf the msg and complain       \
 593              * It's unlikely that the intended recipient is             \
 594              * alive; avoid deadlock at all costs.                      \
 595              */                                                         \
 596             if (q->cursize == q->maxsize) {                             \
 597                 clib_warning ("ERROR: receiver queue full, drop msg");  \
 598                 vl_msg_api_free (mp);                                   \
 599                 return;                                                 \
 600             }                                                           \
 601             vl_msg_api_send_shmem (q, (u8 *)&mp);                       \
 602             return;                                                     \
 603         }                                                               \
 604     }));                                                                \
 605     vl_msg_api_free (mp);                                               \
 606 }
 607
 608 static void setup_message_id_table (api_main_t * am);
 609
 610 /*
 611  * vpe_api_hookup
 612  * Add vpe's API message handlers to the table.
 613  * vlib has already mapped shared memory and
 614  * added the client registration handlers.
 615  * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process()
 616  */
 617 static clib_error_t *
 618 vpe_api_hookup (vlib_main_t * vm)
 619 {
 620   api_main_t *am = vlibapi_get_main ();
 621
 622 #define _(N,n)                                                  \
 623     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
 624                            vl_api_##n##_t_handler,              \
 625                            vl_noop_handler,                     \
 626                            vl_api_##n##_t_endian,               \
 627                            vl_api_##n##_t_print,                \
 628                            sizeof(vl_api_##n##_t), 1);
 629   foreach_vpe_api_msg;
 630 #undef _
 631
 632   /*
 633    * Trace space for classifier mask+match
 634    */
 635   am->api_trace_cfg[VL_API_CLASSIFY_ADD_DEL_TABLE].size += 5 * sizeof (u32x4);
 636   am->api_trace_cfg[VL_API_CLASSIFY_ADD_DEL_SESSION].size +=
 637     5 * sizeof (u32x4);
 638
 639   /*
 640    * Thread-safe API messages
 641    */
 642   am->is_mp_safe[VL_API_CONTROL_PING] = 1;
 643   am->is_mp_safe[VL_API_CONTROL_PING_REPLY] = 1;
 644   am->is_mp_safe[VL_API_IP_ROUTE_ADD_DEL] = 1;
 645   am->is_mp_safe[VL_API_GET_NODE_GRAPH] = 1;
 646
 647   /*
 648    * Set up the (msg_name, crc, message-id) table
 649    */
 650   setup_message_id_table (am);
 651
 652   return 0;
 653 }
 654
 655 VLIB_API_INIT_FUNCTION (vpe_api_hookup);
 656
 657 clib_error_t *
 658 vpe_api_init (vlib_main_t * vm)
 659 {
 660   vpe_api_main_t *am = &vpe_api_main;
 661
 662   am->vlib_main = vm;
 663   am->vnet_main = vnet_get_main ();
 664 #define _(a)                                                    \
 665   am->a##_registration_hash = hash_create (0, sizeof (uword));
 666   foreach_registration_hash;
 667 #undef _
 668
 669   vl_set_memory_region_name ("/vpe-api");
 670   vl_mem_api_enable_disable (vm, 1 /* enable it */ );
 671
 672   return 0;
 673 }
 674
 675 static clib_error_t *
 676 api_segment_config (vlib_main_t * vm, unformat_input_t * input)
 677 {
 678   u8 *chroot_path;
 679   u64 baseva, size, pvt_heap_size;
 680   int uid, gid, rv;
 681   const int max_buf_size = 4096;
 682   char *s, *buf;
 683   struct passwd _pw, *pw;
 684   struct group _grp, *grp;
 685   clib_error_t *e;
 686   buf = vec_new (char, 128);
 687   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 688     {
 689       if (unformat (input, "prefix %s", &chroot_path))
 690         {
 691           vec_add1 (chroot_path, 0);
 692           vl_set_memory_root_path ((char *) chroot_path);
 693         }
 694       else if (unformat (input, "uid %d", &uid))
 695         vl_set_memory_uid (uid);
 696       else if (unformat (input, "gid %d", &gid))
 697         vl_set_memory_gid (gid);
 698       else if (unformat (input, "baseva %llx", &baseva))
 699         vl_set_global_memory_baseva (baseva);
 700       else if (unformat (input, "global-size %lldM", &size))
 701         vl_set_global_memory_size (size * (1ULL << 20));
 702       else if (unformat (input, "global-size %lldG", &size))
 703         vl_set_global_memory_size (size * (1ULL << 30));
 704       else if (unformat (input, "global-size %lld", &size))
 705         vl_set_global_memory_size (size);
 706       else if (unformat (input, "global-pvt-heap-size %lldM", &pvt_heap_size))
 707         vl_set_global_pvt_heap_size (pvt_heap_size * (1ULL << 20));
 708       else if (unformat (input, "global-pvt-heap-size size %lld",
 709                          &pvt_heap_size))
 710         vl_set_global_pvt_heap_size (pvt_heap_size);
 711       else if (unformat (input, "api-pvt-heap-size %lldM", &pvt_heap_size))
 712         vl_set_api_pvt_heap_size (pvt_heap_size * (1ULL << 20));
 713       else if (unformat (input, "api-pvt-heap-size size %lld",
 714                          &pvt_heap_size))
 715         vl_set_api_pvt_heap_size (pvt_heap_size);
 716       else if (unformat (input, "api-size %lldM", &size))
 717         vl_set_api_memory_size (size * (1ULL << 20));
 718       else if (unformat (input, "api-size %lldG", &size))
 719         vl_set_api_memory_size (size * (1ULL << 30));
 720       else if (unformat (input, "api-size %lld", &size))
 721         vl_set_api_memory_size (size);
 722       else if (unformat (input, "uid %s", &s))
 723         {
 724           /* lookup the username */
 725           pw = NULL;
 726           while (((rv =
 727                    getpwnam_r (s, &_pw, buf, vec_len (buf), &pw)) == ERANGE)
 728                  && (vec_len (buf) <= max_buf_size))
 729             {
 730               vec_resize (buf, vec_len (buf) * 2);
 731             }
 732           if (rv < 0)
 733             {
 734               e = clib_error_return_code (0, rv,
 735                                           CLIB_ERROR_ERRNO_VALID |
 736                                           CLIB_ERROR_FATAL,
 737                                           "cannot fetch username %s", s);
 738               vec_free (s);
 739               vec_free (buf);
 740               return e;
 741             }
 742           if (pw == NULL)
 743             {
 744               e =
 745                 clib_error_return_fatal (0, "username %s does not exist", s);
 746               vec_free (s);
 747               vec_free (buf);
 748               return e;
 749             }
 750           vec_free (s);
 751           vl_set_memory_uid (pw->pw_uid);
 752         }
 753       else if (unformat (input, "gid %s", &s))
 754         {
 755           /* lookup the group name */
 756           grp = NULL;
 757           while (((rv =
 758                    getgrnam_r (s, &_grp, buf, vec_len (buf),
 759                                &grp)) == ERANGE)
 760                  && (vec_len (buf) <= max_buf_size))
 761             {
 762               vec_resize (buf, vec_len (buf) * 2);
 763             }
 764           if (rv != 0)
 765             {
 766               e = clib_error_return_code (0, rv,
 767                                           CLIB_ERROR_ERRNO_VALID |
 768                                           CLIB_ERROR_FATAL,
 769                                           "cannot fetch group %s", s);
 770               vec_free (s);
 771               vec_free (buf);
 772               return e;
 773             }
 774           if (grp == NULL)
 775             {
 776               e = clib_error_return_fatal (0, "group %s does not exist", s);
 777               vec_free (s);
 778               vec_free (buf);
 779               return e;
 780             }
 781           vec_free (s);
 782           vec_free (buf);
 783           vl_set_memory_gid (grp->gr_gid);
 784         }
 785       else
 786         return clib_error_return (0, "unknown input `%U'",
 787                                   format_unformat_error, input);
 788     }
 789   return 0;
 790 }
 791
 792 VLIB_EARLY_CONFIG_FUNCTION (api_segment_config, "api-segment");
 793
 794 void *
 795 get_unformat_vnet_sw_interface (void)
 796 {
 797   return (void *) &unformat_vnet_sw_interface;
 798 }
 799
 800 #define vl_msg_name_crc_list
 801 #include <vpp/api/vpe_all_api_h.h>
 802 #undef vl_msg_name_crc_list
 803
 804 static void
 805 setup_message_id_table (api_main_t * am)
 806 {
 807 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
 808   foreach_vl_msg_name_crc_memclnt;
 809   foreach_vl_msg_name_crc_vpe;
 810 #undef _
 811
 812 #define vl_api_version_tuple(n,mj, mi, p) \
 813   vl_msg_api_add_version (am, #n, mj, mi, p);
 814 #include <vpp/api/vpe_all_api_h.h>
 815 #undef vl_api_version_tuple
 816 }
 817
 818
 819 /*
 820  * fd.io coding-style-patch-verification: ON
 821  *
 822  * Local Variables:
 823  * eval: (c-set-style "gnu")
 824  * End:
 825  */