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 7>&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>&7 7>&-
  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 /** multi-bit test: are any of mask bits set? */
 103 #define LDLM_HAVE_MASK(_l, _m)    (((_l)->l_flags & LDLM_FL_##_m##_MASK) != 0)
 104
 105 /** set a ldlm_lock flag bit */
 106 #define LDLM_SET_FLAG(_l, _b)     ((_l)->l_flags |= (_b))
 107
 108 /** clear a ldlm_lock flag bit */
 109 #define LDLM_CLEAR_FLAG(_l, _b)   ((_l)->l_flags &= ~(_b))
 110
 111 /** @} subgroup */
 112 /** @} group */
 113 #endif /* LDLM_ALL_FLAGS_MASK */
 114 [=
 115 (out-push-new (string-append (base-name) "_wshark.c"))
 116 (define flags-vals "")
 117 (define dissect    "")
 118 (define init-text  "")
 119
 120 (define up-name    "")
 121 (define down-name  "")
 122
 123 (define dissect-fmt
 124     "  dissect_uint32(tvb, offset, pinfo, tree, hf_lustre_ldlm_fl_%s);\n")
 125 (out-push-new)     \=]
 126   {
 127     /* p_id    */ &hf_lustre_ldlm_fl_%1$s,
 128     /* hfinfo  */ {
 129       /* name    */ "LDLM_FL_%2$s",
 130       /* abbrev  */ "lustre.ldlm_fl_%1$s",
 131       /* type    */ FT_BOOLEAN,
 132       /* display */ 32,
 133       /* strings */ TFS(&lnet_flags_set_truth),
 134       /* bitmask */ LDLM_FL_%2$s,
 135       /* blurb   */ %3$s,
 136       /* id      */ HFILL
 137     }
 138   },
 139 [= (define init-fmt (out-pop #t)) \=]
 140 /**
 141  * \file [=(out-name)=]
 142  *
 143  * wireshark definitions.  This file contains the ldlm lock flag bits
 144  * that can be transmitted over the wire.  There are many other bits,
 145  * but they are not transmitted and not handled here.
 146  */
 147 #ifdef WSHARK_HEAD
 148 [=
 149
 150 FOR flag                       =][=
 151
 152   (if (match-value? = "f-mask" "on_wire") (begin
 153       (set! temp-txt  (get "f-name"))
 154       (set! up-name   (string-upcase (string->c-name! temp-txt)))
 155       (set! down-name (string-downcase temp-txt))
 156
 157       (set! flags-vals (string-append flags-vals (sprintf
 158             "\n  {LDLM_FL_%-20s \"LDLM_FL_%s\"},"
 159             (string-append up-name ",") up-name )))
 160
 161       (set! dissect (string-append dissect (sprintf dissect-fmt
 162             down-name)))
 163
 164       (set! init-text (string-append init-text (sprintf init-fmt
 165             down-name up-name (c-string (get "f-desc")) )))
 166
 167       (ag-fprintf 0 "\nstatic int hf_lustre_ldlm_fl_%-20s= -1;"
 168            down-name)
 169   )  )                         =][=
 170 ENDFOR flag                    =]
 171
 172 const value_string lustre_ldlm_flags_vals[] = {[= (. flags-vals) =]
 173   { 0, NULL }
 174 };
 175
 176 /* IDL: struct ldlm_reply { */
 177 /* IDL:         uint32 lock_flags; */
 178 /* IDL:         uint32 lock_padding; */
 179 /* IDL:         struct ldlm_lock_desc { */
 180 /* IDL: } lock_desc; */
 181 /* IDL:         struct lustre_handle { */
 182 /* IDL: } lock_handle; */
 183 /* IDL:         uint64 lock_policy_res1; */
 184 /* IDL:         uint64 lock_policy_res2; */
 185 /* IDL: } */
 186
 187 static int
 188 lustre_dissect_element_ldlm_lock_flags(
 189         tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_,
 190         proto_tree *parent_tree _U_, int hf_index _U_)
 191 {
 192   proto_item *item = NULL;
 193   proto_tree *tree = NULL;
 194
 195   if (parent_tree) {
 196     item = proto_tree_add_item(parent_tree,hf_index, tvb, offset, 4, TRUE);
 197     tree = proto_item_add_subtree(item, ett_lustre_ldlm_lock_flags);
 198   }
 199 [= (shell
 200 "sed '$s/^/  /;$i\\
 201   return' <<- \\_EOF_\n" dissect "_EOF_"
 202 ) =]
 203 }
 204 #endif /* WSHARK_HEAD */
 205
 206 #ifdef WSHARK_INIT_DATA
 207 [=
 208
 209 (emit init-text
 210 "\n#endif /* WSHARK_INIT_DATA */\n")
 211 (out-pop)
 212
 213 =][= #
 214
 215 // TEST CODE                    =][=
 216 IF  (getenv "TESTING")          =][=
 217
 218 FOR flag (define len-list "")
 219          (define str-list "")
 220          (define temp-str "")
 221          (define header-name (out-name))
 222          (out-push-new (string-append (base-name) ".c"))
 223
 224          (for-from 0) (for-by 1) =][=
 225
 226   (if (exist? "f-name")
 227       (begin
 228          (set! temp-str (string-upcase! (get "f-name")))
 229          (set! len-list (string-append len-list (c-string
 230                (sprintf "%%%us" (- 20 (string-length temp-str))) ) "\n" ))
 231          (set! str-list (string-append str-list
 232                (c-string temp-str) "\n" ))
 233       )
 234       (begin
 235          (set! len-list (string-append len-list "NULL\n"))
 236          (set! str-list (string-append str-list "NULL\n"))
 237   )   )
 238
 239   =][=
 240
 241 ENDFOR flag
 242
 243 \=]
 244 #include "[=(. header-name)=]"
 245 extern char ** args;
 246
 247 #include <errno.h>
 248 #include <stdbool.h>
 249 #include <stdio.h>
 250 #include <stdlib.h>
 251
 252 static char const * const fill_fmts[] = {
 253 [=(out-push-new)=]
 254 columns --spread=1 -I4 -S, --end=' };' <<_EOF_
 255 [=(. len-list)=]
 256 _EOF_
 257
 258 printf '\nstatic char const * const flag_names[] = {\n'
 259 columns --spread=1 -I4 -S, --end=' };' <<_EOF_
 260 [=(. str-list)=]
 261 _EOF_
 262 [= (shell (out-pop #t)) =]
 263
 264 static void
 265 print_bits(unsigned long long v)
 266 {
 267         static char const new_line[] = "\n";
 268         char const * space_fmt = new_line + 1;
 269         int ix = 0;
 270         int ct = 0;
 271
 272         if ((v & ~LDLM_FL_ALL_FLAGS_MASK) != 0) {
 273                 unsigned long long wrong = v & ~LDLM_FL_ALL_FLAGS_MASK;
 274                 printf("undefined bits: 0x%016llX\n", wrong);
 275                 v &= LDLM_FL_ALL_FLAGS_MASK;
 276         }
 277
 278         for (ix = 0; v != 0ULL; ix++, v >>= 1) {
 279                 if ((v & 0x1ULL) == 0)
 280                         continue;
 281
 282                 printf(space_fmt, "");
 283                 if ((++ct & 0x03) == 0)
 284                         space_fmt = new_line;
 285                 else
 286                         space_fmt = fill_fmts[ix];
 287                 fputs(flag_names[ix], stdout);
 288         }
 289         putc('\n', stdout);
 290 }
 291
 292 void
 293 cmd_ldlm_lock_flags(void)
 294 {
 295         char * p = args[1];
 296         char * e;
 297         unsigned long long v;
 298         bool flip_val = false;
 299
 300         if (p == NULL) {
 301                 printf("no argument\n");
 302                 return;
 303         }
 304         if (*p == '~') {
 305                 flip_val = true;
 306                 p++;
 307         }
 308
 309         v = strtoull(p, &e, 0);
 310         if (*e != '\0') {
 311                 errno = 0;
 312                 v = strtoull(p, &e, 16);
 313                 if ((errno != 0) || (*e != '\0')) {
 314                         printf("invalid number: %s\n", p);
 315                         return;
 316                 }
 317         }
 318         if (flip_val) {
 319                 v ^= ~0ULL;
 320                 v &= LDLM_FL_ALL_FLAGS_MASK;
 321         }
 322
 323         print_bits(v);
 324 }
 325
 326 char * help_ldlm_lock_flags[] = {
 327         "ldlm_lock_flags",
 328         "flag bit names for ldlm_lock",
 329         "<numeric-value>",
 330         "The names of the bits that are set in the numeric value are printed.",
 331         NULL
 332 };
 333
 334 #ifdef LDLM_FLAGS_PROGRAM
 335 #include <ctype.h>
 336
 337 char ** args = NULL;
 338
 339 void
 340 usage(int ex_code, char const * msg)
 341 {
 342         int    ix = 3;
 343         FILE * fp = (ex_code == EXIT_SUCCESS) ? stdout : stderr;
 344         args = help_ldlm_lock_flags;
 345         if (msg != NULL)
 346                 fprintf(fp, "%s usage error:  %s\n", args[0], msg);
 347         fprintf(fp, "%s - %s\n", args[0], args[1]);
 348         fprintf(fp, "Usage: %s %s\n", args[0], args[2]);
 349         for (;;) {
 350                 char * txt = args[ix++];
 351                 if (txt == NULL)
 352                         break;
 353                 fprintf(fp, "%s\n", txt);
 354         }
 355         exit(ex_code);
 356 }
 357
 358 int
 359 main(int argc, char ** argv)
 360 {
 361         int ix = 1;
 362         char * av[3] = { argv[0], NULL, NULL };
 363
 364         args = av;
 365         switch (argc) {
 366         case 0: case 1:
 367                 usage(EXIT_FAILURE, "argument missing");
 368
 369         case 2:
 370         {
 371                 char * arg = argv[1];
 372                 if (*arg != '-')
 373                         break;
 374                 switch (arg[1]) {
 375                 case '-': if (arg[2] == 'h') break;
 376                         /* FALLTHROUGH */
 377                 case 'h': usage(EXIT_SUCCESS, NULL);
 378                 default: break;
 379                 }
 380                 break;
 381         }
 382         }
 383
 384         while (ix < argc) {
 385                 av[1] = argv[ix++];
 386                 cmd_ldlm_lock_flags();
 387         }
 388         return EXIT_SUCCESS;
 389 }
 390 #endif /* LDLM_FLAGS_PROGRAM */
 391 [= (out-pop) =][=
 392
 393 ENDIF TESTING
 394
 395  * Local Variables:
 396  * mode: C
 397  * c-file-style: "linux"
 398  * indent-tabs-mode: t
 399  * End:
 400
 401 =]