Lines Matching defs:handle

166 	handle_t *handle;
223 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE,
225 if (IS_ERR(handle)) {
226 ext4_std_error(inode->i_sb, PTR_ERR(handle));
239 ext4_handle_sync(handle);
251 err = ext4_mark_inode_dirty(handle, inode);
268 err = ext4_xattr_delete_inode(handle, inode, &ea_inode_array,
273 ext4_journal_stop(handle);
289 ext4_orphan_del(handle, inode);
299 if (ext4_mark_inode_dirty(handle, inode))
303 ext4_free_inode(handle, inode);
304 ext4_journal_stop(handle);
414 static void ext4_map_blocks_es_recheck(handle_t *handle,
432 retval = ext4_ext_map_blocks(handle, inode, map, 0);
434 retval = ext4_ind_map_blocks(handle, inode, map, 0);
465 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
478 int ext4_map_blocks(handle_t *handle, struct inode *inode,
500 /* We can handle the block number less than EXT_MAX_BLOCKS */
530 ext4_map_blocks_es_recheck(handle, inode, map,
548 retval = ext4_ext_map_blocks(handle, inode, map, 0);
550 retval = ext4_ind_map_blocks(handle, inode, map, 0);
621 retval = ext4_ext_map_blocks(handle, inode, map, flags);
623 retval = ext4_ind_map_blocks(handle, inode, map, flags);
706 ret = ext4_jbd2_inode_add_wait(handle, inode,
709 ret = ext4_jbd2_inode_add_write(handle, inode,
717 ext4_fc_track_range(handle, inode, map->m_lblk,
814 * `handle' can be NULL if create is zero
816 struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
826 || handle != NULL || create == 0);
831 err = ext4_map_blocks(handle, inode, &map, map_flags);
847 || (handle != NULL));
858 err = ext4_journal_get_create_access(handle, inode->i_sb, bh,
870 err = ext4_handle_dirty_metadata(handle, inode, bh);
881 struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
887 bh = ext4_getblk(handle, inode, block, map_flags);
944 int ext4_walk_page_buffers(handle_t *handle, struct inode *inode,
949 int (*fn)(handle_t *handle, struct inode *inode,
968 err = (*fn)(handle, inode, bh);
981 static int ext4_dirty_journalled_data(handle_t *handle, struct buffer_head *bh)
984 return ext4_handle_dirty_metadata(handle, NULL, bh);
987 int do_journal_get_write_access(handle_t *handle, struct inode *inode,
1006 ret = ext4_journal_get_write_access(handle, inode->i_sb, bh,
1009 ret = ext4_dirty_journalled_data(handle, bh);
1123 handle_t *handle;
1155 * the transaction handle. This also allows us to allocate
1165 * starting the handle.
1173 handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
1174 if (IS_ERR(handle)) {
1176 return PTR_ERR(handle);
1184 ext4_journal_stop(handle);
1204 ret = ext4_walk_page_buffers(handle, inode,
1223 ext4_orphan_add(handle, inode);
1225 ext4_journal_stop(handle);
1249 static int write_end_fn(handle_t *handle, struct inode *inode,
1256 ret = ext4_dirty_journalled_data(handle, bh);
1275 handle_t *handle = ext4_journal_current_handle();
1311 ret = ext4_mark_inode_dirty(handle, inode);
1318 ext4_orphan_add(handle, inode);
1320 ret2 = ext4_journal_stop(handle);
1343 static void ext4_journalled_zero_new_buffers(handle_t *handle,
1363 write_end_fn(handle, inode, bh);
1379 handle_t *handle = ext4_journal_current_handle();
1392 BUG_ON(!ext4_handle_valid(handle));
1400 ext4_journalled_zero_new_buffers(handle, inode, folio,
1404 ext4_journalled_zero_new_buffers(handle, inode, folio,
1406 ret = ext4_walk_page_buffers(handle, inode,
1415 EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1423 ret2 = ext4_mark_inode_dirty(handle, inode);
1433 ext4_orphan_add(handle, inode);
1435 ret2 = ext4_journal_stop(handle);
1889 * The rest of mballoc seems to handle chunks up to full group size.
1923 /* We cannot map unless handle is started... */
1981 /* Buffer needs mapping and handle is not started? */
2139 static int mpage_map_one_extent(handle_t *handle, struct mpage_da_data *mpd)
2171 err = ext4_map_blocks(handle, inode, map, get_blocks_flags);
2175 if (!mpd->io_submit.io_end->handle &&
2176 ext4_handle_valid(handle)) {
2177 mpd->io_submit.io_end->handle = handle->h_rsv_handle;
2178 handle->h_rsv_handle = NULL;
2191 * @handle - handle for journal operations
2207 static int mpage_map_and_submit_extent(handle_t *handle,
2224 err = mpage_map_one_extent(handle, mpd);
2284 err2 = ext4_mark_inode_dirty(handle, inode);
2311 static int ext4_journal_folio_buffers(handle_t *handle, struct folio *folio,
2318 ret = ext4_walk_page_buffers(handle, inode, page_bufs, 0, len,
2320 err = ext4_walk_page_buffers(handle, inode, page_bufs, 0, len,
2324 err = ext4_jbd2_inode_add_write(handle, inode, folio_pos(folio), len);
2327 EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
2332 static int mpage_journal_page_buffers(handle_t *handle,
2347 return ext4_journal_folio_buffers(handle, folio, len);
2382 handle_t *handle = NULL;
2393 handle = ext4_journal_start(mpd->inode, EXT4_HT_WRITE_PAGE,
2395 if (IS_ERR(handle))
2396 return PTR_ERR(handle);
2425 if (handle) {
2426 err = ext4_journal_ensure_credits(handle, bpp,
2473 * first handle writeout of the page for checkpoint and
2474 * only after that handle delayed page dirtying. This
2486 err = mpage_journal_page_buffers(handle,
2509 if (handle)
2510 ext4_journal_stop(handle);
2514 if (handle)
2515 ext4_journal_stop(handle);
2526 handle_t *handle = NULL;
2566 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
2567 if (IS_ERR(handle)) {
2568 ret = PTR_ERR(handle);
2573 ext4_destroy_inline_data(handle, inode);
2574 ext4_journal_stop(handle);
2670 handle = ext4_journal_start_with_reserve(inode,
2672 if (IS_ERR(handle)) {
2673 ret = PTR_ERR(handle);
2687 ret = mpage_map_and_submit_extent(handle, mpd,
2690 * Caution: If the handle is synchronous,
2697 * to be able to complete) before stopping the handle.
2699 if (!ext4_handle_valid(handle) || handle->h_sync == 0) {
2700 ext4_journal_stop(handle);
2701 handle = NULL;
2716 if (handle) {
2718 ext4_journal_stop(handle);
2999 handle_t *handle;
3001 handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
3002 if (IS_ERR(handle))
3003 return PTR_ERR(handle);
3004 ext4_mark_inode_dirty(handle, inode);
3005 ext4_journal_stop(handle);
3281 handle_t *handle;
3300 handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, dio_credits);
3301 if (IS_ERR(handle))
3302 return PTR_ERR(handle);
3322 ret = ext4_map_blocks(handle, inode, map, m_flags);
3332 ext4_journal_stop(handle);
3487 * So handle it here itself instead of querying ext4_map_blocks().
3635 static int __ext4_block_zero_page_range(handle_t *handle,
3706 err = ext4_journal_get_write_access(handle, inode->i_sb, bh,
3715 err = ext4_dirty_journalled_data(handle, bh);
3720 err = ext4_jbd2_inode_add_write(handle, inode, from,
3737 static int ext4_block_zero_page_range(handle_t *handle,
3756 return __ext4_block_zero_page_range(handle, mapping, from, length);
3765 static int ext4_block_truncate_page(handle_t *handle,
3780 return ext4_block_zero_page_range(handle, mapping, from, length);
3783 int ext4_zero_partial_blocks(handle_t *handle, struct inode *inode,
3802 err = ext4_block_zero_page_range(handle, mapping,
3808 err = ext4_block_zero_page_range(handle, mapping,
3815 err = ext4_block_zero_page_range(handle, mapping,
3841 handle_t *handle;
3853 handle = ext4_journal_start(inode, EXT4_HT_MISC, 1);
3854 if (IS_ERR(handle))
3855 return PTR_ERR(handle);
3857 ret = ext4_mark_inode_dirty(handle, inode);
3858 ext4_journal_stop(handle);
3911 handle_t *handle;
3997 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
3998 if (IS_ERR(handle)) {
3999 ret = PTR_ERR(handle);
4004 ret = ext4_zero_partial_blocks(handle, inode, offset,
4026 ret = ext4_ind_remove_space(handle, inode, first_block,
4031 ext4_fc_track_range(handle, inode, first_block, stop_block);
4033 ext4_handle_sync(handle);
4036 ret2 = ext4_mark_inode_dirty(handle, inode);
4040 ext4_update_inode_fsync_trans(handle, inode, 1);
4042 ext4_journal_stop(handle);
4108 handle_t *handle;
4146 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
4147 if (IS_ERR(handle)) {
4148 err = PTR_ERR(handle);
4153 ext4_block_truncate_page(handle, mapping, inode->i_size);
4164 err = ext4_orphan_add(handle, inode);
4173 err = ext4_ext_truncate(handle, inode);
4175 ext4_ind_truncate(handle, inode);
4182 ext4_handle_sync(handle);
4193 ext4_orphan_del(handle, inode);
4196 err2 = ext4_mark_inode_dirty(handle, inode);
4199 ext4_journal_stop(handle);
5078 static int ext4_do_update_inode(handle_t *handle,
5118 err = ext4_handle_dirty_metadata(handle, NULL, bh);
5124 err = ext4_journal_get_write_access(handle, sb,
5133 ext4_handle_sync(handle);
5134 err = ext4_handle_dirty_metadata(handle, NULL,
5137 ext4_update_inode_fsync_trans(handle, inode, need_datasync);
5337 handle_t *handle;
5341 handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
5344 if (IS_ERR(handle)) {
5345 error = PTR_ERR(handle);
5357 ext4_journal_stop(handle);
5364 error = ext4_mark_inode_dirty(handle, inode);
5365 ext4_journal_stop(handle);
5372 handle_t *handle;
5414 handle = ext4_journal_start(inode, EXT4_HT_INODE, 3);
5415 if (IS_ERR(handle)) {
5416 error = PTR_ERR(handle);
5419 if (ext4_handle_valid(handle) && shrink) {
5420 error = ext4_orphan_add(handle, inode);
5431 ext4_fc_track_range(handle, inode,
5437 handle, inode,
5446 rc = ext4_mark_inode_dirty(handle, inode);
5459 ext4_journal_stop(handle);
5496 * If the call to ext4_truncate failed to get a transaction handle at
5720 int ext4_mark_iloc_dirty(handle_t *handle,
5729 ext4_fc_track_inode(handle, inode);
5735 err = ext4_do_update_inode(handle, inode, iloc);
5746 ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
5757 err = ext4_journal_get_write_access(handle, inode->i_sb,
5771 handle_t *handle, int *no_expand)
5816 raw_inode, handle);
5834 handle_t *handle)
5846 * with this same handle. If journal_extend fails, then it will
5851 if (ext4_journal_extend(handle,
5859 handle, &no_expand);
5869 handle_t *handle;
5878 handle = ext4_journal_start(inode, EXT4_HT_INODE,
5880 if (IS_ERR(handle)) {
5881 error = PTR_ERR(handle);
5889 error = ext4_journal_get_write_access(handle, inode->i_sb, iloc->bh,
5897 handle, &no_expand);
5899 rc = ext4_mark_iloc_dirty(handle, inode, iloc);
5905 ext4_journal_stop(handle);
5922 int __ext4_mark_inode_dirty(handle_t *handle, struct inode *inode,
5931 err = ext4_reserve_inode_write(handle, inode, &iloc);
5937 iloc, handle);
5939 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
5959 * We handle synchronous inodes at the highest possible level.
5963 handle_t *handle;
5965 handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
5966 if (IS_ERR(handle))
5968 ext4_mark_inode_dirty(handle, inode);
5969 ext4_journal_stop(handle);
5975 handle_t *handle;
6004 * data (and journalled aops don't know how to handle these cases).
6047 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
6048 if (IS_ERR(handle))
6049 return PTR_ERR(handle);
6052 EXT4_FC_REASON_JOURNAL_FLAG_CHANGE, handle);
6053 err = ext4_mark_inode_dirty(handle, inode);
6054 ext4_handle_sync(handle);
6055 ext4_journal_stop(handle);
6061 static int ext4_bh_unmapped(handle_t *handle, struct inode *inode,
6078 handle_t *handle;
6095 * On data journalling we skip straight to the transaction handle:
6150 handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
6152 if (IS_ERR(handle)) {
6179 if (ext4_journal_folio_buffers(handle, folio, len))
6185 ext4_journal_stop(handle);
6196 ext4_journal_stop(handle);