static int receiver_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key) { unsigned long bits = (unsigned long)key; if (bits && !(bits & (POLLIN | POLLERR))) return 0; return autoremove_wake_function(wait, mode, sync, key); }
static int receiver_wake_function(wait_queue_entry_t *wait, unsigned int mode, int sync, void *key) { /* * Avoid a wakeup if event not interesting for us */ if (key && !(key_to_poll(key) & (EPOLLIN | EPOLLERR))) return 0; return autoremove_wake_function(wait, mode, sync, key); }
static int receiver_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key) { unsigned long bits = (unsigned long)key; /* * Avoid a wakeup if event not interesting for us */ if (bits && !(bits & (POLLIN | POLLERR))) return 0; return autoremove_wake_function(wait, mode, sync, key); }
int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *arg) { struct wait_bit_key *key = arg; struct wait_bit_queue *wait_bit = container_of(wait, struct wait_bit_queue, wait); if (wait_bit->key.flags != key->flags || wait_bit->key.bit_nr != key->bit_nr || test_bit(key->bit_nr, key->flags)) return 0; else return autoremove_wake_function(wait, mode, sync, key); }
static int wake_atomic_t_function(wait_queue_t *wait, unsigned mode, int sync, void *arg) { struct wait_bit_key *key = arg; struct wait_bit_queue *wait_bit = container_of(wait, struct wait_bit_queue, wait); atomic_t *val = key->flags; if (wait_bit->key.flags != key->flags || wait_bit->key.bit_nr != key->bit_nr || atomic_read(val) != 0) return 0; return autoremove_wake_function(wait, mode, sync, key); }
/* * the autoremove wake function will return 0 if it tried to wake up * a process that was already awake, which means that process won't * count as an exclusive wakeup. The waitq code will continue waking * procs until it finds one that was actually sleeping. * * For btrfs, this isn't quite what we want. We want a single proc * to be notified that the lock is ready for taking. If that proc * already happen to be awake, great, it will loop around and try for * the lock. * * So, btrfs_wake_function always returns 1, even when the proc that we * tried to wake up was already awake. */ static int btrfs_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key) { autoremove_wake_function(wait, mode, sync, key); return 1; }