contrib/bit-masks/lustre_dlm_flags.tpl

   1 [= AutoGen5 Template h -*- Mode: C -*- =]
   2 [= (dne " * " "/* ") =]
   3  *
   4 [= (gpl "lustre" " * ") =]
   5  */
   6 /**
   7  * \file [= (out-name) =]
   8  * The flags and collections of flags (masks) for \see struct ldlm_lock.
   9  * This file is derived from flag definitions in [=(def-file)=].
  10  * The format is defined in the [=(tpl-file)=] template file.
  11  *
  12  * \addtogroup LDLM Lustre Distributed Lock Manager
  13  * @{
  14  *
  15  * \name flags
  16  * The flags and collections of flags (masks) for \see struct ldlm_lock.
  17  * @{
  18  */
  19 #ifndef LDLM_ALL_FLAGS_MASK
  20 [=
  21
  22 ;; Guile is unable to handle 64 bit unsigned ints very easily.
  23 ;; BASH does just fine.  Construct a shell script to compute the
  24 ;; bit masks and echo out the appropriate #defines.
  25 ;;
  26 (out-push-new "script.sh")
  27
  28 =]
  29 mask_list=
  30 allbits=0
  31 fmt='#define LDLM_FL_%-16s        0x%016XULL // bit  %2u
  32 #define ldlm_is_%-20s    LDLM_TEST_FLAG(( _l), 1ULL << %2u)
  33 #define ldlm_set_%-20s   LDLM_SET_FLAG((  _l), 1ULL << %2u)
  34 #define ldlm_clear_%-20s LDLM_CLEAR_FLAG((_l), 1ULL << %2u)\n'
  35 acc_fmt=''
  36 tmpfile=[=(base-name)=]-$$.tmp
  37 exec 8>&1 1> $tmpfile
  38 [=
  39
  40 FOR flag
  41
  42 =]
  43 bitno=[=(define temp-txt (get "f-desc"))
  44         (for-index)=]
  45 bitval=$(( 1 << $bitno ))
  46 echo[=
  47
  48   IF (< (string-length temp-txt) 72)=]
  49 echo '/**' [= (raw-shell-str temp-txt) =] '*/'[=
  50   ELSE=]
  51 echo '/**'
  52 { fmt -w 74 | sed 's/^/ * /;s/ *$//;$s@$@ */@'
  53 } <<_EOF_
  54 [=(. temp-txt)=]
  55 _EOF_[=
  56   ENDIF
  57
  58 =]
  59 dn_name=[= (string-downcase! (string->c-name! (get "f-name"))) =]'(_l)'
  60 up_name=[= (string-upcase!   (string->c-name! (get "f-name"))) =]
  61 printf "$fmt" $up_name $bitval $bitno \
  62         $dn_name $bitno \
  63         $dn_name $bitno \
  64         $dn_name $bitno
  65
  66 (( allbits += bitval ))[=
  67
  68   FOR f-mask            =]
  69 mask_list=${mask_list}[= f-mask =]$'\n'
  70 mask_[= f-mask =]=$(( ${mask_[= f-mask =]:-0} + bitval ))[=
  71   ENDFOR f-mask         =][=
  72
  73 ENDFOR flag
  74
  75 =]
  76 exec 1>&8 8>&-
  77 fmt='\n/** l_flags bits marked as "%s" bits */
  78 #define LDLM_FL_%-22s  0x%016XULL\n'
  79 printf "$fmt" all_flags ALL_FLAGS_MASK $allbits
  80
  81 for f in $(echo "$mask_list" | sort -u)
  82 do
  83     ucf=$(echo $f | tr a-z A-Z)_MASK
  84     eval v=\$mask_$f
  85     printf "$fmt" $f $ucf $v
  86 done
  87
  88 cat $tmpfile
  89 rm -f $tmpfile script.sh[=
  90
  91 ;; The script is done.  Pop off the temporary output, handing
  92 ;; it to the shell for evaluation.  stdout becomes the output text
  93 ;;
  94 (out-pop)
  95 (shell ". script.sh")
  96
  97 =]
  98
  99 /** test for ldlm_lock flag bit set */
 100 #define LDLM_TEST_FLAG(_l, _b)        (((_l)->l_flags & (_b)) != 0)
 101
 102 /** set a ldlm_lock flag bit */
 103 #define LDLM_SET_FLAG(_l, _b)         (((_l)->l_flags |= (_b))
 104
 105 /** clear a ldlm_lock flag bit */
 106 #define LDLM_CLEAR_FLAG(_l, _b)       (((_l)->l_flags &= ~(_b))
 107
 108 /** Mask of flags inherited from parent lock when doing intents. */
 109 #define LDLM_INHERIT_FLAGS            LDLM_FL_INHERIT_MASK
 110
 111 /** Mask of Flags sent in AST lock_flags to map into the receiving lock. */
 112 #define LDLM_AST_FLAGS                LDLM_FL_AST_MASK
 113
 114 /** @} subgroup */
 115 /** @} group */
 116 #ifdef WIRESHARK_COMPILE[=
 117 FOR flag                       =][=
 118   (sprintf "\nstatic int hf_lustre_ldlm_fl_%-20s= -1;"
 119            (string-downcase! (get "f-name")) ) =][=
 120 ENDFOR flag                    =]
 121
 122 const value_string lustre_ldlm_flags_vals[] = {[=
 123
 124 FOR flag                       =][=
 125    (define up-name (string-upcase! (string->c-name! (get "f-name"))))
 126    (sprintf "\n  {LDLM_FL_%-20s \"LDLM_FL_%s\"}," (string-append up-name ",")
 127             up-name)           =][=
 128 ENDFOR flag                    =]
 129   { 0, NULL }
 130 };
 131 #endif /*  WIRESHARK_COMPILE */
 132 [= #
 133
 134 // TEST CODE                    =][=
 135 IF  (getenv "TESTING")          =][=
 136
 137 FOR flag (define len-list "")
 138          (define str-list "")
 139          (define temp-str "")
 140          (define header-name (out-name))
 141          (out-push-new (string-append (base-name) ".c"))
 142
 143          (for-from 0) (for-by 1) =][=
 144
 145   (if (exist? "f-name")
 146       (begin
 147          (set! temp-str (string-upcase! (get "f-name")))
 148          (set! len-list (string-append len-list (c-string
 149                (sprintf "%%%us" (- 20 (string-length temp-str))) ) "\n" ))
 150          (set! str-list (string-append str-list
 151                (c-string temp-str) "\n" ))
 152       )
 153       (begin
 154          (set! len-list (string-append len-list "NULL\n"))
 155          (set! str-list (string-append str-list "NULL\n"))
 156   )   )
 157
 158   =][=
 159
 160 ENDFOR flag
 161
 162 \=]
 163 #include "[=(. header-name)=]"
 164 extern char ** args;
 165
 166 #include <errno.h>
 167 #include <stdbool.h>
 168 #include <stdio.h>
 169 #include <stdlib.h>
 170
 171 static char const * const fill_fmts[] = {
 172 [=(out-push-new)=]
 173 columns --spread=1 -I4 -S, --end=' };' <<_EOF_
 174 [=(. len-list)=]
 175 _EOF_
 176
 177 printf '\nstatic char const * const flag_names[] = {\n'
 178 columns --spread=1 -I4 -S, --end=' };' <<_EOF_
 179 [=(. str-list)=]
 180 _EOF_
 181 [= (shell (out-pop #t)) =]
 182
 183 static void
 184 print_bits(unsigned long long v)
 185 {
 186         static char const new_line[] = "\n";
 187         char const * space_fmt = new_line + 1;
 188         int ix = 0;
 189         int ct = 0;
 190
 191         if ((v & ~LDLM_FL_ALL_FLAGS_MASK) != 0) {
 192                 unsigned long long wrong = v & ~LDLM_FL_ALL_FLAGS_MASK;
 193                 printf("undefined bits: 0x%016llX\n", wrong);
 194                 v &= LDLM_FL_ALL_FLAGS_MASK;
 195         }
 196
 197         for (ix = 0; v != 0ULL; ix++, v >>= 1) {
 198                 if ((v & 0x1ULL) == 0)
 199                         continue;
 200
 201                 printf(space_fmt, "");
 202                 if ((++ct & 0x03) == 0)
 203                         space_fmt = new_line;
 204                 else
 205                         space_fmt = fill_fmts[ix];
 206                 fputs(flag_names[ix], stdout);
 207         }
 208         putc('\n', stdout);
 209 }
 210
 211 void
 212 cmd_ldlm_lock_flags(void)
 213 {
 214         char * p = args[1];
 215         char * e;
 216         unsigned long long v;
 217         bool flip_val = false;
 218
 219         if (p == NULL) {
 220                 printf("no argument\n");
 221                 return;
 222         }
 223         if (*p == '~') {
 224                 flip_val = true;
 225                 p++;
 226         }
 227
 228         v = strtoull(p, &e, 0);
 229         if (*e != '\0') {
 230                 errno = 0;
 231                 v = strtoull(p, &e, 16);
 232                 if ((errno != 0) || (*e != '\0')) {
 233                         printf("invalid number: %s\n", p);
 234                         return;
 235                 }
 236         }
 237         if (flip_val) {
 238                 v ^= ~0ULL;
 239                 v &= LDLM_FL_ALL_FLAGS_MASK;
 240         }
 241
 242         print_bits(v);
 243 }
 244
 245 char * help_ldlm_lock_flags[] = {
 246         "ldlm_lock_flags",
 247         "flag bit names for ldlm_lock",
 248         "<numeric-value>",
 249         "The names of the bits that are set in the numeric value are printed.",
 250         NULL
 251 };
 252
 253 #ifdef LDLM_FLAGS_PROGRAM
 254 #include <ctype.h>
 255
 256 char ** args = NULL;
 257
 258 void
 259 usage(int ex_code, char const * msg)
 260 {
 261         int    ix = 3;
 262         FILE * fp = (ex_code == EXIT_SUCCESS) ? stdout : stderr;
 263         args = help_ldlm_lock_flags;
 264         if (msg != NULL)
 265                 fprintf(fp, "%s usage error:  %s\n", args[0], msg);
 266         fprintf(fp, "%s - %s\n", args[0], args[1]);
 267         fprintf(fp, "Usage: %s %s\n", args[0], args[2]);
 268         for (;;) {
 269                 char * txt = args[ix++];
 270                 if (txt == NULL)
 271                         break;
 272                 fprintf(fp, "%s\n", txt);
 273         }
 274         exit(ex_code);
 275 }
 276
 277 int
 278 main(int argc, char ** argv)
 279 {
 280         int ix = 1;
 281         char * av[3] = { argv[0], NULL, NULL };
 282
 283         args = av;
 284         switch (argc) {
 285         case 0: case 1:
 286                 usage(EXIT_FAILURE, "argument missing");
 287
 288         case 2:
 289         {
 290                 char * arg = argv[1];
 291                 if (*arg != '-')
 292                         break;
 293                 switch (arg[1]) {
 294                 case '-': if (arg[2] == 'h') break;
 295                         /* FALLTHROUGH */
 296                 case 'h': usage(EXIT_SUCCESS, NULL);
 297                 default: break;
 298                 }
 299                 break;
 300         }
 301         }
 302
 303         while (ix < argc) {
 304                 av[1] = argv[ix++];
 305                 cmd_ldlm_lock_flags();
 306         }
 307         return EXIT_SUCCESS;
 308 }
 309 #endif /* LDLM_FLAGS_PROGRAM */
 310 [= (out-pop) =][=
 311
 312 ENDIF TESTING
 313
 314  * Local Variables:
 315  * mode: C
 316  * c-file-style: "linux"
 317  * indent-tabs-mode: t
 318  * End:
 319
 320 \=]
 321 #endif /* LDLM_ALL_FLAGS_MASK */