一 模块的启动
1557static int __init eventpoll_init(void)
1558{
1559 struct sysinfo si;
1560
1561 si_meminfo(&si);
1562 /*
1563 * Allows top 4% of lomem to be allocated for epoll watches (per user).
1564 */
1565 max_user_watches = (((si.totalram - si.totalhigh) / 25) << PAGE_SHIFT) /
1566 EP_ITEM_COST;
1567 BUG_ON(max_user_watches < 0);
1568
1569 /*
1570 * Initialize the structure used to perform epoll file descriptor
1571 * inclusion loops checks.
1572 */
1573 ep_nested_calls_init(&poll_loop_ncalls);
1574
1575 /* Initialize the structure used to perform safe poll wait head wake ups */
1576 ep_nested_calls_init(&poll_safewake_ncalls);
1577
1578 /* Initialize the structure used to perform file's f_op->poll() calls */
1579 ep_nested_calls_init(&poll_readywalk_ncalls);
1580
1581 /* Allocates slab cache used to allocate "struct epitem" items */
1582 epi_cache = kmem_cache_create("eventpoll_epi", sizeof(struct epitem),
1583 0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
1584
1585 /* Allocates slab cache used to allocate "struct eppoll_entry" */
1586 pwq_cache = kmem_cache_create("eventpoll_pwq",
1587 sizeof(struct eppoll_entry), 0, SLAB_PANIC, NULL);
1588
1589 return 0;
1590}二. epoll_create 的实现
1303/*
1304 * Open an eventpoll file descriptor.
1305 */
1306SYSCALL_DEFINE1(epoll_create1, int, flags)
1307{
1308 int error;
1309 struct eventpoll *ep = NULL;
1310
1311 /* Check the EPOLL_* constant for consistency. */
1312 BUILD_BUG_ON(EPOLL_CLOEXEC != O_CLOEXEC);
1313
1314 if (flags & ~EPOLL_CLOEXEC)
1315 return -EINVAL;
1316 /*
1317 * Create the internal data structure ("struct eventpoll").
1318 */
1319 error = ep_alloc(&ep);
1320 if (error < 0)
1321 return error;
1322 /*
1323 * Creates all the items needed to setup an eventpoll file. That is,
1324 * a file structure and a free file descriptor.
1325 */
1326 error = anon_inode_getfd("[eventpoll]", &eventpoll_fops, ep,
1327 O_RDWR | (flags & O_CLOEXEC));
1328 if (error < 0)
1329 ep_free(ep);
1330
1331 return error;
1332}
1333
1334SYSCALL_DEFINE1(epoll_create, int, size)
1335{
1336 if (size <= 0)
1337 return -EINVAL;
1338
1339 return sys_epoll_create1(0);
1340}
1341
748static int ep_alloc(struct eventpoll **pep)
749{
750 int error;
751 struct user_struct *user;
752 struct eventpoll *ep;
753
754 user = get_current_user();
755 error = -ENOMEM;
756 ep = kzalloc(sizeof(*ep), GFP_KERNEL);
757 if (unlikely(!ep))
758 goto free_uid;
759
760 spin_lock_init(&ep->lock);
761 mutex_init(&ep->mtx);
762 init_waitqueue_head(&ep->wq);
763 init_waitqueue_head(&ep->poll_wait);
764 INIT_LIST_HEAD(&ep->rdllist);
765 ep->rbr = RB_ROOT;
766 ep->ovflist = EP_UNACTIVE_PTR;
767 ep->user = user;
768
769 *pep = ep;
770
771 return 0;
772
773free_uid:
774 free_uid(user);
775 return error;
776}
777 141/**
142 * anon_inode_getfd - creates a new file instance by hooking it up to an
143 * anonymous inode, and a dentry that describe the "class"
144 * of the file
145 *
146 * @name: [in] name of the "class" of the new file
147 * @fops: [in] file operations for the new file
148 * @priv: [in] private data for the new file (will be file's private_data)
149 * @flags: [in] flags
150 *
151 * Creates a new file by hooking it on a single inode. This is useful for files
152 * that do not need to have a full-fledged inode in order to operate correctly.
153 * All the files created with anon_inode_getfd() will share a single inode,
154 * hence saving memory and avoiding code duplication for the file/inode/dentry
155 * setup. Returns new descriptor or an error code.
156 */
157int anon_inode_getfd(const char *name, const struct file_operations *fops,
158 void *priv, int flags)
159{
160 int error, fd;
161 struct file *file;
162
163 error = get_unused_fd_flags(flags);
164 if (error < 0)
165 return error;
166 fd = error;
167
168 file = anon_inode_getfile(name, fops, priv, flags);
169 if (IS_ERR(file)) {
170 error = PTR_ERR(file);
171 goto err_put_unused_fd;
172 }
173 fd_install(fd, file);
174
175 return fd;
176
177err_put_unused_fd:
178 put_unused_fd(fd);
179 return error;
180}
181EXPORT_SYMBOL_GPL(anon_inode_getfd); 696/* File callbacks that implement the eventpoll file behaviour */
697static const struct file_operations eventpoll_fops = {
698 .release = ep_eventpoll_release,
699 .poll = ep_eventpoll_poll,
700 .llseek = noop_llseek,
701};
639static int ep_eventpoll_release(struct inode *inode, struct file *file)
640{
641 struct eventpoll *ep = file->private_data;
642
643 if (ep)
644 ep_free(ep);
645
646 return 0;
647}
648
676static unsigned int ep_eventpoll_poll(struct file *file, poll_table *wait)
677{
678 int pollflags;
679 struct eventpoll *ep = file->private_data;
680
681 /* Insert inside our poll wait queue */
682 poll_wait(file, &ep->poll_wait, wait);
683
684 /*
685 * Proceed to find out if wanted events are really available inside
686 * the ready list. This need to be done under ep_call_nested()
687 * supervision, since the call to f_op->poll() done on listed files
688 * could re-enter here.
689 */
690 pollflags = ep_call_nested(&poll_readywalk_ncalls, EP_MAX_NESTS,
691 ep_poll_readyevents_proc, ep, ep, current);
692
693 return pollflags != -1 ? pollflags : 0;
694}
695
106/**
107 * noop_llseek - No Operation Performed llseek implementation
108 * @file: file structure to seek on
109 * @offset: file offset to seek to
110 * @origin: type of seek
111 *
112 * This is an implementation of ->llseek useable for the rare special case when
113 * userspace expects the seek to succeed but the (device) file is actually not
114 * able to perform the seek. In this case you use noop_llseek() instead of
115 * falling back to the default implementation of ->llseek.
116 */
117loff_t noop_llseek(struct file *file, loff_t offset, int origin)
118{
119 return file->f_pos;
120}
121EXPORT_SYMBOL(noop_llseek);
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
