btrfs: update function comments

	return cache;

}

/**

/*

 * Check if we can do a NOCOW write for a given extent.

 *

 * @fs_info:       The filesystem information object.

	return bg;

}

/**

/*

 * Decrement the number of NOCOW writers in a block group.

 *

 * @bg:       The block group.

 *

 * This is meant to be called after a previous call to btrfs_inc_nocow_writers(),

 * and on the block group returned by that call. Typically this is called after

 * creating an ordered extent for a NOCOW write, to prevent races with scrub and

	write_sequnlock(&fs_info->profiles_lock);

}

/**

 * Map a physical disk address to a list of logical addresses

/*

 * Map a physical disk address to a list of logical addresses.

 *

 * @fs_info:       the filesystem

 * @chunk_start:   logical address of block group

	return ret;

}

/**

 * btrfs_add_reserved_bytes - update the block_group and space info counters

/*

 * Update the block_group and space info counters.

 *

 * @cache:	The cache we are manipulating

 * @ram_bytes:  The number of bytes of file content, and will be same to

 *              @num_bytes except for the compress path.

	return ret;

}

/**

 * btrfs_free_reserved_bytes - update the block_group and space info counters

/*

 * Update the block_group and space info counters.

 *

 * @cache:      The cache we are manipulating

 * @num_bytes:  The number of bytes in question

 * @delalloc:   The blocks are allocated for the delalloc write

	return ret;

}

/**

/*

 * Search for a valid slot for the given path.

 *

 * @root:	The root node of the tree.

	}

}

/**

 * setup_items_for_insert - Helper called before inserting one or more items

 * to a leaf. Main purpose is to save stack depth by doing the bulk of the work

 * in a function that doesn't call btrfs_search_slot

/*

 * Make space in the node before inserting one or more items.

 *

 * @root:	root we are inserting items to

 * @path:	points to the leaf/slot where we are going to insert new items

 * @batch:      information about the batch of items to insert

 *

 * Main purpose is to save stack depth by doing the bulk of the work in a

 * function that doesn't call btrfs_search_slot

 */

static void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,

				   const struct btrfs_item_batch *batch)

	btrfs_qgroup_free_data(inode, reserved, start, len);

}

/**

 * Release any excessive reservation

/*

 * Release any excessive reservations for an inode.

 *

 * @inode:       the inode we need to release from

 * @qgroup_free: free or convert qgroup meta. Unlike normal operation, qgroup

	return 0;

}

/**

 * Release a metadata reservation for an inode

/*

 * Release a metadata reservation for an inode.

 *

 * @inode:        the inode to release the reservation for.

 * @num_bytes:    the number of bytes we are releasing.

	btrfs_inode_rsv_release(inode, qgroup_free);

}

/**

 * btrfs_delalloc_release_extents - release our outstanding_extents

/*

 * Release our outstanding_extents for an inode.

 *

 * @inode:      the inode to balance the reservation for.

 * @num_bytes:  the number of bytes we originally reserved with

 *

	btrfs_inode_rsv_release(inode, true);

}

/**

 * btrfs_delalloc_reserve_space - reserve data and metadata space for

 * delalloc

/*

 * Reserve data and metadata space for delalloc

 *

 * @inode:     inode we're writing to

 * @start:     start range we are writing to

 * @len:       how long the range we are writing to

 *

 * This will do the following things

 *

 * - reserve space in data space info for num bytes

 *   and reserve precious corresponding qgroup space

 * - reserve space in data space info for num bytes and reserve precious

 *   corresponding qgroup space

 *   (Done in check_data_free_space)

 *

 * - reserve space for metadata space, based on the number of outstanding

 *   extents and how much csums will be needed

 *   also reserve metadata space in a per root over-reserve method.

 *   extents and how much csums will be needed also reserve metadata space in a

 *   per root over-reserve method.

 * - add to the inodes->delalloc_bytes

 * - add it to the fs_info's delalloc inodes list.

 *   (Above 3 all done in delalloc_reserve_metadata)

 *

 * Return 0 for success

 * Return <0 for error(-ENOSPC or -EQUOT)

 * Return <0 for error(-ENOSPC or -EDQUOT)

 */

int btrfs_delalloc_reserve_space(struct btrfs_inode *inode,

			struct extent_changeset **reserved, u64 start, u64 len)

	return ret;

}

/**

/*

 * Release data and metadata space for delalloc

 *

 * @inode:       inode we're releasing space for

 * @len:         length of the space already reserved

 * @qgroup_free: should qgroup reserved-space also be freed

 *

 * This function will release the metadata space that was not used and will

 * decrement ->delalloc_bytes and remove it from the fs_info delalloc_inodes

 * list if there are no delalloc bytes left.

 * Also it will handle the qgroup reserved space.

 * Release the metadata space that was not used and will decrement

 * ->delalloc_bytes and remove it from the fs_info->delalloc_inodes list if

 * there are no delalloc bytes left.  Also it will handle the qgroup reserved

 * space.

 */

void btrfs_delalloc_release_space(struct btrfs_inode *inode,

				  struct extent_changeset *reserved,

	return btrfs_check_space_for_delayed_refs(trans->fs_info);

}

/**

 * Release a ref head's reservation

/*

 * Release a ref head's reservation.

 *

 * @fs_info:  the filesystem

 * @nr:       number of items to drop

 *

 * This drops the delayed ref head's count from the delayed refs rsv and frees

 * any excess reservation we had.

 * Drops the delayed ref head's count from the delayed refs rsv and free any

 * excess reservation we had.

 */

void btrfs_delayed_refs_rsv_release(struct btrfs_fs_info *fs_info, int nr)

{

}

/*

 * btrfs_update_delayed_refs_rsv - adjust the size of the delayed refs rsv

 * @trans - the trans that may have generated delayed refs

 * Adjust the size of the delayed refs rsv.

 *

 * This is to be called anytime we may have adjusted trans->delayed_ref_updates,

 * it'll calculate the additional size and add it to the delayed_refs_rsv.

	trans->delayed_ref_updates = 0;

}

/**

 * Transfer bytes to our delayed refs rsv

/*

 * Transfer bytes to our delayed refs rsv.

 *

 * @fs_info:   the filesystem

 * @src:       source block rsv to transfer from

				delayed_refs_rsv->space_info, to_free);

}

/**

 * Refill based on our delayed refs usage

/*

 * Refill based on our delayed refs usage.

 *

 * @fs_info: the filesystem

 * @flush:   control how we can flush for this reservation.

#define BTRFS_DISCARD_MAX_DELAY_MSEC	(1000UL)

#define BTRFS_DISCARD_MAX_IOPS		(10U)

/* Montonically decreasing minimum length filters after index 0 */

/* Monotonically decreasing minimum length filters after index 0 */

static int discard_minlen[BTRFS_NR_DISCARD_LISTS] = {

	0,

	BTRFS_ASYNC_DISCARD_MAX_FILTER,

	return running;

}

/**

 * find_next_block_group - find block_group that's up next for discarding

/*

 * Find block_group that's up next for discarding.

 *

 * @discard_ctl:  discard control

 * @now:          current time

 *

	return ret_block_group;

}

/**

 * Wrap find_next_block_group()

/*

 * Look up next block group and set it for use.

 *

 * @discard_ctl:   discard control

 * @discard_state: the discard_state of the block_group after state management

 * @discard_index: the discard_index of the block_group after state management

 * @now:           time when discard was invoked, in ns

 *

 * This wraps find_next_block_group() and sets the block_group to be in use.

 * discard_state's control flow is managed here.  Variables related to

 * discard_state are reset here as needed (eg discard_cursor).  @discard_state

 * Wrap find_next_block_group() and set the block_group to be in use.

 * @discard_state's control flow is managed here.  Variables related to

 * @discard_state are reset here as needed (eg. @discard_cursor).  @discard_state

 * and @discard_index are remembered as it may change while we're discarding,

 * but we want the discard to execute in the context determined here.

 */

	return block_group;

}

/**

 * btrfs_discard_check_filter - updates a block groups filters

/*

 * Update a block group's filters.

 *

 * @block_group:  block group of interest

 * @bytes:        recently freed region size after coalescing

 *

	}

}

/**

 * btrfs_update_discard_index - moves a block group along the discard lists

/*

 * Move a block group along the discard lists.

 *

 * @discard_ctl: discard control

 * @block_group: block_group of interest

 *

	add_to_discard_list(discard_ctl, block_group);

}

/**

 * btrfs_discard_cancel_work - remove a block_group from the discard lists

/*

 * Remove a block_group from the discard lists.

 *

 * @discard_ctl: discard control

 * @block_group: block_group of interest

 *

 * This removes @block_group from the discard lists.  If necessary, it waits on

 * the current work and then reschedules the delayed work.

 * Remove @block_group from the discard lists.  If necessary, wait on the

 * current work and then reschedule the delayed work.

 */

void btrfs_discard_cancel_work(struct btrfs_discard_ctl *discard_ctl,

			       struct btrfs_block_group *block_group)

	}

}

/**

 * btrfs_discard_queue_work - handles queuing the block_groups

/*

 * Handles queuing the block_groups.

 *

 * @discard_ctl: discard control

 * @block_group: block_group of interest

 *

 * This maintains the LRU order of the discard lists.

 * Maintain the LRU order of the discard lists.

 */

void btrfs_discard_queue_work(struct btrfs_discard_ctl *discard_ctl,

			      struct btrfs_block_group *block_group)

}

/*

 * btrfs_discard_schedule_work - responsible for scheduling the discard work

 * Responsible for scheduling the discard work.

 *

 * @discard_ctl:  discard control

 * @override:     override the current timer

 *

	spin_unlock(&discard_ctl->lock);

}

/**

 * btrfs_finish_discard_pass - determine next step of a block_group

/*

 * Determine next step of a block_group.

 *

 * @discard_ctl: discard control

 * @block_group: block_group of interest

 *

 * This determines the next step for a block group after it's finished going

 * through a pass on a discard list.  If it is unused and fully trimmed, we can

 * mark it unused and send it to the unused_bgs path.  Otherwise, pass it onto

 * the appropriate filter list or let it fall off.

 * Determine the next step for a block group after it's finished going through

 * a pass on a discard list.  If it is unused and fully trimmed, we can mark it

 * unused and send it to the unused_bgs path.  Otherwise, pass it onto the

 * appropriate filter list or let it fall off.

 */

static void btrfs_finish_discard_pass(struct btrfs_discard_ctl *discard_ctl,

				      struct btrfs_block_group *block_group)

	}

}

/**

 * btrfs_discard_workfn - discard work function

/*

 * Discard work queue callback

 *

 * @work: work

 *

 * This finds the next block_group to start discarding and then discards a

 * single region.  It does this in a two-pass fashion: first extents and second

 * Find the next block_group to start discarding and then discard a single

 * region.  It does this in a two-pass fashion: first extents and second

 * bitmaps.  Completely discarded block groups are sent to the unused_bgs path.

 */

static void btrfs_discard_workfn(struct work_struct *work)

	spin_unlock(&discard_ctl->lock);

}

/**

 * btrfs_run_discard_work - determines if async discard should be running

/*

 * Determine if async discard should be running.

 *

 * @discard_ctl: discard control

 *

 * Checks if the file system is writeable and BTRFS_FS_DISCARD_RUNNING is set.

 * Check if the file system is writeable and BTRFS_FS_DISCARD_RUNNING is set.

 */

bool btrfs_run_discard_work(struct btrfs_discard_ctl *discard_ctl)

{

		test_bit(BTRFS_FS_DISCARD_RUNNING, &fs_info->flags));

}

/**

 * btrfs_discard_calc_delay - recalculate the base delay

/*

 * Recalculate the base delay.

 *

 * @discard_ctl: discard control

 *

 * Recalculate the base delay which is based off the total number of

	spin_lock(&discard_ctl->lock);

	/*

	 * The following is to fix a potential -1 discrepenancy that we're not

	 * The following is to fix a potential -1 discrepancy that we're not

	 * sure how to reproduce. But given that this is the only place that

	 * utilizes these numbers and this is only called by from

	 * btrfs_finish_extent_commit() which is synchronized, we can correct

	spin_unlock(&discard_ctl->lock);

}

/**

 * btrfs_discard_update_discardable - propagate discard counters

/*

 * Propagate discard counters.

 *

 * @block_group: block_group of interest

 *

 * This propagates deltas of counters up to the discard_ctl.  It maintains a

 * current counter and a previous counter passing the delta up to the global

 * stat.  Then the current counter value becomes the previous counter value.

 * Propagate deltas of counters up to the discard_ctl.  It maintains a current

 * counter and a previous counter passing the delta up to the global stat.

 * Then the current counter value becomes the previous counter value.

 */

void btrfs_discard_update_discardable(struct btrfs_block_group *block_group)

{

	}

}

/**

 * btrfs_discard_punt_unused_bgs_list - punt unused_bgs list to discard lists

/*

 * Punt unused_bgs list to discard lists.

 *

 * @fs_info: fs_info of interest

 *

 * The unused_bgs list needs to be punted to the discard lists because the

	spin_unlock(&fs_info->unused_bgs_lock);

}

/**

 * btrfs_discard_purge_list - purge discard lists

/*

 * Purge discard lists.

 *

 * @discard_ctl: discard control

 *

 * If we are disabling async discard, we may have intercepted block groups that