src/vlib/buffer.h

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 /*
  16  * buffer.h: VLIB buffers
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining
  21  * a copy of this software and associated documentation files (the
  22  * "Software"), to deal in the Software without restriction, including
  23  * without limitation the rights to use, copy, modify, merge, publish,
  24  * distribute, sublicense, and/or sell copies of the Software, and to
  25  * permit persons to whom the Software is furnished to do so, subject to
  26  * the following conditions:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  31  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  34  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  35  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  36  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38  */
  39
  40 #ifndef included_vlib_buffer_h
  41 #define included_vlib_buffer_h
  42
  43 #include <vppinfra/types.h>
  44 #include <vppinfra/cache.h>
  45 #include <vppinfra/serialize.h>
  46 #include <vppinfra/vector.h>
  47 #include <vppinfra/lock.h>
  48 #include <vlib/error.h>         /* for vlib_error_t */
  49
  50 #include <vlib/config.h>        /* for __PRE_DATA_SIZE */
  51 #define VLIB_BUFFER_DATA_SIZE           (2048)
  52 #define VLIB_BUFFER_PRE_DATA_SIZE       __PRE_DATA_SIZE
  53
  54 /* Minimum buffer chain segment size. Does not apply to last buffer in chain.
  55    Dataplane code can safely asume that specified amount of data is not split
  56    into 2 chained buffers */
  57 #define VLIB_BUFFER_MIN_CHAIN_SEG_SIZE  (128)
  58
  59 /* Amount of head buffer data copied to each replica head buffer */
  60 #define VLIB_BUFFER_CLONE_HEAD_SIZE (256)
  61
  62 typedef u8 vlib_buffer_free_list_index_t;
  63
  64 /** \file
  65     vlib buffer structure definition and a few select
  66     access methods. This structure and the buffer allocation
  67     mechanism should perhaps live in vnet, but it would take a lot
  68     of typing to make it so.
  69 */
  70
  71 /**
  72  * Buffer Flags
  73  */
  74 #define foreach_vlib_buffer_flag \
  75   _( 0, NON_DEFAULT_FREELIST, "non-default-fl")         \
  76   _( 1, IS_TRACED, 0)                                   \
  77   _( 2, NEXT_PRESENT, 0)                                \
  78   _( 3, TOTAL_LENGTH_VALID, 0)                          \
  79   _( 4, EXT_HDR_VALID, "ext-hdr-valid")
  80
  81 /* NOTE: only buffer generic flags should be defined here, please consider
  82    using user flags. i.e. src/vnet/buffer.h */
  83
  84 enum
  85 {
  86 #define _(bit, name, v) VLIB_BUFFER_##name  = (1 << (bit)),
  87   foreach_vlib_buffer_flag
  88 #undef _
  89 };
  90
  91 enum
  92 {
  93 #define _(bit, name, v) VLIB_BUFFER_LOG2_##name  = (bit),
  94   foreach_vlib_buffer_flag
  95 #undef _
  96 };
  97
  98   /* User defined buffer flags. */
  99 #define LOG2_VLIB_BUFFER_FLAG_USER(n) (32 - (n))
 100 #define VLIB_BUFFER_FLAG_USER(n) (1 << LOG2_VLIB_BUFFER_FLAG_USER(n))
 101 #define VLIB_BUFFER_FLAGS_ALL (0x1f)
 102
 103 /* VLIB buffer representation. */
 104 typedef struct
 105 {
 106   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
 107   STRUCT_MARK (template_start);
 108   /* Offset within data[] that we are currently processing.
 109      If negative current header points into predata area. */
 110   i16 current_data;  /**< signed offset in data[], pre_data[]
 111                         that we are currently processing.
 112                         If negative current header points into predata area.
 113                      */
 114   u16 current_length;  /**< Nbytes between current data and
 115                           the end of this buffer.
 116                        */
 117   u32 flags; /**< buffer flags:
 118                 <br> VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index,
 119                 <br> VLIB_BUFFER_IS_TRACED: trace this buffer.
 120                 <br> VLIB_BUFFER_NEXT_PRESENT: this is a multi-chunk buffer.
 121                 <br> VLIB_BUFFER_TOTAL_LENGTH_VALID: as it says
 122                 <br> VLIB_BUFFER_EXT_HDR_VALID: buffer contains valid external buffer manager header,
 123                 set to avoid adding it to a flow report
 124                 <br> VLIB_BUFFER_FLAG_USER(n): user-defined bit N
 125              */
 126
 127   u32 flow_id;  /**< Generic flow identifier */
 128
 129
 130   u32 next_buffer;   /**< Next buffer for this linked-list of buffers.
 131                         Only valid if VLIB_BUFFER_NEXT_PRESENT flag is set.
 132                      */
 133
 134     STRUCT_MARK (template_end);
 135
 136   u32 current_config_index; /**< Used by feature subgraph arcs to
 137                                visit enabled feature nodes
 138                             */
 139   vlib_error_t error;   /**< Error code for buffers to be enqueued
 140                            to error handler.
 141                         */
 142   u8 n_add_refs; /**< Number of additional references to this buffer. */
 143
 144   u8 buffer_pool_index; /**< index of buffer pool this buffer belongs. */
 145
 146   u32 opaque[10]; /**< Opaque data used by sub-graphs for their own purposes.
 147                     See .../vnet/vnet/buffer.h
 148                  */
 149     CLIB_CACHE_LINE_ALIGN_MARK (cacheline1);
 150
 151   u32 trace_index; /**< Specifies index into trace buffer
 152                       if VLIB_PACKET_IS_TRACED flag is set.
 153                    */
 154   u32 recycle_count; /**< Used by L2 path recycle code */
 155
 156   u32 total_length_not_including_first_buffer;
 157   /**< Only valid for first buffer in chain. Current length plus
 158      total length given here give total number of bytes in buffer chain.
 159   */
 160   vlib_buffer_free_list_index_t free_list_index; /** < only used if
 161                                                    VLIB_BUFFER_NON_DEFAULT_FREELIST
 162                                                    flag is set */
 163   u8 align_pad[3]; /**< available */
 164   u32 opaque2[12];  /**< More opaque data, see ../vnet/vnet/buffer.h */
 165
 166   /***** end of second cache line */
 167     CLIB_CACHE_LINE_ALIGN_MARK (cacheline2);
 168   u8 pre_data[VLIB_BUFFER_PRE_DATA_SIZE];  /**< Space for inserting data
 169                                                before buffer start.
 170                                                Packet rewrite string will be
 171                                                rewritten backwards and may extend
 172                                                back before buffer->data[0].
 173                                                Must come directly before packet data.
 174                                             */
 175
 176   u8 data[0]; /**< Packet data. Hardware DMA here */
 177 } vlib_buffer_t;                /* Must be a multiple of 64B. */
 178
 179 #define VLIB_BUFFER_HDR_SIZE  (sizeof(vlib_buffer_t) - VLIB_BUFFER_PRE_DATA_SIZE)
 180
 181 /** \brief Prefetch buffer metadata.
 182     The first 64 bytes of buffer contains most header information
 183
 184     @param b - (vlib_buffer_t *) pointer to the buffer
 185     @param type - LOAD, STORE. In most cases, STORE is the right answer
 186 */
 187
 188 #define vlib_prefetch_buffer_header(b,type) CLIB_PREFETCH (b, 64, type)
 189 #define vlib_prefetch_buffer_data(b,type) \
 190   CLIB_PREFETCH (vlib_buffer_get_current(b), CLIB_CACHE_LINE_BYTES, type)
 191
 192 always_inline void
 193 vlib_buffer_struct_is_sane (vlib_buffer_t * b)
 194 {
 195   ASSERT (sizeof (b[0]) % 64 == 0);
 196
 197   /* Rewrite data must be before and contiguous with packet data. */
 198   ASSERT (b->pre_data + VLIB_BUFFER_PRE_DATA_SIZE == b->data);
 199 }
 200
 201 always_inline uword
 202 vlib_buffer_get_va (vlib_buffer_t * b)
 203 {
 204   return pointer_to_uword (b->data);
 205 }
 206
 207 /** \brief Get pointer to current data to process
 208
 209     @param b - (vlib_buffer_t *) pointer to the buffer
 210     @return - (void *) (b->data + b->current_data)
 211 */
 212
 213 always_inline void *
 214 vlib_buffer_get_current (vlib_buffer_t * b)
 215 {
 216   /* Check bounds. */
 217   ASSERT ((signed) b->current_data >= (signed) -VLIB_BUFFER_PRE_DATA_SIZE);
 218   return b->data + b->current_data;
 219 }
 220
 221 always_inline uword
 222 vlib_buffer_get_current_va (vlib_buffer_t * b)
 223 {
 224   return vlib_buffer_get_va (b) + b->current_data;
 225 }
 226
 227 /** \brief Advance current data pointer by the supplied (signed!) amount
 228
 229     @param b - (vlib_buffer_t *) pointer to the buffer
 230     @param l - (word) signed increment
 231 */
 232 always_inline void
 233 vlib_buffer_advance (vlib_buffer_t * b, word l)
 234 {
 235   ASSERT (b->current_length >= l);
 236   b->current_data += l;
 237   b->current_length -= l;
 238
 239   ASSERT ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0 ||
 240           b->current_length >= VLIB_BUFFER_MIN_CHAIN_SEG_SIZE);
 241 }
 242
 243 /** \brief Check if there is enough space in buffer to advance
 244
 245     @param b - (vlib_buffer_t *) pointer to the buffer
 246     @param l - (word) size to check
 247     @return - 0 if there is less space than 'l' in buffer
 248 */
 249 always_inline u8
 250 vlib_buffer_has_space (vlib_buffer_t * b, word l)
 251 {
 252   return b->current_length >= l;
 253 }
 254
 255 /** \brief Reset current header & length to state they were in when
 256     packet was received.
 257
 258     @param b - (vlib_buffer_t *) pointer to the buffer
 259 */
 260
 261 always_inline void
 262 vlib_buffer_reset (vlib_buffer_t * b)
 263 {
 264   b->current_length += clib_max (b->current_data, 0);
 265   b->current_data = 0;
 266 }
 267
 268 /** \brief Get pointer to buffer's opaque data array
 269
 270     @param b - (vlib_buffer_t *) pointer to the buffer
 271     @return - (void *) b->opaque
 272 */
 273 always_inline void *
 274 vlib_get_buffer_opaque (vlib_buffer_t * b)
 275 {
 276   return (void *) b->opaque;
 277 }
 278
 279 /** \brief Get pointer to buffer's opaque2 data array
 280
 281     @param b - (vlib_buffer_t *) pointer to the buffer
 282     @return - (void *) b->opaque2
 283 */
 284 always_inline void *
 285 vlib_get_buffer_opaque2 (vlib_buffer_t * b)
 286 {
 287   return (void *) b->opaque2;
 288 }
 289
 290 /** \brief Get pointer to the end of buffer's data
 291  * @param b     pointer to the buffer
 292  * @return      pointer to tail of packet's data
 293  */
 294 always_inline u8 *
 295 vlib_buffer_get_tail (vlib_buffer_t * b)
 296 {
 297   return b->data + b->current_data + b->current_length;
 298 }
 299
 300 /** \brief Append uninitialized data to buffer
 301  * @param b     pointer to the buffer
 302  * @param size  number of uninitialized bytes
 303  * @return      pointer to beginning of uninitialized data
 304  */
 305 always_inline void *
 306 vlib_buffer_put_uninit (vlib_buffer_t * b, u16 size)
 307 {
 308   void *p = vlib_buffer_get_tail (b);
 309   /* XXX make sure there's enough space */
 310   b->current_length += size;
 311   return p;
 312 }
 313
 314 /** \brief Prepend uninitialized data to buffer
 315  * @param b     pointer to the buffer
 316  * @param size  number of uninitialized bytes
 317  * @return      pointer to beginning of uninitialized data
 318  */
 319 always_inline void *
 320 vlib_buffer_push_uninit (vlib_buffer_t * b, u8 size)
 321 {
 322   ASSERT (b->current_data + VLIB_BUFFER_PRE_DATA_SIZE >= size);
 323   b->current_data -= size;
 324   b->current_length += size;
 325
 326   return vlib_buffer_get_current (b);
 327 }
 328
 329 /** \brief Make head room, typically for packet headers
 330  * @param b     pointer to the buffer
 331  * @param size  number of head room bytes
 332  * @return      pointer to start of buffer (current data)
 333  */
 334 always_inline void *
 335 vlib_buffer_make_headroom (vlib_buffer_t * b, u8 size)
 336 {
 337   ASSERT (b->current_data + VLIB_BUFFER_PRE_DATA_SIZE >= size);
 338   b->current_data += size;
 339   return vlib_buffer_get_current (b);
 340 }
 341
 342 /** \brief Retrieve bytes from buffer head
 343  * @param b     pointer to the buffer
 344  * @param size  number of bytes to pull
 345  * @return      pointer to start of buffer (current data)
 346  */
 347 always_inline void *
 348 vlib_buffer_pull (vlib_buffer_t * b, u8 size)
 349 {
 350   if (b->current_length + VLIB_BUFFER_PRE_DATA_SIZE < size)
 351     return 0;
 352
 353   void *data = vlib_buffer_get_current (b);
 354   vlib_buffer_advance (b, size);
 355   return data;
 356 }
 357
 358 /* Forward declaration. */
 359 struct vlib_main_t;
 360
 361 typedef struct vlib_buffer_free_list_t
 362 {
 363   /* Template buffer used to initialize first 16 bytes of buffers
 364      allocated on this free list. */
 365   vlib_buffer_t buffer_init_template;
 366
 367   /* Our index into vlib_main_t's buffer_free_list_pool. */
 368   vlib_buffer_free_list_index_t index;
 369
 370   /* Number of data bytes for buffers in this free list. */
 371   u32 n_data_bytes;
 372
 373   /* Number of buffers to allocate when we need to allocate new buffers */
 374   u32 min_n_buffers_each_alloc;
 375
 376   /* Total number of buffers allocated from this free list. */
 377   u32 n_alloc;
 378
 379   /* Vector of free buffers.  Each element is a byte offset into I/O heap. */
 380   u32 *buffers;
 381
 382   /* index of buffer pool used to get / put buffers */
 383   u8 buffer_pool_index;
 384
 385   /* Free list name. */
 386   u8 *name;
 387
 388   /* Callback functions to initialize newly allocated buffers.
 389      If null buffers are zeroed. */
 390   void (*buffer_init_function) (struct vlib_main_t * vm,
 391                                 struct vlib_buffer_free_list_t * fl,
 392                                 u32 * buffers, u32 n_buffers);
 393
 394   uword buffer_init_function_opaque;
 395 } __attribute__ ((aligned (16))) vlib_buffer_free_list_t;
 396
 397 typedef uword (vlib_buffer_fill_free_list_cb_t) (struct vlib_main_t * vm,
 398                                                  vlib_buffer_free_list_t * fl,
 399                                                  uword min_free_buffers);
 400 typedef void (vlib_buffer_free_cb_t) (struct vlib_main_t * vm, u32 * buffers,
 401                                       u32 n_buffers);
 402 typedef void (vlib_buffer_free_no_next_cb_t) (struct vlib_main_t * vm,
 403                                               u32 * buffers, u32 n_buffers);
 404
 405 typedef struct
 406 {
 407   vlib_buffer_fill_free_list_cb_t *vlib_buffer_fill_free_list_cb;
 408   vlib_buffer_free_cb_t *vlib_buffer_free_cb;
 409   vlib_buffer_free_no_next_cb_t *vlib_buffer_free_no_next_cb;
 410   void (*vlib_packet_template_init_cb) (struct vlib_main_t * vm, void *t,
 411                                         void *packet_data,
 412                                         uword n_packet_data_bytes,
 413                                         uword
 414                                         min_n_buffers_each_physmem_alloc,
 415                                         u8 * name);
 416   void (*vlib_buffer_delete_free_list_cb) (struct vlib_main_t * vm,
 417                                            vlib_buffer_free_list_index_t
 418                                            free_list_index);
 419 } vlib_buffer_callbacks_t;
 420
 421 extern vlib_buffer_callbacks_t *vlib_buffer_callbacks;
 422
 423 typedef struct
 424 {
 425   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
 426   uword start;
 427   uword size;
 428   uword log2_page_size;
 429   u32 physmem_map_index;
 430   u32 buffer_size;
 431   u32 *buffers;
 432   clib_spinlock_t lock;
 433 } vlib_buffer_pool_t;
 434
 435 typedef struct
 436 {
 437   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
 438   /* Virtual memory address and size of buffer memory, used for calculating
 439      buffer index */
 440   uword buffer_mem_start;
 441   uword buffer_mem_size;
 442   vlib_buffer_pool_t *buffer_pools;
 443
 444   /* Buffer free callback, for subversive activities */
 445     u32 (*buffer_free_callback) (struct vlib_main_t * vm,
 446                                  u32 * buffers,
 447                                  u32 n_buffers, u32 follow_buffer_next);
 448 #define VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX (0)
 449 #define VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES VLIB_BUFFER_DATA_SIZE
 450
 451   /* Hash table mapping buffer size (rounded to next unit of
 452      sizeof (vlib_buffer_t)) to free list index. */
 453   uword *free_list_by_size;
 454
 455   /* Hash table mapping buffer index into number
 456      0 => allocated but free, 1 => allocated and not-free.
 457      If buffer index is not in hash table then this buffer
 458      has never been allocated. */
 459   uword *buffer_known_hash;
 460   clib_spinlock_t buffer_known_hash_lockp;
 461
 462   /* Callbacks */
 463   vlib_buffer_callbacks_t cb;
 464   int callbacks_registered;
 465 } vlib_buffer_main_t;
 466
 467 extern vlib_buffer_main_t buffer_main;
 468
 469 static_always_inline vlib_buffer_pool_t *
 470 vlib_buffer_pool_get (u8 buffer_pool_index)
 471 {
 472   vlib_buffer_main_t *bm = &buffer_main;
 473   return vec_elt_at_index (bm->buffer_pools, buffer_pool_index);
 474 }
 475
 476 u8 vlib_buffer_register_physmem_map (struct vlib_main_t * vm,
 477                                      u32 physmem_map_index);
 478
 479 clib_error_t *vlib_buffer_main_init (struct vlib_main_t *vm);
 480
 481 typedef struct
 482 {
 483   struct vlib_main_t *vlib_main;
 484
 485   u32 first_buffer, last_buffer;
 486
 487   union
 488   {
 489     struct
 490     {
 491       /* Total accumulated bytes in chain starting with first_buffer. */
 492       u32 n_total_data_bytes;
 493
 494       /* Max number of bytes to accumulate in chain starting with first_buffer.
 495          As this limit is reached buffers are enqueued to next node. */
 496       u32 max_n_data_bytes_per_chain;
 497
 498       /* Next node to enqueue buffers to relative to current process node. */
 499       u32 next_index;
 500
 501       /* Free list to use to allocate new buffers. */
 502       vlib_buffer_free_list_index_t free_list_index;
 503     } tx;
 504
 505     struct
 506     {
 507       /* CLIB fifo of buffer indices waiting to be unserialized. */
 508       u32 *buffer_fifo;
 509
 510       /* Event type used to signal that RX buffers have been added to fifo. */
 511       uword ready_one_time_event;
 512     } rx;
 513   };
 514 } vlib_serialize_buffer_main_t;
 515
 516 void serialize_open_vlib_buffer (serialize_main_t * m, struct vlib_main_t *vm,
 517                                  vlib_serialize_buffer_main_t * sm);
 518 void unserialize_open_vlib_buffer (serialize_main_t * m,
 519                                    struct vlib_main_t *vm,
 520                                    vlib_serialize_buffer_main_t * sm);
 521
 522 u32 serialize_close_vlib_buffer (serialize_main_t * m);
 523 void unserialize_close_vlib_buffer (serialize_main_t * m);
 524 void *vlib_set_buffer_free_callback (struct vlib_main_t *vm, void *fp);
 525
 526 always_inline u32
 527 serialize_vlib_buffer_n_bytes (serialize_main_t * m)
 528 {
 529   serialize_stream_t *s = &m->stream;
 530   vlib_serialize_buffer_main_t *sm
 531     = uword_to_pointer (m->stream.data_function_opaque,
 532                         vlib_serialize_buffer_main_t *);
 533   return sm->tx.n_total_data_bytes + s->current_buffer_index +
 534     vec_len (s->overflow_buffer);
 535 }
 536
 537 /*
 538  */
 539
 540 /** \brief Compile time buffer trajectory tracing option
 541     Turn this on if you run into "bad monkey" contexts,
 542     and you want to know exactly which nodes they've visited...
 543     See vlib/main.c...
 544 */
 545 #define VLIB_BUFFER_TRACE_TRAJECTORY 0
 546
 547 #if VLIB_BUFFER_TRACE_TRAJECTORY > 0
 548 extern void (*vlib_buffer_trace_trajectory_cb) (vlib_buffer_t * b, u32 index);
 549 extern void (*vlib_buffer_trace_trajectory_init_cb) (vlib_buffer_t * b);
 550 extern void vlib_buffer_trace_trajectory_init (vlib_buffer_t * b);
 551 #define VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b) \
 552   vlib_buffer_trace_trajectory_init (b);
 553 #else
 554 #define VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b)
 555 #endif /* VLIB_BUFFER_TRACE_TRAJECTORY */
 556
 557 #endif /* included_vlib_buffer_h */
 558
 559 #define VLIB_BUFFER_REGISTER_CALLBACKS(x,...)                           \
 560     __VA_ARGS__ vlib_buffer_callbacks_t __##x##_buffer_callbacks;       \
 561 static void __vlib_add_buffer_callbacks_t_##x (void)                    \
 562     __attribute__((__constructor__)) ;                                  \
 563 static void __vlib_add_buffer_callbacks_t_##x (void)                    \
 564 {                                                                       \
 565     if (vlib_buffer_callbacks)                                          \
 566       clib_panic ("vlib buffer callbacks already registered");          \
 567     vlib_buffer_callbacks = &__##x##_buffer_callbacks;                  \
 568 }                                                                       \
 569 static void __vlib_rm_buffer_callbacks_t_##x (void)                     \
 570     __attribute__((__destructor__)) ;                                   \
 571 static void __vlib_rm_buffer_callbacks_t_##x (void)                     \
 572 { vlib_buffer_callbacks = 0; }                                          \
 573 __VA_ARGS__ vlib_buffer_callbacks_t __##x##_buffer_callbacks
 574
 575 /*
 576  * fd.io coding-style-patch-verification: ON
 577  *
 578  * Local Variables:
 579  * eval: (c-set-style "gnu")
 580  * End:
 581  */