Lines Matching refs:space
94 * track the space used by the log vectors separately to prevent log space hangs
95 * due to inaccurate accounting (i.e. a leak) of the used log space through the
98 * We also add space for the xlog_op_header that describes this region in the
154 int cycle, space;
156 xlog_crack_grant_head_val(head_val, &cycle, &space);
158 space -= bytes;
159 if (space < 0) {
160 space += log->l_logsize;
165 new = xlog_assign_grant_head_val(cycle, space);
181 int cycle, space;
183 xlog_crack_grant_head_val(head_val, &cycle, &space);
185 tmp = log->l_logsize - space;
187 space += bytes;
189 space = bytes - tmp;
194 new = xlog_assign_grant_head_val(cycle, space);
258 * move, there still won't be space available for the
264 * Therefore, if there isn't space to wake the first waiter on
323 * Atomically get the log space required for a log ticket.
354 * up all the waiters then go to sleep waiting for more free space,
355 * otherwise try to get some space for this transaction.
452 * Reserve log space and return a ticket corresponding to the reservation.
454 * Each reservation is going to reserve extra space for a log record header.
456 * log record header from any reservation. By wasting space in each
510 * space waiters so they can process the newly set shutdown state. We really
666 * parameters, we can validate the given log space and drop a critical
668 * small can lead to unexpected situations in transaction log space
737 * space grant counters are, we can initialise the permanent ticket
904 * the data space used in the unmount ticket as this write is not done from a
941 /* account for space used by record data */
1136 * Wake up processes waiting for log space after we have moved the log tail.
1178 * cover the log as we may be in a situation where there isn't log space
1317 * Return the space in the log between the tail and the head. The head
1320 * longer valid. In this case, just return 0 which means there is no space
1362 * return the size of the log as the amount of space left.
1676 * (a) enough on-disk log space to log the number of bytes specified, (b) at
1677 * least 25% of the log space free, and (c) at least 256 blocks free. If the
1678 * log free space already meets all three thresholds, this function returns
1732 * Push the tail of the log if we need to do so to maintain the free log space
2235 * to have enough space to write the entire log vector into.
2299 * length. We write until we cannot fit a full record into the remaining space
2319 /* walk the logvec, copying until we run out of space in the iclog */
2332 * Hence if there isn't space for region data after the
2370 * space in an iclog and hence requiring us to release the iclog
2373 * space for log transaction opheaders left in the current
2376 * space left in the current iclog, and check for the end of the
2382 * space we need in the new iclog by adding that size
2384 * needs to be accounted to the ticket as the space it
2445 * A. Reserve as much space in this iclog as can get
2470 * we don't really know exactly how much space will be used. As a result,
2538 * the current iclog, and hence it will already have the space used by
2696 * amount of log space bound up in this committing transaction then the
2698 * freeing space in the log. Hence once we've updated the last_sync_lsn we
2887 * log's data space.
3015 /* just return if we still have some of the pre-reserved space */
3028 * Give back the space left from a reservation.
3030 * All the information we need to make a correct determination of space left
3033 * space remaining in the current reservation part of the ticket. If the
3034 * ticket contains a permanent reservation, there may be left over space which
3036 * reservation can be done before we need to ask for more space. The first
3038 * space, the count will stay at zero and the only space remaining will be
3057 * up more space based on the remaining count.
3406 * Figure out the total log space unit (in bytes) that would be
3420 * in the log. A unit in this case is the amount of space for one
3422 * and their unit amount is the total amount of space required.
3425 * which occupy space in the on-disk log.
3434 * more space.
3457 * for LR headers - the space for data in an iclog is the size minus
3458 * the space used for the headers. If we use the iclog size, then we
3462 * increase the space required enough to require more log and op
3467 * accounted to it, then the remaining space in the iclog is
3554 int cycle, space;
3556 xlog_crack_grant_head(&log->l_write_head.grant, &cycle, &space);
3565 if (space > BBTOB(tail_blocks) &&
3568 "%s: space > BBTOB(tail_blocks)", __func__);
3586 xfs_emerg(log->l_mp, "%s: ran out of log space", __func__);
3595 xfs_emerg(log->l_mp, "%s: ran out of log space", __func__);
3607 * B. tid ptr value falls in valid ptr space (user space code)