Eth audio device can notify processes
[akaros.git] / kern / src / eth_audio.c
1 /* Copyright (c) 2010 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * Rimas's Ethernet-Audio device */
6
7 #include <eth_audio.h>
8 #include <string.h>
9 #include <devfs.h>
10 #include <page_alloc.h>
11 #include <pmap.h>
12 #include <arch/nic_common.h>
13 #include <process.h>
14 #include <smp.h>
15
16 struct file_operations ethaud_in_f_op;
17 struct file_operations ethaud_out_f_op;
18 struct page_map_operations ethaud_pm_op;
19
20 /* There is only one packet we'll ever send out.  It's a full ethernet frame
21  * that we build and submit to send_frame() (which does another memcpy). */
22 struct ethaud_udp_packet eth_udp_out;
23
24 /* Consider a lock to protect this */
25 struct proc *active_proc = 0;
26
27 /* Nodes/inodes representing the device */
28 struct inode *ethaud_in, *ethaud_out;
29
30 /* Builds the device nodes in /dev */
31 void eth_audio_init(void)
32 {
33         struct page *page;
34         struct file *in_f, *out_f;
35         in_f = make_device("/dev/eth_audio_in", S_IRUSR, __S_IFBLK,
36                            &ethaud_in_f_op);
37         out_f = make_device("/dev/eth_audio_out", S_IRUSR | S_IWUSR, __S_IFBLK,
38                             &ethaud_out_f_op);
39         /* Grab and save the inodes (might change if we change make_device) */
40         ethaud_in = in_f->f_dentry->d_inode;
41         kref_get(&ethaud_in->i_kref, 1);
42         ethaud_out = out_f->f_dentry->d_inode;
43         kref_get(&ethaud_out->i_kref, 1);
44         /* Let go of the files (mostly used to get the dentry in the right place) */
45         kref_put(&in_f->f_kref);
46         kref_put(&out_f->f_kref);
47         /* make sure the inode tracks the right pm op */
48         ethaud_in->i_mapping->pm_op = &ethaud_pm_op;
49         ethaud_out->i_mapping->pm_op = &ethaud_pm_op;
50         /* zalloc pages and associate them with the devices' inodes */
51         assert(!kpage_alloc(&page));
52         memset(page2kva(page), 0, PGSIZE);
53         ethaud_in->i_fs_info = page;
54         assert(!kpage_alloc(&page));
55         memset(page2kva(page), 0, PGSIZE);
56         ethaud_out->i_fs_info = page;
57 }
58
59 /* Lots of unnecessary copies.  For now, we need to build the ethernet frame,
60  * which means we prepend the ethernet header... */
61 static void eth_audio_sendpacket(void *buf)
62 {
63         int retval;
64         /* Fill the outgoing buffer (Copy #1.  2 is in send_frame, 3 is the DMA). */
65         memcpy(&eth_udp_out.payload, buf, ETH_AUDIO_PAYLOAD_SZ);
66         /* Make sure there is still a reasonable header. */
67         static_assert(sizeof(eth_udp_out) == ETH_AUDIO_FRAME_SZ);
68         /* Should compute the UDP checksum before sending the frame out.  The
69          * Eth-audio device shouldn't care (and Linux seems to be okay with packets
70          * that have no checksum (but not a wrong checksum)).  Technically, this
71          * hurts our performance a bit (and some NICs can offload this). */
72         eth_udp_out.udp_hdr.checksum = htons(udp_checksum(&eth_udp_out.ip_hdr,
73                                                           &eth_udp_out.udp_hdr));
74         /* Send it out */
75         retval = send_frame((const char*)&eth_udp_out, ETH_AUDIO_FRAME_SZ);
76         assert(retval >= 0);
77 }
78
79 /* This is how we know who to send the packet back to, since we have no real
80  * networking stack.  Lots of assumptions about how things stay in sync. */
81 static void eth_audio_prep_response(struct ethaud_udp_packet *incoming,
82                                     struct ethaud_udp_packet *outgoing)
83 {
84         /* If you're looking for optimizations, we can do this just once */
85         memcpy(&outgoing->eth_hdr.dst_mac, &incoming->eth_hdr.src_mac, 6); 
86         memcpy(&outgoing->eth_hdr.src_mac, device_mac, 6); 
87         outgoing->eth_hdr.eth_type = htons(IP_ETH_TYPE);
88         outgoing->ip_hdr.version = IPPROTO_IPV4;
89         outgoing->ip_hdr.hdr_len = ETH_AUDIO_IP_HDR_SZ >> 2;
90         outgoing->ip_hdr.tos = 0;
91         outgoing->ip_hdr.packet_len = htons(ETH_AUDIO_PAYLOAD_SZ + UDP_HDR_SZ +
92                                             ETH_AUDIO_IP_HDR_SZ);
93         outgoing->ip_hdr.id = htons(0);
94         outgoing->ip_hdr.flags_frags = htons(0);
95         outgoing->ip_hdr.ttl = DEFAULT_TTL;
96         outgoing->ip_hdr.protocol = IPPROTO_UDP;
97         /* Need a non-broadcast IP.  Picking one higher than the sender's */
98         outgoing->ip_hdr.src_addr = htonl(ntohl(incoming->ip_hdr.src_addr) + 1);
99         outgoing->ip_hdr.dst_addr = incoming->ip_hdr.src_addr;
100         /* Since the IP header is set already, we can compute the checksum. */
101         outgoing->ip_hdr.checksum = htons(ip_checksum(&outgoing->ip_hdr));
102         outgoing->udp_hdr.src_port = htons(ETH_AUDIO_SRC_PORT);
103         outgoing->udp_hdr.dst_port = htons(ETH_AUDIO_DST_PORT);
104         outgoing->udp_hdr.length = htons(ETH_AUDIO_PAYLOAD_SZ + UDP_HDR_SZ);
105         outgoing->udp_hdr.checksum = htons(0);
106
107         /* Debugging */
108         static int once = 0;
109         if (!once++)
110                 printd("I will send %d bytes from %08p:%d to %08p:%d, iplen %04p, "
111                        "udplen %04p\n",
112                        ntohs(outgoing->udp_hdr.length),
113                        ntohl(outgoing->ip_hdr.src_addr),
114                        ntohs(outgoing->udp_hdr.src_port), 
115                        ntohl(outgoing->ip_hdr.dst_addr),
116                        ntohs(outgoing->udp_hdr.dst_port),
117                        ntohs(outgoing->ip_hdr.packet_len),
118                        ntohs(outgoing->udp_hdr.length)
119                            ); 
120 }
121
122 /* This is called by net subsys when it detects an ethernet audio packet.  Make
123  * sure the in device has the contents, and send out the old frame. */
124 void eth_audio_newpacket(void *buf)
125 {
126         struct page *in_page, *out_page;
127         /* Bail out if these two haven't been initialized yet */
128         if (!ethaud_in || !ethaud_out)
129                 return;
130         /* Put info from the packet into the outgoing packet */
131         eth_audio_prep_response((struct ethaud_udp_packet*)buf, &eth_udp_out);
132         in_page = (struct page*)ethaud_in->i_fs_info;
133         out_page = (struct page*)ethaud_out->i_fs_info;
134         /* third copy (1st being the NIC to RAM). */
135         memcpy(page2kva(in_page), buf + ETH_AUDIO_HEADER_OFF, ETH_AUDIO_PAYLOAD_SZ);
136         /* Send the current outbound packet (can consider doing this by fsync) */
137         eth_audio_sendpacket(page2kva(out_page));
138         if (active_proc)
139                 proc_notify(active_proc, NE_FREE_APPLE_PIE, 0);
140 }
141
142 /* mmap() calls this to do any FS specific mmap() work.  Since our files are
143  * defined to be only one page, we need to make sure they aren't mmapping too
144  * much, and that it isn't a PRIVATE mapping.
145  *
146  * Then we need to make sure the one page of the VMR is mapped in the page table
147  * (circumventing handle_page_fault and the page cache).  Avoiding the page
148  * cache means we won't need to worry about accidentally unmapping this under
149  * pressure and having to remap it (which will cause a readpage). */
150 int eth_audio_mmap(struct file *file, struct vm_region *vmr)
151 {
152         struct page *page = (struct page*)file->f_dentry->d_inode->i_fs_info;
153         /* Only allow mmaping from the start of the file */
154         if (vmr->vm_foff)
155                 return -1;
156         /* Only allow mmaping of a page */
157         if (vmr->vm_end - vmr->vm_base != PGSIZE)
158                 return -1;
159         /* No private mappings (would be ignored anyway) */
160         if (vmr->vm_flags & MAP_PRIVATE)
161                 return -1;
162         /* Only one proc can use it at a time (we need to know who to notify, since
163          * we don't have any sockets or other abstractions to work with).  Note we
164          * are storing a reference. */
165         if (active_proc && active_proc != vmr->vm_proc)
166                 return -1;
167         if (!active_proc) {
168                 kref_get(&vmr->vm_proc->kref, 1);
169                 active_proc = vmr->vm_proc;
170         }
171         assert(page);
172         /* Get the PTE for the page this VMR represents */
173         pte_t *pte = pgdir_walk(vmr->vm_proc->env_pgdir, (void*)vmr->vm_base, 1);
174         if (!pte)
175                 return -ENOMEM;
176         /* If there was a page there, it should have be munmapp()d. */
177         assert(!PAGE_PRESENT(*pte));
178         /* update the page table */
179         int pte_prot = (vmr->vm_prot & PROT_WRITE) ? PTE_USER_RW :
180                        (vmr->vm_prot & (PROT_READ|PROT_EXEC)) ? PTE_USER_RO : 0;
181         /* Storing a reference to the page in the PTE */
182         page_incref(page);
183         *pte = PTE(page2ppn(page), PTE_P | pte_prot);
184         return 0;
185 }
186
187 /* This shouldn't be called.  It could be if we ever handled a PF on the device,
188  * and the device wasn't present in the page table.  This should not happen,
189  * since ea_mmap() should have sorted that out.  Even if there was an unmap()
190  * then a new mmap(), it still shouldn't happen. */
191 int eth_audio_readpage(struct page_map *pm, struct page *page)
192 {
193         warn("Eth audio readpage!  (Did you page fault?)");
194         return -1;
195 }
196
197 /* Called when the file is about to be closed (file obj freed).  This is the
198  * least intrusive way to find out when the device is unmapped and closed, so we
199  * can let go of the proc.  TODO: Note that currently, the kernel will not be
200  * able to unmap the file by itself, due to the circular dependence of the kref,
201  * proc_free, and destroy_vmr.  Programs have to unmap it themselves.  Since
202  * this device is a bit of a hack anyway, I'm okay with not making big changes
203  * to the kernel to support this yet. */
204 int eth_audio_release(struct inode *inode, struct file *file)
205 {
206         /* Disconnect the proc from the device, decref. */
207         if (active_proc && current) {
208                 assert(active_proc == current);
209                 kref_put(&active_proc->kref);
210                 active_proc = 0;
211         }
212         return 0;
213 }
214
215 /* File operations */
216 struct file_operations ethaud_in_f_op = {
217         dev_c_llseek,   /* Errors out, can't llseek */
218         0,                              /* Can't read, only mmap */
219         0,                              /* Can't write, only mmap */
220         kfs_readdir,    /* this will fail gracefully */
221         eth_audio_mmap,
222         kfs_open,
223         kfs_flush,
224         eth_audio_release,
225         0,                              /* fsync - makes no sense */
226         kfs_poll,
227         0,      /* readv */
228         0,      /* writev */
229         kfs_sendpage,
230         kfs_check_flags,
231 };
232
233 struct file_operations ethaud_out_f_op = {
234         dev_c_llseek,   /* Errors out, can't llseek */
235         0,                              /* Can't read, only mmap */
236         0,                              /* Can't write, only mmap */
237         kfs_readdir,    /* this will fail gracefully */
238         eth_audio_mmap,
239         kfs_open,
240         kfs_flush,
241         eth_audio_release,
242         0,                              /* fsync - TODO: make this send the packet */
243         kfs_poll,
244         0,      /* readv */
245         0,      /* writev */
246         kfs_sendpage,
247         kfs_check_flags,
248 };
249
250 /* Eth audio page map ops: */
251 struct page_map_operations ethaud_pm_op = {
252         eth_audio_readpage,
253 };
254