1  /* Internal representation of tunables.
       2  
       3     Copyright (C) 2016-2023 Free Software Foundation, Inc.
       4     This file is part of the GNU C Library.
       5  
       6     The GNU C Library is free software; you can redistribute it and/or
       7     modify it under the terms of the GNU Lesser General Public
       8     License as published by the Free Software Foundation; either
       9     version 2.1 of the License, or (at your option) any later version.
      10  
      11     The GNU C Library is distributed in the hope that it will be useful,
      12     but WITHOUT ANY WARRANTY; without even the implied warranty of
      13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14     Lesser General Public License for more details.
      15  
      16     You should have received a copy of the GNU Lesser General Public
      17     License along with the GNU C Library; if not, see
      18     <https://www.gnu.org/licenses/>.  */
      19  
      20  #ifndef _TUNABLE_TYPES_H_
      21  #define _TUNABLE_TYPES_H_
      22  
      23  /* Note: This header is included in the generated dl-tunables-list.h and
      24     only used internally in the tunables implementation in dl-tunables.c.  */
      25  
      26  #include <stdbool.h>
      27  #include <stddef.h>
      28  #include <stdint.h>
      29  
      30  typedef enum
      31  {
      32    TUNABLE_TYPE_INT_32,
      33    TUNABLE_TYPE_UINT_64,
      34    TUNABLE_TYPE_SIZE_T,
      35    TUNABLE_TYPE_STRING
      36  } tunable_type_code_t;
      37  
      38  typedef struct
      39  {
      40    tunable_type_code_t type_code;
      41    tunable_num_t min;
      42    tunable_num_t max;
      43  } tunable_type_t;
      44  
      45  /* Security level for tunables.  This decides what to do with individual
      46     tunables for AT_SECURE binaries.  */
      47  typedef enum
      48  {
      49    /* Erase the tunable for AT_SECURE binaries so that child processes don't
      50       read it.  */
      51    TUNABLE_SECLEVEL_SXID_ERASE = 0,
      52    /* Ignore the tunable for AT_SECURE binaries, but don't erase it, so that
      53       child processes can read it.  */
      54    TUNABLE_SECLEVEL_SXID_IGNORE = 1,
      55    /* Read the tunable.  */
      56    TUNABLE_SECLEVEL_NONE = 2,
      57  } tunable_seclevel_t;
      58  
      59  /* A tunable.  */
      60  struct _tunable
      61  {
      62    const char name[TUNABLE_NAME_MAX];	/* Internal name of the tunable.  */
      63    tunable_type_t type;			/* Data type of the tunable.  */
      64    tunable_val_t val;			/* The value.  */
      65    bool initialized;			/* Flag to indicate that the tunable is
      66  					   initialized.  */
      67    tunable_seclevel_t security_level;	/* Specify the security level for the
      68  					   tunable with respect to AT_SECURE
      69  					   programs.  See description of
      70  					   tunable_seclevel_t to see a
      71  					   description of the values.
      72  
      73  					   Note that even if the tunable is
      74  					   read, it may not get used by the
      75  					   target module if the value is
      76  					   considered unsafe.  */
      77    /* Compatibility elements.  */
      78    const char env_alias[TUNABLE_ALIAS_MAX]; /* The compatibility environment
      79  					   variable name.  */
      80  };
      81  
      82  typedef struct _tunable tunable_t;
      83  
      84  static __always_inline bool
      85  unsigned_tunable_type (tunable_type_code_t t)
      86  {
      87    switch (t)
      88      {
      89      case TUNABLE_TYPE_INT_32:
      90        return false;
      91      case TUNABLE_TYPE_UINT_64:
      92      case TUNABLE_TYPE_SIZE_T:
      93        return true;
      94      case TUNABLE_TYPE_STRING:
      95      default:
      96        break;
      97      }
      98    __builtin_unreachable ();
      99  }
     100  
     101  #endif