Lines Matching refs:buffer
51 * Sector aligned buffer routines for buffer create/read/write/access
56 * an operation involving the given XFS log buffer. Returns true if the fields
73 * Allocate a buffer to hold log data. The buffer needs to be able to map to
84 * Pass log block 0 since we don't have an addr yet, buffer will be
88 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
98 * In addition, the buffer may be used for a non-sector-aligned block
100 * beyond the end of the buffer. If the requested size is only 1 basic
103 * blocks (sector size 1). But otherwise we extend the buffer by one
115 * in a log buffer. The buffer covers a log sector-aligned region.
137 "Invalid log block/length (0x%llx, 0x%x) for buffer",
277 char *buffer,
291 error = xlog_bread(log, mid_blk, 1, buffer, &offset);
327 char *buffer;
333 * Greedily allocate a buffer big enough to handle the full
341 while (!(buffer = xlog_alloc_buffer(log, bufblks))) {
352 error = xlog_bread(log, i, bcount, buffer, &buf);
370 kmem_free(buffer);
392 * of the last block in the given buffer. extra_bblks contains the number
407 char *buffer;
417 buffer = xlog_alloc_buffer(log, num_blks);
418 if (!buffer) {
419 buffer = xlog_alloc_buffer(log, 1);
420 if (!buffer)
424 error = xlog_bread(log, start_blk, num_blks, buffer, &offset);
441 error = xlog_bread(log, i, 1, buffer, &offset);
486 kmem_free(buffer);
508 char *buffer;
538 buffer = xlog_alloc_buffer(log, 1);
539 if (!buffer)
542 error = xlog_bread(log, 0, 1, buffer, &offset);
549 error = xlog_bread(log, last_blk, 1, buffer, &offset);
619 error = xlog_find_cycle_start(log, buffer, first_blk, &head_blk,
636 * in one buffer.
740 kmem_free(buffer);
754 kmem_free(buffer);
765 * records encountered or a negative error code. The log block and buffer
774 char *buffer,
793 error = xlog_bread(log, i, 1, buffer, &offset);
812 error = xlog_bread(log, i, 1, buffer, &offset);
839 * buffer pointer of the last record seen are returned in rblk and rhead
848 char *buffer,
867 error = xlog_bread(log, i, 1, buffer, &offset);
885 error = xlog_bread(log, i, 1, buffer, &offset);
948 char *buffer;
955 buffer = xlog_alloc_buffer(log, 1);
956 if (!buffer)
963 error = xlog_seek_logrec_hdr(log, head_blk, *tail_blk, 1, buffer,
993 buffer, &tmp_tail, &thead, &wrapped);
1008 kmem_free(buffer);
1030 char *buffer,
1046 * that could have been in flight at one time. Use a temporary buffer so
1047 * we don't trash the rhead/buffer pointers from the caller.
1077 * Get the header block and buffer pointer for the last good
1085 buffer, rhead_blk, rhead, wrapped);
1145 char *buffer,
1173 error = xlog_bread(log, umount_data_blk, 1, buffer, &offset);
1241 * We could speed up search by using current head_blk buffer, but it is not
1252 char *buffer;
1266 buffer = xlog_alloc_buffer(log, 1);
1267 if (!buffer)
1270 error = xlog_bread(log, 0, 1, buffer, &offset);
1286 error = xlog_rseek_logrec_hdr(log, *head_blk, *head_blk, 1, buffer,
1308 rhead_blk, buffer, &clean);
1325 error = xlog_verify_head(log, head_blk, tail_blk, buffer,
1336 rhead, rhead_blk, buffer,
1374 kmem_free(buffer);
1402 char *buffer;
1412 buffer = xlog_alloc_buffer(log, 1);
1413 if (!buffer)
1415 error = xlog_bread(log, 0, 1, buffer, &offset);
1422 kmem_free(buffer);
1427 error = xlog_bread(log, log_bbnum-1, 1, buffer, &offset);
1433 kmem_free(buffer);
1439 error = xlog_find_cycle_start(log, buffer, 0, &last_blk, 0);
1480 kmem_free(buffer);
1488 * to initialize a buffer full of empty log record headers and write
1523 char *buffer;
1532 * Greedily allocate a buffer big enough to handle the full
1540 while (!(buffer = xlog_alloc_buffer(log, bufblks))) {
1547 * the buffer in the starting sector not covered by the first
1552 error = xlog_bread_noalign(log, start_block, 1, buffer);
1566 * the buffer in the final sector not covered by the write.
1572 buffer + BBTOB(ealign - start_block));
1578 offset = buffer + xlog_align(log, start_block);
1584 error = xlog_bwrite(log, start_block, endcount, buffer);
1592 kmem_free(buffer);
1808 * cancelled buffer and replaying the cancelled buffer can remove it
1809 * form the cancelled buffer table. Hence they have tobe done last.
1812 * read the buffer and replay changes into it. For filesystems using the
1818 * This ensures that inodes are completely flushed to the inode buffer
1824 * But there's a problem with that - we can't tell an inode allocation buffer
1825 * apart from a regular buffer, so we can't separate them. We can, however,
1826 * tell an inode unlink buffer from the others, and so we can separate them out
1831 * - item_list for all non-buffer items
1949 * If the transaction modifies a buffer or inode, do it now. Otherwise,
2353 * The recovered buffer queue is drained only once we know that all
2357 * - Buffer write submission updates the metadata LSN of the buffer.
2360 * - Separate recovery items against the same metadata buffer can share
2366 * In other words, we are allowed to submit a buffer from log recovery
2775 * Unlock the buffer so that it can be acquired in the normal
2778 * buffer, we don't even need to hold it locked to read the
2779 * initial unlinked bucket entries out of the buffer. We keep
2780 * buffer reference though, so that it stays pinned in memory
2781 * while we need the buffer.
2907 * and h_len must not be greater than LR buffer size.
2955 * Read the header of the tail block and get the iclog buffer size from
2978 * log buffer can be too small for the record and cause an
2981 * Detect this condition here. Use lsunit for the buffer size as
2983 * error to avoid a buffer overrun.
3002 * still allocate the buffer based on the incorrect on-disk
3064 * - we increased the buffer size originally
3126 * - we increased the buffer size originally
3316 * Now that we've finished replaying all buffer and inode updates,