| /openbmc/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 | transaction.c | 3 * linux/fs/jbd2/transaction.c
9 * Generic filesystem transaction handling code; part of the ext2fs
46 pr_emerg("JBD2: failed to create transaction cache\n"); in jbd2_journal_init_transaction_cache()
58 void jbd2_journal_free_transaction(transaction_t *transaction) in jbd2_journal_free_transaction() argument
60 if (unlikely(ZERO_OR_NULL_PTR(transaction))) in jbd2_journal_free_transaction()
62 kmem_cache_free(transaction_cache, transaction); in jbd2_journal_free_transaction()
68 * Simply initialise a new transaction. Initialize it in
70 * have an existing running transaction: we only make a new transaction
75 * new transaction and we can't block without protecting against other
81 transaction_t *transaction) in jbd2_get_transaction() argument
[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 …]
|
| /openbmc/sdbusplus/include/sdbusplus/server/ |
| H A D | transaction.hpp | 15 namespace transaction namespace
20 // Transaction Id
23 struct Transaction struct
25 Transaction() : time(std::time(nullptr)), thread(std::this_thread::get_id()) in Transaction() function
34 struct Transaction struct
36 Transaction(sdbusplus::bus_t& bus_in, sdbusplus::message_t& msg_in) : in Transaction() argument
44 } // namespace transaction
65 /** @ brief Overload of std::hash for Transaction */
67 struct hash<sdbusplus::server::transaction::Transaction>
70 operator()(const sdbusplus::server::transaction::Transaction& t) const;
[all …]
|
| /openbmc/linux/drivers/net/ipa/ |
| H A D | gsi_trans.h | 25 /* Maximum number of TREs in an IPA immediate command transaction */
29 * struct gsi_trans - a GSI transaction
31 * Most fields in this structure for internal use by the transaction core code:
33 * @channel_id: Channel number transaction is associated with
34 * @cancelled: If set by the core code, transaction was cancelled
35 * @rsvd_count: Number of TREs reserved for this transaction
37 * @len: Number of bytes sent or received by the transaction
38 * @data: Preserved but not touched by the core transaction code
43 * @completion: Completed when the transaction completes
44 * @byte_count: TX channel byte count recorded when transaction committed
[all …]
|
| H A D | gsi_private.h | 20 * gsi_trans_move_complete() - Mark a GSI transaction completed
21 * @trans: Transaction whose state is to be updated
26 * gsi_trans_move_polled() - Mark a transaction polled
27 * @trans: Transaction whose state is to be updated
32 * gsi_trans_complete() - Complete a GSI transaction
33 * @trans: Transaction to complete
35 * Marks a transaction complete (including freeing it).
40 * gsi_channel_trans_mapped() - Return a transaction mapped to a TRE index
41 * @channel: Channel associated with the transaction
42 * @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 | 84 * ipa_cmd_table_init_add() - Add table init command to a transaction
85 * @trans: GSI transaction
102 * ipa_cmd_hdr_init_local_add() - Add a header init command to a transaction
103 * @trans: GSI transaction
114 * ipa_cmd_register_write_add() - Add a register write command to a transaction
115 * @trans: GSI transaction
125 * ipa_cmd_dma_shared_mem_add() - Add a DMA memory command to a transaction
126 * @trans: GSI transaction
136 * ipa_cmd_pipeline_clear_add() - Add pipeline clear commands to a transaction
137 * @trans: GSI transaction
[all …]
|
| /openbmc/linux/Documentation/filesystems/ |
| H A D | xfs-delayed-logging-design.rst | 13 themselves with the general concepts of how transaction processing in XFS works.
16 transaction reservations are structured and accounted, and then move into how we
59 transactions. Permanent transaction reservations can take reservations that span
68 In the code, a one-shot transaction pattern looks somewhat like this::
72 <join item to transaction>
76 As items are modified in the transaction, the dirty regions in those items are
77 tracked via the transaction handle. Once the transaction is committed, all
79 space that was taken at the transaction allocation time.
81 In contrast, a permanent transaction is made up of multiple linked individual
97 While this might look similar to a one-shot transaction, there is an important
[all …]
|
| 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 …]
|
| /openbmc/sdbusplus/src/server/ |
| H A D | transaction.cpp | 1 #include "sdbusplus/server/transaction.hpp"
7 namespace transaction namespace
12 // Transaction Id
19 // If the transaction id has not been initialized, generate one. in get_id()
22 details::Transaction t; in get_id()
23 details::id = std::hash<details::Transaction>{}(t); in get_id()
36 auto t = Transaction(tbus, msg); in set_id()
37 set_id(std::hash<Transaction>{}(t)); in set_id()
40 } // namespace transaction
59 // to correlate messages as one transaction. in operator ()()
[all …]
|
| /openbmc/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 …]
|
| H A D | jbd2.h | 9 * Definitions for transaction data structures for the buffer cache
86 * the transaction, so that at all times we know how many buffers the
87 * outstanding updates on a transaction might possibly touch.
99 * We use the journal_t to keep track of all outstanding transaction
219 #define JBD2_FLAG_DELETED 4 /* block deleted by this transaction */
395 * ordered mode present in a transaction so that we can sync them during commit.
401 * Which transaction does this inode belong to? Either the running
402 * transaction or the committing one. [j_list_lock]
409 * Pointer to the running transaction modifying inode's data in case
410 * there is already a committing transaction touching it. [j_list_lock]
[all …]
|
| /openbmc/qemu/include/qemu/ |
| H A D | transactions.h | 23 * = Generic transaction API =
26 * represents the actions. They will usually have Transaction* argument, and
30 * Then, when you need to make a transaction, create an empty Transaction by
32 * tran_abort() or tran_commit() to finalize the transaction by corresponding
35 * The clean() functions registered by the drivers in a transaction are called
50 typedef struct Transaction Transaction; typedef
52 Transaction *tran_new(void);
53 void tran_add(Transaction *tran, TransactionActionDrv *drv, void *opaque);
54 void tran_abort(Transaction *tran);
55 void tran_commit(Transaction *tran);
[all …]
|
| /openbmc/linux/Documentation/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 …]
|
| /openbmc/linux/fs/btrfs/ |
| H A D | transaction.c | 18 #include "transaction.h"
41 * Transaction states and transitions
43 * No running transaction (fs tree blocks are not modified)
48 * Transaction N [[TRANS_STATE_RUNNING]]
50 * | New trans handles can be attached to transaction N by calling all
55 * | transaction N
57 * Transaction N [[TRANS_STATE_COMMIT_PREP]]
60 * | the race and the rest will wait for the winner to commit the transaction.
62 * | The winner will wait for previous running transaction to completely finish
65 * Transaction N [[TRANS_STATE_COMMIT_START]]
[all …]
|
| H A D | transaction.h | 43 * transaction, it must be zero before the transaction is
48 * total writers in this transaction, it must be zero before the
49 * transaction can end
72 * it do so under some form of transaction critical section, namely:
75 * run by one of the transaction committers. Refer to
79 * commit_cowonly_roots from transaction critical section
82 * - btrfs_cleanup_dirty_bgs - called on transaction abort
102 * Number of ordered extents the transaction must wait for before
132 struct btrfs_transaction *transaction; member
140 * Error code of transaction abort, set outside of locks and must use
[all …]
|
| /openbmc/linux/drivers/usb/host/ |
| H A D | octeon-hcd.c | 108 * @CVMX_USB_STATUS_OK: The transaction / operation finished without
111 * @CVMX_USB_STATUS_CANCEL: The transaction was canceled while in flight
113 * @CVMX_USB_STATUS_ERROR: The transaction aborted with an unexpected
115 * @CVMX_USB_STATUS_STALL: The transaction received a USB STALL response
117 * @CVMX_USB_STATUS_XACTERR: The transaction failed with an error from the
119 * @CVMX_USB_STATUS_DATATGLERR: The transaction failed with a data toggle
121 * @CVMX_USB_STATUS_BABBLEERR: The transaction failed with a babble error
122 * @CVMX_USB_STATUS_FRAMEERR: The transaction failed with a frame error
238 * enum represents all of the possible stages a transaction can
241 * transaction with a simple clearing of bit 0.
[all …]
|
| /openbmc/linux/fs/ntfs/ |
| H A D | usnjrnl.h | 3 * usnjrnl.h - Defines for NTFS kernel transaction log ($UsnJrnl) handling.
20 * Transaction log ($UsnJrnl) organization:
22 * The transaction log records whenever a file is modified in any way. So for
28 * The transaction log is in the $Extend directory which is in the root
29 * directory of each volume. If it is not present it means transaction
30 * logging is disabled. If it is present it means transaction logging is
34 * To determine whether the transaction logging is enabled or in the process
38 * If the flag VOLUME_DELETE_USN_UNDERWAY is set it means the transaction log
40 * transaction log is enabled.
42 * The transaction log consists of two parts; the $DATA/$Max attribute as well
[all …]
|
| /openbmc/qemu/hw/usb/ |
| H A D | u2f-passthru.c | 47 struct transaction { struct
68 struct transaction current_transactions[CURRENT_TRANSACTIONS_NUM]; argument
73 /* Transaction time checking */
152 static struct transaction *u2f_transaction_get(U2FPassthruState *key, in u2f_transaction_get()
162 static struct transaction *u2f_transaction_get_from_nonce(U2FPassthruState *key, in u2f_transaction_get_from_nonce()
190 sizeof(struct transaction)); in u2f_transaction_close()
208 struct transaction *transaction; in u2f_transaction_add() local
211 /* Close the oldest transaction */ in u2f_transaction_add()
213 transaction = &key->current_transactions[index]; in u2f_transaction_add()
214 u2f_transaction_close(key, transaction->cid); in u2f_transaction_add()
[all …]
|
| /openbmc/linux/fs/xfs/ |
| H A D | xfs_trans.c | 49 * Initialize the precomputed transaction reservation values
61 * Free the transaction structure. If there is more clean up
80 * This is called to create a new transaction which will share the
81 * permanent log reservation of the given transaction. The remaining
83 * implies that the original transaction is no longer allowed to allocate
85 * be added to the new transaction explicitly.
98 * Initialize the new transaction structure. in xfs_trans_dup()
114 /* We gave our writer reference to the new transaction */ in xfs_trans_dup()
136 * given transaction. This must be done before allocating any resources
137 * within the transaction.
[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 …]
|
| /openbmc/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 …]
|
| /openbmc/bmcweb/include/ |
| H A D | openbmc_dbus_rest.hpp | 114 const std::shared_ptr<bmcweb::AsyncResp>& transaction) in introspectObjects() argument
116 if (transaction->res.jsonValue.is_null()) in introspectObjects()
118 transaction->res.jsonValue["status"] = "ok"; in introspectObjects()
119 transaction->res.jsonValue["bus_name"] = processName; in introspectObjects()
120 transaction->res.jsonValue["objects"] = nlohmann::json::array(); in introspectObjects()
124 [transaction, processName{std::string(processName)}, in introspectObjects()
138 transaction->res.jsonValue["objects"].emplace_back( in introspectObjects()
165 introspectObjects(processName, newpath, transaction); in introspectObjects()
280 const std::shared_ptr<InProgressEnumerateData>& transaction) in getManagedObjectsForEnumerate() argument
288 [transaction, objectName, in getManagedObjectsForEnumerate()
[all …]
|
| /openbmc/linux/fs/xfs/libxfs/ |
| H A D | xfs_trans_inode.c | 21 * Add a locked inode to the transaction.
23 * The inode must be locked, and it cannot be associated with any transaction.
24 * If lock_flags is non-zero the inode will be unlocked on transaction commit.
50 * joined to the transaction supplied. Relies on the transaction subsystem to
77 * logged when the transaction is committed. The inode must already be
78 * associated with the given transaction. All we do here is record where the
79 * inode was dirtied and mark the transaction and inode log item dirty;
81 * changes in the transaction have been completed.
99 * First time we log the inode in a transaction, bump the inode change in xfs_trans_log_inode()
|