| /linux/fs/jbd2/ |
| H A D | checkpoint.c | 26 * Unlink a buffer from a transaction checkpoint list.
32 transaction_t *transaction = jh->b_cp_transaction; in __buffer_unlink() local
36 if (transaction->t_checkpoint_list == jh) { in __buffer_unlink()
37 transaction->t_checkpoint_list = jh->b_cpnext; in __buffer_unlink()
38 if (transaction->t_checkpoint_list == jh) in __buffer_unlink()
39 transaction->t_checkpoint_list = NULL; in __buffer_unlink()
67 * transaction to complete. If there is absolutely no way in __jbd2_log_wait_for_space()
147 * Perform an actual checkpoint. We take the first transaction on the
158 transaction_t *transaction; in jbd2_log_do_checkpoint() local
176 * OK, we need to start writing disk blocks. Take one transaction in jbd2_log_do_checkpoint()
[all …]
|
| H A D | revoke.c | 17 * transaction's revoked blocks to the journal
19 * + Recovery: during recovery we record the transaction ID of all
26 * single transaction:
30 * cancel the revoke before the transaction commits.
37 * in the current transaction, so any revoke for that block in the
38 * transaction must have happened after the block was journaled and so
47 * We cache revoke status of a buffer in the current transaction in b_states
62 * running transaction (is pointed to by journal->j_revoke), the other one
63 * belongs to the committing transaction. Accesses to the second hash table
66 * running and which to the committing transaction is called only from
[all …]
|
| H A D | journal.c | 163 transaction_t *transaction; in kjournald2() local
180 * transaction commit and any fs involvement might get stuck waiting for in kjournald2()
226 transaction = journal->j_running_transaction; in kjournald2()
227 if (transaction == NULL || in kjournald2()
228 time_before(jiffies, transaction->t_expires)) { in kjournald2()
241 transaction = journal->j_running_transaction; in kjournald2()
242 if (transaction && time_after_eq(jiffies, transaction->t_expires)) { in kjournald2()
243 journal->j_commit_request = transaction->t_tid; in kjournald2()
311 * If the source buffer has already been modified by a new transaction
325 int jbd2_journal_write_metadata_buffer(transaction_t *transaction, in jbd2_journal_write_metadata_buffer() argument
[all …]
|
| /linux/drivers/net/ipa/ |
| H A D | gsi_trans.h | 24 /* Maximum number of TREs in an IPA immediate command transaction */
28 * struct gsi_trans - a GSI transaction
30 * Most fields in this structure for internal use by the transaction core code:
32 * @channel_id: Channel number transaction is associated with
33 * @cancelled: If set by the core code, transaction was cancelled
34 * @rsvd_count: Number of TREs reserved for this transaction
36 * @len: Number of bytes sent or received by the transaction
37 * @data: Preserved but not touched by the core transaction code
42 * @completion: Completed when the transaction completes
43 * @byte_count: TX channel byte count recorded when transaction committed
[all …]
|
| H A D | gsi_private.h | 21 * gsi_trans_move_complete() - Mark a GSI transaction completed
22 * @trans: Transaction whose state is to be updated
27 * gsi_trans_move_polled() - Mark a transaction polled
28 * @trans: Transaction whose state is to be updated
33 * gsi_trans_complete() - Complete a GSI transaction
34 * @trans: Transaction to complete
36 * Marks a transaction complete (including freeing it).
41 * gsi_channel_trans_mapped() - Return a transaction mapped to a TRE index
42 * @channel: Channel associated with the transaction
43 * @index: Index of the TRE having a transaction
[all …]
|
| H A D | gsi_trans.c | 24 * A GSI transaction abstracts the behavior of a GSI channel by representing
28 * by the GSI transaction core, allowing users to simply describe operations
29 * to be performed. When a transaction has completed a callback function
31 * cleanup of resources associated with the transaction.
33 * To perform an operation (or set of them), a user of the GSI transaction
34 * interface allocates a transaction, indicating the number of TREs required
36 * for use in the transaction and the allocation succeeds. This way
39 * transaction are also allocated when the transaction is allocated.
41 * Operations performed as part of a transaction are represented in an array
42 * of Linux scatterlist structures, allocated with the transaction. These
[all …]
|
| H A D | ipa_cmd.h | 72 * ipa_cmd_table_init_add() - Add table init command to a transaction
73 * @trans: GSI transaction
90 * ipa_cmd_hdr_init_local_add() - Add a header init command to a transaction
91 * @trans: GSI transaction
102 * ipa_cmd_register_write_add() - Add a register write command to a transaction
103 * @trans: GSI transaction
113 * ipa_cmd_dma_shared_mem_add() - Add a DMA memory command to a transaction
114 * @trans: GSI transaction
124 * ipa_cmd_pipeline_clear_add() - Add pipeline clear commands to a transaction
125 * @trans: GSI transaction
[all …]
|
| H A D | ipa_gsi.h | 16 * ipa_gsi_trans_complete() - GSI transaction completion callback
17 * @trans: Transaction that has completed
20 * transaction has completed.
25 * ipa_gsi_trans_release() - GSI transaction release callback
26 * @trans: Transaction whose resources should be freed
29 * transaction is about to be freed, so any resources associated
48 * ipa_gsi_channel_tx_completed() - GSI transaction completion callback
|
| /linux/fs/btrfs/ |
| H A D | transaction.c | 18 #include "transaction.h"
39 * Transaction states and transitions
41 * No running transaction (fs tree blocks are not modified)
46 * Transaction N [[TRANS_STATE_RUNNING]]
48 * | New trans handles can be attached to transaction N by calling all
53 * | transaction N
55 * Transaction N [[TRANS_STATE_COMMIT_PREP]]
58 * | the race and the rest will wait for the winner to commit the transaction.
60 * | The winner will wait for previous running transaction to completely finish
63 * Transaction N [[TRANS_STATE_COMMIT_START]]
[all …]
|
| H A D | transaction.h | 36 /* Radix-tree tag for roots that are part of the transaction. */
58 * transaction, it must be zero before the transaction is
63 * total writers in this transaction, it must be zero before the
64 * transaction can end
87 * it do so under some form of transaction critical section, namely:
90 * run by one of the transaction committers. Refer to
94 * commit_cowonly_roots from transaction critical section
97 * - btrfs_cleanup_dirty_bgs - called on transaction abort
117 * Number of ordered extents the transaction must wait for before
149 struct btrfs_transaction *transaction; member
[all …]
|
| /linux/Documentation/arch/powerpc/ |
| H A D | transactional_memory.rst | 21 A simple transaction looks like this::
41 /* Retry the transaction if it failed because it conflicted with
50 example, the transaction completes as though it were normal straight-line code
58 transaction, the transaction will be aborted by the CPU. Register and memory
66 Causes of transaction aborts
78 Syscalls made from within an active transaction will not be performed and the
79 transaction will be doomed by the kernel with the failure code TM_CAUSE_SYSCALL
82 Syscalls made from within a suspended transaction are performed as normal and
83 the transaction is not explicitly doomed by the kernel. However, what the
84 kernel does to perform the syscall may result in the transaction being doomed
[all …]
|
| /linux/include/linux/ |
| H A D | journal-head.h | 16 typedef unsigned int tid_t; /* Unique transaction ID */
17 typedef struct transaction_s transaction_t; /* Compound transaction type */
50 * the currently running transaction
69 * Pointer to the compound transaction which owns this buffer's
70 * metadata: either the running transaction or the committing
71 * transaction (if there is one). Only applies to buffers on a
72 * transaction's data or metadata journaling list.
80 * Pointer to the running compound transaction which is currently
81 * modifying the buffer's metadata, if there was already a transaction
82 * committing it when the new transaction touched it.
[all …]
|
| /linux/fs/xfs/ |
| H A D | xfs_trans.c | 52 * Initialize the precomputed transaction reservation values
64 * Free the transaction structure. If there is more clean up
83 * This is called to create a new transaction which will share the
84 * permanent log reservation of the given transaction. The remaining
86 * implies that the original transaction is no longer allowed to allocate
88 * be added to the new transaction explicitly.
101 * Initialize the new transaction structure. in xfs_trans_dup()
116 /* We gave our writer reference to the new transaction */ in xfs_trans_dup()
138 * transaction before allocating any resources within the transaction.
172 * Reserve the log space needed for this transaction. in xfs_trans_reserve()
[all …]
|
| H A D | xfs_trans_buf.c | 20 * a part of the given transaction.
52 * Add the locked buffer to the transaction.
55 * transaction.
58 * then allocate one for it. Then add the buf item to the transaction.
84 * Take a reference for this transaction on the buf item. in _xfs_trans_bjoin()
89 * Attach the item to the transaction so we can find it in in _xfs_trans_bjoin()
108 * locked within the given transaction. If it is already locked
109 * within the transaction, just increment its lock recursion count
112 * If the transaction pointer is NULL, make this just a normal
133 * If we find the buffer in the cache with this transaction in xfs_trans_get_buf_map()
[all …]
|
| H A D | xfs_log_priv.h | 84 * little, the last transaction for the file could contain the wrong
86 * transaction, and the system crashes, the allocation transaction
91 * system is idle. We need two dummy transaction because the h_tail_lsn
93 * non-dummy transaction. The first dummy changes the h_tail_lsn to
94 * the first transaction before the dummy. The second dummy causes
104 * NEED -- logging has occurred and we need a dummy transaction
107 * transaction.
108 * NEED2 -- we detected that a dummy transaction has gone to the
110 * DONE2 -- we committed a dummy transaction when in the NEED2 state.
115 * We commit the dummy transaction and switch to DONE or DONE2,
[all …]
|
| /linux/Documentation/filesystems/ |
| H A D | journalling.rst | 42 this use jbd2_journal_start() which returns a transaction handle.
45 which indicates the end of a transaction are nestable calls, so you can
46 reenter a transaction if necessary, but remember you must call
48 jbd2_journal_start() before the transaction is completed (or more
52 Inside each transaction you need to wrap the modifications to the
59 uncommitted transaction. At this point you are at last ready to modify a
74 single outstanding transaction at any one time, remember nothing commits
76 the transaction at the end of each file/inode/address etc. operation you
83 if there isn't enough space in the journal for your transaction (based
96 transaction. I advise having a look at at least ext4_jbd.h to see the
[all …]
|
| /linux/include/linux/dma/ |
| H A D | sprd-dma.h | 18 * configurations. Once the source channel's transaction is done, it will
19 * trigger the destination channel's transaction automatically by hardware
49 * @SPRD_DMA_FRAG_DONE_TRG: Trigger the transaction of destination channel
51 * @SPRD_DMA_BLOCK_DONE_TRG: Trigger the transaction of destination channel
53 * @SPRD_DMA_TRANS_DONE_TRG: Trigger the transaction of destination channel
55 * @SPRD_DMA_LIST_DONE_TRG: Trigger the transaction of destination channel
70 * @SPRD_DMA_TRANS_REQ: transaction request mode
73 * We have 4 types request mode: fragment mode, block mode, transaction mode
74 * and linklist mode. One transaction can contain several blocks, one block can
94 * @SPRD_DMA_TRANS_INT: tansaction done interrupt when one transaction
[all …]
|
| /linux/fs/xfs/libxfs/ |
| H A D | xfs_defer.c | 40 * we can roll the transaction to adhere to AG locking order rules and
51 * roll a transaction to facilitate this, but using this facility
63 * start, we define "rolling a deferred-op transaction" as follows:
72 * > Roll the transaction.
74 * NOTE: To avoid exceeding the transaction reservation, we limit the
80 * - Roll the deferred-op transaction as above.
87 * wants a new transaction. See the "Requesting a Fresh
88 * Transaction while Finishing Deferred Work" section below for
92 * work items every time we roll the transaction, and that we must log
97 * Requesting a Fresh Transaction while Finishing Deferred Work
[all …]
|
| /linux/drivers/net/wireless/intel/iwlwifi/dvm/ |
| H A D | tt.c | 24 /* default Thermal Throttling transaction table
341 struct iwl_tt_trans *transaction; in iwl_advance_tt_handler() local
346 * find the curresponding transaction table in iwl_advance_tt_handler()
348 * tt->transaction + ((old_state * (IWL_TI_STATE_MAX - 1)) in iwl_advance_tt_handler()
351 * find the next state need to transaction to in iwl_advance_tt_handler()
353 * in the current table to see if transaction is needed in iwl_advance_tt_handler()
355 transaction = tt->transaction + in iwl_advance_tt_handler()
357 if (temp >= transaction->tt_low && in iwl_advance_tt_handler()
358 temp <= transaction->tt_high) { in iwl_advance_tt_handler()
372 transaction->next_state) { in iwl_advance_tt_handler()
[all …]
|
| /linux/include/trace/events/ |
| H A D | firewire.h | 40 …TP_PROTO(u64 transaction, unsigned int card_index, unsigned int generation, unsigned int scode, co…
41 TP_ARGS(transaction, card_index, generation, scode, header, data, data_count),
43 __field(u64, transaction)
51 __entry->transaction = transaction;
60 …"transaction=0x%llx card_index=%u generation=%u scode=%u dst_id=0x%04x tlabel=%u tcode=%u src_id=0…
61 __entry->transaction,
78 …TP_PROTO(u64 transaction, unsigned int card_index, unsigned int generation, unsigned int scode, un…
79 TP_ARGS(transaction, card_index, generation, scode, status, timestamp),
81 __field(u64, transaction)
89 __entry->transaction = transaction;
[all …]
|
| /linux/Documentation/locking/ |
| H A D | ww-mutex-design.rst | 36 In the RDBMS literature, a reservation ticket is associated with a transaction.
39 If the transaction holding the lock is younger, the locking transaction waits.
40 If the transaction holding the lock is older, the locking transaction backs off
43 If the transaction holding the lock is younger, the locking transaction
44 wounds the transaction holding the lock, requesting it to die.
45 If the transaction holding the lock is older, it waits for the other
46 transaction. Hence Wound-Wait.
47 The two algorithms are both fair in that a transaction will eventually succeed.
53 running transaction. Note that this is not the same as process preemption. A
54 Wound-Wait transaction is considered preempted when it dies (returning
[all …]
|
| /linux/Documentation/i2c/busses/ |
| H A D | i2c-mlxcpld.rst | 19 The next transaction types are supported:
29 Bits [6:5] - transaction length. b01 - 72B is supported,
43 It should be written last as it triggers an I2C transaction.
45 Number of data bytes to write in read transaction
47 Number of address bytes to write in read transaction.
49 Bit 0 - transaction is completed.
52 For write transaction address is specified in four first bytes
54 For read transactions address is sent in a separate transaction and
|
| /linux/tools/testing/selftests/powerpc/tm/ |
| H A D | tm-resched-dscr.c | 3 * when within a transaction.
12 * Start a transaction, and suspend it (*).
14 * Hard loop checking to see if the transaction has become doomed.
21 * (*) If the transaction is not suspended we can't see the problem because
22 * the transaction abort handler will restore the DSCR to it's checkpointed
54 /* start and suspend a transaction */ in test_body()
59 /* hard loop until the transaction becomes doomed */ in test_body()
79 assert(rv); /* make sure the transaction aborted */ in test_body()
|
| /linux/arch/powerpc/kernel/ptrace/ |
| H A D | ptrace-tm.c | 56 * regisers in transaction checkpointed GPR category.
75 * This function gets transaction checkpointed GPR registers.
77 * When the transaction is active, 'ckpt_regs' holds all the checkpointed
78 * GPR register values for the current transaction to fall back on if it
123 * This function sets in transaction checkpointed GPR registers.
125 * When the transaction is active, 'ckpt_regs' holds the checkpointed
126 * GPR register values for the current transaction to fall back on if it
198 * regisers in transaction checkpointed FPR category.
217 * This function gets in transaction checkpointed FPR registers.
219 * When the transaction is active 'ckfp_state' holds the checkpointed
[all …]
|
| /linux/fs/jfs/ |
| H A D | jfs_txnmgr.c | 8 * jfs_txnmgr.c: transaction manager
11 * transaction starts with txBegin() and ends with txCommit()
24 * tlock during write()/mmap() under anonymous transaction (tid = 0):
25 * transferred (?) to transaction at commit time.
51 * transaction management structures
84 static int nTxBlock = -1; /* number of transaction blocks */
87 "Number of transaction blocks (max:65536)");
89 static int nTxLock = -1; /* number of transaction locks */
92 "Number of transaction locks (max:65536)");
94 struct tblock *TxBlock; /* transaction block table */
[all …]
|