✎ soc:nikhil:proposal - Etherboot/gPXE Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Summer of Code - Implementing support for IPv6 ======

**Project Title:** Implementing support for IPv6\\
**Summary:** Redesign the TCP/IP stack implementation in gPXE to provide support for IPv6\\
**Mentoring Organization:** Etherboot\\

===== Synopsis =====

gPXE uses uIP to implement its TCP/IP stack. uIP is an implementation of the TCP/IP stack which uses a fraction of the resources used by a full fledged TCP/IP implementation.

The project is to implement support for IPv6. uIP (in its current avatar) tightly integrates the TCP and IP layers in order to save code size. As a result, it is not easy to replace IPv4 with any other network layer protocol in uIP. This project aims to re-design the TCP/IP stack of gPXE in order to facilitate IPv6 implementation.

===== Project Description =====

==== Current Problem ====


uIP strays away from the conventional API of the TCP/IP stack so that it can cut down on resources. Instead, it implements its own API where the application is implemented as a function call uip_tcp_appcall(). Every time an event occurs (new data received, re-transmit request, etc.) uIP calls the application and testers resolve which event fired the call. At the other end of the stack, the network driver calls uip_input() (when new data arrives) and uip_periodic() (at regular intervals of time) which trigger off the TCP/IP state machine (uip_process()) in uIP.

In the current architecture, refer http://www.cse.iitb.ac.in/nikhilr/etherboot/tcpip-arch.jpg , a wrapper insulates applications above and network devices below from the uIP API. It provides applications above the TCP/IP stack with an API defined by /include/gpxe/tcp.h. It gives the network devices below an API defined by /include/gpxe/netdevice.h to use the network layer protocol.

The current architecture has problems and limitations (taken from the discussion lists):
  * uIP was designed for embedded systems and 8-bit micro-controllers. As a result, data representation and arithmetic operations do not utilize the resources offered by the 32-bit architectures.
  * The lack of modularity in uIP makes it difficult to implement a new protocol like IPv6 instead of IPv4.
  * The current method of invocation imposes restrictions (unnecessarily) on the TCP-based protocol handlers.

A solution to overcome these limitations would be to re-design the TCP/IP stack implementation (essentially replacing the uIP module) keeping to the specifications defined in the gPXE API (refer http://www.cse.iitb.ac.in/nikhilr/etherboot/proposed-arch.jpg). It is necessary to define a clean interface between the transport layer and network layer in order to implement a new protocol like IPv6. The event based model can be replaced but this requires further investigation.

==== Plan of Action ====


I propose applying the following algorithm to solve the problem (start off with IPv4 and TCP - we will look at other protocols once the interface is more clearly defined):

=== Main goals ===

Step 0: Investigate the working of uIP\\
Step 1: Define bare necessary requirements of transport layer and network layer\\
Step 2: Define the interface between these layers based on the requirements\\
Step 3: Implement the TCP, IP modules using the interface\\
Step 4: Test implementation; Re-implement if necessary\\
Step 5: Increase requirements if necessary and go back to step 2\\
Step 6: Investigate minimum requirements to support IPv6\\
Step 7: Extend interface/requirements if necessary and go back to step 2\\
Step 8: Implement IPv6\\
Step 9: If time permits, implement stretch goals\\

=== Stretch goals ===

Step 10: Investigate UDP implementation in Etherboot-5.4 and earlier\\
Step 11: Extend interface/requirements if necessary and perform steps 2 - 5\\
Step 12: Implement UDP support\\
Step 13: Investigate various features that can be added to IPv6\\
Step 14: Perform steps 7 - 8\\

===== Deliverables =====


The final deliverables for the project are:
  - A clean, well-defined interface between the transport-layer and network-layer. The interface would be generic enough to allow any transport layer protocol to interact with any network layer protocol
  - Re-design and implementation of the TCP/IP stack using the proposed interface (which fits within the gPXE API)
  - Minimal support for IPv6

The stretch goals for the project are:
  - Extension of the gPXE API to include UDP
  - An implementation of UDP/IP (within the extended gPXE API)
  - Support for additional features in IPv6

===== Timeline =====


I have created a timeline for this project using Google Calendar which is available on the following links:

[[http://www.google.com/calendar/feeds/p9tuujnjpv02p7ehvqdb88m0uo@group.calendar.google.com/public/basic|XML]]\\
[[http://www.google.com/calendar/ical/p9tuujnjpv02p7ehvqdb88m0uo@group.calendar.google.com/public/basic|ICAL]]

Please contact me at nikhilcrao@gmail.com if other formats (or plain text) are more preferable.

===== Bio =====


I am a 21 year old Computer Science and Engineering graduate [just graduated last week! :) ] from the Indian Institute of Technology, Bombay (IIT Bombay). I am headed to the University of Michigan, Ann Arbor for my graduate studies in the EECS department. My area of interest is computer architecture and distributed systems. Last summer, I was an Extreme Blue Intern ( www.ibm.com/extremeblue) with the Deep Computing group at IBM, Bangalore. The summer before that, I worked with the Center for Formal Verification and Design of Software (CFDVS) at IIT Bombay. This summer, I want to work with Etherboot and the Summer of Code project sponsored by Google!

I have been involved in C/C++ development since high school (for the last 6 years). I have also programmed micro-controllers and micro-processors using assembly and have taught this to my juniors as well. I have been involved in many projects in the past - ranging from small/medium sized course projects to large scale projects like 'A novel de-synchronization technique' and 'BlueStreak middleware for HPC application development' which I implemented in my senior year thesis and in my internship respectively. While I have never been involved in an open source project (yet!), I am enthusiastic about this project and I am confident I can deliver results to your satisfaction.

My exposure to Etherboot and the concept of network booting is recent. In the last week, I have studied the Etherboot manual twice and have gone through the source code once to understand the twisted process of network booting. I am dedicated, passionate and hardworking, and I feel I am well suited to take on and complete this project.

I believe in quality over quantity and I will be sending applications only to Etherboot for this summer of code.

My resume is available at the following link:

[[http://www.cse.iitb.ac.in/nikhilr/soc/nikhil-resume.pdf|PDF]]

Please let me know if other formats are preferable. My preferred method of contact is by e-mail. The e-mail IDs I check most regularly are nikhilcrao@gmail.com and nikhilr@cse.iitb.ac.in.
Trace: • week8 • project_plan • mdeck • uhci_port_reset_issue • probsbkoromomatic • week3 • proxydhcp • week11 • week7 • journal
Navigation

Search

Toolbox

QR Code
