Driven-Monkey

Last Friday I handed in what was hopefully the last piece of assessment that I will ever have to do for university. It’s not to say that I wouldnt like to go back next year and look at doing a Masters or a PhD, but I feel after 5 years at university it’s about time to move on and start my career. Tomorrow I will be moving back to my home town, where I will be staying with my parents while searching for that elusive first computer science job. I have already had a few places that have been interested, but none of them have worked out for some reason or another, the main one being that I was unable to start until this week, so hopefully now it shouldnt take too long to find one.

So what does this mean for my MPLS project with FreeBSD? Basically I will not have internet for a while, at least until I can get a connection setup at my parents house, but once this is done I will continue to work on MPLS. At this stage I am going to start looking at how to implement the routing table. I was thinking of using a hash map of some form, due to the fact that the MPLS labels means that this will probably be the most efficient way of storing them. Given that I will have a lot of free time on my hands now I will hopefully be able to dedicate a lot more time to this than I have this past year.

So I figured that even though the Summer of Code has finished I am still going to keep posting here. Mostly I will be posting about the progress of MPLS in FreeBSD, but I will also write a few other posts about other interesting, and not so interesting depending on your point of view, things that I am up to.

As I am writing this I currently have just under 4 weeks till I have finished university, hopefully for good. I have been going through the process of trying to find a job that I can step into once I complete my degree but unfortunately the graduate IT jobs in New Zealand are few and far between, so much so that I have started applying for jobs overseas.

The biggest problem with this time of year is the amount of work that is due in a matter of a few weeks. I have been working a lot on getting my assignments done. The majority of them are reasonably standard and uninteresting, like the work I have been doing in XNA using Vertex and Pixel Shaders, but some of it is a lot more interesting. The biggest project I have at the moment, besides my Implementation of MPLS in FreeBSD which is due in 5 weeks, is a Distributed File System using FUSE. This file system, if successful, may be looked at for using on the University of Waikato’s cluster computer.

Hopefully within the next week I will have some serious time to go over MPLS. I am up to the stage now of testing the code for receiving and sending of packets, and hopefully that works pretty quickly so I can start on routing table implementation and then maybe even move onto LDP, but I very much doubt I will have the time before the dissertation on the project is due (approximately October 24th).

Summer of Code has now officially finished. Well, at least the coding part of it has. This is my final GSoC report, but hopefully will not be my last post here. As it stands at the moment, I have not managed to get sending and receiving working, but I am very close to it. I honestly am unsure as to why it is not working,  but I believe it may be to do with how I have tied my code into the kernel, and I dont think it is getting initialized or compiled with the right preprocessor defines or something. However, I will still be working on getting this going, as not only is it my dissertation for university this year to do this, but it has become somewhat of a personal challenge to prove to myself that I can do it.

With that in mind I will keep on working on this at every oppurtunity I get, and will definately have at least sending/receiving working by October, which is when the dissertation is due. So here is a run down of what I have accomplished so far for the GSoC, and what I plan to implement in the future.

Accomplished:

MPLS-needle – this is a small tool I built for testing of MPLS. It takes a configuration file and uses that to define and build an MPLS packet, which is then inserted onto the networking stack using a BPF device.

Basic port of OpenBSD/Ayame code – I have been working solidly for the last few months on porting the OpenBSD code, which is based on Ayame, to FreeBSD. This was a much bigger task than I orginally intended. As I have had no previous experience with kernel coding this has involved a huge learning curve, not only in just kernel coding itself, but in how the FreeBSD networking code works, and how it differs to OpenBSD (by the way, it is a lot more than I thought it would be). The code has been ported over and changed accordingly, but still does not work. However, the kernel does compile and run, it just appears that the MPLS code does not run when a packet is received. I think this is because of incorrect #defines, as I’m not entirely sure where I need to define these (in the Makefile or somewhere in my code). I will continue to work on this and attempt to get it working asap.

Future Plans:

Once basic sending/receiving is acheived, I will be attempting to implement the following features. I believe this will be a lot easier as I will be working mostly on my own code, independant of the kernel code itself, but I have been known to be wrong before.

Routing Table Manipulation – create a way to store, insert, edit and delete MPLS routes in a table.

Static Label Switching – being able to receive a packet, swap the label, and send it out using a statically defined route in the routing table.

LDP Implementation – implement the LDP daemon for autmatic label distribution and routing table building.

Tunnels – implement MPLS L2 and L3 tunnels with first virtual interfaces, and then real interfaces.

At least thats the plan for now, and I’m really hoping that it becomes a reality.

I would like to take this chance to thank everyone that has helped me through this transition into kernel hacking and opensource hacking. It has been a lot of fun, with a lot of frustration, but very much worth it. If anyone would like to take a look at my work and provide some feedback, whether it be stuff I need to change, or help on completing my goals, it would be welcomed and very much appreciated. The code can be viewed here on Perforce.

Thank you

-Ryan French.

I managed to get a few things done this week which and spend a few hours going over FreeBSD networking code and making changes to my own code. I am very close to being able to get the basics of MPLS going, and once that is done the more advanced features will actually be a bit easier as I have the Ayame project to reference those off, whereas at the moment I have no real reference material on how to integrate my MPLS code with the FreeBSD networking code. As I said last week, if anyone has any advice or experience on how to get netisr calling my MPLS code, I think I almost have it, but it would be hugely appreciated as it will save me precious time that I dont really have. I realised this weekend that there is only a month till the end of the Summer of Code, at which point I really need to have at least simple sending/receiving and basic label switching going. Luckily, I am also doing this project as a dissertation for my Post Graduate Diploma in Computer Science this year, so I will be working on it for at elast another month after the summer of code stuff has finished, and I plan on getting a fully working implementation of MPLS going for FreeBSD eventually by completing it once I leave university.

Accomplished Last Week:

- Went through the FreeBSD networking code, trying to figure out where abouts the actual call to the protocol initialising functions are made. It’s not as easy as you would think for someone with almost no previous Operating System code experience to look at this stuff and try and figure it all out, but I’m getting there.

- Made some changes to my own code to use the FreeBSD specific networking routines, rather than the OpenBSD ones, particularly involving if_ethersubr.c and the netisr files.

Plans for Next Week:

- Finally finish figuring out where I am to call the mplsinitr function and getting the protocol registered with netisr. I’ve said this many times before, and  it keeps elluding me, but basically once this is done then the protocol will have a basic functionality and I can actually be semi-happy with the work I have accomplished.

- Figure out what feature is more important to concentrate on next. With so little time remaining in the GSoC I am wanting to make sure I have gotten as many features of the protocol implemented as I can, but I want to make sure I have all the key features that I need implemented as well.