1 /* 2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README 3 */ 4 5 #include <linux/time.h> 6 #include <linux/reiserfs_fs.h> 7 8 // this contains item handlers for old item types: sd, direct, 9 // indirect, directory 10 11 /* and where are the comments? how about saying where we can find an 12 explanation of each item handler method? -Hans */ 13 14 ////////////////////////////////////////////////////////////////////////////// 15 // stat data functions 16 // 17 static int sd_bytes_number(struct item_head *ih, int block_size) 18 { 19 return 0; 20 } 21 22 static void sd_decrement_key(struct cpu_key *key) 23 { 24 key->on_disk_key.k_objectid--; 25 set_cpu_key_k_type(key, TYPE_ANY); 26 set_cpu_key_k_offset(key, (loff_t) (-1)); 27 } 28 29 static int sd_is_left_mergeable(struct reiserfs_key *key, unsigned long bsize) 30 { 31 return 0; 32 } 33 34 static char *print_time(time_t t) 35 { 36 static char timebuf[256]; 37 38 sprintf(timebuf, "%ld", t); 39 return timebuf; 40 } 41 42 static void sd_print_item(struct item_head *ih, char *item) 43 { 44 printk("\tmode | size | nlinks | first direct | mtime\n"); 45 if (stat_data_v1(ih)) { 46 struct stat_data_v1 *sd = (struct stat_data_v1 *)item; 47 48 printk("\t0%-6o | %6u | %2u | %d | %s\n", sd_v1_mode(sd), 49 sd_v1_size(sd), sd_v1_nlink(sd), 50 sd_v1_first_direct_byte(sd), 51 print_time(sd_v1_mtime(sd))); 52 } else { 53 struct stat_data *sd = (struct stat_data *)item; 54 55 printk("\t0%-6o | %6Lu | %2u | %d | %s\n", sd_v2_mode(sd), 56 (unsigned long long)sd_v2_size(sd), sd_v2_nlink(sd), 57 sd_v2_rdev(sd), print_time(sd_v2_mtime(sd))); 58 } 59 } 60 61 static void sd_check_item(struct item_head *ih, char *item) 62 { 63 // FIXME: type something here! 64 } 65 66 static int sd_create_vi(struct virtual_node *vn, 67 struct virtual_item *vi, 68 int is_affected, int insert_size) 69 { 70 vi->vi_index = TYPE_STAT_DATA; 71 //vi->vi_type |= VI_TYPE_STAT_DATA;// not needed? 72 return 0; 73 } 74 75 static int sd_check_left(struct virtual_item *vi, int free, 76 int start_skip, int end_skip) 77 { 78 if (start_skip || end_skip) 79 BUG(); 80 return -1; 81 } 82 83 static int sd_check_right(struct virtual_item *vi, int free) 84 { 85 return -1; 86 } 87 88 static int sd_part_size(struct virtual_item *vi, int first, int count) 89 { 90 if (count) 91 BUG(); 92 return 0; 93 } 94 95 static int sd_unit_num(struct virtual_item *vi) 96 { 97 return vi->vi_item_len - IH_SIZE; 98 } 99 100 static void sd_print_vi(struct virtual_item *vi) 101 { 102 reiserfs_warning(NULL, "STATDATA, index %d, type 0x%x, %h", 103 vi->vi_index, vi->vi_type, vi->vi_ih); 104 } 105 106 static struct item_operations stat_data_ops = { 107 .bytes_number = sd_bytes_number, 108 .decrement_key = sd_decrement_key, 109 .is_left_mergeable = sd_is_left_mergeable, 110 .print_item = sd_print_item, 111 .check_item = sd_check_item, 112 113 .create_vi = sd_create_vi, 114 .check_left = sd_check_left, 115 .check_right = sd_check_right, 116 .part_size = sd_part_size, 117 .unit_num = sd_unit_num, 118 .print_vi = sd_print_vi 119 }; 120 121 ////////////////////////////////////////////////////////////////////////////// 122 // direct item functions 123 // 124 static int direct_bytes_number(struct item_head *ih, int block_size) 125 { 126 return ih_item_len(ih); 127 } 128 129 // FIXME: this should probably switch to indirect as well 130 static void direct_decrement_key(struct cpu_key *key) 131 { 132 cpu_key_k_offset_dec(key); 133 if (cpu_key_k_offset(key) == 0) 134 set_cpu_key_k_type(key, TYPE_STAT_DATA); 135 } 136 137 static int direct_is_left_mergeable(struct reiserfs_key *key, 138 unsigned long bsize) 139 { 140 int version = le_key_version(key); 141 return ((le_key_k_offset(version, key) & (bsize - 1)) != 1); 142 } 143 144 static void direct_print_item(struct item_head *ih, char *item) 145 { 146 int j = 0; 147 148 // return; 149 printk("\""); 150 while (j < ih_item_len(ih)) 151 printk("%c", item[j++]); 152 printk("\"\n"); 153 } 154 155 static void direct_check_item(struct item_head *ih, char *item) 156 { 157 // FIXME: type something here! 158 } 159 160 static int direct_create_vi(struct virtual_node *vn, 161 struct virtual_item *vi, 162 int is_affected, int insert_size) 163 { 164 vi->vi_index = TYPE_DIRECT; 165 //vi->vi_type |= VI_TYPE_DIRECT; 166 return 0; 167 } 168 169 static int direct_check_left(struct virtual_item *vi, int free, 170 int start_skip, int end_skip) 171 { 172 int bytes; 173 174 bytes = free - free % 8; 175 return bytes ? : -1; 176 } 177 178 static int direct_check_right(struct virtual_item *vi, int free) 179 { 180 return direct_check_left(vi, free, 0, 0); 181 } 182 183 static int direct_part_size(struct virtual_item *vi, int first, int count) 184 { 185 return count; 186 } 187 188 static int direct_unit_num(struct virtual_item *vi) 189 { 190 return vi->vi_item_len - IH_SIZE; 191 } 192 193 static void direct_print_vi(struct virtual_item *vi) 194 { 195 reiserfs_warning(NULL, "DIRECT, index %d, type 0x%x, %h", 196 vi->vi_index, vi->vi_type, vi->vi_ih); 197 } 198 199 static struct item_operations direct_ops = { 200 .bytes_number = direct_bytes_number, 201 .decrement_key = direct_decrement_key, 202 .is_left_mergeable = direct_is_left_mergeable, 203 .print_item = direct_print_item, 204 .check_item = direct_check_item, 205 206 .create_vi = direct_create_vi, 207 .check_left = direct_check_left, 208 .check_right = direct_check_right, 209 .part_size = direct_part_size, 210 .unit_num = direct_unit_num, 211 .print_vi = direct_print_vi 212 }; 213 214 ////////////////////////////////////////////////////////////////////////////// 215 // indirect item functions 216 // 217 218 static int indirect_bytes_number(struct item_head *ih, int block_size) 219 { 220 return ih_item_len(ih) / UNFM_P_SIZE * block_size; //- get_ih_free_space (ih); 221 } 222 223 // decrease offset, if it becomes 0, change type to stat data 224 static void indirect_decrement_key(struct cpu_key *key) 225 { 226 cpu_key_k_offset_dec(key); 227 if (cpu_key_k_offset(key) == 0) 228 set_cpu_key_k_type(key, TYPE_STAT_DATA); 229 } 230 231 // if it is not first item of the body, then it is mergeable 232 static int indirect_is_left_mergeable(struct reiserfs_key *key, 233 unsigned long bsize) 234 { 235 int version = le_key_version(key); 236 return (le_key_k_offset(version, key) != 1); 237 } 238 239 // printing of indirect item 240 static void start_new_sequence(__u32 * start, int *len, __u32 new) 241 { 242 *start = new; 243 *len = 1; 244 } 245 246 static int sequence_finished(__u32 start, int *len, __u32 new) 247 { 248 if (start == INT_MAX) 249 return 1; 250 251 if (start == 0 && new == 0) { 252 (*len)++; 253 return 0; 254 } 255 if (start != 0 && (start + *len) == new) { 256 (*len)++; 257 return 0; 258 } 259 return 1; 260 } 261 262 static void print_sequence(__u32 start, int len) 263 { 264 if (start == INT_MAX) 265 return; 266 267 if (len == 1) 268 printk(" %d", start); 269 else 270 printk(" %d(%d)", start, len); 271 } 272 273 static void indirect_print_item(struct item_head *ih, char *item) 274 { 275 int j; 276 __le32 *unp; 277 __u32 prev = INT_MAX; 278 int num = 0; 279 280 unp = (__le32 *) item; 281 282 if (ih_item_len(ih) % UNFM_P_SIZE) 283 reiserfs_warning(NULL, "indirect_print_item: invalid item len"); 284 285 printk("%d pointers\n[ ", (int)I_UNFM_NUM(ih)); 286 for (j = 0; j < I_UNFM_NUM(ih); j++) { 287 if (sequence_finished(prev, &num, get_block_num(unp, j))) { 288 print_sequence(prev, num); 289 start_new_sequence(&prev, &num, get_block_num(unp, j)); 290 } 291 } 292 print_sequence(prev, num); 293 printk("]\n"); 294 } 295 296 static void indirect_check_item(struct item_head *ih, char *item) 297 { 298 // FIXME: type something here! 299 } 300 301 static int indirect_create_vi(struct virtual_node *vn, 302 struct virtual_item *vi, 303 int is_affected, int insert_size) 304 { 305 vi->vi_index = TYPE_INDIRECT; 306 //vi->vi_type |= VI_TYPE_INDIRECT; 307 return 0; 308 } 309 310 static int indirect_check_left(struct virtual_item *vi, int free, 311 int start_skip, int end_skip) 312 { 313 int bytes; 314 315 bytes = free - free % UNFM_P_SIZE; 316 return bytes ? : -1; 317 } 318 319 static int indirect_check_right(struct virtual_item *vi, int free) 320 { 321 return indirect_check_left(vi, free, 0, 0); 322 } 323 324 // return size in bytes of 'units' units. If first == 0 - calculate from the head (left), otherwise - from tail (right) 325 static int indirect_part_size(struct virtual_item *vi, int first, int units) 326 { 327 // unit of indirect item is byte (yet) 328 return units; 329 } 330 331 static int indirect_unit_num(struct virtual_item *vi) 332 { 333 // unit of indirect item is byte (yet) 334 return vi->vi_item_len - IH_SIZE; 335 } 336 337 static void indirect_print_vi(struct virtual_item *vi) 338 { 339 reiserfs_warning(NULL, "INDIRECT, index %d, type 0x%x, %h", 340 vi->vi_index, vi->vi_type, vi->vi_ih); 341 } 342 343 static struct item_operations indirect_ops = { 344 .bytes_number = indirect_bytes_number, 345 .decrement_key = indirect_decrement_key, 346 .is_left_mergeable = indirect_is_left_mergeable, 347 .print_item = indirect_print_item, 348 .check_item = indirect_check_item, 349 350 .create_vi = indirect_create_vi, 351 .check_left = indirect_check_left, 352 .check_right = indirect_check_right, 353 .part_size = indirect_part_size, 354 .unit_num = indirect_unit_num, 355 .print_vi = indirect_print_vi 356 }; 357 358 ////////////////////////////////////////////////////////////////////////////// 359 // direntry functions 360 // 361 362 static int direntry_bytes_number(struct item_head *ih, int block_size) 363 { 364 reiserfs_warning(NULL, "vs-16090: direntry_bytes_number: " 365 "bytes number is asked for direntry"); 366 return 0; 367 } 368 369 static void direntry_decrement_key(struct cpu_key *key) 370 { 371 cpu_key_k_offset_dec(key); 372 if (cpu_key_k_offset(key) == 0) 373 set_cpu_key_k_type(key, TYPE_STAT_DATA); 374 } 375 376 static int direntry_is_left_mergeable(struct reiserfs_key *key, 377 unsigned long bsize) 378 { 379 if (le32_to_cpu(key->u.k_offset_v1.k_offset) == DOT_OFFSET) 380 return 0; 381 return 1; 382 383 } 384 385 static void direntry_print_item(struct item_head *ih, char *item) 386 { 387 int i; 388 int namelen; 389 struct reiserfs_de_head *deh; 390 char *name; 391 static char namebuf[80]; 392 393 printk("\n # %-15s%-30s%-15s%-15s%-15s\n", "Name", 394 "Key of pointed object", "Hash", "Gen number", "Status"); 395 396 deh = (struct reiserfs_de_head *)item; 397 398 for (i = 0; i < I_ENTRY_COUNT(ih); i++, deh++) { 399 namelen = 400 (i ? (deh_location(deh - 1)) : ih_item_len(ih)) - 401 deh_location(deh); 402 name = item + deh_location(deh); 403 if (name[namelen - 1] == 0) 404 namelen = strlen(name); 405 namebuf[0] = '"'; 406 if (namelen > sizeof(namebuf) - 3) { 407 strncpy(namebuf + 1, name, sizeof(namebuf) - 3); 408 namebuf[sizeof(namebuf) - 2] = '"'; 409 namebuf[sizeof(namebuf) - 1] = 0; 410 } else { 411 memcpy(namebuf + 1, name, namelen); 412 namebuf[namelen + 1] = '"'; 413 namebuf[namelen + 2] = 0; 414 } 415 416 printk("%d: %-15s%-15d%-15d%-15Ld%-15Ld(%s)\n", 417 i, namebuf, 418 deh_dir_id(deh), deh_objectid(deh), 419 GET_HASH_VALUE(deh_offset(deh)), 420 GET_GENERATION_NUMBER((deh_offset(deh))), 421 (de_hidden(deh)) ? "HIDDEN" : "VISIBLE"); 422 } 423 } 424 425 static void direntry_check_item(struct item_head *ih, char *item) 426 { 427 int i; 428 struct reiserfs_de_head *deh; 429 430 // FIXME: type something here! 431 deh = (struct reiserfs_de_head *)item; 432 for (i = 0; i < I_ENTRY_COUNT(ih); i++, deh++) { 433 ; 434 } 435 } 436 437 #define DIRENTRY_VI_FIRST_DIRENTRY_ITEM 1 438 439 /* 440 * function returns old entry number in directory item in real node 441 * using new entry number in virtual item in virtual node */ 442 static inline int old_entry_num(int is_affected, int virtual_entry_num, 443 int pos_in_item, int mode) 444 { 445 if (mode == M_INSERT || mode == M_DELETE) 446 return virtual_entry_num; 447 448 if (!is_affected) 449 /* cut or paste is applied to another item */ 450 return virtual_entry_num; 451 452 if (virtual_entry_num < pos_in_item) 453 return virtual_entry_num; 454 455 if (mode == M_CUT) 456 return virtual_entry_num + 1; 457 458 RFALSE(mode != M_PASTE || virtual_entry_num == 0, 459 "vs-8015: old_entry_num: mode must be M_PASTE (mode = \'%c\'", 460 mode); 461 462 return virtual_entry_num - 1; 463 } 464 465 /* Create an array of sizes of directory entries for virtual 466 item. Return space used by an item. FIXME: no control over 467 consuming of space used by this item handler */ 468 static int direntry_create_vi(struct virtual_node *vn, 469 struct virtual_item *vi, 470 int is_affected, int insert_size) 471 { 472 struct direntry_uarea *dir_u = vi->vi_uarea; 473 int i, j; 474 int size = sizeof(struct direntry_uarea); 475 struct reiserfs_de_head *deh; 476 477 vi->vi_index = TYPE_DIRENTRY; 478 479 if (!(vi->vi_ih) || !vi->vi_item) 480 BUG(); 481 482 dir_u->flags = 0; 483 if (le_ih_k_offset(vi->vi_ih) == DOT_OFFSET) 484 dir_u->flags |= DIRENTRY_VI_FIRST_DIRENTRY_ITEM; 485 486 deh = (struct reiserfs_de_head *)(vi->vi_item); 487 488 /* virtual directory item have this amount of entry after */ 489 dir_u->entry_count = ih_entry_count(vi->vi_ih) + 490 ((is_affected) ? ((vn->vn_mode == M_CUT) ? -1 : 491 (vn->vn_mode == M_PASTE ? 1 : 0)) : 0); 492 493 for (i = 0; i < dir_u->entry_count; i++) { 494 j = old_entry_num(is_affected, i, vn->vn_pos_in_item, 495 vn->vn_mode); 496 dir_u->entry_sizes[i] = 497 (j ? deh_location(&(deh[j - 1])) : ih_item_len(vi->vi_ih)) - 498 deh_location(&(deh[j])) + DEH_SIZE; 499 } 500 501 size += (dir_u->entry_count * sizeof(short)); 502 503 /* set size of pasted entry */ 504 if (is_affected && vn->vn_mode == M_PASTE) 505 dir_u->entry_sizes[vn->vn_pos_in_item] = insert_size; 506 507 #ifdef CONFIG_REISERFS_CHECK 508 /* compare total size of entries with item length */ 509 { 510 int k, l; 511 512 l = 0; 513 for (k = 0; k < dir_u->entry_count; k++) 514 l += dir_u->entry_sizes[k]; 515 516 if (l + IH_SIZE != vi->vi_item_len + 517 ((is_affected 518 && (vn->vn_mode == M_PASTE 519 || vn->vn_mode == M_CUT)) ? insert_size : 0)) { 520 reiserfs_panic(NULL, 521 "vs-8025: set_entry_sizes: (mode==%c, insert_size==%d), invalid length of directory item", 522 vn->vn_mode, insert_size); 523 } 524 } 525 #endif 526 527 return size; 528 529 } 530 531 // 532 // return number of entries which may fit into specified amount of 533 // free space, or -1 if free space is not enough even for 1 entry 534 // 535 static int direntry_check_left(struct virtual_item *vi, int free, 536 int start_skip, int end_skip) 537 { 538 int i; 539 int entries = 0; 540 struct direntry_uarea *dir_u = vi->vi_uarea; 541 542 for (i = start_skip; i < dir_u->entry_count - end_skip; i++) { 543 if (dir_u->entry_sizes[i] > free) 544 /* i-th entry doesn't fit into the remaining free space */ 545 break; 546 547 free -= dir_u->entry_sizes[i]; 548 entries++; 549 } 550 551 if (entries == dir_u->entry_count) { 552 reiserfs_panic(NULL, "free space %d, entry_count %d\n", free, 553 dir_u->entry_count); 554 } 555 556 /* "." and ".." can not be separated from each other */ 557 if (start_skip == 0 && (dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM) 558 && entries < 2) 559 entries = 0; 560 561 return entries ? : -1; 562 } 563 564 static int direntry_check_right(struct virtual_item *vi, int free) 565 { 566 int i; 567 int entries = 0; 568 struct direntry_uarea *dir_u = vi->vi_uarea; 569 570 for (i = dir_u->entry_count - 1; i >= 0; i--) { 571 if (dir_u->entry_sizes[i] > free) 572 /* i-th entry doesn't fit into the remaining free space */ 573 break; 574 575 free -= dir_u->entry_sizes[i]; 576 entries++; 577 } 578 if (entries == dir_u->entry_count) 579 BUG(); 580 581 /* "." and ".." can not be separated from each other */ 582 if ((dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM) 583 && entries > dir_u->entry_count - 2) 584 entries = dir_u->entry_count - 2; 585 586 return entries ? : -1; 587 } 588 589 /* sum of entry sizes between from-th and to-th entries including both edges */ 590 static int direntry_part_size(struct virtual_item *vi, int first, int count) 591 { 592 int i, retval; 593 int from, to; 594 struct direntry_uarea *dir_u = vi->vi_uarea; 595 596 retval = 0; 597 if (first == 0) 598 from = 0; 599 else 600 from = dir_u->entry_count - count; 601 to = from + count - 1; 602 603 for (i = from; i <= to; i++) 604 retval += dir_u->entry_sizes[i]; 605 606 return retval; 607 } 608 609 static int direntry_unit_num(struct virtual_item *vi) 610 { 611 struct direntry_uarea *dir_u = vi->vi_uarea; 612 613 return dir_u->entry_count; 614 } 615 616 static void direntry_print_vi(struct virtual_item *vi) 617 { 618 int i; 619 struct direntry_uarea *dir_u = vi->vi_uarea; 620 621 reiserfs_warning(NULL, "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x", 622 vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags); 623 printk("%d entries: ", dir_u->entry_count); 624 for (i = 0; i < dir_u->entry_count; i++) 625 printk("%d ", dir_u->entry_sizes[i]); 626 printk("\n"); 627 } 628 629 static struct item_operations direntry_ops = { 630 .bytes_number = direntry_bytes_number, 631 .decrement_key = direntry_decrement_key, 632 .is_left_mergeable = direntry_is_left_mergeable, 633 .print_item = direntry_print_item, 634 .check_item = direntry_check_item, 635 636 .create_vi = direntry_create_vi, 637 .check_left = direntry_check_left, 638 .check_right = direntry_check_right, 639 .part_size = direntry_part_size, 640 .unit_num = direntry_unit_num, 641 .print_vi = direntry_print_vi 642 }; 643 644 ////////////////////////////////////////////////////////////////////////////// 645 // Error catching functions to catch errors caused by incorrect item types. 646 // 647 static int errcatch_bytes_number(struct item_head *ih, int block_size) 648 { 649 reiserfs_warning(NULL, 650 "green-16001: Invalid item type observed, run fsck ASAP"); 651 return 0; 652 } 653 654 static void errcatch_decrement_key(struct cpu_key *key) 655 { 656 reiserfs_warning(NULL, 657 "green-16002: Invalid item type observed, run fsck ASAP"); 658 } 659 660 static int errcatch_is_left_mergeable(struct reiserfs_key *key, 661 unsigned long bsize) 662 { 663 reiserfs_warning(NULL, 664 "green-16003: Invalid item type observed, run fsck ASAP"); 665 return 0; 666 } 667 668 static void errcatch_print_item(struct item_head *ih, char *item) 669 { 670 reiserfs_warning(NULL, 671 "green-16004: Invalid item type observed, run fsck ASAP"); 672 } 673 674 static void errcatch_check_item(struct item_head *ih, char *item) 675 { 676 reiserfs_warning(NULL, 677 "green-16005: Invalid item type observed, run fsck ASAP"); 678 } 679 680 static int errcatch_create_vi(struct virtual_node *vn, 681 struct virtual_item *vi, 682 int is_affected, int insert_size) 683 { 684 reiserfs_warning(NULL, 685 "green-16006: Invalid item type observed, run fsck ASAP"); 686 return 0; // We might return -1 here as well, but it won't help as create_virtual_node() from where 687 // this operation is called from is of return type void. 688 } 689 690 static int errcatch_check_left(struct virtual_item *vi, int free, 691 int start_skip, int end_skip) 692 { 693 reiserfs_warning(NULL, 694 "green-16007: Invalid item type observed, run fsck ASAP"); 695 return -1; 696 } 697 698 static int errcatch_check_right(struct virtual_item *vi, int free) 699 { 700 reiserfs_warning(NULL, 701 "green-16008: Invalid item type observed, run fsck ASAP"); 702 return -1; 703 } 704 705 static int errcatch_part_size(struct virtual_item *vi, int first, int count) 706 { 707 reiserfs_warning(NULL, 708 "green-16009: Invalid item type observed, run fsck ASAP"); 709 return 0; 710 } 711 712 static int errcatch_unit_num(struct virtual_item *vi) 713 { 714 reiserfs_warning(NULL, 715 "green-16010: Invalid item type observed, run fsck ASAP"); 716 return 0; 717 } 718 719 static void errcatch_print_vi(struct virtual_item *vi) 720 { 721 reiserfs_warning(NULL, 722 "green-16011: Invalid item type observed, run fsck ASAP"); 723 } 724 725 static struct item_operations errcatch_ops = { 726 errcatch_bytes_number, 727 errcatch_decrement_key, 728 errcatch_is_left_mergeable, 729 errcatch_print_item, 730 errcatch_check_item, 731 732 errcatch_create_vi, 733 errcatch_check_left, 734 errcatch_check_right, 735 errcatch_part_size, 736 errcatch_unit_num, 737 errcatch_print_vi 738 }; 739 740 ////////////////////////////////////////////////////////////////////////////// 741 // 742 // 743 #if ! (TYPE_STAT_DATA == 0 && TYPE_INDIRECT == 1 && TYPE_DIRECT == 2 && TYPE_DIRENTRY == 3) 744 #error Item types must use disk-format assigned values. 745 #endif 746 747 struct item_operations *item_ops[TYPE_ANY + 1] = { 748 &stat_data_ops, 749 &indirect_ops, 750 &direct_ops, 751 &direntry_ops, 752 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 753 &errcatch_ops /* This is to catch errors with invalid type (15th entry for TYPE_ANY) */ 754 }; 755