Lines Matching defs:block

80  * for file header and block header are.
92 * (Private) Allocate a new block. Return NULL on failure. 'istag'
93 * is true if the block is to be non-reclaimable.
98 tnf_block_header_t *block;
132 /* Get the block shift and generation shift values. */
149 * If we need a tag block, check the reserved tag block space
157 block = (tnf_block_header_t *) ((char *) fh + i);
158 if (!tnfw_b_get_lock(&block->A_lock) &&
159 block->generation == 0)
170 block->tag = TNFW_B_TAG_DIFF(
173 block->generation = TNF_TAG_GENERATION_NUM;
174 block->bytes_valid = sizeof (tnf_block_header_t);
175 block->next_block = NULL;
176 tnfw_b_clear_lock(&block->A_lock);
177 return (block);
202 block = (tnf_block_header_t *)
206 if (block->generation == TNF_TAG_GENERATION_NUM)
208 else if (block->generation >= generation)
210 else if (tnfw_b_get_lock(&block->A_lock))
212 else if (block->generation == TNF_TAG_GENERATION_NUM)
214 else if (block->generation >= generation)
216 else if (tnfw_b_get_lock(&block->B_lock)) {
217 tnfw_b_clear_lock(&block->A_lock);
223 if (block->generation < generation &&
224 !tnfw_b_get_lock(&block->A_lock)) {
225 if (block->generation < generation &&
226 !tnfw_b_get_lock(&block->B_lock)) {
229 tnfw_b_clear_lock(&block->A_lock);
251 "alloc_block (%d): got blocknum = %d, gen %d, block at 0x%x\n",
252 thr_self(), blocknum, generation, block);
255 block->tag = TNFW_B_TAG_DIFF(forwarding_ptrs.fw_block_header, fh);
256 block->generation = (istag) ? TNF_TAG_GENERATION_NUM : generation;
257 block->bytes_valid = sizeof (tnf_block_header_t);
258 block->next_block = NULL;
260 tnfw_b_clear_lock(&block->A_lock);
262 tnfw_b_clear_lock(&block->B_lock);
307 return (block);
331 * are currently rejected. The code "ought to work" with any block
343 tnf_block_header_t *block;
355 * Check to see if block size is a power of 2, and get
356 * log2(block size).
367 /* reserve first two words for file header tag and block header tag */
417 block = (tnf_block_header_t *)
420 block->tag = 0;
421 block->generation = 0;
422 tnfw_b_clear_lock(&block->A_lock);
423 tnfw_b_clear_lock(&block->B_lock);
443 tnf_block_header_t *block, *new_block;
469 block = pos->tnfw_w_block;
478 if (block != NULL && wcb->tnfw_w_a_lock_released) {
479 /* re-acquire the A-lock for the current block */
480 if (!tnfw_b_get_lock(&block->A_lock)) {
482 if (wcb->tnfw_w_generation != block->generation) {
483 tnfw_b_clear_lock(&block->A_lock);
491 if (block == NULL || offset + size > fh->com.block_size) {
499 "wcb 0x%x: new block at 0x%x, old block is 0x%x, "
501 wcb, new_block, block, pos->tnfw_w_uncommitted);
503 if (block != NULL) {
506 (void) bzero((char *)block + offset,
509 (void) memset((char *)block + offset, 0,
514 /* Could still be holding the A-lock on block */
516 tnfw_b_clear_lock(&block->A_lock);
519 tnfw_b_clear_lock(&block->A_lock);
527 /* Assert(block != NULL); */
528 block->next_block = new_block;
533 pos->tnfw_w_uncommitted = block;
559 tnf_block_header_t *block;
569 * cope with the normal record block(s) first
573 block = pos->tnfw_w_uncommitted;
574 while (block && (block != pos->tnfw_w_block)) {
576 fprintf(stderr, "commit %d: block = 0x%x, last = 0x%x\n",
577 block->generation, block, pos->tnfw_w_block);
579 block->bytes_valid = fh->com.block_size;
580 pos->tnfw_w_uncommitted = block->next_block;
581 tnfw_b_clear_lock(&block->A_lock);
582 block = pos->tnfw_w_uncommitted;
584 if (block != NULL) {
586 fprintf(stderr, "commit last %d: block = 0x%x, offset = 0x%x\n",
587 block->generation, block, pos->tnfw_w_write_off);
589 block->bytes_valid = pos->tnfw_w_write_off;
594 wcb->tnfw_w_generation = block->generation;
595 tnfw_b_clear_lock(&block->A_lock);
601 * cope with the tag block(s)
605 block = pos->tnfw_w_uncommitted;
606 while (block && (block != pos->tnfw_w_block)) {
608 fprintf(stderr, "commit %d: block = 0x%x, last = 0x%x\n",
609 thr_self(), block, pos->tnfw_w_block);
611 block->bytes_valid = fh->com.block_size;
612 pos->tnfw_w_uncommitted = block->next_block;
613 block = pos->tnfw_w_uncommitted;
615 if (block != NULL)
616 block->bytes_valid = pos->tnfw_w_write_off;
628 tnf_block_header_t *block, *next;
633 block = pos->tnfw_w_block = pos->tnfw_w_uncommitted;
634 if (block != NULL) {
635 pos->tnfw_w_write_off = block->bytes_valid;
638 tnfw_b_clear_lock(&block->A_lock);
639 wcb->tnfw_w_generation = block->generation;
643 block = block->next_block;
645 while (block != NULL) {
646 next = block->next_block;
647 tnfw_b_clear_lock(&block->A_lock);
648 block = next;
652 block = pos->tnfw_w_uncommitted;
653 while (block && (block != pos->tnfw_w_block)) {
654 block->bytes_valid = fh->com.block_size;
655 pos->tnfw_w_uncommitted = block->next_block;
656 block = pos->tnfw_w_uncommitted;
658 if (block != NULL)
659 block->bytes_valid = pos->tnfw_w_write_off;