kevent: poll/select() notifications.
Subsystems (10)
A message that is not in the archive (sent off-list or not yet received): [email protected]
PATCH 3/10 kevent: poll/select() notifications.
poll/select() notifications.
This patch includes generic poll/select notifications. kevent_poll works simialr to epoll and has the same issues (callback is invoked not from internal state machine of the caller, but through process awake, a lot of allocations and so on).
fs/file_table.c +3 -0
@@ -20,6 +20,7 @@#include <linux/cdev.h> #include <linux/fsnotify.h> #include <linux/sysctl.h> +#include <linux/kevent.h> #include <linux/percpu_counter.h> #include <asm/atomic.h>
@@ -119,6 +120,7 @@ struct file *get_empty_filp(void) f->f_uid = tsk->fsuid; f->f_gid = tsk->fsgid;eventpoll_init_file (f); +kevent_init_file (f);/* f->f_version: 0 */ return f;
@@ -164,6 +166,7 @@ void fastcall __fput(struct file *file)* in the file cleanup chain. */ eventpoll_release (file); +kevent_cleanup_file (file);locks_remove_flock (file);if (file->f_op && file->f_op->release)
include/linux/fs.h +10 -0
@@ -280,6 +280,7 @@ extern int dir_notify_enable;#include <linux/init.h> #include <linux/pid.h> #include <linux/mutex.h> +#include <linux/kevent_storage.h> #include <asm/atomic.h> #include <asm/semaphore.h>
@@ -408,6 +409,8 @@ struct address_space_operations {int (*readpages)(struct file *filp,struct address_space *mapping,struct list_head *pages,unsigned nr_pages); +int (*aio_readpages)(struct file *filp,struct address_space *mapping, +struct list_head *pages,unsigned nr_pages,void *priv);/* * ext3 requires that a successful prepare_write() call be followed
@@ -579,6 +582,10 @@ struct inode {struct mutex inotify_mutex;/* protects the watches list */ #endif +#if definedCONFIG_KEVENT_SOCKET || definedCONFIG_KEVENT_PIPE +struct kevent_storage st; +#endif +unsigned long i_state;unsigned long dirtied_when;/* jiffies of first dirtying */
@@ -738,6 +745,9 @@ struct file {struct list_head f_ep_links;spinlock_t f_ep_lock;#endif /* #ifdef CONFIG_EPOLL */ +#ifdef CONFIG_KEVENT_POLL +struct kevent_storage st; +#endif struct address_space *f_mapping; };extern spinlock_t files_lock;
kernel/kevent/kevent_poll.c new file +234 -0
234 lines not on this page · raw message
PATCH 4/10 kevent: Socket notifications.
Socket notifications.
This patch includes socket send/recv/accept notifications.
fs/inode.c +7 -0
@@ -21,6 +21,7 @@#include <linux/cdev.h> #include <linux/bootmem.h> #include <linux/inotify.h> +#include <linux/kevent.h> #include <linux/mount.h> /*
@@ -164,12 +165,18 @@ static struct inode *alloc_inode(struct super_block *sb) } inode->i_private =NULL ; inode->i_mapping = mapping; +#if definedCONFIG_KEVENT_SOCKET || definedCONFIG_KEVENT_PIPE +kevent_storage_init (inode, &inode->st); +#endif }return inode; }void destroy_inode (struct inode *inode) { +#if definedCONFIG_KEVENT_SOCKET || definedCONFIG_KEVENT_PIPE +kevent_storage_fini (&inode->st); +#endif BUG_ON (inode_has_buffers (inode));security_inode_free (inode);if (inode->i_sb->s_op->destroy_inode)
include/net/sock.h +17 -15
@@ -49,6 +49,7 @@#include <linux/skbuff.h> /* struct sk_buff */ #include <linux/mm.h> #include <linux/security.h> +#include <linux/kevent.h> #include <linux/filter.h>
@@ -451,6 +452,21 @@ static inline int sk_stream_memory_free(struct sock *sk)extern void sk_stream_rfree (struct sk_buff *skb); +struct socket_alloc { +struct socket socket; +struct inode vfs_inode; +}; + +static inline struct socket *SOCKET_I (struct inode *inode) +{ + return &container_of(inode, struct socket_alloc, vfs_inode)->socket; +} + +static inline struct inode *SOCK_INODE (struct socket *socket) +{ + return &container_of(socket, struct socket_alloc, socket)->vfs_inode; +} +static inline void sk_stream_set_owner_r (struct sk_buff *skb,struct sock *sk) { skb->sk = sk;
@@ -478,6 +494,7 @@ static inline void sk_add_backlog(struct sock *sk, struct sk_buff *skb) sk->sk_backlog.tail = skb; } skb->next =NULL ; +kevent_socket_notify (sk,KEVENT_SOCKET_RECV ); }#define sk_wait_event (__sk, __timeo, __condition) \
@@ -679,21 +696,6 @@ static inline struct kiocb *siocb_to_kiocb(struct sock_iocb *si)return si->kiocb; } -struct socket_alloc { -struct socket socket; -struct inode vfs_inode; -}; - -static inline struct socket *SOCKET_I (struct inode *inode) -{ - return &container_of(inode, struct socket_alloc, vfs_inode)->socket; -} - -static inline struct inode *SOCK_INODE (struct socket *socket) -{ - return &container_of(socket, struct socket_alloc, socket)->vfs_inode; -} -extern void __sk_stream_mem_reclaim (struct sock *sk);extern int sk_stream_mem_schedule (struct sock *sk,int size,int kind);
include/net/tcp.h +1 -0
@@ -864,6 +864,7 @@ static inline int tcp_prequeue(struct sock *sk, struct sk_buff *skb) tp->ucopy.memory =0 ; }else if (skb_queue_len (&tp->ucopy.prequeue) ==1 ) {wake_up_interruptible (sk->sk_sleep); +kevent_socket_notify (sk,KEVENT_SOCKET_RECV |KEVENT_SOCKET_SEND );if (!inet_csk_ack_scheduled (sk)) inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK, (3 * TCP_RTO_MIN) / 4,
kernel/kevent/kevent_socket.c new file +144 -0
144 lines not on this page · raw message
net/core/sock.c +9 -1
@@ -1393,6 +1393,7 @@ static void sock_def_wakeup(struct sock *sk)if (sk->sk_sleep &&waitqueue_active (sk->sk_sleep))wake_up_interruptible_all (sk->sk_sleep);read_unlock (&sk->sk_callback_lock); +kevent_socket_notify (sk,KEVENT_SOCKET_RECV |KEVENT_SOCKET_SEND ); }static void sock_def_error_report (struct sock *sk)
@@ -1402,6 +1403,7 @@ static void sock_def_error_report(struct sock *sk)wake_up_interruptible (sk->sk_sleep);sk_wake_async (sk,0 ,POLL_ERR );read_unlock (&sk->sk_callback_lock); +kevent_socket_notify (sk,KEVENT_SOCKET_RECV |KEVENT_SOCKET_SEND ); }static void sock_def_readable (struct sock *sk,int len)
@@ -1411,6 +1413,7 @@ static void sock_def_readable(struct sock *sk, int len)wake_up_interruptible (sk->sk_sleep);sk_wake_async (sk,1 ,POLL_IN );read_unlock (&sk->sk_callback_lock); +kevent_socket_notify (sk,KEVENT_SOCKET_RECV |KEVENT_SOCKET_SEND ); }static void sock_def_write_space (struct sock *sk)
@@ -1430,6 +1433,7 @@ static void sock_def_write_space(struct sock *sk) }read_unlock (&sk->sk_callback_lock); +kevent_socket_notify (sk,KEVENT_SOCKET_SEND |KEVENT_SOCKET_RECV ); }static void sock_def_destruct (struct sock *sk)
@@ -1480,6 +1484,8 @@ void sock_init_data(struct socket *sock, struct sock *sk) sk->sk_state =TCP_CLOSE ; sk->sk_socket = sock; +kevent_sk_reinit (sk); +sock_set_flag (sk,SOCK_ZAPPED );if (sock)
@@ -1546,8 +1552,10 @@ void fastcall release_sock(struct sock *sk)if (sk->sk_backlog.tail)__release_sock (sk); sk->sk_lock.owner =NULL ; -if (waitqueue_active (&sk->sk_lock.wq)) +if (waitqueue_active (&sk->sk_lock.wq)) {wake_up (&sk->sk_lock.wq); +kevent_socket_notify (sk,KEVENT_SOCKET_RECV |KEVENT_SOCKET_SEND ); + }spin_unlock_bh (&sk->sk_lock.slock); }EXPORT_SYMBOL (release_sock);
net/core/stream.c +1 -0
@@ -36,6 +36,7 @@ void sk_stream_write_space(struct sock *sk)wake_up_interruptible (sk->sk_sleep);if (sock->fasync_list && !(sk->sk_shutdown &SEND_SHUTDOWN ))sock_wake_async (sock,2 ,POLL_OUT ); +kevent_socket_notify (sk,KEVENT_SOCKET_SEND |KEVENT_SOCKET_RECV ); } }
net/ipv4/tcp_input.c +1 -0
@@ -3128,6 +3128,7 @@ static void tcp_ofo_queue(struct sock *sk)__skb_unlink (skb, &tp->out_of_order_queue);__skb_queue_tail (&sk->sk_receive_queue, skb); +kevent_socket_notify (sk,KEVENT_SOCKET_RECV ); tp->rcv_nxt =TCP_SKB_CB (skb)->end_seq;if (skb->h.th->fin)tcp_fin (skb, sk, skb->h.th);
net/ipv4/tcp_ipv4.c +2 -0
@@ -61,6 +61,7 @@#include <linux/jhash.h> #include <linux/init.h> #include <linux/times.h> +#include <linux/kevent.h> #include <net/icmp.h> #include <net/inet_hashtables.h>
@@ -1391,6 +1392,7 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)reqsk_free (req); }else {inet_csk_reqsk_queue_hash_add (sk, req,TCP_TIMEOUT_INIT ); +kevent_socket_notify (sk,KEVENT_SOCKET_ACCEPT ); }return 0 ;
net/socket.c +3 -0
@@ -84,6 +84,7 @@#include <linux/kmod.h> #include <linux/audit.h> #include <linux/wireless.h> +#include <linux/kevent.h> #include <asm/uaccess.h> #include <asm/unistd.h>
@@ -496,6 +497,8 @@ static struct socket *sock_alloc(void) inode->i_uid = current->fsuid; inode->i_gid = current->fsgid; +kevent_socket_reinit (sock); +get_cpu_var (sockets_in_use)++;put_cpu_var (sockets_in_use);return sock;
net/unix/af_unix.c +21 -1
@@ -1563,8 +1563,10 @@ static int unix_dgram_recvmsg(struct kiocb *iocb, struct socket *sock,struct scm_cookie tmp_scm;struct sock *sk = sock->sk;struct unix_sock *u =unix_sk (sk); +struct sock *other;int noblock = flags &MSG_DONTWAIT ;struct sk_buff *skb; +int err; err = -EOPNOTSUPP ;
@@ -1580,6 +1582,12 @@ static int unix_dgram_recvmsg(struct kiocb *iocb, struct socket *sock, goto out_unlock;wake_up_interruptible (&u->peer_wait); + other =unix_peer_get (sk); +if (other) { +kevent_socket_notify (other,KEVENT_SOCKET_SEND ); +sock_put (other); + }else +kevent_socket_notify (sk,KEVENT_SOCKET_RECV );if (msg->msg_name)unix_copy_addr (msg, skb->sk);
@@ -1674,7 +1682,7 @@ static int unix_stream_recvmsg(struct kiocb *iocb, struct socket *sock, {struct sock_iocb *siocb =kiocb_to_siocb (iocb);struct scm_cookie tmp_scm; -struct sock *sk = sock->sk; +struct sock *sk = sock->sk, *other;struct unix_sock *u =unix_sk (sk);struct sockaddr_un *sunaddr=msg->msg_name;int copied =0 ;
@@ -1803,6 +1811,14 @@ static int unix_stream_recvmsg(struct kiocb *iocb, struct socket *sock, } }while (size); + other =unix_peer_get (sk); +if (other) { +kevent_socket_notify (other,KEVENT_SOCKET_SEND ); +sock_put (other); + } +if (sk->sk_shutdown &RCV_SHUTDOWN || !other) +kevent_socket_notify (sk,KEVENT_SOCKET_RECV ); +mutex_unlock (&u->readlock);scm_recv (sock, msg, siocb->scm, flags); out:
@@ -1824,6 +1840,10 @@ static int unix_shutdown(struct socket *sock, int mode)sock_hold (other);unix_state_wunlock (sk); sk->sk_state_change (sk); +kevent_socket_notify (sk,KEVENT_SOCKET_SEND |KEVENT_SOCKET_RECV ); +if (other) +kevent_socket_notify (other,KEVENT_SOCKET_SEND |KEVENT_SOCKET_RECV ); +kevent_socket_notify (sk,KEVENT_SOCKET_SEND |KEVENT_SOCKET_RECV );if (other && (sk->sk_type ==SOCK_STREAM || sk->sk_type ==SOCK_SEQPACKET )) {
PATCH 5/10 kevent: Timer notifications.
Timer notifications.
Timer notifications can be used for fine grained per-process time management, since interval timers are very inconvenient to use, and they are limited.
This subsystem uses high-resolution timers.
id.raw[0] is used as number of seconds
id.raw[1] is used as number of nanoseconds
kernel/kevent/kevent_timer.c new file +114 -0
@@ -0,0 +1,114 @@ +/* +* 2006 Copyright (c) Evgeniy Polyakov <[email protected]> +* All rights reserved. +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; either version 2 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#include <linux/kernel.h> +#include <linux/types.h> +#include <linux/list.h> +#include <linux/slab.h> +#include <linux/spinlock.h> +#include <linux/hrtimer.h> +#include <linux/jiffies.h> +#include <linux/kevent.h> + +struct kevent_timer +{ +struct hrtimer ktimer; +struct kevent_storage ktimer_storage; +struct kevent *ktimer_event; +}; + +static int kevent_timer_func (struct hrtimer *timer) +{ + struct kevent_timer *t = container_of(timer, struct kevent_timer, ktimer); +struct kevent *k = t->ktimer_event; + +kevent_storage_ready (&t->ktimer_storage,NULL ,KEVENT_MASK_ALL ); +hrtimer_forward (timer, timer->base->softirq_time, +ktime_set (k->event.id.raw[0 ], k->event.id.raw[1 ])); +return HRTIMER_RESTART ; +} + +static struct lock_class_key kevent_timer_key; + +static int kevent_timer_enqueue (struct kevent *k) +{ +int err; +struct kevent_timer *t; + + t =kmalloc (sizeof (struct kevent_timer ),GFP_KERNEL ); +if (!t) +return -ENOMEM ; + +hrtimer_init (&t->ktimer,CLOCK_MONOTONIC ,HRTIMER_REL ); + t->ktimer.expires =ktime_set (k->event.id.raw[0 ], k->event.id.raw[1 ]); + t->ktimer.function = kevent_timer_func; + t->ktimer_event = k; + + err =kevent_storage_init (&t->ktimer, &t->ktimer_storage); +if (err) + goto err_out_free; +lockdep_set_class (&t->ktimer_storage.lock, &kevent_timer_key); + + err =kevent_storage_enqueue (&t->ktimer_storage, k); +if (err) + goto err_out_st_fini; + +hrtimer_start (&t->ktimer, t->ktimer.expires,HRTIMER_REL ); + +return 0 ; + +err_out_st_fini: +kevent_storage_fini (&t->ktimer_storage); +err_out_free: +kfree (t); + +return err; +} + +static int kevent_timer_dequeue (struct kevent *k) +{ +struct kevent_storage *st = k->st; + struct kevent_timer *t = container_of(st, struct kevent_timer, ktimer_storage); + +hrtimer_cancel (&t->ktimer); +kevent_storage_dequeue (st, k); +kfree (t); + +return 0 ; +} + +static int kevent_timer_callback (struct kevent *k) +{ + k->event.ret_data[0 ] =jiffies_to_msecs (jiffies); +return 1 ; +} + +static int __init kevent_init_timer (void ) +{ +struct kevent_callbacks tc = { + .callback = &kevent_timer_callback, + .enqueue = &kevent_timer_enqueue, + .dequeue = &kevent_timer_dequeue, + .flags =0 , + }; + +return kevent_add_callbacks (&tc,KEVENT_TIMER ); +} +module_init (kevent_init_timer); +
PATCH 6/10 kevent: Pipe notifications.
Pipe notifications.
fs/pipe.c +6 -0
@@ -16,6 +16,7 @@#include <linux/uio.h> #include <linux/highmem.h> #include <linux/pagemap.h> +#include <linux/kevent.h> #include <asm/uaccess.h> #include <asm/ioctls.h>
@@ -313,6 +314,7 @@ redo:break ; }if (do_wakeup) { +kevent_pipe_notify (inode,KEVENT_SOCKET_SEND );wake_up_interruptible_sync (&pipe->wait);kill_fasync (&pipe->fasync_writers,SIGIO ,POLL_OUT ); }
@@ -322,6 +324,7 @@ redo:/* Signal writers asynchronously that there is more room. */ if (do_wakeup) { +kevent_pipe_notify (inode,KEVENT_SOCKET_SEND );wake_up_interruptible (&pipe->wait);kill_fasync (&pipe->fasync_writers,SIGIO ,POLL_OUT ); }
@@ -484,6 +487,7 @@ redo2:break ; }if (do_wakeup) { +kevent_pipe_notify (inode,KEVENT_SOCKET_RECV );wake_up_interruptible_sync (&pipe->wait);kill_fasync (&pipe->fasync_readers,SIGIO ,POLL_IN ); do_wakeup =0 ;
@@ -495,6 +499,7 @@ redo2: out:mutex_unlock (&inode->i_mutex);if (do_wakeup) { +kevent_pipe_notify (inode,KEVENT_SOCKET_RECV );wake_up_interruptible (&pipe->wait);kill_fasync (&pipe->fasync_readers,SIGIO ,POLL_IN ); }
@@ -590,6 +595,7 @@ pipe_release(struct inode *inode, int decr, int decw)free_pipe_info (inode); }else {wake_up_interruptible (&pipe->wait); +kevent_pipe_notify (inode,KEVENT_SOCKET_SEND |KEVENT_SOCKET_RECV );kill_fasync (&pipe->fasync_readers,SIGIO ,POLL_IN );kill_fasync (&pipe->fasync_writers,SIGIO ,POLL_OUT ); }
kernel/kevent/kevent_pipe.c new file +123 -0
123 lines not on this page · raw message
PATCH 7/10 kevent: Signal notifications.
Signal notifications.
This type of notifications allows to deliver signals through kevent queue. One can find example application signal.c on project homepage.
If KEVENT_SIGNAL_NOMASK bit is set in raw_u64 id then signal will be delivered only through queue, otherwise both delivery types are used - old through update of mask of pending signals and through queue.
If signal is delivered only through kevent queue, mask of pending signals is not updated at all, which is equal to putting signal into blocked mask, but with delivery of that signal through kevent queue.
include/linux/sched.h +5 -0
@@ -82,6 +82,7 @@ struct sched_param {#include <linux/resource.h> #include <linux/timer.h> #include <linux/hrtimer.h> +#include <linux/kevent_storage.h> #include <linux/task_io_accounting.h> #include <asm/processor.h>
@@ -1048,6 +1049,10 @@ struct task_struct {#ifdef CONFIG_TASK_DELAY_ACCT struct task_delay_info *delays;#endif +#ifdef CONFIG_KEVENT_SIGNAL +struct kevent_storage st; +u32 kevent_signals; +#endif #ifdef CONFIG_FAULT_INJECTION int make_it_fail;#endif
kernel/fork.c +8 -0
@@ -49,6 +49,7 @@#include <linux/delayacct.h> #include <linux/taskstats_kern.h> #include <linux/random.h> +#include <linux/kevent.h> #include <asm/pgtable.h> #include <asm/pgalloc.h>
@@ -118,6 +119,9 @@ void __put_task_struct(struct task_struct *tsk)WARN_ON (atomic_read (&tsk->usage));WARN_ON (tsk == current); +#ifdef CONFIG_KEVENT_SIGNAL +kevent_storage_fini (&tsk->st); +#endif security_task_free (tsk);free_uid (tsk->user);put_group_info (tsk->group_info);
@@ -1126,6 +1130,10 @@ static struct task_struct *copy_process(unsigned long clone_flags,if (retval) goto bad_fork_cleanup_namespaces; +#ifdef CONFIG_KEVENT_SIGNAL +kevent_storage_init (p, &p->st); +#endif + p->set_child_tid = (clone_flags &CLONE_CHILD_SETTID ) ? child_tidptr :NULL ;/* * Clear TID on mm_release()?
kernel/kevent/kevent_signal.c new file +94 -0
94 lines not on this page · raw message
kernel/signal.c +26 -0
@@ -23,6 +23,7 @@#include <linux/ptrace.h> #include <linux/signal.h> #include <linux/capability.h> +#include <linux/kevent.h> #include <linux/freezer.h> #include <linux/pid_namespace.h> #include <linux/nsproxy.h>
@@ -714,6 +715,9 @@ static int send_signal(int sig, struct siginfo *info, struct task_struct *t, {struct sigqueue * q =NULL ;int ret =0 ; + +if (kevent_signal_notify (t, sig)) +return 1 ;/* * fast-pathed signals for kernel-internal things like SIGSTOP
@@ -793,6 +797,17 @@ specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t) ret =send_signal (sig, info, t, &t->pending);if (!ret && !sigismember (&t->blocked, sig))signal_wake_up (t, sig ==SIGKILL ); +#ifdef CONFIG_KEVENT_SIGNAL +/* +* Kevent allows to deliver signals through kevent queue, +* it is possible to setup kevent to not deliver +* signal through the usual way, in that case send_signal() +* returns 1 and signal is delivered only through kevent queue. +* We simulate successfull delivery notification through this hack: +*/ +if (ret ==1 ) + ret =0 ; +#endif out:return ret; }
@@ -982,6 +997,17 @@ __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)* to avoid several races. */ ret =send_signal (sig, info, p, &p->signal->shared_pending); +#ifdef CONFIG_KEVENT_SIGNAL +/* +* Kevent allows to deliver signals through kevent queue, +* it is possible to setup kevent to not deliver +* signal through the usual way, in that case send_signal() +* returns 1 and signal is delivered only through kevent queue. +* We simulate successfull delivery notification through this hack: +*/ +if (ret ==1 ) + ret =0 ; +#endif if (unlikely (ret))return ret;
PATCH 8/10 kevent: Kevent posix timer notifications.
Kevent posix timer notifications.
Simple extension to POSIX timers which allows
to deliver notification of the timer expiration
through kevent queue.
Example application posix_timer.c can be found
in archive on project homepage.
include/asm-generic/siginfo.h +3 -0
@@ -235,6 +235,7 @@ typedef struct siginfo {#define SIGEV_NONE 1/* other notification: meaningless */ #define SIGEV_THREAD 2/* deliver via thread creation */ #define SIGEV_THREAD_ID 4/* deliver to thread */ +#define SIGEV_KEVENT 8/* deliver through kevent queue */ /* * This works because the alignment is ok on all current architectures
@@ -260,6 +261,8 @@ typedef struct sigevent {void (*_function)(sigval_t );void *_attribute;/* really pthread_attr_t */ } _sigev_thread; + +int kevent_fd; } _sigev_un; } sigevent_t;
include/linux/posix-timers.h +4 -0
@@ -4,6 +4,7 @@#include <linux/spinlock.h> #include <linux/list.h> #include <linux/sched.h> +#include <linux/kevent_storage.h> union cpu_time_count {cputime_t cpu;
@@ -49,6 +50,9 @@ struct k_itimer {sigval_t it_sigev_value;/* value word of sigevent struct */ struct task_struct *it_process;/* process to send signal to */ struct sigqueue *sigq;/* signal queue entry. */ +#ifdef CONFIG_KEVENT_TIMER +struct kevent_storage st; +#endif union { struct { struct hrtimer timer;
kernel/posix-timers.c +171 -48
264 lines not on this page · raw message
PATCH 9/10 kevent: Private userspace notifications.
Private userspace notifications.
Allows to register notifications of any private userspace events over kevent. Events can be marked as ready using kevent_ctl(KEVENT_READY) command.
kernel/kevent/kevent_unotify.c new file +62 -0
@@ -0,0 +1,62 @@ +/* +* 2006 Copyright (c) Evgeniy Polyakov <[email protected]> +* All rights reserved. +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; either version 2 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#include <linux/kernel.h> +#include <linux/kevent.h> + +static int kevent_unotify_callback (struct kevent *k) +{ +return 1 ; +} + +int kevent_unotify_enqueue (struct kevent *k) +{ +int err; + + err =kevent_storage_enqueue (&k->user->st, k); +if (err) + goto err_out_exit; + +if (k->event.req_flags &KEVENT_REQ_ALWAYS_QUEUE ) +kevent_requeue (k); + +return 0 ; + +err_out_exit: +return err; +} + +int kevent_unotify_dequeue (struct kevent *k) +{ +kevent_storage_dequeue (k->st, k); +return 0 ; +} + +static int __init kevent_init_unotify (void ) +{ +struct kevent_callbacks sc = { + .callback = &kevent_unotify_callback, + .enqueue = &kevent_unotify_enqueue, + .dequeue = &kevent_unotify_dequeue, + .flags =0 , + }; + +return kevent_add_callbacks (&sc,KEVENT_UNOTIFY ); +} +module_init (kevent_init_unotify);
PATCH 10/10 kevent: Kevent based generic AIO.
Kevent based generic AIO.
This patch only implements network AIO, which is _COMPLETELY_ impossible and broken in _ANY_ micro-thread design. For details and test consider following link:
http://tservice.net.ru/~s0mbre/blog/2007/02/10#2007_02_10
Designing AIO without network in mind can only be result of heavy hang-over.
Kevent AIO is implemented as state machine.
There is a patch which implements async open/send_header/sendfile/close.
aio_sendfile()/aio_sendfile_path() contains of two major parts: AIO state machine and page processing code.
The former is just a small subsystem, which allows to queue callback for theirs invocation in process' context on behalf of pool of kernel threads. It allows to queue caches of callbacks to the local thread or to any other specified. Each cache of callbacks is processed until there are callbacks in it, callbacks can requeue themselfs into the same cache.
Real work is being done in page processing code - code which populates pages into VFS cache and then sends pages to the destination socket via ->sendpage(). Unlike previous aio_sendfile() implementation, new one does not require low-level filesystem specific callbacks (->get_block()) at all, instead I extended struct address_space_operations to contain new member called ->aio_readpages(), which is exactly the same as ->readpage() (read: mpage_readpages()) except different BIO allocation and sumbission routines. I changed mpage_readpages() to provide mpage_alloc() and mpage_bio_submit() to the new function called __mpage_readpages(), which is exactly old mpage_readpages() with provided callback invocation instead of usage for old functions. mpage_readpages_aio() provides kevent specific callbacks, which calls old functions, but with different destructor callbacks, which are essentially the same, except that they reschedule AIO processing.
aio_sendfile_path() is essentially aio_sendfile(), except that it takes source filename as parameter, has a pointer to private header and its size (which allows to send header and file's content in one syscall instead of three (open, send, sendfile) and returns opened file descriptor.
Benchmark of the 100 1MB files transfer (files are in VFS already) using sync sendfile() against aio_sendfile_path() shows about 10MB/sec performance win (78 MB/s vs 66-72 MB/s over 1 Gb network, sendfile sending server is one-way AMD Athlong 64 3500+) for aio_sendfile_path().
AIO state machine is a base for network AIO (which becomes quite trivial), but I will not start implementation until roadback of kevent as a whole and AIO implementation become more clear.
fs/bio.c +1 -1
@@ -120,7 +120,7 @@ void bio_free(struct bio *bio, struct bio_set *bio_set)/* * default destructor for a bio allocated with bio_alloc_bioset() */ -static void bio_fs_destructor (struct bio *bio) +void bio_fs_destructor (struct bio *bio) {bio_free (bio, fs_bio_set); }
fs/ext3/inode.c +8 -0
@@ -1650,6 +1650,13 @@ ext3_readpages(struct file *file, struct address_space *mapping,return mpage_readpages (mapping, pages, nr_pages, ext3_get_block); } +static int +ext3_readpages_aio (struct file *file,struct address_space *mapping, +struct list_head *pages,unsigned nr_pages,void *priv) +{ +return mpage_readpages_aio (mapping, pages, nr_pages, ext3_get_block, priv); +} +static void ext3_invalidatepage (struct page *page,unsigned long offset) {journal_t *journal =EXT3_JOURNAL (page->mapping->host);
@@ -1768,6 +1775,7 @@ static int ext3_journalled_set_page_dirty(struct page *page) }static const struct address_space_operations ext3_ordered_aops = { + .aio_readpages = ext3_readpages_aio, .readpage = ext3_readpage, .readpages = ext3_readpages, .writepage = ext3_ordered_writepage,
fs/mpage.c +76 -41
188 lines not on this page · raw message
include/linux/mpage.h +2 -0
@@ -16,6 +16,8 @@ typedef int (writepage_t)(struct page *page, struct writeback_control *wbc);int mpage_readpages (struct address_space *mapping,struct list_head *pages,unsigned nr_pages,get_block_t get_block); +int mpage_readpages_aio (struct address_space *mapping,struct list_head *pages, +unsigned nr_pages,get_block_t get_block,void *priv);int mpage_readpage (struct page *page,get_block_t get_block);int mpage_writepages (struct address_space *mapping,struct writeback_control *wbc,get_block_t get_block);
kernel/kevent/kevent_aio.c new file +939 -0
939 lines not on this page · raw message
Re: [take36 10/10] kevent: Kevent based generic AIO.
Quoted 5 lines · Evgeniy Polyakov
aio_sendfile_path()is essentiallyaio_sendfile(), except that it takes source filename as parameter, has a pointer to private header and its size (which allows to send header and file's content in one syscall instead of three (open, send, sendfile) and returns opened file descriptor.
Are you sure this is a useful optimization? Do you have numbers vs open+aio_sendfile+close?
Compared to the cost of sending a complete file three system calls should be quite in the noise. And Linux system calls are not that expensive (few hundred cycles normally)
Adding such compound system calls would be a worrying precedent because I'm sure others would want them then for their favourite system call combo too. If they were really useful it might make more sense to have a batch() system call that works for arbitary calls, but I'm not convinced yet it's even needed. It would be certainly ugly.
-Andi
Re: [take36 10/10] kevent: Kevent based generic AIO.
Quoted 9 lines · Andi Kleen
Quoted 5 lines · Evgeniy Polyakov
aio_sendfile_path()is essentiallyaio_sendfile(), except that it takes source filename as parameter, has a pointer to private header and its size (which allows to send header and file's content in one syscall instead of three (open, send, sendfile) and returns opened file descriptor.Are you sure this is a useful optimization? Do you have numbers vs open+aio_sendfile+close?
Quoted 8 lines
Compared to the cost of sending a complete file three system calls should be quite in the noise. And Linux system calls are not that expensive (few hundred cycles normally)
Adding such compound system calls would be a worrying precedent because I'm sure others would want them then for their favourite system call combo too. If they were really useful it might make more sense to have a
batch()system call that works for arbitary calls, but I'm not convinced yet it's even needed. It would be certainly ugly.
Yes, that call ends up about 10MB/sec faster for 100 1mb file transfers over 1gbit network (78 MB/s vs 66-72 MB/s over 1 Gb network, sendfile sending server is one-way AMD Athlong 64 3500+), but indeed, it can be the case that async IO sending was main speed factor.
I added header by request from Suparna Bhattacharya - my main position is the same about syscall overhead, but I do not that care.
Quoted 1 line
-Andi
Signature · 1 line
Evgeniy Polyakov
Re: [take36 10/10] kevent: Kevent based generic AIO.
In reply to Andi KleenQuoted 4 lines
I'm sure others would want them then for their favourite system call combo too. If they were really useful it might make more sense to have a
batch()system call that works for arbitary calls, but I'm not convinced yet it's even needed. It would be certainly ugly.
batch() would possibly make a lot of sense in terms of the fibril/thread based removal for the need for all the AIO stuff, just to provide a natural way to group and order sequences of synchronous operations into asynchronous groups.
I am extremely sceptical about the need for aio_sendfile_path since with sendfile/sendpath hacking around there didn't seem to be much gain.
I'm even more sceptical of the header buffer stuff as while other OS's do that as a hack to make TCP packetising work we simply fixed the root problem with TCP_CORK
Alan
Re: [take36 10/10] kevent: Kevent based generic AIO.
Quoted 10 lines · Alan
Quoted 4 lines
I'm sure others would want them then for their favourite system call combo too. If they were really useful it might make more sense to have a
batch()system call that works for arbitary calls, but I'm not convinced yet it's even needed. It would be certainly ugly.
batch()would possibly make a lot of sense in terms of the fibril/thread based removal for the need for all the AIO stuff, just to provide a natural way to group and order sequences of synchronous operations into asynchronous groups.
Quoted 6 lines
I am extremely sceptical about the need for
aio_sendfile_pathsince with sendfile/sendpath hacking around there didn't seem to be much gain.I'm even more sceptical of the header buffer stuff as while other OS's do that as a hack to make TCP packetising work we simply fixed the root problem with
TCP_CORK
Well, that does not matter that much - that syscall is an example of how kevent AIO state machine works - it trivially allows to have async open/send/sendfile/close like aio_senfile_path.
I would remove header too (it was not there in the first release, added on request), but the whole idea of async open/send/close seems natural for web-like workloads, when user should not even care about proper state machine.
Having batch() mode would be good too - with kevent state machine it is quite trivially:
req = kaio_add_call(NULL, first_call)kaio_append_call(req, second_call);kaio_append_call(req, third_call);
...kaio_schedule_req(req);
Yes, state machine handling requires additional code, but when it ends up in faster processing implementation complexities deserve its price.
Quoted 1 line
Alan
Signature · 1 line
Evgeniy Polyakov