Lines Matching defs:handle
141 static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh);
169 handle_t *handle;
254 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE,
256 if (IS_ERR(handle)) {
257 ext4_std_error(inode->i_sb, PTR_ERR(handle));
270 ext4_handle_sync(handle);
282 err = ext4_mark_inode_dirty(handle, inode);
299 err = ext4_xattr_delete_inode(handle, inode, &ea_inode_array,
304 ext4_journal_stop(handle);
320 ext4_orphan_del(handle, inode);
330 if (ext4_mark_inode_dirty(handle, inode))
334 ext4_free_inode(handle, inode);
335 ext4_journal_stop(handle);
445 static void ext4_map_blocks_es_recheck(handle_t *handle,
463 retval = ext4_ext_map_blocks(handle, inode, map, 0);
465 retval = ext4_ind_map_blocks(handle, inode, map, 0);
496 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
509 int ext4_map_blocks(handle_t *handle, struct inode *inode,
531 /* We can handle the block number less than EXT_MAX_BLOCKS */
558 ext4_map_blocks_es_recheck(handle, inode, map,
570 retval = ext4_ext_map_blocks(handle, inode, map, 0);
572 retval = ext4_ind_map_blocks(handle, inode, map, 0);
645 retval = ext4_ext_map_blocks(handle, inode, map, flags);
647 retval = ext4_ind_map_blocks(handle, inode, map, flags);
734 ret = ext4_jbd2_inode_add_wait(handle, inode,
737 ret = ext4_jbd2_inode_add_write(handle, inode,
745 ext4_fc_track_range(handle, inode, map->m_lblk,
831 * `handle' can be NULL if create is zero
833 struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
842 || handle != NULL || create == 0);
846 err = ext4_map_blocks(handle, inode, &map, map_flags);
859 || (handle != NULL));
870 err = ext4_journal_get_create_access(handle, bh);
881 err = ext4_handle_dirty_metadata(handle, inode, bh);
892 struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
898 bh = ext4_getblk(handle, inode, block, map_flags);
955 int ext4_walk_page_buffers(handle_t *handle,
960 int (*fn)(handle_t *handle,
979 err = (*fn)(handle, bh);
1006 * will _not_ run commit under these circumstances because handle->h_ref
1010 int do_journal_get_write_access(handle_t *handle,
1029 ret = ext4_journal_get_write_access(handle, bh);
1031 ret = ext4_handle_dirty_metadata(handle, NULL, bh);
1137 handle_t *handle;
1169 * the transaction handle. This also allows us to allocate
1178 * starting the handle.
1186 handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
1187 if (IS_ERR(handle)) {
1189 return PTR_ERR(handle);
1197 ext4_journal_stop(handle);
1218 ret = ext4_walk_page_buffers(handle, page_buffers(page),
1237 ext4_orphan_add(handle, inode);
1239 ext4_journal_stop(handle);
1263 static int write_end_fn(handle_t *handle, struct buffer_head *bh)
1269 ret = ext4_handle_dirty_metadata(handle, NULL, bh);
1287 handle_t *handle = ext4_journal_current_handle();
1322 ret = ext4_mark_inode_dirty(handle, inode);
1329 ext4_orphan_add(handle, inode);
1331 ret2 = ext4_journal_stop(handle);
1354 static void ext4_journalled_zero_new_buffers(handle_t *handle,
1373 write_end_fn(handle, bh);
1388 handle_t *handle = ext4_journal_current_handle();
1401 BUG_ON(!ext4_handle_valid(handle));
1408 ext4_journalled_zero_new_buffers(handle, page, from, to);
1411 ext4_journalled_zero_new_buffers(handle, page,
1413 ret = ext4_walk_page_buffers(handle, page_buffers(page), from,
1422 EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1430 ret2 = ext4_mark_inode_dirty(handle, inode);
1440 ext4_orphan_add(handle, inode);
1442 ret2 = ext4_journal_stop(handle);
1621 static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh)
1858 static int bget_one(handle_t *handle, struct buffer_head *bh)
1864 static int bput_one(handle_t *handle, struct buffer_head *bh)
1876 handle_t *handle = NULL;
1895 ext4_walk_page_buffers(handle, page_bufs, 0, len,
1906 handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
1908 if (IS_ERR(handle)) {
1909 ret = PTR_ERR(handle);
1913 BUG_ON(!ext4_handle_valid(handle));
1919 ext4_journal_stop(handle);
1925 ret = ext4_mark_inode_dirty(handle, inode);
1927 ret = ext4_walk_page_buffers(handle, page_bufs, 0, len, NULL,
1930 err = ext4_walk_page_buffers(handle, page_bufs, 0, len, NULL,
1935 err = ext4_jbd2_inode_add_write(handle, inode, page_offset(page), len);
1938 EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1939 err = ext4_journal_stop(handle);
1979 * - ext4_writepages after taking page lock (have journal handle)
1980 * - journal_submit_inode_data_buffers (no journal handle)
1981 * - shrink_page_list via the kswapd/direct reclaim (no journal handle)
1982 * - grab_page_cache when doing write_begin (have journal handle)
2146 * The rest of mballoc seems to handle chunks up to full group size.
2180 /* We cannot map unless handle is started... */
2238 /* Buffer needs mapping and handle is not started? */
2396 static int mpage_map_one_extent(handle_t *handle, struct mpage_da_data *mpd)
2428 err = ext4_map_blocks(handle, inode, map, get_blocks_flags);
2432 if (!mpd->io_submit.io_end->handle &&
2433 ext4_handle_valid(handle)) {
2434 mpd->io_submit.io_end->handle = handle->h_rsv_handle;
2435 handle->h_rsv_handle = NULL;
2448 * @handle - handle for journal operations
2464 static int mpage_map_and_submit_extent(handle_t *handle,
2481 err = mpage_map_one_extent(handle, mpd);
2542 err2 = ext4_mark_inode_dirty(handle, inode);
2704 handle_t *handle = NULL;
2754 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
2755 if (IS_ERR(handle)) {
2756 ret = PTR_ERR(handle);
2761 ext4_destroy_inline_data(handle, inode);
2762 ext4_journal_stop(handle);
2838 handle = ext4_journal_start_with_reserve(inode,
2840 if (IS_ERR(handle)) {
2841 ret = PTR_ERR(handle);
2855 ret = mpage_map_and_submit_extent(handle, &mpd,
2858 * Caution: If the handle is synchronous,
2865 * to be able to complete) before stopping the handle.
2867 if (!ext4_handle_valid(handle) || handle->h_sync == 0) {
2868 ext4_journal_stop(handle);
2869 handle = NULL;
2884 if (handle) {
2886 ext4_journal_stop(handle);
3390 handle_t *handle;
3409 handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, dio_credits);
3410 if (IS_ERR(handle))
3411 return PTR_ERR(handle);
3431 ret = ext4_map_blocks(handle, inode, map, m_flags);
3441 ext4_journal_stop(handle);
3589 * So handle it here itself instead of querying ext4_map_blocks().
3735 static int __ext4_block_zero_page_range(handle_t *handle,
3802 err = ext4_journal_get_write_access(handle, bh);
3810 err = ext4_handle_dirty_metadata(handle, inode, bh);
3815 err = ext4_jbd2_inode_add_write(handle, inode, from,
3832 static int ext4_block_zero_page_range(handle_t *handle,
3851 return __ext4_block_zero_page_range(handle, mapping, from, length);
3860 static int ext4_block_truncate_page(handle_t *handle,
3875 return ext4_block_zero_page_range(handle, mapping, from, length);
3878 int ext4_zero_partial_blocks(handle_t *handle, struct inode *inode,
3897 err = ext4_block_zero_page_range(handle, mapping,
3903 err = ext4_block_zero_page_range(handle, mapping,
3910 err = ext4_block_zero_page_range(handle, mapping,
3936 handle_t *handle;
3948 handle = ext4_journal_start(inode, EXT4_HT_MISC, 1);
3949 if (IS_ERR(handle))
3950 return PTR_ERR(handle);
3952 ret = ext4_mark_inode_dirty(handle, inode);
3953 ext4_journal_stop(handle);
4007 handle_t *handle;
4093 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
4094 if (IS_ERR(handle)) {
4095 ret = PTR_ERR(handle);
4100 ret = ext4_zero_partial_blocks(handle, inode, offset,
4126 ret = ext4_ind_remove_space(handle, inode, first_block,
4131 ext4_fc_track_range(handle, inode, first_block, stop_block);
4133 ext4_handle_sync(handle);
4136 ret2 = ext4_mark_inode_dirty(handle, inode);
4140 ext4_update_inode_fsync_trans(handle, inode, 1);
4142 ext4_journal_stop(handle);
4208 handle_t *handle;
4246 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
4247 if (IS_ERR(handle)) {
4248 err = PTR_ERR(handle);
4253 ext4_block_truncate_page(handle, mapping, inode->i_size);
4264 err = ext4_orphan_add(handle, inode);
4273 err = ext4_ext_truncate(handle, inode);
4275 ext4_ind_truncate(handle, inode);
4282 ext4_handle_sync(handle);
4293 ext4_orphan_del(handle, inode);
4296 err2 = ext4_mark_inode_dirty(handle, inode);
4299 ext4_journal_stop(handle);
5177 static int ext4_do_update_inode(handle_t *handle,
5217 err = ext4_handle_dirty_metadata(handle, NULL, bh);
5223 err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
5230 ext4_handle_sync(handle);
5231 err = ext4_handle_dirty_metadata(handle, NULL,
5234 ext4_update_inode_fsync_trans(handle, inode, need_datasync);
5434 handle_t *handle;
5438 handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
5441 if (IS_ERR(handle)) {
5442 error = PTR_ERR(handle);
5454 ext4_journal_stop(handle);
5463 error = ext4_mark_inode_dirty(handle, inode);
5464 ext4_journal_stop(handle);
5471 handle_t *handle;
5513 handle = ext4_journal_start(inode, EXT4_HT_INODE, 3);
5514 if (IS_ERR(handle)) {
5515 error = PTR_ERR(handle);
5518 if (ext4_handle_valid(handle) && shrink) {
5519 error = ext4_orphan_add(handle, inode);
5532 ext4_fc_track_range(handle, inode,
5538 handle, inode,
5547 rc = ext4_mark_inode_dirty(handle, inode);
5560 ext4_journal_stop(handle);
5595 * If the call to ext4_truncate failed to get a transaction handle at
5781 int ext4_mark_iloc_dirty(handle_t *handle,
5790 ext4_fc_track_inode(handle, inode);
5804 err = ext4_do_update_inode(handle, inode, iloc);
5815 ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
5826 err = ext4_journal_get_write_access(handle, iloc->bh);
5839 handle_t *handle, int *no_expand)
5884 raw_inode, handle);
5902 handle_t *handle)
5914 * with this same handle. If journal_extend fails, then it will
5919 if (ext4_journal_extend(handle,
5927 handle, &no_expand);
5937 handle_t *handle;
5946 handle = ext4_journal_start(inode, EXT4_HT_INODE,
5948 if (IS_ERR(handle)) {
5949 error = PTR_ERR(handle);
5957 error = ext4_journal_get_write_access(handle, iloc->bh);
5964 handle, &no_expand);
5966 rc = ext4_mark_iloc_dirty(handle, inode, iloc);
5972 ext4_journal_stop(handle);
5989 int __ext4_mark_inode_dirty(handle_t *handle, struct inode *inode,
5998 err = ext4_reserve_inode_write(handle, inode, &iloc);
6004 iloc, handle);
6006 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
6026 * We handle synchronous inodes at the highest possible level.
6034 handle_t *handle;
6038 handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
6039 if (IS_ERR(handle))
6042 ext4_mark_inode_dirty(handle, inode);
6044 ext4_journal_stop(handle);
6052 handle_t *handle;
6081 * data (and journalled aops don't know how to handle these cases).
6124 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
6125 if (IS_ERR(handle))
6126 return PTR_ERR(handle);
6130 err = ext4_mark_inode_dirty(handle, inode);
6131 ext4_handle_sync(handle);
6132 ext4_journal_stop(handle);
6138 static int ext4_bh_unmapped(handle_t *handle, struct buffer_head *bh)
6154 handle_t *handle;
6171 * On data journalling we skip straight to the transaction handle:
6227 handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
6229 if (IS_ERR(handle)) {
6257 if (ext4_walk_page_buffers(handle, page_buffers(page),
6260 if (ext4_walk_page_buffers(handle, page_buffers(page),
6263 if (ext4_jbd2_inode_add_write(handle, inode,
6271 ext4_journal_stop(handle);
6282 ext4_journal_stop(handle);