locks: add fl_grant callback for asynchronous lock return

 * If the filesystem defines a private ->lock() method, then @conf will

 * be left unchanged; so a caller that cares should initialize it to

 * some acceptable default.

 *

 * To avoid blocking kernel daemons, such as lockd, that need to acquire POSIX

 * locks, the ->lock() interface may return asynchronously, before the lock has

 * been granted or denied by the underlying filesystem, if (and only if)

 * fl_grant is set. Callers expecting ->lock() to return asynchronously

 * will only use F_SETLK, not F_SETLKW; they will set FL_SLEEP if (and only if)

 * the request is for a blocking lock. When ->lock() does return asynchronously,

 * it must return -EINPROGRESS, and call ->fl_grant() when the lock

 * request completes.

 * If the request is for non-blocking lock the file system should return

 * -EINPROGRESS then try to get the lock and call the callback routine with

 * the result. If the request timed out the callback routine will return a

 * nonzero return code and the file system should release the lock. The file

 * system is also responsible to keep a corresponding posix lock when it

 * grants a lock so the VFS can find out which locks are locally held and do

 * the correct lock cleanup when required.

 * The underlying filesystem must not drop the kernel lock or call

 * ->fl_grant() before returning to the caller with a -EINPROGRESS

 * return code.

 */

int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf)

{

struct lock_manager_operations {

	int (*fl_compare_owner)(struct file_lock *, struct file_lock *);

	void (*fl_notify)(struct file_lock *);	/* unblock callback */

	int (*fl_grant)(struct file_lock *, struct file_lock *, int);

	void (*fl_copy_lock)(struct file_lock *, struct file_lock *);

	void (*fl_release_private)(struct file_lock *);

	void (*fl_break)(struct file_lock *);