raichoo :: λpunk

Building GHC under Illumos

2012-01-04T08:20:00.000-08:00

I like the bleeding edge, that's why I always want to have the newest compilers for my favorite languages and Haskell is one of those languages. In this blogpost I'm going to show you how to build the latest and greatest GHC on the Illumos distribution OpenIndiana. If you don't want to build it yourself you can pick up a fairly recent version of GHC from the SFE Repository.

To make things easier let's get our hand on a GHC binary from which we can bootstrap our environment, luckily there is a package for GHC 7.0.3 for Solaris which works just fine under Illumos. Just install it and put it in your PATH environment variable.

Due to it's Solaris heritage, Illumos currently ships with a pretty outdated version of GCC. I recommend that you install the GCC provided by the SFE Repository since the shipped version causes some linking problems when dealing with the hidden attribute. If you have to use the old compiler you can get rid of this issue by using this quick and dirty patch which just gets rid of some pragmas and macros:


diff --git a/includes/Rts.h b/includes/Rts.h
index 91ec76d..adbbe54 100644
--- a/includes/Rts.h
+++ b/includes/Rts.h
@@ -52,7 +52,7 @@ extern "C" {
 // with visibility "hidden" to hide them outside the RTS shared
 // library.
 #if defined(HAS_VISIBILITY_HIDDEN)
-#define RTS_PRIVATE  GNUC3_ATTRIBUTE(visibility("hidden"))
+#define RTS_PRIVATE  //GNUC3_ATTRIBUTE(visibility("hidden"))
 #else
 #define RTS_PRIVATE  /* disabled: RTS_PRIVATE */
 #endif
diff --git a/rts/BeginPrivate.h b/rts/BeginPrivate.h
index 6471b92..1af4c90 100644
--- a/rts/BeginPrivate.h
+++ b/rts/BeginPrivate.h
@@ -6,5 +6,5 @@
        error: visibility attribute not supported in this configuration; ignored
    */
 #if defined(HAS_VISIBILITY_HIDDEN) && !defined(freebsd_HOST_OS)
-#pragma GCC visibility push(hidden)
+//#pragma GCC visibility push(hidden)
 #endif
diff --git a/rts/EndPrivate.h b/rts/EndPrivate.h
index 4cfb68f..c2e3154 100644
--- a/rts/EndPrivate.h
+++ b/rts/EndPrivate.h
@@ -1,3 +1,3 @@
 #if defined(HAS_VISIBILITY_HIDDEN) && !defined(freebsd_HOST_OS)
-#pragma GCC visibility pop
+//#pragma GCC visibility pop
 #endif

Now we are good to go. Get your hands on some fresh tarball, perhaps the latest and greatest RC. To configure your future GHC just run something like:


./configure --prefix=~/Library/GHC/version --with-gmp-includes=/usr/include/gmp

I usually install self compiled software in ~/Library/program/version. From here I can manage everything using softlinks but feel free to use any other prefix.

Be sure to run the GNU Make (gmake) command and not the Illumos one. Sadly gmake seems to be unable to handle multiple jobs when compiling GHC so our final step looks like this:


gmake && gmake install

From here on you should be able to build pretty much every version you wish for. If you pick a version that is supported by cabal-install installing additional packages from hackage is a piece of cake. I usually have more than one GHC installed, the one that is shipped with the current Haskell Platform and the latest version with all the hot new features.

Illumos has the potential to be one of the best platforms for developing Haskell since it has exquisite DTrace support. If you want to help to improve the Haskell experience on Illumos, feel free to contact me in #openindiana on freenode.

More Fun with Scala "Dependent" Types

2011-08-24T11:21:00.000-07:00

In my last post I wrote about lists that encode their length within their type and the possibilities that gives us to ensure correctness of our code. In this post I want to expand these ideas.

Let's assume that we have a list with an even number of elements. By knowing that the length is even we could do various things like extracting pairs. Odd length is not very suitable for this… no shit Sherlock!

To make this happen we first need boolean values in the type system to represent that a proposition is actually true and we need to be able to negate them.

sealed trait Bool {

  type Not <: Bool

}

sealed trait True extends Bool {

  type Not = False

}

sealed trait False extends Bool {               

  type Not = True

}

In the next step we have to extend our type-level natural numbers. Let's give them a predecessor and a property that indicates if a number is even.



sealed trait Nat {

  type IsEven <: Bool

  type Pred <: Nat

}

sealed trait Z extends Nat {

  type IsEven = True

  type Pred = Z

}

sealed trait S[A <: Nat] extends Nat {          

  type IsEven = A#IsEven#Not

  type Pred = A

}

To make it a little nicer to read and write we will add a witness that represents that a natural number is even we check this with the =:= type constraint which witnesses that two types are equal.



sealed trait Even[A <: Nat]

object Even {

  implicit def isEven[A <: Nat](implicit e: A#IsEven =:= True): Even[A] =

    new Even[A]{}                                                                                                                           

}

Now the fun part. We now start building our list with a getPairs method that only works on lists with an even length. Here is our interface for this NList:



sealed trait NList[A <: Nat, +B] {                                                                             

  type Length = A

  def getPairs(implicit e: Even[Length]): List[(B, B)]

  def head: B

  def tail: NList[Length#Pred, B]

}

The first case again is trivial, we are dealing with an empty list, the only thing that we can extract is an empty list.



case object NNil extends NList[Z, Nothing] {                                      

  def getPairs(implicit e: Even[Length]): List[(Nothing, Nothing)] =

    Nil

  def head = sys.error("empty list")

  def tail = sys.error("empty list")

}

Now this one is a little more tricky, we might know that a natural number A is even but what the typesystem does not know if A#Pred#Pred is also even when we call getPairs recursively. We now need to to create a witness that A#Pred#Pred is even when A is even. We can do this with another method that generates a witness when you hand it the witness for A's evenness, let's call that method predPredEven.



sealed case class NCons[A <: Nat, B](h: B, t: NList[A, B])

extends NList[S[A], B] {

  private def predPredEven[A](e: Even[Length]): Even[Length#Pred#Pred] =                                       

    new Even[Length#Pred#Pred]{}

  def getPairs(implicit e: Even[Length]): List[(B, B)] =

      (head, tail.head) :: tail.tail.getPairs(predPredEven(e))

  def head: B = h

  def tail: NList[Length#Pred, B] = t

}

That's all. How does this look when we put it into action?



scala> val lo = NCons(1, NNil)

lo: nlist.NCons[nlist.Z,Int] = NCons(1,NNil)

scala> le.getPairs

res0: List[(Int, Int)] = List((1,2))

scala> NNil.getPairs

res1: List[(Nothing, Nothing)] = List()

scala> lo.getPairs

:12: error: could not find implicit value for parameter e: nlist.Even[lo.Length]

            lo.getPairs

               ^

Very nice! getPairs only works on lists with an even length, otherwise we get a compile error. Once again: If you want to play with this code check out this gist.

In future blogposts I'd like to show you how a language that bears these techniques in mind handles these problems.

A Taste of Dependent Types in Scala

2011-08-22T11:43:00.001-07:00

One thing starts to cross my way very frequently is dependent typing. While I'm not an expert on this topic I found some very interesting things in various papers that I would like to be able to do in Scala. Dependent types help to verify that your program does what it's supposed to do by proving theorems.
Since Scala is not dependently typed we need to become a little tricky, but let's give it a try.

Think about the type signature of the following method called zap (which stands for zip-apply):



def zap[A, B](l: List[A], fs: List[A => B]): List[B]

By looking at the signature it should become obvious what the method does. You have a list l that provides elements of type A and a list fs that provides a function from A to B for each element in l. Lets look at the implementation:



def zap[A, B](l: List[A], fs: List[A => B]): List[B] =

 (l, fs) match {

   case (_, Nil) | (Nil, _) => Nil

   case (a :: as, b :: bs)  => b(a) :: zap(as, bs)

 }

That's a pretty straight forward example, but there is a problem with this code. What if we do provide lists with different length? In one case we would not execute some functions in the other case we would lose data. So what can we do? We could throw an exception but that's already to late, our program is already in a state where things don't make sense anymore, we have to avoid this situation at all and the best thing to achieve this is that such code does not compile at all.

In a dependently typed language we could create a list that encodes it's length within the type of the list itself and write zap in a way so that it would only accept lists of the same length. But since we are not in a dependently typed language we cannot do that, this concludes this blogpost, see you in another episode… ok, just kidding. We actually CAN do that in Scala. Here is how:

The first thing we need is: natural numbers in the type system to encode the length of our list. That is easy:



sealed trait Nat

sealed trait Z extends Nat

sealed trait S[A <: Nat] extends Nat

Z is our zero here and S[A <: Nat] is the successor of the natural number A, so we can create the natural numbers recursively: Z == 0, S[Z] == 1, S[S[Z]] == 2 etc.

Now let's start with the fun part, the list itself.

The first thing we need is the trait for our NList.



trait NList[A <: Nat, +B] {

  type Length = A

  def zap[C](l: NList[Length, B => C]): NList[Length, C]

}

We can now see that the type of zap enforces that the both lists need to have the same length A. We can now create our first case where we are zapping two lists of length 0 (or Z). The implementation is rather trivial.



case object NNil extends NList[Z, Nothing] {

 def zap[A](l: NList[Length, Nothing => A]): NNil.type =

   NNil

}

The next case is not as simple (if someone has a better idea of how to implement this, I would love to see it. Please drop a comment).



case class NCons[A <: Nat, B](head: B, tail: NList[A, B])

extends NList[S[A], B] {

  def zap[C](l: NList[Length, B => C]): NList[Length, C] = 

    l match {

      case NCons(f, fs) =>  

        NCons(f(head), tail zap fs) 

    }   

}

We can see that our NCons is actually a NList that is one element longer
than it's tail which has length A, the pattern match inside our zap method only has to handle the cons case since the type signature does not allow anything else.

Now let's put that little bugger to the test:

First lets define some NLists



scala> val l1 = NCons(1, NCons(2, NCons(3, NNil)))

scala> val l2 = NCons(1, NCons(2, NNil))

scala> val f = (_: Int) + 1

scala> val f1 = NCons(f, NCons(f, NCons(f, NNil)))

scala> val f2 = NCons(f, NCons(f, NNil))

Zapping lists with the same length:



scala> l1 zap f1

res1: nlist.NList[l1.Length,Int] = NCons(2,NCons(3,NCons(4,NNil)))



scala> l2 zap f2

res2: nlist.NList[l2.Length,Int] = NCons(2,NCons(3,NNil))

This works just fine, now lets see what happens if we zap two lists with a different length:



scala> l1 zap f2

:14: error: type mismatch;

 found   : nlist.NCons[nlist.S[nlist.Z],Int => Int]

 required: nlist.NList[l1.Length,Int => ?]

              l1 zap f2

Exactly what we wanted! This code does not even compile since it doesn't make any sense.
This is a very basic example of what we can do with the Scala type system. Stay tuned for more!

If you would like to play around with the code check out my gist

From Functions to Monads in Scala

2011-07-10T04:08:00.000-07:00

"Monad" that's a word you hear quite often these days. There is a lot of unjustified FUD whenever this word pops up. People seem to be downright scared about it. You can tell by the amount of rhetorical trick words people use to scare others away from trying to understand monads at all. "Academic", "no use in real world programming" etc etc. I find it quite frustrating to hear something like that even within the Scala community from time to time (even though this is getting rarer and rarer), since these are the "arguments" people bring up when they try to scare others away from Scala.

First of all, I'm not a category theorist. These things just fascinate me, and I enjoy reading about this in my free time. I'm your ordinary "Joe, the programmer" working at a small software company.

Still, I find these things useful in my day job. Why? Because as a programmer I'm building mathematical machines (namely software) all day long and these concepts help me to order my thoughts and make at easier to reason about my software and design stuff.

In this blogpost I want to show how to derive Monads from what you already know and give names to things you maybe never even thought about.

Categories

Since monads come from Category Theory we first have to define what a category is.

A category C basically consists of 2 sets ob(C) and hom(C) where we call ob(C) the objects of C and hom(C) the morphisms of C. Morphisms are maps that go between objects.

Never saw a Category in your every day programming? Sure? There is a Category called Hask, its objects are the Haskell types and its morphisms are Haskell functions. So you can think about that in a Scala context:

Let f be a function of type Int => String. Int and String are both elements of ob(C) and f is an element of hom(C).

There's more to a Category, we need to be able to compose morphisms and there has to be a special element called identity. Lets looks at composition first.

Let f and g be functions:



f: A => B

g: B => C

We can compose those 2 functions in Scala by using the compose method to get a new function.



g compose f // yields a function of type A => C

OK, that's half the rent. Now we just need the special element called identity which basically is a function that does nothing. It just takes a value and returns it unmodified. So when we compose a function f with identity we get back a function that is equivalent to f and it should not matter if we compose f with identity or identity with f.

In short: The following 3 functions are equivalent (which means: when fed with the same input values they will yield the exact same result)



f // A => B

f compose id // A => B

id compose f // A => B

Now we know that a Category is (well, at least we know enough to start, a real category theorist can take you on a breathtaking journey from here :)). Let's move on!

Enter Higher-Kinded-Types

Next "scary word", but again: You use them all the time. First we need to know what a kind is. We know what types and values are. You can think of them as levels. A value like 1 and x => x (that's a function value, yes those are values too!) live a the value level while types like Int and Int => Int live at the type level. We group values into types. true and false are both values of type Boolean (think of types as sets of values).

OK, if we group values into types, can we group types? Yes, we can! We can group types into… *drumroll* KINDS! Now we have a third level and our world looks something like this:



  kinds  

---------

  types

---------

  values

In most languages we only deal with one kind called * (pronounced type) that groups all types, but there are languages that allow infinite levels (I might cover one of them in future blog posts).

We now have a basic idea of what kinds are, so what are higher kinded types? Like High-Order-Functions (functions that take functions as arguments and yield functions e.g. compose)
higher kinded types are type constructors that take types as arguments and yield types.

"Wait a minute… are you talking about generics?"

Yes, sort of. Think about List. It's not a type by itself, you need to feed it a type as an argument to get a type. This is called a Type Constructor.List takes one type and returns a type, hence List has the kind * -> * (this notation is borrowed from Haskell). The Scala notation for a higher kinded type like List is List[_].

Functors

Now that we have higher kinded types, let's take a look at our functions f and g from the beginning and lets add a higher kinded type F[_] to the mix (this is Scala notation and means: takes one type and yields a type). We can now produce a whole new set of types with this higher kind (e.g. F[Int], F[String] etc.). We could now create functions that work with these types… hey I know this. This sounds like… a Category! Yes, it is! It's actually a Subcategory of our Hask Category we introduced at the beginning. Let's call this new Category D (so we don't confuse it with the higher kinded type F). So elements of ob(D) would be something like F[A] and for hom(D) it would be something like F[A] => F[B].

Now wouldn't it be cool if there was a morphism between those two categories, one that preservers composition and the identity rule? Something that could map a function of type A => B to a function of type F[A] => F[B]? That's what's we call a Functor, it's a morphism between categories.

"Why is this useful?" you might ask. Just think about the kind of code reuse you could achieve. Let's look at Option as a concrete example. It's a higher kinded type. So how do we map a function of type Int => Int to a function of type Option[Int] => Option[Int]? Can't you tell by now? The answer is the map method of Option ;).

Let's check it out:



scala> val f = (_: Int) + 1

f: (Int) => Int = <function1>



scala> Some(1) map f

res0: Option[Int] = Some(2)

We could now reuse our function f with Option, there was no need to write a special version of f that works with Option.

The second ingredient we need to make our Functor complete is a morphism that maps a value of type A to a value of type F[A]. In the case of Option this is just the factory function:



scala> Some(_: Int)

res0: (Int) => Some[Int] = 



scala> Option(_: Int)

res1: (Int) => Option[Int] = 



scala> Option(1)

res2: Option[Int] = Some(1)



scala> Some(1)

res3: Some[Int] = Some(1)

Endofunctors

Now, let's assume that we want something like this:



scala> Some(1) map {

     | case x if x % 2 == 0 => Some("YES!")

     | case _               => None

     | }

res1: Option[Option[java.lang.String]] = Some(None)

We want to use a function of type Int => Option[String] with Option's map method. But what's that? We get an Option[Option[String]]. That's stupid, now I have to unpack one Option to get the result I actually wanted.

What happened here? Remember how we mapped a function of type A => B to a function of type F[A] => F[B] in the previous section about functors? What we did now is: we mapped a function of type Int => Option[String] to a function of Option[Int] => Option[Option[String]]. Yikes, we went a little bit over the top here, huh? We kind of like mapped something into an Option and into an Option this is how we ended up with an Option[Option[String]]. You can think of this as a result of a composition of 2 Option Functors.

This is a special kind of Functor that maps a category into itself and is called an Endofunctor

Natural Transformations

Now that we have morphisms between objects of a Category which are Scala functions and Functors which are basically morphisms between categories it's time to introduce morphisms between Functors.

Why do we need this? Well in the last example we ended up with an Endofunctor (we mapped a Category into itself). We need to get rid of one of the Options. We do this with a morphism that maps the composition of 2 Functors F (F composed with F) to the Functor F.

Lets do a concrete example that involves List



scala> List(1,2,3) map { x => List(x + 1) }

res0: List[List[Int]] = List(List(2), List(3), List(4))

It happened again, but this time we ended up with a List[List[Int]]! We now need a Natural Transformation to join those lists together, this Natural Transformation is called flatten in Scala.



scala> List(1,2,3) map { x => List(x + 1) } flatten

res1: List[Int] = List(2, 3, 4)

List comes with a method that does both in one step, it's called flatMap.



scala> List(1,2,3) flatMap { x => List(x + 1) }

res2: List[Int] = List(2, 3, 4)

This enables us to chain functions together in a very convenient way.



scala> Some(1) flatMap { x => Some(2) flatMap { y => Some(x + y) } }

res3: Option[Int] = Some(3)

or a little more concise



scala> Some(1) flatMap { x => Some(2) map { y => x + y } }

res4: Option[Int] = Some(3)

Monads

This is actually what makes up a Monad. It's an Endofunctor with two Natural Transformations called unit and join (which is called flatten in Scala). They are such a fundamental concept that Scala features a syntactic sugar for them, the for-comprehension. Do NOT confuse this with a mere for-loop, this is a different animal. The last example above can be written in the following way:



scala> for {

     | x <- Some(1)

     | y <- Some(2)

     | } yield x + y

res5: Option[Int] = Some(3)



//translates to



scala> Some(1) flatMap { x => Some(2) map { y => x + y } }

res6: Option[Int] = Some(3)

Conclusion

This is an introduction on how to think about monads and how to derive them from simple building blocks. They are a very powerful abstraction that pops up all the time. You use them all the time without knowing. Since programming is all about abstraction it's useful to recognize those underlying patterns. Don't let others fool you into believing that this is just some bizarre functional stuff that has no use in the real world. This is just the tip of the iceberg, an amazing journey lies ahead. Let's learn!

DTrace and it's impact on JVM performance

2011-07-09T05:45:00.000-07:00

So, I did this blogpost that gave a very shallow introduction to what DTrace can do with the JVM and I got an amazing feedback after that. Actually I'm quite flattered that it had such an impact.

One message I received pointed out that DTrace probes are having a significant impact on the JVM's performance, he (the author) would never recommend using the DTrace JVM integration, and then he pointed me… well, a product by his own company (which shall remain nameless, since I don't want to advertise commercial products on this blog). To be fair: I admit that I would do the same. When you put a lot of effort into a piece of software you do it for reasons you believe in.

However, he gave me a link to some benchmarks that showed some impressive results and diagrams about how much the performance of the JVM suffers when DTrace probes are enabled. The bar diagrams were scary, DTrace looked pretty bad compared to the "rival" technology (you can't really call it a rival since DTrace has a completely different objective). But something was fishy about this, and that was: the axes of the diagrams were not labeled. They did show a small blue bar and a big green bar and nothing else. The code for the test case was provided as a gif (no copy and paste to reproduce the results nice and easy). Numbers were not put into any perspective. And blog comments were disabled.

None the less, this was interesting enough to start a little bit of research on the topic.

The benchmarks seemed to focus on how much enabled probes did slow down method calls. I personally don't like benchmarks that use extremely unrealistic cases as a foundation (look how fast I can increment them integers in a tight loop suckaz! Mah language iz teh fast!) but this time I will just go with the flow because this is pretty much what they did in that benchmark (don't try this at home kids, use realistic conditions to benchmark your stuff). I'm not using the same test code here but the idea seems to be pretty much the same.

The system I'm running this on is a Thinkpad X201 with a core i7 and 8 gigs of RAM (yeah I know, I'm just compensating, get over it ;)). The operating system is OpenIndiana Build 151-beta with DTrace 1.7. Java is at 1.6.0_25.

The stupid test case I will be using is this Java program:


class Test {

  public int callTest(int i) {
    if (i != 0)
      callTest(i - 1);

    return i;
  }

  public static void main(String[] args) {
    Test t = new Test();

    long starttime = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++)
      callTest(100)
    long endtime = System.currentTimeMillis();

    System.out.println(endtime - starttime);
  }
}

Once again, this is not a realistic example. I will just use it to demonstrate that there really is an impact.


> java Test
118
> java -XX:+ExtendedDTraceProbes Test
4106

Wow, this really seems to hurt… the programm is about 35 times slower with DTrace probes enabled.

To put this into perspective I will commit a capital crime in programming. I will compare this stupid program in language A to the same stupid program written in language B. Let language B be Python in this case. To be crystal clear about this: this is NOT a comparison of Python and Java performance. I just need some landmarks to make all those numbers meaningful (at least to some extent since this is a very badly chosen scenario to begin with).

Here is our Python test case.


import time                                                                     

def callTest(i):
  if not i == 0:
    callTest(i - 1)

  return i

r = range(0,1000000)

starttime = time.time()

for i in r:
  callTest(100)

endtime = time.time()
print (endtime - starttime)

And the result:


> python test.py
21.9892270565

OK, our software runs slower with probes enabled, but we are still faster than Python and Python's performance is acceptable for a lot of use cases. We now have a slower JVM that can be instrumented. So I'd say: No real harm done.

Now let's use those probes and aggregate some real data. For this test I will use a slightly modified version of j_methodcalls.d, a script by Brendan Gregg that is shipped with the DTrace Toolkit. The script is licensed under CDDL but I did remove the license header here to make it more concise and blog-friendly.


#!/usr/sbin/dtrace -Zs                                                          

hotspot$target:::method-entry
{
  this->class = (char *)copyin(arg1, arg2 + 1); 
  this->class[arg2] = '\0';
  this->method = (char *)copyin(arg3, arg4 + 1); 
  this->method[arg4] = '\0';
  this->name = strjoin(strjoin(stringof(this->class), "."),
                       stringof(this->method));
  @calls[pid, this->name] = count();
}

Let's run it!


> pfexec ./j_methodcalls.d -c "java -XX:+ExtendedDTraceProbes Test"
[…snip…]
249126

OK, this is A LOT slower, even slower than Python. 4 Minutes!

We are now aggregating data and that means we are copying data from userspace into kernelspace from where it can be fetched by DTrace consumers (in our case the dtrace command line tool). What data did we get in this amount of time? Actually: A LOT. It flooded my terminal and I had to pipe the result into less to be able to read all of it. DTrace recorded every method call that happened in the JVM while the program was running. It counted the calls per method, and the class the method belongs to. Keep in mind that we did not need to modify our code to get these results. We don't even need to restart a running JVM to enable the probes we can activate them by using the jinfo command. And we could have used DTrace to gather system wide data in the same script (something I might demonstrate sometime on this blog)

Now lets use the most naive debugging technique on earth. We will print out "CALLED!" every time our callTest method gets called (if you ever did this before you know how disastrous the result well be). This gives us pretty much no information. We just know that a particular method has been called and we need to modify our code, recompile and load it into running JVM.


> time java Test
[…snip…]
CALLED!
5958514

real 1h39m18.15s
user 3m53.29s
sys 7m55.68s

As we expected, the result is a disaster. Calling print in a tight loop is an extremely stupid thing to do. We could have used a counter that get incremented with every method call, proxy objects, interceptors etc. (all of them would have been significantly faster).

To do something similar like the print example with DTrace I just a another clause to the script:


tick-1s {
  printa(@calls);
  trunc(@calls);
}

This addition prints out what happened in 1 second intervals


  1  75779               :tick-1s 
     4028  Test.callTest          400379

  1  75779               :tick-1s 
     4028  Test.callTest          404720

  1  75779               :tick-1s 
     4028  Test.callTest          402135

  1  75779               :tick-1s
     4028  Test.callTest          398934

253064
dtrace: pid 4028 has exited


real 4m14.23s
user 4m13.89s
sys 0m0.46s

The performance impact stays pretty much the same with DTrace, we are done in 4 Minutes while we are presented with a readable stream of information.

There are a lot of ways to generate similar data, but most of them require code changes, are not able to do system wide tracing, are limited to one process and/or just one specific runtime.

Conclusion

Tracing the JVM costs (this shows especially in this pathological use case), but DTrace provides us with a very broad spectrum of probes. The JVM ones are just one source of data. We can actually instrument every part of the system with our DTrace script. Maybe a problem is not even related to our program at all, maybe it's NFS misbehaving, something is wrong with the database or there is some heavy IO going on. With DTrace the whole system becomes transparent. This changes the whole "blame game" and that's the whole point of DTrace. Looking at the system as a whole.

The bottom line is: trace the JVM only if you need to and be aware of the performance impact. This tool is for hunting down problems that are very hard or even impossible to analyze with traditional tools. I did use it to trace obscure memory leaks and dead-locks (both in non-Java contexts) and I was able to exactly pinpoint the culprit.

Don't use DTrace when there is a tool that does a better job for this specific task. Use it wisely. Anyway, it's a great utility to have in your toolbox.

Last but not least: use realistic use cases for benchmarking, label your diagram axes, and compare tools that have the same objective.

DTrace and Scala

2011-07-06T11:48:00.000-07:00

DTrace is one of my favorite technologies ever, it absolutely redefined my view on software and how it can be debugged. In a lot of situations you are basically forced to debug your software by vomiting print-statements just all over the place. To make things worse you have to take them out when you are actually shipping your software, leaving you blind to errors to come. In other cases you probably are missing some print-statements to trace down a very nasty bug, or the bug is hidden in some 3rd-party lib that would take hours to recompile with your new print statement (don't start thinking about libs that you don't have the code of…). In most cases this can become a very unpleasant situation (to put it mildly). DTrace takes a lot of the hassle away by providing you with a mechanism that can modify your program while it's running without stopping it.
Pretty amazing, huh? Wait, it gets better. You can even trace into the runtime of some high level languages (if they provide the probes). This is also true for the JVM, and that means we can instrument a running Scala program.

In this post I will walk you through a very basic script that shows what methods from Predef get called by your program. DTrace is a tool that reaches deep down into the lower levels of your machine. Sounds scary? Nah not really, one of the design goals of DTrace is safety. Your scripts run in a managed environment that keeps it from doing harmful things.

OK, enough sweet-talk. Time to get our hands dirty by writing a very simple Scala program:


import scala.annotation.tailrec

object Main {
  @tailrec
  def sayHallo() {
    println("HALLO!")
    Thread.sleep(1000)
    sayHallo()
  }
                                                                                
  def main(args: Array[String]) {
    sayHallo()
  }
}

This just prints out "HALLO!" in 1 second intervals (not exactly rocket science, but I put a little sugar on top of it by replacing the while loop with a tail recursive function for fun and profit).

What's that? When running my program DTrace is not showing me ANY probes!!?!?! FFFFUUUUUUUU! That's because we have to enable them first, we can instruct a running JVM to do this by using jinfo. Since I only got one JVM running on this box I will fetch the PID with pgrep.


jinfo -flag +ExtendedDTraceProbes $(pgrep java)

The JVM probes are now armed and "dangerous" (just kiddin') and you will have access to the hotspot provider.

Now lets write the DTrace script. Keep in mind: this script is running in kernel space, so we have to copy in some information from userspace, we do this by using copyin and we have to NULL-terminate the strings ourselves. Yep, this is what it feels like to program low-level stuff, it's not as pretty as FP but aaaaaaaaaanyway, here is the little bugger.


#!/usr/sbin/dtrace -s                                                           

#pragma D option quiet

hotspot$$target:::method-entry
{
  this->class = (char *) copyin(arg1, arg2 + 1); 
  this->class[arg2] = '\0';
  self->tracefunc = stringof(this->class);
}

hotspot$$target:::method-entry
/self->tracefunc == "scala/Predef$"/
{
  this->method = (char *) copyin(arg3, arg4 + 1); 
  this->method[arg4] = '\0';
  printf("%s %Y\n", stringof(this->method), walltimestamp);
  self->tracefunc = 0;
}

hotspot$$target:::method-entry
/self->tracefunc/
{
  self->tracefunc = 0;
}

This thing will fire whenever a function from Predef is called and will give us the function name (in our test case this is just println) and the time when this function was being called. I run this on OpenIndiana build151-beta by issuing pfexec dtrace ./tracescript.d -p $(pgrep java) after I enabled the hotspot provider on the JVM. (pfexec is kind of like sudo, just use whatever gives you the permission to run dtrace on your box)
The output will look like this:


println 2011 Jul  6 21:27:34
println 2011 Jul  6 21:27:35
println 2011 Jul  6 21:27:36
println 2011 Jul  6 21:27:37
println 2011 Jul  6 21:27:38
println 2011 Jul  6 21:27:39
println 2011 Jul  6 21:27:40
println 2011 Jul  6 21:27:41
println 2011 Jul  6 21:27:42
println 2011 Jul  6 21:27:43
println 2011 Jul  6 21:27:44
println 2011 Jul  6 21:27:45
println 2011 Jul  6 21:27:46
println 2011 Jul  6 21:27:47
println 2011 Jul  6 21:27:48
println 2011 Jul  6 21:27:49
println 2011 Jul  6 21:27:50
println 2011 Jul  6 21:27:51
println 2011 Jul  6 21:27:52
println 2011 Jul  6 21:27:53
println 2011 Jul  6 21:27:54
println 2011 Jul  6 21:27:55

WTF IS THIS I DON'T EVEN!?!?!? TL;DR

OK, this is not even the tip of the iceberg but I think I will wrap it up because there is a lot of ground to cover when it comes to DTrace. If you are hungry for more you should check out the "DTrace Review" by @bcantrill, this stuff will blow your mind (seriously, WATCH IT!) or buy the book by @brendangregg. I will make sure to dig deeper on the topic, so stay tuned. Tell me what you think, good tool or best tool? :P

English, please!

2011-07-06T10:56:00.000-07:00

It took me quite some time to make up my mind about this… should I switch the language of this blog to English or should leave it just the way it is. I think it's worth to give this a try, since twitter brought me towards a mostly non-German audience which I also would like to address. This is also a great opportunity to polish my language skills a little since they got kind of neglected in the last few years (so bear with me ;)

So, to all my new readers, here is a little overview on what this blog is about. I work as a developer at a German software company so quite a lot of stuff you will find here will focus on programming and debugging. In my free time I like to play around with different operating systems (mainly Illumos, FreeBSD and DragonFlyBSD) so this place will be stuffed with information about OS specific wizardry :3

OK, folks! Let's give this a shot!

Dynamic-Dispatch in Scala

2011-02-23T05:30:00.001-08:00

Ich bin ja hin und wieder schon mal richtig neidisch auf Clojures Multimethods, möchte aber nicht wirklich meine statisch typisierte Welt verlassen (auch wenn Clojure vermutlich die einzige Sprache wäre die ich von allen dynamischen Sprachen wählen würde).

Lange Rede, kurzer Unsinn: Ich will Multimethods in Scala! Auf den ersten Blick klingt das als würde man sich eine Sprache zu etwas hinbiegen wollen was sie gar nicht ist, aber in Scala geht das ganze erschreckend schmerzlos.

Zum dispatchen verwende ich einfach ein paar partielle Funktionen die man mit orElse beliebig aneinanderketten kann. Der Vorteil davon ist das ich keinen Code aufmachen muss wenn ich einen weiteren Fall hinzufügen will sondern durch Komposition zum Ziel komme.


trait Dynamic

class A extends Dynamic
class B extends Dynamic

object Dynamic {
  // 2 dynamische argumente
  type Dyn2 = (Dynamic, Dynamic)

  // infix notation fuer PartialFunction
  type ~>[A, B] = PartialFunction[A, B]
                                                                             
  val f: Dyn2 ~> String = {
    case (a: A, b: A) => "A A"
  }

  val g: Dyn2 ~> String = {
    case (a: A, b: B) => "A B"
  }

  // d ist die dispatchfunktion
  def dispatch[A, B](d: A ~> B, a: A): Option[B] =
    if (d.isDefinedAt(a)) Some(d(a))
    else None
}

In Aktion sieht das Ganze so aus:



scala> :l ./dynamic.scala                                            
Loading ./dynamic.scala...
defined trait Dynamic
defined class A
defined class B
defined module Dynamic

scala> import Dynamic._
import Dynamic._

scala> dispatch(f, (new A, new A))
res0: Option[String] = Some(A A)

scala> dispatch(f, (new A, new B))
res1: Option[String] = None

scala> dispatch(f orElse g, (new A, new B))
res2: Option[String] = Some(A B)

Wie man schön sehen kann werden auch die nicht abgedeckten Fälle behandelt indem wir einfach eine Option verwenden, dadurch könnten wir unseren Dispatch auch in einer for-Comprehension verwenden (Monaden für den Gewinn!)

Viel Spass beim ausprobieren ;)

Hier ein kleiner Nachtrag wozu Multimethods gut sind. Für alle die Das Visitorpattern schon immer gehasst haben ;)

Scala: Besseres Pattern-Matching mit Sealed Classes

2011-02-21T13:54:00.000-08:00

Neulich bin ich auf eine recht interessante Mail in der jvm-languages Google Group gestossen. Ein Vergleich von Scala und OCaml! Wie spannend!
Besonders interessant fand ich folgendes Beispiel:


# let foo = function
    | true, _ -> 0
    | _, false -> 1;; 
Warning P: this pattern-matching is not exhaustive.
Here is an example of a value that is not matched:
(false, true)
val foo : bool * bool -> int =

OCaml liefert hier beim kompilieren einen Fehler: Das Patternmatching würde nicht alle Möglichkeiten erschöpfen. Zusätzlich bekommt man noch ein Beispiel wo der Match fehlschlägt. Tolle Sache! Das Scala Beispiel sieht hier doch eher ernüchternd aus.


scala> def foo(b: (Boolean, Boolean)): Int = b match {
     |   case (true, _) => 0
     |   case (_, false) => 0
     | }
foo: ((Boolean, Boolean))Int

scala> foo(false, true)
scala.MatchError: (false,true)
   at .foo(:4)
   at .(:5)
   at .()
   at java.lang.Class.initializeClass(libgcj.so.81)
   at RequestResult$.(:3)
   at RequestResult$.()
   at java.lang.Class.initializeClass(libgcj.so.81)
   at RequestResult$result()
   at java.lang.reflect.Method.invoke(libgcj.so.81)
  ...

Anscheinend ist Scala wohl nicht in der Lage herauszufinden welche Fälle möglich sind und kann so nicht testen ob das Matching auch wirklich alle Möglichkeiten ausschöpft. Aber genau dieser Effekt lässt sich mit Sealed Classes erreichen.

Als Beispiel definiere ich einen eigenen Booltypen mit einem Subtypen für jeweils true und false (ich nehme hier Objects da wir nicht mehr als eine Instanz von True bzw. False brauchen). Das gleiche Beispiel schlägt hier mit einer ähnlichen Fehlermeldung wie bei OCaml fehl:


abstract sealed class MyBool
case object True extends MyBool
case object False extends MyBool

object MyBool {
  def test(a: (MyBool, MyBool)): Unit = a match {
    case (True, _) => ()
    case (_, False) => ()
  }
} 

MyBool.scala:6: warning: match is not exhaustive!
missing combination          False          True

  def test(a: (MyBool, MyBool)): Unit = a match {
      ^
one warning found

Die Sealed Class hat zur Folge das wir keine weiteren Subtypen außerhalb unser Quelldatei anlegen können, der Compiler hat jetzt also alle Information die er braucht um den Match zu prüfen.

Mehr zum diesem Thema gibt es wieder mal bei Mario Gleichmann.

Scala: Spass mit Streams

2011-01-31T10:36:00.000-08:00

Ich wurde ja neulich mal gefragt ob ich mal was über Streams in Scala bloggen könnte (auch wenn es hier eher um IO ging). Da mir da allerdings ein gutes Beispiel gefehlt hat, habe ich das erst einmal auf die lange Bank geschoben (irgendwie blogge ich derzeit glaub ich etwas zu wenig :/).

Aber ok, dank eines hervorragenden Posts von Mario Gleichmann bin ich dann doch noch auf eine ganz brauchbare Idee gekommen. (Schon allein Vollständigkeit halber empfehle ich den Post von Mario zu lesen!)

Im folgenden Code geht es einfach nur darum die nachfolgende Jahreszeit zu bestimmen.


sealed abstract class Season
case object Spring extends Season
case object Summer extends Season
case object Fall extends Season
case object Winter extends Season

object Main {
  lazy val seasons: Stream[Season] =
    Spring #:: Summer #:: Fall #:: Winter #:: seasons

  def nextSeason(now: Season): Season = {
    @scala.annotation.tailrec
    def getNextFromStream(s: Stream[Season]): Season =                                                                                              
      s match {
        case a @ x #:: y #:: _ =>
          if (now eq x)
            y
          else
            getNextFromStream(a tail)
      }
    getNextFromStream(seasons)
  }

  def main(args: Array[String]): Unit = { 
    println(nextSeason(Spring))
    println(nextSeason(Summer))
    println(nextSeason(Fall))
    println(nextSeason(Winter))
  }
}

Um die Jahreszeiten abzubilden nutze ich hier einen Stream (also eine unendliche Liste) die ich rekursiv durchgehe bis ich die aktuelle Jahreszeit gefunden habe und einfach die Nächste ausgebe.

Dieses Beispiel wirkt zugegebenermaßen etwas wie mit Kanonen auf Spatzen zu schiessen, zeigt aber die Ausdrucksstärke von Streams und Lazy-Evaluation. Ein sehr realer Anwendungsfall ist hier z.B. ein Roundrobin-Verfahren. Anstelle also stumpf eine Liste durchzugehen und am Ende wieder an den Anfang springen in Zukunft einfach mal über einen Stream nachdenken ;)

Die Sache mit Apple

2010-12-25T05:57:00.000-08:00

"Hallo, ich bin raichoo und ich habe ein MacBook". Das sind Sätze mit denen man in vielen Kreisen schnell Freunde finden kann (Vorsicht Ironie!). Aber mal ehrlich, in den letzten Tagen kann man sich besonders schöne Kommentare gefallen lassen. Mein Favorit ist hier "Apfelnazi" (Goodwin's Law lässt grüßen). Die Diskussionskultur lässt hier ziemlich zu wünschen übrig, wer Leute nach dem Betriebssystem beurteilt hat in meinen Augen doch eher einen massiven Schaden.

Aber was bewegt die Leute dazu so zu reagieren? Auf der einen Seite mag das ganze auf einem pseudoelitären Gefühl basieren. Apple ist Mainstream. Gegen Mainstream sein ist rebellisch, cool und was weiß ich noch alles. Ich bin ja selber keine Ausnahme, meine Lebensweise ist sicherlich nicht die eines Ottonormalverbrauchers. Aber diese extremen Anfeindungen gehen doch echt schon zu weit.
Doch zurück zu den Beweggründen. Wikileaks ist im Moment sicherlich ein sehr bewegendes Thema, und das Verhalten vieler Firmen wie Visa, Paypal, Mastercard und auch Apple ist nicht nur verwerflich, es ist in meinen Augen auch undemokratisch.
Was also machen? Boykottieren? Guter Plan, Boykott war immer schon die wirksamste Waffe des Verbrauchers, denkt man sich. Die Problematik die sich hieraus aber ergibt ist folgende: der überwiegende Großteil der Firmen wird so reagieren. Ein bisschen Druck vom Staat eventuell noch ein paar Zuwendungen unter der Hand und schon wird der Stecker gezogen. Unsere Freiheit wird also potentiell von jeder Firma beschnitten die nur den nötigen Einfluss hat, oben genannte Beispiele befinden sich nur gerade in dieser Situation besonders in so einer Position. Man kann sich also praktisch totboykottieren, der Hydra wachsen die Köpfe einfach nach.

Wie also reagieren? Alle Apple Produkte aus dem Fenster werfen in den nächsten Mediamarkt rennen, ein Plastikwaffeleisen kaufen das nach einem Jahr auseinanderfällt und Ubuntu installieren? Ich sag es ehrlich: Linux ist derzeit einfach technisch keine Alternative für mich, und FreeBSD's Treibersituation auf Notebooks ist auch nicht wirklich berauschend. Windows mag ich nicht, usw.. Erreicht wird damit doch praktisch eh nichts. In meinen Augen ist beim Thema Wikileaks das effektivste Mittel doch eh: so hartnäckig spenden wie es nur geht. Wege dafür gibt es genug. Unterstützung ist weitaus mächtiger als Boykott.

Wenn mir also jemand ein Notebook mit 13" Formfaktor, 6 Stunden+ Akkulaufzeit, Alugehäuse, großen Touchpad auf dem mindestens ein FreeBSD rennt (damit meine ich das ALLE Komponenten auch zuverlässige Treiber haben) und das dazu auch noch KEINERLEI Komponenten von irgendeiner Firma enthält die irgendwo mal Scheisse gebaut hat zeigen kann, bring it on. (Das ist ernst gemeint, würde mich interessieren ob es da draußen irgendwas gibt was dem auch nur ansatzweise entspricht)

Scala: Klassen erweitern mal anders

2010-09-20T10:39:00.000-07:00

Datentypen erweitern ist mehr oder weniger etwas das man des öfteren machen muss, und das ist nicht umbedingt immer unproblematisch. Nehmen wir mal an wir hätten folgende Klasse:


class Test(val x: Int)

Ganz klar: hochkomplizierter Code. Test quillt an Features nur so über, aber uns fehlt gerade eine Methode damit
wir Objekte dieser Klasse in unserem Code nahtlos verwenden können. Diese Methode nennen wir bla. Das Problem ist allerdings: Wir haben den Code von Test nicht und können ihn deswegen nicht um bla erweitern.
Jetzt gibt es verschiedene Wege wie wir diese Methode in Test einbinden könnten. Der offensichtlichste ist sicherlich Vererbung. Blöd ist nur: Wir haben bla schon geschrieben und würden ihn ungern duplizieren, vor allem weil wir den Code bereits schön generalisiert haben.

Eine Lösung ist hier ziemlich elegant mit Traits, Selftyping und Structural Types zu machen.

Als erstes definieren wir einen Structural Type der eine genaue Schnittstelle definiert. Wir nennen ihn xAble und er macht nichts weiter als zu definieren das alle Klassen die eine Methode x anbieten vom Typ xAble sind.


type xAble = { def x: Int }

Was wir jetzt brauchen ist unsere generalisierte Implementation von bla. Hier verwenden wir, Selftyping. Das ist ein Feature das es uns erlaubt innerhalb eines Traits so zu tun als wäre es von einem bestimmten Typ ohne davon zu erben.


trait Gimme[A <: xAble] {
  self: A =>
  def bla(): Unit = println(self.x + 1)                                                              
}

Wie man sieht muss der muss der Typparameter A ein Subtyp von xAble sein, also die methode x liefern.

Alles was wir jetzt noch machen müssen ist das Trait Gimme in das Objekt des Typs Test zu mischen und wir haben das ganze um bla erweitert.


object Main {

  class Test(val x: Int)

  type xAble = { def x: Int }

  trait Gimme[A <: xAble] {
    self: A =>
    def bla(): Unit = println(self.x + 1)
  }

  def main(args: Array[String]): Unit = {
    val t = new Test(666) with Gimme[Test]                                                             
    t.bla()
  }
}

Das ganze Zeit mal wieder wie extrem mächtig das Scala Typsystem ist und was für elegante Features die Sprache zum lösen immer wiederkehrender Probleme bietet. Ich hoffe dieses Beispiel gibt euch eine kleine Idee was man damit machen kann. ;)

FreeBSD 8.1 und die JVM

2010-06-24T12:58:00.000-07:00

Alios hat gerade seinen Server auf den neusten Stand gebracht und prompt funktionierte Sakura natürlich wieder nicht. Das Problem war das die JVM wohl anscheinen den IPv6 Stack genommen hat und sich damit nicht verträgt, ein Workaround ist die JVM einfach dazu zu zwingen den IPv4 Stack zu nehmen. Das geht mit der -Djava.net.preferIPv4Stack=true Option.

Wenn euch also das nächste mal ein Socket beim Connect aus unerfindlichen Gründen abraucht, versucht es mal damit.

100 Posts!

2010-06-24T12:56:00.001-07:00

Spass mit Scala Infixtypen

2010-06-21T09:09:00.000-07:00

In Scala gibt es das interessante Konzept der Infix Typen, dabei handelt es sich um nichts weiter als Typen die zwei Parameter erwarten. Scala erlaubt hier Infix Notation.


object Main {
  class FooBar[A, B]

  def main(args: Array[String]): Unit = { 
    //zwei unterschiedliche Schreibweisen die das gleiche
    //meinen
    var x: FooBar[Int, BigInt] = null
    var y: Int FooBar BigInt   = null
  }
}

Damit eröffnen sich interessante Möglichkeiten des Typsystems, z.B: "Operatoren" aus Typen erstellen die wiederum Typen erstellen. Verwirrt? In Scala gibt es bereits =:=, <:< und <%<, diese Konstrukte kann man sich unter anderem auch selbst zusammenbasteln, im folgenden Beispiel bauen wir uns einen <@@@< "Operator"


abstract class <@@@<[A, B] extends (A => B)

class Test[T <: (Int => Int)]

object Main {
  def main(args: Array[String]) = { 
    val t = new Test[Int <@@@< Int]
  }
}

Ziemlich cool, jetzt kann man sich Operatoren basteln die Typen erstellen und sich anfühlen wie native Features der Sprache :)

Paralleles Primzahlsieb in Scala

2010-06-02T13:11:00.000-07:00

Nach der Präsentation von Google Go habe ich mich gefragt ob man das parallele Primzahlsieb auch in Scala so machen kann. Ich muss sagen das ich das Resultat sogar einfacher und eleganter finde als die Go Implementation. Sicherlich gibt es performantere Algorithmen aber hier geht es einfach um das Prinzip zu zeigen wie einfach man Parallelisieren kann.

HINWEIS: Das Programm terminiert nicht, da für jede Primzahl ein eigener "Thread" (Actors die per react warten verhalten sich nicht ganz so wie Threads die in einem Loop warten, sondern sind leichtgewichtiger) gestartet wird und diese weiter auf Futter warten. Es ist auf jeden Fall möglich das das ganze anhält, ich will lediglich das Prinzip zeigen und das Beispiel nicht unnötig aufblasen.


import scala.actors.Actor
import scala.actors.Actor._

class Prime(value: Int) extends Actor {
  var next: Option[Prime] = None

  println(value)
  start

  def act(): Unit = loop {
      react {
        case x: Int if ((x % value) != 0) =>  
          next match {
            case Some(p: Prime) => p ! x 
            case None => next = Some(new Prime(x))
          }   
      }   
    }   
}

object Main {
  def main(args: Array[String]): Unit = { 
    val primer = new Prime(2)
    3 to args(0).toInt map (primer ! _)
  }
}

Mergesort in Scala

2010-05-10T13:26:00.000-07:00

Und aus der Kategorie "Sortieren für Besessene" kommt heute mal wieder ein Beispiel, aber ausnahmsweise kein Quicksort ;)

Was ich besonders toll an diesem Beispiel finde ist das auf gleich 2 Listen gleichzeitig gematcht wird wie es auch in Haskell geht. Da hat Scala mal wieder richtig Spass gemacht.


object Main {

  def merge[T <% Ordered[T]](l: List[T], r: List[T]): List[T] = 
    (l,r) match {
      case (x::xs, y::ys) => if (x < y)
                               x::(merge(xs, r)) 
                             else
                               y::(merge(l, ys))
      case (xs,  Nil) => xs
      case (Nil, ys)  => ys
    }   

  def mergesort[T <% Ordered[T]](list: List[T]): List[T] =   
    if (list.length > 1) { 
      val (l, r) = list splitAt (list length)/2
      merge(mergesort(l), mergesort(r))
    } else list

  def main(args: Array[String]): Unit = { 
    println(mergesort(List(4,5,9,1,2,4,5,9,8,7)))
  }
}

Scala in der Warpzone

2010-05-08T17:22:00.000-07:00

Scala in der warpzone Münster from raichoo on Vimeo.

Git-Mode für die KSH

2010-04-17T01:43:00.001-07:00

Ich habe gerade mal meine Git Erweiterung für die Kornshell in meinen Bitbucket gestellt. Das ganze liegt zwar noch unter "Mercurial-Integration" aber sollte zu finden sein ;). Wie schon beim Mercurial mode wechselt man mit mode git in den entsprechenden Modus. Die Farbe der Commit ID wechselt von Rot (uncommited changes) zu Gelb (nicht die aktuellste Revision) zu Grün (aktuellste Revision und nichts zu commiten). Außerdem wird der aktuelle Branch angezeigt und im Falle eines "detached HEAD" Zustands visuell gewarnt. Viel Spass damit!

Git happens

2010-04-17T00:13:00.001-07:00

Ich bin kein besonders großer Fan von Git, allerdings kommt man hin und wieder einfach nicht drum herum. Da mein Standard-Workflow derzeit einfach darin besteht Commits im Nirvana verschwinden zu lassen gibt es eigentlich nur 2 Alternativen für mich:

Eine Selbsthilfegruppe für Git-Geschädigte aufsuchen

Ein paar Skripten schreiben die mir das Leben leichter machen

Zweiteres klang bei näherer Betrachtung einfach attraktiver.

Da ich im privaten Umfeld mehr Mercurial nutze platzt meine .gitconfig derzeit durch Aliase auseinander die meinen Workflow erhalten, 2 davon replizieren in etwa das Verhalten von incoming und outgoing, oder anders gesagt: sie zeigen mir eingehende bzw. ausstehende Commits an.

Beispiel:


// commits die noch nicht in origin/master
// eingeflossen sind
git out origin/master

// commit aus origin/master die noch nicht
// in meinem lokalen Branch liegen
git in origin/master

Die beiden Aliase sind nicht besonders spektakulär aber nützlich:


  out = "log --stat HEAD --not"
  in  = "!f() { git log --stat $1 --not HEAD; }; f"

Ein weiteres Alias reproduziert das verhalten von hg log -G und zeigt mit die History in einem halbwegs lesbaren Graphen an (bei komplexeren Bäumen greife ich aber lieber zu einem Tool wie GitX)


  graph = "log --graph --pretty=oneline --abbrev-commit --decorate --all"

Das alles hilft aber noch nicht bei meinem eigentlichen Problem: Commits schrotten.
Hierfür habe ich mir eine kleine Erweiterung geschrieben… Also nicht zum schrotten, sondern zum wiederherstellen ^^.
Mit git orphans werden mir sogenannte "dangling commits" angezeigt, das sind Commits die auf normalem Wege nicht mehr erreichbar sind. Da git ohne Garbage Collection (git gc oder git prune) nicht so ohne weiteres Commits wegwirft sondern als "dangling commits" im Nirvana vorhält, kann ich mit git reset --hard SHA1 (oder in meinem Fall mit dem Alias git rollback SHA1) meinen HEAD auf gerade verlorene Commits umbiegen und alles ist wieder beim Alten. git orphans verifiziert Commitobjekte und zeigt mir den dazugehören History Eintrag an. Das Ganze ist ein simples Shellskript das man einfach zu den anderen git Kommandos (welche bei mir in libexec/git-core liegen) unter dem Namen git-orphans abglegt.


#!/bin/sh

USAGE=''
OPTIONS_SPEC=
. git-sh-setup

if [ "$#" != "0" ]
then
    usage
fi

git fsck --lost-found |
while read dangling type sha1
do
  case "$type" in
  commit)
    if git rev-parse -q --verify "$sha1" >/dev/null
    then
      git log --color -n 1 "$sha1"
      echo ""
    fi  
    ;;  
  esac
done | git_pager

Für mich sind das ein paar sehr brauchbare Anpassungen, ich hoffe der ein oder andere findet sie ebenso brauchbar :)

C++ "Lazy Evaluation" für Streams

2010-04-14T11:52:00.000-07:00

Manchmal will man nicht das ein Stream überhaupt Sachen ausgibt (z.B. für Debugstreams die sich bei Bedarf zuschalten kann) und dann will man natürlich auch nicht das die Parameter die durch den Streamoperator gehen abgearbeitet werden da sich dort eventuell komplexe Parsereien verstecken könnten.

Hierfür gibt es einen denkbar einfachen Trick mit C-Macros (jaja ich weiß, aber hin und wieder bin sogar ich da pragmatisch :P ).


#include <iostream>
#define DEBUGSTREAM if (!debug); else std::cerr

int main() {
  bool debug = false;
  DEBUGSTREAM << "Test\n";
  return 0;
}

In diesem Code wird nichts ausgegeben und auch nichts ausgewertet, das Verhalten lässt sich einfach zur Laufzeit ändern. Tada! "Lazy Evaluation" on demand :)

C++ Steams dressieren

2010-04-14T11:33:00.000-07:00

Manchmal möchte man gerne bestimmte Aktionen auslösen die sich nach dem Abwickeln einer Streambefüllung zutragen sollen (z.B. das ein Lock freigeben). Hier ist ein kleiner Trick der genau das macht und in bestimmten Situationen durchaus hilfreich sein kann: wenn z.B. man durch widrige Umstände nicht in der Lage ist den Scope zu begrenzen.


#include <iostream> 
#include <tr1/memory> 
 
class Tester { 
  public: 
 
    Tester& operator<<(std::string s) { 
      std::cout << s; 
      return *this; 
    }   
 
    ~Tester() { 
      std::cout << "End\n"; 
    }   
}; 
 
std::tr1::shared_ptr<Tester> wrapper() { 
  std::cout << "Begin\n"; 
  return std::tr1::shared_ptr<Tester>(new Tester()); 
} 
 
int main() { 
  *(wrapper()) << "A "<<  "test!\n"; 
  std::cout << "Ending scope\n"; 
  return 0; 
}

Deadlocks jagen mit DTrace

2010-04-14T09:55:00.000-07:00

Deadlocks gehören so ziemlich zu den widerlichsten Phänomenen die man sich so beim Programmieren vorstellen kann. Vor allem wenn sie nur sporadisch auftreten. Irgendein Thread weigert sich einfach ein Lock wieder freizugeben und wir hängen. Mit dem gleichen Problem durfte ich mich neulich auch rumschlagen, leider tappten wir total im Dunkeln da nicht lokalisieren war wer das Lock eigentlich in Beschlag genommen hat. Hier musste wieder mal meine Lieblingswunderwaffe ran und das Problem mit einem D Skript eingekreist werden.

Was dieses Skript macht ist nichts anderes als sich zu jedem Lock der geschlossen wird den Stacktrace zu merken und sobald wir an den Punkt kommen an dem das Deadlock auftritt uns zu zeigen wer gerade das Lock hält das uns am weitergehen hindert. Das ganze ist ein unglaublicher Speicherfresser (ich muss dazu sagen das die jeweiligen Stacktraces einfach nur abnorm waren) da ich hier Speculations verwende (siehe letzter Eintrag ;) ) und DTrace bereinigt den Speicher nur in bestimmten Intervallen, was in bei der Menge an Locks einfach zu langsam war. Außerdem hat man nur eine begrenzte Anzahl an Speculations zur Verfügung. Aber DTrace wär nicht das was es ist wenn man das nicht auch "aushebeln" könnte ;)

nspec dient dazu die Anzahl der möglichen Speculations hochzusetzen und cleanrate bestimmt die Frequenz der Garbagecollection, mit -b schrauben wir den Gesamtpuffer auf 128MB hoch.

Also, ohne weitere Umschweife: der Star des gestrigen Tages!


#!/usr/sbin/dtrace -b 128m -x nspec=20 -x cleanrate=101 -s

pid$target::deadlockgoeshere:entry
{
  self->traceme = 1;
}

pid$target::deadlockgoeshere:return
/self->traceme/
{
  self->traceme = 0;
}

pid$target::pthread_mutex_lock:entry 
/spec[arg0] == 0/
{
  spec[arg0] = speculation();
  speculate(spec[arg0]);
  ustack();
}

pid$target::pthread_mutex_lock:entry
/spec[arg0] && self->traceme/
{
  commit(spec[arg0]); 
  spec[arg0] = 0;
}

pid$target::pthread_mutex_lock:entry
/spec[arg0] && self->traceme == 0/
{
  discard(spec[arg0]);  
  spec[arg0] = 0;
}

pid$target::pthread_mutex_unlock:entry
{
  discard(spec[arg0]);
  spec[arg0] = 0;
}

Spekulatives Tracen mit DTrace

2010-03-30T13:43:00.000-07:00

Spekulieren ist ja nicht erst seit der "Finanzkrise" der letzte Schrei, auch wir Programmierer stehen hin und wieder mal vor der Situation das wir Kram anhäufen von dem wir nicht wissen ob wir ihn später noch gebrauchen können. Besonders beim Debuggen fallen oft Daten an bei denen wir erst wissen ob sie interessant sind wenn wir schon bis zum Hals in Messwerten stecken. Wie also die Spreu vom Weizen trennen? DTrace hat ein Feature das leider viel zu wenig Beachtung bekommt: Speculations.

Ein einfaches Beispiel: Wir interessieren uns für alles was im Kernel während des Öffnens einer Datei passiert, allerdings wollen wir das Ergebnis nur wissen wenn das Öffnen fehlschlägt. Das macht folgendes D-Script:


#!/usr/sbin/dtrace -s

syscall::open:entry
/execname == "a.out"/ {
  self->spec = speculation();
  speculate(self->spec);
  printf("%s",copyinstr(arg0));
}

fbt:::
/self->spec/ {
  speculate(self->spec);
}

syscall::open:return
/self->spec && arg1 == -1/ {
  commit(self->spec);
}

syscall::open:return
/self->spec/ {
  discard(self->spec);
}

Ok, gehen wir das Ganze mal durch: self->spec = speculation(); legt threadlokal einen Puffer unter dem Namen spec an. Eine Speculation ist also nichts anderes als ein Puffer in dem wir Messwerte zwischenspeichern und darauf warten ob sie wichtig werden.
Um in einer Klausel das "Aufzeichnen" zu starten reicht ein speculate(self->spec), alle darauf folgenden Messwerte wandern in unseren Puffer. Tritt ein Ereignis ein das unseren Werten im Puffer Bedeutung verleiht können wir sie mit commit(self->spec); ausgeben oder im gegenteiligen Fall mit discard(self->spec); verwerfen.

ACHTUNG: Puffer zu füllen ist eine kostspielige Angelegenheit, denkt daran das wir uns hier im Kernelkontext befinden. Also solltet ihr Daten die ihr nicht mehr braucht auch sofort verwerfen. Wachsen eure Puffer ungehindert weiter wird die DTrace VM euch einen Strich durch die Rechnung ziehen und selbst anfangen Daten zu verwerfen damit ihr das System nicht in den Abgrund zieht. Des weiteren ist der Trace den ich oben beschrieben habe auch schon recht "brutal" da der Puffer mit einem kompletten fbt Messdatensatz befüllt wird. Das bremst open-systemcalls übel aus, also: HANDLE WITH CARE!

Ganz viel DTrace :D

2010-03-16T14:02:00.000-07:00

Heute war ein ziemlich voller Tag. Ich habe unter anderem meinen Vortrag über DTrace den ich schon einmal in der warpzone gegeben habe bei der Mac User Group Gütersloh gehalten. Ich hab versucht dieses doch sehr technische Thema möglichst einfach rüber zu bringen da die Folien eigentlich eher für ein sehr technophiles Publikum gedacht waren. Hoffe ihr habt trotzdem Spass daran ;)

Für alle die was auf die Ohren wollen hatte ich die Ehre eine Sendung mit Mario Heide von Pofacs zu machen. Also: die volle Dröhung DTrace :D

Quicksort in Scala

2010-02-22T15:39:00.000-08:00

Ich weiß, ich weiß. Nicht schon wieder ein Quicksort. Dem ein oder anderen wird es sicher schon zur Nase rausquillen, aber generische Quicksort Algorithmen sind wirklich ein guter Weg um eine neue Sprachen kennenzulernen (zumindest empfinde ich das so ^^) Dieser hier ist mit ein wenig Hilfe zustande gekommen. Warum ist das ganze überhaupt wert gepostet zu werden? Erstmal ist Scala eine sehr interessante Sprache die den Versuch unternimmt FP und OOP zu vereinen (ohne dabei in das Kitchen-Sink Muster zu verfallen), des weiteren läuft sie auf der JVM was einem die Möglichkeit gibt auf den reichhaltigen Fundus an Java-Libs zurückzugreifen und die Vorzüge der JVM zu nutzen. Spannende Sprache für alle die mal was ganz anderes sehen wollen ;)


object Main {
  def qs[T <% Ordered[T]](list: List[T]): List[T] = 
    list match {
      case Nil   => Nil 
      case x::xs => {
        val (l, g) = xs partition (_ < x)
        qs(l) ++ (x::qs(g))
      }   
    }   

  def main(args: Array[String]): Unit = { 
    val a = List(5,3,2,1,7,8,9,4,6)
    println(qs(a))
  }

}

Bitbucket Repository für Codeschnipsel

2010-02-01T08:05:00.000-08:00

Ich werde immer mal wieder nach Config-Files oder Codeschnipseln gefragt die ich dann meistens auf meinen Blog stelle. Diese sind aber dank von Blogspot schwer bis gar nicht lesbar, also habe ich sie einfach mal auf Bitbucket geschoben. Dann haben alle was davon ;)


hg clone https://raichoo@bitbucket.org/raichoo/ksh-mercurial-integration/

Viel Spass beim rumspielen. Ich hoffe ihr könnt was damit anfangen und habt vielleicht den ein oder anderen Verbesserungsvorschlag.

UPDATE: Links aktualisiert

KSH93: Mercurial Promptmode

2010-02-01T05:32:00.000-08:00

Nach dem großartigen Blogeintrag von Steve Losh und seinem ZSH-Mercurial Prompt habe ich mir gedacht: "Ok, das geht auch mit der KSH". Ich verfolge allerdings einen etwas anderen Ansatz. Anstatt das meine Shell bei jedem Kommando selbst überprüft ob sie in einem Repository ist (zuviel Overhead meines Erachtens nach) habe ich unterschiedliche Modes definiert (ksh für "shell" und hg für "mercurial") zwischen denen ich mit mode wechseln kann.
Der Prompt färbt sich rot wenn sich der Status verändert hat und zeigt mir neben der Revisionsnummer auch noch den Namen das Branches an auf dem ich gerade bin :)



_checkrevision() {
    set -A HGOUTPUT $(hg id -n -b -t 2> /dev/null)
    if [[ ${HGOUTPUT[0]} != "" ]]
    then
        if grep '+' <(echo ${HGOUTPUT[0]}) > \
/dev/null 2> /dev/null
        then
            print ":${BOLD}${RED}${HGOUTPUT[0]}${NORM}\
@${CYAN}${HGOUTPUT[1]}${NORM}" && return
        elif grep -v 'tip' <(echo ${HGOUTPUT[*]}) > \
/dev/null 2> /dev/null
        then
            print ":${BOLD}${YELLOW}${HGOUTPUT[0]}${NORM}\
@${CYAN}${HGOUTPUT[1]}${NORM}"\
 && return
        else
            print ":${BOLD}${GREEN}${HGOUTPUT[0]}${NORM}\
@${CYAN}${HGOUTPUT[1]}${NORM}"\
 && return
        fi  
    fi  
}

mode() {
    if [[ $1 == 'ksh' ]]
    then
        export PS1='${NORM}\[${USERCOL}${USER}${NORM}\@\
${HOSTCOL}${HOSTNAME}${NORM}\:${BLUE}$(_checkdir)\
${NORM}]\:${RED}${HISTCMD}${NORM}\> '
    elif [[ $1 == 'hg' ]]
    then
        export PS1='${PURPLE}☿${NORM}$(_checkrevision)> ' 
    fi  
}

Das ist jetzt die erste Version. Mal sehen wie sich das gute Stück noch weiterentwickelt :)

UPDATE: Hab den Code noch mal um einiges verbessert.

Quicksort in Python

2010-01-04T16:49:00.000-08:00

Und einfach nochmal weils so schön ist:


def partition(f, a): 
    l = []
    r = []
    for i in a:
        if f(i):
            l.append(i)
        else:
            r.append(i)
    return l,r 

def qs(a):
    if a == []: 
        return a
    return  qs([x for x in a[1:] if x < a[0]]) \
            + [a[0]] + \
            qs([x for x in a[1:] if x >= a[0]])

def qs2(a):
    if a == []: 
        return a
    l,g = partition(lambda x: x < a[0], a[1:])
    return qs2(l) + [a[0]] + qs2(g)

a = [4,6,3,5,1,2,7,0,9,8]

print qs(a)
print qs2(a)

Und die Ersties bei mir an der Uni beschweren sich darüber das sie funktionale Programmierung lernen müssen -_-

UPDATE: Das ganze geht noch schöner mit Python List Comprehensions

Ein Hauch von Python

2010-01-04T11:55:00.000-08:00

Ich spiele ja in letzter Zeit sehr viel mit Ruby und Python herum. Was mir an Python besonders gefällt sind unter anderem Generatoren. Damit kann man schöne Sachen machen.


def test():
    for i in range(0,3):
        yield i

x = test()

for i in x:
    print i

Einen ähnlichen Effekt kann man unter Ruby mit Enumeratoren hinkriegen


class Test
    def each
        if block_given?
            for i in 0...3
                yield i
            end
        else
            Enumerator.new(self)
        end 
    end 
end

t = Test.new
e = t.each

for i in e
    puts i
end

Ich gebe zu das ich hier ziemlich geschummelt habe und Python Generatoren über das hinausgehen was ich hier in Ruby zeige. Aber es kann hin und wieder mal recht praktisch sein ;)

Quicksort in Ruby

2010-01-04T08:41:00.001-08:00

Angestachelt vom Alios' kurzer Illustration von Quicksort in Haskell hab ich mir mal überlegt ob man das gleiche auch in Ruby 1.9 so schreiben kann. Man kann ;)


def qs(a)
    return a if a == []
    (qs a.drop(1).find_all{|x| x < a[0]}) \
    + [a[0]] + \
    (qs a.drop(1).find_all{|x| x >= a[0]})
end

Ich finde das ganze zeigt sehr eindrucksvoll wie mächtig moderne Sprachen sind die OOP und FP vereinen. Prinzipiell kann man das Ding auch twittern :P (darum die kurzen Namen)

UPDATE: Da konnte man noch etwas verkürzen ^^

UPDATE 2: Für alle denen 2 Array Durchläufe mit find_all zuviel sind gibts hier auch noch eine etwas nettere Version ;)


def qs(a)
    return a if a.empty?
    l, g = a.drop(1).partition{|x| x < a[0]}
    (qs l) + [a[0]] + (qs g)
end

By popular demand: Meine .kshrc

2009-11-06T02:10:00.000-08:00

Ich werde des öfteren mal nach meinen Einstellungen für die ksh93 die ich als meine Defaultshell auf allen Systemen die ich derzeit aktiv verwende einsetze. Der Commandeditor fc hat es mir in dieser Shell besonders angetan ganz zu schweigen davon das sie im Vergleich zu anderen Shells ziemlich bugfrei ist.

Für alle nicht vi-User VORSICHT: Diese Config kommt mit aktiviertem vi-Modus daher ;) Außerdem habe ich PS ein wenig blogtauglicher formatiert.

Noch ein Tipp für die Mac-User: die ksh in der Standardinstallation ist ziemlich veraltet. Schnappt euch Macports und installiert sie euch daraus. Danach die neue Shell in die /etc/shells eintragen und sudo chsh -s /opt/local/bin/ksh username und ksh93 ist eure Defaultshell.


set -o noclobber
set -o ignoreeof
set -o globstar
set -o vi

HISTFILE=$HOME/.histfile.$(tty | cut -d/ -f 3)
RED=$(print -n "\033[0;31m")
GREEN=$(print -n "\033[0;32m")
YELLOW=$(print -n "\033[0;33m")
BLUE=$(print -n "\033[0;34m")
PURPLE=$(print -n "\033[0;35m")
CYAN=$(print -n "\033[0;36m")
WHITE=$(print -n "\033[0;38m")

export HOSTNAME=$(hostname)
export EDITOR="vim"
export HISTEDIT="vim"

_checkdir() {
    if [[ $PWD == $HOME ]]
    then
        print -n "~"
    elif [[ $PWD == "/" ]]
    then
        print $PWD
    else
        print -n ${PWD##*/} 
    fi
}

if [[ $(uname) == "Darwin" ]]
then
    export PS1='${WHITE}[${GREEN}${USER}${WHITE}@${YELLOW}\
${HOSTNAME}${WHITE}:${BLUE}$(_checkdir)${WHITE}]:\
${RED}$HISTCMD${WHITE}> '
    alias ls='ls -FG'
    alias pkill='killall'
    alias pgrep='ps -A | grep -i'
    alias grep='grep --color=always'
elif [[ $(uname) == "SunOS" ]]
then
    export PS1='[${WHITE}[${GREEN}${USER}${WHITE}@${CYAN}\
${HOSTNAME}${WHITE}:${BLUE}$(_checkdir)${WHITE}]:\
${RED}${HISTCMD}${WHITE}> '
    export PATH="/bin:/sbin:/usr/bin:/usr/sbin:\
/opt/SunStudioExpress/bin:$PATH"
    alias ls='ls -F'
elif [[ $(uname) == "FreeBSD" ]]
then
    export PS1='[${WHITE}[${GREEN}${USER}${WHITE}@${PURPLE}\
${HOSTNAME}${WHITE}:${BLUE}$(_checkdir)${WHITE}]:\
${RED}${HISTCMD}${WHITE}> '
    alias ls='ls -FG'
    alias pkill='killall'
    alias grep='grep --color=always'
    alias pgrep='ps -A | grep -i'
fi
     
alias !!='fc -s -1'
alias vi='vim'

Gespiegelt: Festnahme auf "Freiheit statt Angst"

2009-09-15T05:58:00.001-07:00

Ich bin so frei und spiegele ebenfalls einen Blogeintrag der dazu führt das diverse Blogs derzeit den Geist unter der Last aufgeben.

Am Wochenende des 11.-13. September 2009 fand in Berlin die Demonstration „Freiheit statt Angst“ statt. Ich war am Freitag gegen Abend in Berlin angekommen und kam am frühen Samstag Mittag mit der U-Bahn am Potsdamer Platz an, von dem aus die Demonstration starten sollte. Beim Betreten des Platzes zwischen Sony Center und Daimler Chrysler City wurde ich von einem Polizisten der Bereitschaftspolizei freundlich angesprochen, ob er einen Blick in meinen Rucksack werfen dürfe. Ich gestattete ihm dies ebenso freundlich. Während er den Inhalt meines Rucksacks untersuchte (eine Regenjacke, eine Wasserflasche) fragte er, ob ich irgendwelche spitzen Gegenstände mit mir führte. Tatsächlich hatte ich – wie immer – mein Letherman Tool, eine Art Multifunktionswerkzeug, im Rucksack. Dies gab ich an und suchte es auf Nachfrage aus dem Rucksack. Ich erklärte mein Letherman dem Polizisten, der das Werkzeug nicht kannte und zeigte ihm auch, dass sich ein Messer zwischen den Werkzeugen befindet. Der Polizist begutachtete das Tool und erklärte mir dann, dass das Mitführen eines Messers auf Demonstrationen nicht erlaubt sei. Er fragte, ob ich das Messer noch schnell nach Hause bringen könnte. Das konnte ich nicht, denn ich bin ja kein Berliner. Der Polizist bot mir daraufhin an, das Messer bei der Polizei vor Ort abzugeben und es nach der Veranstaltung wieder abzuholen. Ich willigte ein.
Gemeinsam gingen wir um die Ecke in die Potsdamer Straße, wo mehrere Einsatzwagen der Polizei standen. Der mich begleitende Polizist erklärte seinen Kollegen, dass ich das Tool abgeben wolle. Der Ton der dort wartenden Beamten war deutlich unfreundlicher, ich wurde abgetastet und sollte meinen Rucksack in einen der Mannschaftswagen stellen. Auf Nachfrage wurde mir gesagt, dass dies aus Sicherheitsgründen geschehe, damit ich keine Waffe aus dem Rucksack ziehen könne. Meinen Personalausweis stellte ich bereitwillig zur Verfügung, um das Ausstellen der Formulare zu erleichtern. Während nun ein weiterer Polizist abseits an einem anderen Wagen die Formulararbeit machte, erklärte der Beamte, der mich ursprünglich angesprochen hatte, seinen Kollegen, dass er das Tool nicht gefunden hätte, sondern dass ich es ihm ausgehändigt hätte, wonach die Behandlung und der Ton mir gegenüber deutlich freundlicher wurde.

Ich erkundigte mich, wo ich das Tool später wieder abholen könne. Ich könne es im “Abschnitt 34″, Alt Moabit 145 wieder abholen, wurde mir mitgeteilt. Dann wurde ich gefragt, ob ich “schon mal Kontakt mit der Polizei” gehabt habe: Nein. Auf Nachfrage, warum mir diese Frage gestellt wurde, sagte mir der Beamte, dass eine routinemäßige Kontrolle über Funk meiner Person erfolgen würde. Kurze Zeit später kam der Polizist mit dem Formular wieder und eröffnete mir, dass über Funk die Order ergangen sei, dass gegen mich eine Anzeige geschrieben werden müsse. Ich war total entsetzt, doch die umstehenden Polizisten versicherten mir, dies sei kein Problem und nur ein formaler Akt; die Staatsanwaltschaft würde das Verfahren voraussichtlich automatisch wieder einstellen.

Meinen Schrecken minderte das wenig, doch als erstes sollte ich das Protokoll über die, wie es mittlerweile hieß, “Beschlagnahme” des Tools unterschreiben, was ich auch tat. Wider Erwarten durfte ich nun nicht zur Demonstration gehen, sondern musste mit aufs Polizeipräsidium kommen, ein Fahrzeug war bereits auf dem Weg, um mich abzuholen. Der Polizist, der mich am Platz angesprochen hatte, registrierte meine aufkeimende Panik und versuchte, mich zu beruhigen. Auch er habe damit nicht gerechnet. Aber er könne nichts tun. Dies sei eine Anweisung “von oben”.

Eine Anweisung von oben war offensichtlich auch der vergitterte Wagen, in dessen Zelle ich eingeschlossen und abtransportiert wurde. Zu diesem Zeitpunkt hatte ich nichts mehr bei mir außer den Durchschlag des Formulars über die Beschlagnahme. Mein Rucksack mit komplettem Inhalt (Handy, Fotoapparat, Schlüssel, Geldbörse etc.) hatte der Beamte in der Fahrerkabine. Ich studierte den Durchschlag: Dort war angekreuzt: Festgenommen. Nun brach ich erstmal vollständig zusammen… Auf Nachfrage, was mir vorgeworfen würde und warum ich festgenommen sei und warum ich in einer Gefängniszelle sitze wurde mir gesagt, dies würde ich auf dem Präsidium erfahren, es sei aber alles nicht so schlimm und festgenommen höre sich viel schlimmer an als es sei.

Der Wagen wollte gerade losfahren, hielt dann aber noch mal wieder an – es sei noch zu einer weiteren Festnahme gekommen und wir müssen noch kurz warten um eine weitere Person mitzunehmen. Der Polizist der bis dahin noch mit hinten im Wagen (außerhalb der Zelle) saß und sozusagen meinen einzigen Ansprechpartner dar stellte, verließ daraufhin das Fahrzeug wieder und ließ mich allein. Total aufgelöst versuchte ich den Beamten vorne im Fahrzeug anzusprechen: was los sei und ob ich noch mal an die frische Luft könne, da mir schlecht sei von der stickigen Luft (und der Situation) sei. Erst nach mehrmalige Ansprache sagte er kurz es ginge gleich weiter und schob das Sichtfenster zwischen Fahrer Bereich und dem hinteren Teil des Wagens zu.

Nach geschätzten 10 Minuten stiegen der Beamte von zuvor, eine Kollegin und ein weiterer scheinbar festgenommener Junge ein Wir fuhren darauf hin los. Nach etwa 10min Fahrt kamen wir an einer PolizeiwWache an und wurden hinein geführt. Nach kurzem Warten vor einer Tür wurden wir herein gelassen und ich wurde in eine Zelle geführt,die Tür wurde hinter mir verschlossen. Kurz Zeit später wurde ich wieder aus der Zelle geholt und sollte mich auf dem Flur vor eine Wand stellen, wo ein Beamter mit einer Digitalkamera Fotos von mir machte. Anschließend wurde ich wieder in die Zelle zurück geführt. Nach geschätzten weitern 10 Minuten wurde ich in einen weiteren Raum geführt, wo zwei Beamten auf mich warteten. Mein Rucksack wurde nun noch mal vollständig entleert und der Inhalt protokolliert. Während dessen fragte mich einer der Protokoll führende Beamte ob ich mit einer Blutprobe einverstanden sei; ich fragte, wozu. Mir wurde erklärt, dies sei eine StandardfFrage für ein Standardformular und es würde jeder gefragt. Darauf verweigerte ich die Entnahme eine Blutprobe formell, was in dem Formular vermerkt wurde.

Im Anschluss wurde ich aufgefordert mich bis auf die Unterhose auszuziehen (das Recht diese doch recht unangenehme Situation verweigern zu können kannte ich zu dem Zeitpunkt leider nicht) und meine Anziehsachen wurden erneut durchsucht. Nach kurzer Zeit erhielt ich sie zurück, durfte ich mich wieder anziehen, musste noch meinen Gürtel und meine Schnürsenkel abgeben und unterschrieb das Protokoll in dem alles was ich bei mir hatte aufgeführt war.

Mein Frage was mir denn nun vorgeworfen würde konnte der Beamte wieder nicht beantwortet: “das wisse er nicht, er sei nur dazu da meine Sachen aufzunehmen”. Ich fragte was den nun passieren würde und er sagte mir, dass ich vermutlich gleich befragt würde und ich dann auch Antwort auf meine Fragen erhalten würde. Ich schilderte den beiden anwesenden Beamten noch mal den Sachverhalt und sie erklärten mir, ich würde bestimmt schnell wieder entlassen, er führe schließlich auch meist sein Taschenmesser mit sich und ich hätte es ja freiwillig abgegeben.

Nach dem ich anschließend wieder in eine Zelle gesperrt worden war, begann das lange Warten. Von Zeit zu Zeit wurde die Tür kurz geöffnet und direkt wieder geschlossen – bei jedem Mal dachte ich, es würde nun endlich weiter gehen und ich würde endlich erfahren, was mir eigentlich vorgeworfen wurde, dem war aber leider nicht so. Als wieder einmal die Tür geöffnet wurde, fragte ich schnell nach der Uhrzeit – es war mittlerweile 16.15 Uhr. Ich saß also mittlerweile seit fast 4 Stunden fest und wusste immer noch nicht, warum. Es muss etwa 17.00 Uhr gewesen sein, als ich endlich aufgefordert wurde, mitzukommen. Meine Hoffnung nun endlich mit einem Ermittler sprechen zu können um den ganzen Sachverhalt aufzuklären, wurde aber leider wieder enttäuscht. Stattdessen wurde in einen Raum, ein Stockwerk tiefer, zum “LKA Berlin Erkennungsdienst” geführt.

Auch den drei Beamten dort schilderte ich unter Tränen nochmals den ganzen Sachverhalt und fragte, ob ich der Erkennungsdienstlichen Erfassung denn wenigstens formell widersprechen könne, da es sich doch ganz klar um ein Missverständnis handele – dies wurde verneint und ein Schild an der Wand wies mich mittels eines Paragraphen darauf hin, dass die Erkennungsdienstlichen Maßnahmen notfalls auch mit Gewalt durchgeführt werden könnten. Ich könne aber mit Hilfe eines Anwalts im Nachhinein der Maßnahme widersprechen, wozu er mir auch raten würde. Meine Frage, wer die Maßnahme angeordnet hätte, wurde mir mit einem Buchstabenabkürzung beantwortet, deren Bedeutung mir die anwesenden Beamten aber nicht erklären konnten oder wollten. Es wurden meine Fingerabdrücke von beiden Händen (alle Finger und komplette Hand), in doppelter Ausführung genommen, sowie erneut Fotos, offensichtlich für die Verbrecherkartei,gemacht.

Zurück in der Zelle betätigte ich nach kurzer Zeit die Klingel, es muss mittlerweile etwa 18.00 gewesen sein, um darum zu bitten meinen Rechtsanwalt anrufen zu können, da ich anfing zu befürchten auch noch die Nacht in der Zelle zuzubringen zu müssen. Wieso hast du das denn nichtvorher gefragt? Kommt hier komisch. Dies konnte der Polizist nicht entscheiden, versprach mir aber, seinen Vorgesetzten zu informieren und ihn zu mir zu schicken. Als nach einer geschätzten halben Stunde immer noch nichts passiert war, schellte ich erneut – ich fühlte mich zu diesem Zeitpunkt schon völlig ausgelaugt und fertig, was man mir auch anzusehen schien, da die Beamtin mit der ich sprach mir sagte es würden „jetzt erstmal die Sanitäter kommen“.

Zum Glück bestätigte sich meine erste Befürchtung, nun auch noch in eine psychiatrische Klinik verlegt zu werden, nicht (nichts erschien mir mehr unmöglich), sondern der Polizeisanitäter holte mich ab und wir gingen in seinen Behandlungsraum. Physiologisch wies ich zu diesem Zeitpunkt eine ausgeprägte Hypertonie (hoher Blutdruck) und einen sehr schnellen Puls auf. Die Vermutung, dass ich vermutlich absolut dehydriert war, schien plausibel, denn außer eine Tasse Kaffe zum Frühstück und einen kleinen Plastikbecher Tee, den ich nach mehrmaliger Nachfrage erhalten hatte, hatte ich den ganzen Tag noch nichts getrunken. Hier kam ich das erste Mal wieder etwas zur Ruhe und hatte das Gefühl als Mensch ernst- und wahrgenommen zu werden. Der Beamte sagte mir dann auch, dass er gehört hätte, dass ich vermutlich in der nächsten Stunde entlassen würde.

Nach einem anschließenden weiteren kurzen Aufenthalt in der Zelle erhielt ich gegen 19.30 tatsächlich alle meine Sachen (bis auf das Letherman Tool) zurück und konnte die Polizeiwache verlassen.

Bis zum heute weiß ich nicht was mir eigendlich vorgeworfen wurde. Meinen Anwalt habe ich bereits kontaktiert und es wird sich wohl in den nächsten Wochen zeigen wie es weiter geht. Mein vorrangiges Ziel ist natürlich mit meinen Fingerabdrücken und meinen Fotos wieder aus der Datei des LKAs heraus zu kommen.

Ich kann sagen, daß die Ereignisse vom Samstag das schlimmste sind was mir in meinem Leben bisher passiert ist. Die Aussage das Freiheitsentzug mit das brutalste ist, was man einer menschlichen Seele antun kann, kann ich voll bestätigen – nie zuvor habe ich mich so ängstlich und hilflos gefühlt.

Das man Angst haben muss, und die habe ich im Moment noch, auf einer friedlichen Demonstartion scheinbar grundlos von der Polizei verprügelt oder verhaftet zu werden, kommt in meinen Augen faktisch einer massiven Einschränkung des Demonstrationsrechts gleich.

Ebenfalls schockierend fand ich wie der Staatsapperat einmal ins Rollen gebracht, nicht wieder zu stoppen war. Persöhnlich kann man wohl kaum einem der Beteiligten der Exekutive einen Vorwurf machen – ein Jeder der Beteiligten konnte sich darauf berufen nur Befehle und Anweisungen ausgeführt zu haben. Diese Argumentation habe ich bisher nur von Angehörigen ehemaliger Unrechtsregimen gehört – ich habe mir eigendlich immer verboten ernsthaft zu glauben, daß so etwas im Rechtsstaat Bundesrepublik Deutschland tatsächlich möglich ist – wurde aber schmerzlich eines besseren belehrt.

Bug: Snow Leopard's dynamic_cast und explizit instanziierte C++ Templates

2009-09-06T03:32:00.000-07:00

Derzeit arbeite ich an einem Projekt welches ich auf dem Mac (allerdings nicht für den Mac) entwickle. Dabei verwende ich unter anderem auch gerne die RTTI (RunTime Type Information) Fähigkeiten von C++ die mir unter anderem auch sichere Downcasts zur Verfügung stellen (Ist ein Downcast nicht möglich wird der Nullpointer zurückgegeben). Das alles klappt durchaus gut, es sei denn ich schreibe eine Lib in der ich bereits die Templates instanziiere die ich später in meiner Applikation nutzen will. Alles kompiliert zwar wunderbar und das Template lässt sich ebenfalls nutzen sobald ich aber auf Polymorphie zurückgreife wird es hässlich, da anscheinend die Typinformationen verloren gehen und dynamic_cast nicht mehr in der Lage ist richtig zu arbeiten.

Der ganze Fehler lässt sich mit folgendem Testfall reproduzieren:



//TestLib.hpp
class Base {
public:
    virtual ~Base() {}
};

template <typename T>
class Derived : public Base {
public:
    Derived();
};

/*TestLib.cpp
* compile with: g++ -dynamiclib TestLib.cpp -o libTestLib.dylib
*/
#include "TestLib.hpp"
#include <typeinfo>
#include <iostream>

template <typename T>
Derived<T>::Derived() {
    std::cout << typeid(*this).name() << std::endl;    
}

template class Derived<int>;

Wie man in der letzten Zeile sieht wird das Template Derived explizit mit int in TestLib.cpp instanziiert. Diesen Typen werden wir jetzt in einer kleinen Anwendung etwas durch die Typhierarchie scheuchen und ein sehr seltsames Verhalten beobachten.


/* main.cpp
* compile with: g++ -L. -lTestLib main.cpp -o main
*/
#include "TestLib.hpp"
#include <iostream>

int main() {
    Derived<int>* i = new Derived<int>();
    std::cout << typeid(*i).name() << std::endl;
    Base *o = i;
    std::cout << typeid(*o).name() << std::endl;
    std::cout << o << std::endl;
    std::cout << dynamic_cast< Derived<int>* >(o) << std::endl;
    std::cout << typeid(*o).name() << std::endl;
    delete i;
}

Wir erhalten folgende Ausgabe:


7DerivedIiE
7DerivedIiE
0x100100080
0
7DerivedIiE

Die Typid verändert sich nicht und trotzdem liefert ein gültiger Downcast den Nullpointer zurück. Ich habe den Code ebenfalls unter FreeBSD und DragonflyBSD getestet, in beiden Fällen war der Downcast erfolgreich. Meines Wissens tritt dieses Verhalten erst seit Snow Leopard auf, aber da ich derzeit nirgends eine aktuelle Version von Leopard laufen habe kann ich nicht testen ob es sich hier um einen neuen Bug handelt.

Der einzige Workaround der mir derzeit einfällt ist die Instanziierung des Templates in die Compilezeit der Anwendung zu verlegen.

UPDATE: Mal ein delete nachgebessert, nicht das sich hier noch jemand beschwert das mein Testcase leakt :P

Ein Hackerspace für Münster und Umgebung.

2009-08-15T09:55:00.001-07:00

Kaffee ist eine wunderbare Sache, vor allem wenn man ihn trinkt während man Ideen ausarbeitet. Heute war wieder einer dieser Tage. Angestachelt vom CRE zum Thema Hackerspaces hat ein Freund von mir den Entschluss gefasst ein solches Projekt in die Wege zu leiten. Ein Name war schnell gefunden: Warpzone.

Die Grundidee der Warpzone ist es, ein angemessenes Umfeld für kreative Köpfe allen Alters und Geschlechts zu bieten in dem sie sich frei entfalten können. Ein Stück Kultur also. Während so ziemlich jede Subkultur einen Platz hat an dem sie Freitag und Samstag abends rausgeht und sich selbst feiert, sind Nerds und Hacker oft isoliert im stillen Kämmerlein. Das ist hin und wieder schon gewünscht aber sozialer Kontakt wird doch schon mal hin und wieder vermisst und unter Gleichgesinnten ist man oft zu kreativen Leistungen im stande die man selber nicht für möglich gehalten hätte.

Was soll die Warpzone werden? Atmosphäre hat eine ziemlich motivierende Kraft und genau das soll die Warpzone bieten. Wie die C-Base soll sie ihren eigenen Charakter entwickeln und sich mit ihren Besuchern weiterentwickelt. Ihr hab eine Idee wie man das Treiben in der Zone noch verbessern kann? Klasse, such dir ein paar Leute und Gründe eine Initiative die das ganze umsetzt. Außerdem soll mindestens einmal die Woche die ein Vortrag gehalten werden, jeder der etwas zu erzählen hat und etwas präsentieren will, sei es eine Neuentdeckung die man umbedingt bekannter machen will oder ein Projekt das man selber an den Start gebracht hat. Bringt euch ein und erschafft etwas!

Was soll die Warpzone nicht werden? Sie soll kein Stammtisch werden in der man sich ein oder zweimal im Monat trifft und redet was man denn alles so gemacht hat. Das kann man im Zweifelsfall auch in einer Kneipe. Sie soll kein dröger Raum mit ein paar Stühlen sein in der in Redner an einem Flipchart stundenlang referiert. Wer die Warpzone betritt verlässt die normale Welt.

Nun handelt es sich bei einem solchen Projekt um ein aufwändiges Unterfangen, braucht man doch Räumlichkeiten, Möbel und einfach angemessene Infrastruktur (Nerds brauchen Netz und Werkzeug). Vor allem brauchen wir aber erst einmal Leute und Ideen mit denen sich ein solches Projekt durchziehen lässt. Im Moment sind wir zwei und die Idee ist gerade mal ein paar Stunden alt. Aber bereits eine Menge Input der sich bereits realisieren lässt, jetzt fehlst nur noch DU!

Ernsthafte Interessenten erreichen mich am besten über Jabber oder Twitter (siehe mein Profil). Also meldet euch und schafft ein Stück Hackerkultur im kreativen Vakuum ;)

UPDATE: Wir habe inzwischen einen Chatroom auf irc.freenode.org #warpzone und eine Mailing Liste

Auch ich leiste meinen Beitrag

2009-08-14T11:47:00.001-07:00

Auch wenn ich der Partei nicht angehöre, konnte ich einem Remix des Plakates nicht widerstehen :D

Podcasts und Chaosradio Express

2009-08-09T13:56:00.001-07:00

Heute will ich mal nicht von irgendetwas technischem schreiben sondern mich mal mit dem Medium Podcast befassen, genauer mit Chaosradio Express, einem "Spin-Off" der Mutter aller deutschen Nerd-Podcasts: dem Chaosradio. (vor allem da wir Tim damit bestechen sollen Folgen zu releasen :D)

Für mich selber wurde CRE eine ansprechende Alternative als es im original Chaosradio immer mehr um das Thema Überwachung und Politik ging. Versteht mich nicht falsch, das sind wichtige Themen, aber auf Weg in die Stadt oder im Zug hab ich ganz einfach auch mal gerne etwas was mich nicht total aufregt sondern "weiterbildet" (den Wutclown kann ich auch zuhause noch prügeln ^^).

CRE ist für mich ein Ansporn mich mit Sachen zu befassen auf die ich oft selber gar nicht so ohne weiteres komme, sei es nur weil das Lesen von Dokumentation in vielen Fällen einfach zu mühselig ist. Der Mensch ist halt ein faules Tier.

Was gefällt mir besonders gut an CRE? In erster Linie sind es die sehr technischen Themen. Meistens im Bereich Betriebssysteme oder Programmiersprachen (jeder der mich kennt weiß das ich da schnell in Sammelwut verfallen und teilweise schon selber die Übersicht verliere ^^). Hier bietet CRE eine ziemlich reichhaltige Sammlung auch an etwas esoterischeren Themen wie z.B. der Sprache Dylan (von der ich bis heute keinen lauffähigen Compiler gefunden habe -_-). Ein besonderes Highlight war für mich der C++ Podcast mit Pavel Mayer, vor allem wegen der grandiosen Buchtipps (mehr davon! Ich bin süchtig nach Fachliteratur!). Auch sehr spannend war der Podcast über FreeBSD. Ich muss zu meiner Schande gestehen das ich mich mit BSD erst befasst habe als sich einige wenige in der Linuxwelt gegenüber ZFS (gibt es auch einen CRE zu ;) in meinem Augen ziemlich blöd verhalten haben (Erläuterung was ich damit meine bitte in den Kommentaren nachlesen;) ). CRE hat mir hier eine sehr schöne Einführung in die BSD Welt gegeben.

Was verspreche ich mir von CRE? In erster Linie ist es Futter fürs Hirn wenn meine Hände mit etwas anderem beschäftigt sind (trainieren oder einfach unterwegs sein). Ich möchte mich am liebsten permanent weiterbilden und das überall wo ich bin. Podcasts bieten dort eine Möglichkeit Neugierde auf bestimmte Themen zu machen oder einen einfach mal in die richtige Richtung zu schubsen wenn man selber den Wald vor lauter Bäumen nicht sieht. (You are doing it WRONG!). Auch bieten sie einem ein gewisses Gefühl an Zugehörigkeit, man sieht halt das man mit seiner Nerdigkeit nicht ganz alleine ist. Ein Gefühl was man auf dem Lande gerne mal bekommt ^^. Sie sind ein Sprachrohr unserer Kultur, einem Haufen Coder, Admins und Katzenliebhaber. Vor allem woher diese Katzenbilder eigentlich kommen war mal sehr interessant zu erfahren (auch wenn ich den Podcast im Fitnessstudio gehört habe und im Fernsehen gerade eine Raubkatze eine Kürbis verspeist hat... ich glaube ich habe selten so doof gegrinst...i can haz pumpkin?).

Für die Zukunft würde ich mir sicher noch mehr technisches Zeug wünschen, das Problem ist da aber sicherlich das es auch an geeigneten Leuten gibt. Klar könnte ich mich mit Tim in einen Raum setzen und 2 Stunden über OpenSolaris quatschen, aber ob das Endresultat jetzt so brauchbar wäre stell ich einfach mal dahin. Oft sind es auch Podcasts die man gar nicht so auf dem Schirm hatte die einen begeistern, wie z.B. über das Thema Kaffee. Plötzlich rennt man von einem Laden zum anderen und wundert sich warum man das nicht schon viel früher gemacht hat. (Auch wenn ich immer noch kein schlechtes gewissen habe diese Instant Trinkpisse von Ja! zu trinken ^^)

So. Ich habe keine Ahnung ob das Bestechung genug ist. Ich habe wieder mal das Gefühl von Hölzchen auf Stöckchen gekommen zu sein und nur um den heißen Brei geredet zu haben. Aber bei Texten ohne geschweifte Klammern tu ich mich manchmal sehr schwer ^^.

Erm... Pic unrelated!

Dieses war der erste Streich, doch der ZWEITE folgt sogleich! (Incoming Blogkette FTW!)
Und "previously on Lo... erm Blogkette". Der Blogpost mit dem alles angefangen hat!

C Funktionen aus C# rufen

2009-07-20T14:49:00.000-07:00

Für mich ist es immer wichtig das Sprachen nicht isoliert dastehen. Ich möchte von jeder Sprache oder Laufzeitumgebung ungehindert mit dem System kommunizieren. Da ich mich meistens auf diversen UNIX Systemen herumtreibe ist das größtenteils C. Gerade im Moment hat es mir C# ein wenig angetan und auch hier kann man ohne weiteres mit dem System schnacken. Darum hier mal ein kleines Beispiel das eventuell dem ein oder anderen weiterhilft. Das ganze wurde auf MacOSX mit Mono getestet läuft aber genauso gut unter *BSD und Linux.

Als erstes legen wir eine kleine Library an die die Funktion enthält die wir später aufrufen wollen.


//compile with gcc -dynamiclib test.c -o test.dylib
#include 

int test(const char* s) {
    printf("Printing from C: %s\n",s);
    return 666;
}

Nichts dramatisches, unser Programm soll lediglich etwas Text übernehmen ausgeben und einen Integer an unser C# Programm zurück liefern. Nach dem kompilieren erhalten wir eine dynamische Bibliothek mit Namen test.dylib.

Unser C# Code ist ähnlich spektakulär aufgebaut:


using System;
using System.Runtime.InteropServices;

class PTest {
    [DllImport("test.dylib")]
    public static extern int test(string s); 

    public static void Main() {
        Console.WriteLine(test("this is a test"));
    }   
}

Eine interessante Anmerkung nebenbei: test.dylib muss zum Zeitpunkt der Übersetzung nicht existieren.

Jetzt ist man also ohne weiteres in der Lage mit Libs wie z.B. libzfs oder libdtrace von C# aus zu kommunizieren um stark integrierte (aber logischerweise nicht mehr plattformunabhängige) Applikationen zu schreiben.

"Spielt nicht mit Schmuddelkindern!"

2009-07-11T19:05:00.001-07:00

Die Junge Union ist entrüstet über den Zuspruch den die Piratenpartei unter Studenten findet, spricht gar von einem Mangel an Werten. Es muss weh tun wenn man keiner mehr mit einem spielen will.

Elektronische Revolutionen: Mit TOR gegen Zensur

2009-06-28T06:18:00.000-07:00

Gerade in den letzten Wochen macht vor allem ein Thema immer wieder die Runde: Zensur. Andere Länder leiden bereits unter ihr und unsere Regierung ist nun auch fröhlich dabei Stück für Stück eine solche Infrastruktur zu errichten und gleichzeitig aber Länder zu verurteilen die diese bereits haben.

Des weiteren werden wir im Moment auch Zeuge eines Volksaufstandes wie wir ihn noch nie in der Geschichte der Menschheit erlebt haben. Die Bevölkerung des Iran erhebt sich gegen das Regime und nutzt das Internet als Medium der Kommunikation in die ganze Welt. Da gerade der Iran über Kontrolltechnologien verfügt die wir uns in unseren wüstesten Albträumen nicht wünschen würden brauchen diese Menschen einen Weg diese Sperren zu umgehen. Einer der prominentesten ist sicherlich The Onion Router, ein anonymisierendes Netzwerk welches es Menschen ermöglichet Zensur zu umgehen und Information aus oder einzuschleusen. Das schöne an TOR ist: jeder kann praktisch mitmachen und ich will hier mal 3 Methoden vorstellen wie das geht.

Relays

TOR besteht aus vielen Knoten die Daten untereinander weiterleiten. Die Verbindung zwischen diesen Knoten ist in TOR komplett verschlüsselt und lässt praktisch kaum Rückschlüsse auf Absender und Ziel zu (sicher ist dies mit einem hohen technischen Aufwand auch zu bewerkstelligen). Ein solches Relay ist relativ einfach zu konfigurieren und spendet dem Netzwerk Bandbreite. Wichtig ist hierbei das von einem Relay aus keine Verbindung aus dem TOR Netzwerk heraus aufgebaut werden kann (man hat also nicht zu befürchten das kriminelle Inhalte durch ein Relay aufgerufen werden).

Eine Konfiguration für ein Relay wäre z.B. folgende:


SocksPort 0
DirPort 443
ORPort 80
ExitPolicy reject *:*

Das ganze lässt sich einfach über tor -f /pfad/zur/config starten. Man sollte allerdings sichergehen das DirPort und ORPort durch die Firewall erreichbar sind. (Protip: TOR als Solaris Zone ;) ). Mehr Infos zu Relays findet man auch auf der TOR Seite. Die ExitPolicy sichert das man von diesem Knoten aus das TOR Netzwerk nicht verlassen kann, diesen Eintrag sollte man auf keinen Fall weglassen wenn man sich nicht genau der Konsequenzen bewusst ist. Mehr dazu im Abschnitt über Exit Nodes.

Bridges

Diese speziellen Relays werden "geheim" gehalten. Da Regierungen gerne mal Zugangspunkte zum TOR Netzwerk blockiert verlangt es nach Zugangspunkten die in keiner Liste auftauchen. Durch diese kann man dann anonym ins Netz kommen um z.B. brisantes Material aus Krisengebieten herauszuschleusen. Anhand eines Fingerprints kann man sich mit solch einer Bridge verbinden.


SocksPort 0
ORPort 443
BridgeRelay 1
Exitpolicy reject *:*

Es gibt unter anderem eine Initiative die sich dafür einsetzt TOR Bridges für den Iran bereitzustellen.

Exit Nodes (VORSICHT!)

Diese Dinger sind nicht ganz ohne. An einem Exit Node wird das TOR Netzwerk verlassen und es werden Verbindungen ins unverschlüsselte Netz aufgebaut. Hierbei kann es sich auch um strafbares Material handeln, wer also nicht umbedingt unangemeldeten Besuch von der Polizei haben möchte sollte sich absichern oder halt darüber im klaren sein was hier passiert. Um einen Exit Node einzurichten entfernt man lediglich die Exit Policy aus der Relay Konfiguration. Ich übernehme keine Verantwortung für entstehende Schäden. YOU HAVE BEEN WARNED!Auch wenn die Beschlagnahmung eines TOR Servers in der Regel nichts bringt da keine verwertbaren Daten anfallen, sollte man sich nicht umgedingt darauf verlassen das dies als Argument gilt die Maschine nicht mitzunehmen.

Relay oder Bridge? Was hilft am meisten und wann?

Diese Frage habe ich mir zu Anfang auch gestellt. Bridges sind sehr wichtig, allerdings bringt es nicht viel dies vom heimischen DSL Anschluss aus zu machen, da deutsche Provider innerhalb von 24 Stunden die Netzverbindung kappen. Hat man allerdings das Glück eine feste IP zu haben oder einen Anbieter ohne 24h-Disconnect sollte man sich überlegem eine Bridge aufzusetzen. Bridges fressen im allgemeinen recht wenig Bandbreite, Relays hingegen stehen eigentlich permanent unter Strom und verteilen Daten, es ist also nicht unklug den Transferrate etwas anzupassen wenn man nicht komplett auf seine Verbindung verzichten will. Dies geht über z.B. folgende Konfigurationseinträge:


RelayBandwidthRate 50 KBytes  
RelayBandwidthBurst 200 KBytes

In meinen Augen ist TOR ein immer wichtiger werdendes Netzwerk das es Menschen ermöglicht sich über staatliche Willkür hinwegzusetzen und eventuell sogar Leben zu retten oder gar ganze Regierungen zu stürzen. TOR wird heute schon genutzt um die Chinesische Firewall zu umgehen und wird hoffentlich immer mehr Menschen die in Unterdrückung leben die Möglichkeit geben sich Gehör zu verschaffen.

Find more videos like this on www.truveo.com.

LLVM: Neue Compiler braucht das Land!

2009-06-16T09:54:00.000-07:00

In letzter Zeit macht die Low Level Virtual Machine immer mehr von sich Reden. Blöderweise ist der Name doch ein wenig verwirrend und man denkt schnell an die Java VM oder dergleichen. In Wirklichkeit handelt es sich um ein Compilerframework (und eine eigene Sprache) welches einem sehr interessante Möglichkeiten eröffnet. Apple verwendet LLVM unter anderem um OpenCL zu realisieren.
Was mich besonders an LLVM interessiert sind vor allem die Möglichkeiten zur Analyse von Fehlern die es bietet. Hier mal gcc und clang (ein C/C++/ObjC Frontend für LLVM) im Vergleich.


$ gcc-4.2 -fsyntax-only t.c
t.c:7: error: invalid operands to binary + (have 'int' and 'struct A')
$ clang -fsyntax-only t.c
t.c:7:39: error: invalid operands to binary expression ('int' and 'struct A')
return y + func(y ? ((SomeA.X + 40) + SomeA) / 42 + SomeA.X : SomeA.X);
                     ~~~~~~~~~~~~~~ ^ ~~~~~

Clang nagelt den Fehler auf Zeile UND Spalte fest, nebenher verbraucht er zum kompilieren auch noch weniger Speicher und ist auch noch schneller. Ziemlich beeindruckend.

LLVM wird sicherlich den Compilermarkt in der Opensource Welt nachhaltig verändern. So gibt es z.B. Ambitionen FreeBSD komplett mit Clang anstelle von GCC zu übersetzen.

Auch die Rubyfraktion will von LLVM profitieren und so experimentiert das MacRuby-Projekt ebenfalls mit LLVM um Ruby auf dem Mac zu beschleunigen.

Für alle die jetzt neugierig geworden sind gibt es hier einen interessanten Tech Talk zum Thema, genauso wie einen Podcast vom Chaosradio Express

Stoppschild für die SPD

2009-06-16T09:14:00.000-07:00

Ich wollte eigentlich politischen Content auf diesem Blog außen vor lassen, aber die derzeitige politische Lage veranlasst mich dazu. Die SPD winkt das Zensurgesetz der CDU brav durch wie es sich schon angedeutet hat. Ich für meinen Teil sehe beide Parteien somit für diese Bundestagswahl als unwählbar an. Meine Stimme wird weder die Stasi CDU noch die Kohlekumpel und BILD-Leser SPD kriegen.

Vortrag: LDC - ein D Frontend für LLVM

2009-06-15T11:54:00.000-07:00

Im Moment bin ich extrem auf der Suche nach einer modernen Sprache mit der sich ein elegantes Framework für das Programmieren von Applikationen realisieren lässt (schon frustrierend wie wenig der Markt da wirklich bietet, vor allem wenn es darum geht auch auf exotischeren Plattformen zu laufen). D hat einige interessante Ansätze die die Probleme vieler Sprachen löst. Mit LDC stehen jetzt auch die Chancen gut diese Sprache auf weitaus mehr Plattformen zu bringen als bisher, darum habe ich hier mal einen kleinen Vortrag verlinkt der das Projekt erklärt. Leider ist die Tonqualität ziemlich schlecht aber man kann es gerade noch so aushalten.

LDC from Tom Stachowiak on Vimeo.

Vortrag: Inside the Mac OS X Kernel

2009-06-10T05:54:00.001-07:00

Diesen Vortrag wollte ich eigentlich schon vor lange Zeit mal verlinken, aber irgendwie habe ich das immer verschwitzt. Sollte sich jeder mal ansehen der sich für Kernel Designs interessiert. Vor allem die Mach IPC und IOKit sind wirklich einen Blick wert.

Vortrag: Threading in DragonflyBSD

2009-05-21T20:13:00.000-07:00

Programmierung: Ein kleiner Einblick in D

2009-04-23T03:50:00.000-07:00

Jeder der sich schon mal mit C++ befasst hat kommt irgendwann mal an den Punkt an dem er denkt "Oh man geht das nicht auch einfacher?". Fakt ist: Kaum eine Sprache ist so schwer zu lernen und so aufwändig durch den Compiler zu kriegen wie diese, dazu kommen noch einige C Altlasten und vor allem der Preprozessor. Oft ertappt man sich dabei möglichst trickreich die Sprache aus den Angeln zu hebeln (mir fällt da spontan das sizeof Voodoo ein um zur Compilezeit herauszufinden ob ein Cast gemacht werden kann oder nicht). Viele dieser Tricks basieren auf ausgefuchsten C++-Templates und gerade die sorgen bei vielen Programmierern für spontanes "schreiend im Kreis rennen" (schon mal mit Typelists gearbeitet? :P). Hier springt D von Digitalmars in die Bresche, oder versucht es zumindest. Ein paar Highlights möchte ich hier beleuchten.

Keine Rückwärtskompatibilität

Was in C++ Anfangs noch Mittel zum Zweck war ist inzwischen zu einem unangenehmen Anhängsel geworden. Vielen geht schon beim Anblick eines const char* die Sause geschweige denn der ganze Mist den Arrays mit sich schleppen. Vieles davon bessert die STL schon lange nach (std::string und std::vector sei dank) ein wenig übel ist der Nachgeschmack dennoch... zumindest für mich ;). Besonders "schön" ist da vor allem der Preprozessor hat er doch keine Ahnung was es mit der Sprache auf sich hat und setzt nur fröhlich irgendwelche Markos oder Definitionen ein. Entscheidungen die zur Compilezeit getroffen werden gehen an im vorbei da er ja schon lange fertig ist wenn es zur Sache geht. Hier kommen dann bei C++ die Templates zum Schuss and genau dort wird es für viele kompliziert. D bietet hier ein eigenes Sprachmittel: static if.


import std.stdio;

class A {}
class B : A {}
class C {}

void main(string[] args) {
    static if (is(B : A)) {
        writefln("B erbt von A");
    } else {
        writefln("B erbt nicht von A");
    }
    static if (is(C : A)) {
        writefln("C erbt von A");
    } else {
        writefln("C erbt nicht von A");
    }   
}

Ohne große Umwege lässt sich hier das Gewünschte ausdrücken. Ein Preprozessor würde hier versagen da er keine Ahnung von Sprachmitteln wie Vererbung hat, man wäre also auf C++-Template Voodoo angewiesen, hier ist schon alles in der Sprache drin.

Besonders Templates wurden in D stark überarbeitet, da gerade hier sich Schwächen auftuen die zu sehr großen Problemen führen können. Das ganze Elend fängt schon bei der Syntax an. Da die Spitzen Klammern die in C++ verwendet werden auch irrtümlicherweise als größer oder kleiner-Operatoren angesehen werden können (in solchen Situationen muss man dem Compiler meist noch unter die Arme greifen). D benutzt hier eine etwas gewöhnungsbedürftige Syntax die allerdings diese Probleme umgeht da sie einen Operator verwendet der im Normalfall nur unär ist hier aber binär verwendet wird, nämlich den !-Operator.


import std.stdio;

template Foo(T) {
    T a = 666;
}

void main(string[] args) {
    alias Foo!(int) tmp;
    writefln("%d",tmp.a);
}

Hier taucht auch gleichzeitig eine andere Besonderheit von D auf, das alias. Dieses Schlüsselwort macht eigentlich nichts anderes als das was wir von C/C++ kennen, denn im Gegensatz zu diesen Sprachen verfügt D über echte Typedefs die auch überladen können.


import std.stdio;

typedef int bla;

void test(int a) {
    writefln("int: %d",a);
}

void test(bla a) {
    writefln("bla: %d",a);
}

void main(string[] args) {
    int a = 666;
    bla b = 777;
    test(a);
    test(b);
}

Eine andere Kleinigkeit die bei unserem Template Beispiel aufgefallen ist, ist das es sich bei diesem Template weder um eine Template-Klasse noch um eine Template-Funktion handelt. Es ist einfach nur ein Template. Das bietet eine weitere Interessante Möglichkeit, nämlich Mixins.


import std.stdio;

template Foo(T) {
    void test() {
        writefln("Foo.test");
    }   
}

class Test {
    public {
        mixin Foo!(int);
    }   
}

void main(string[] args) {
    Test t = new Test;
    t.test();
}

Ein nicht ganz so offensichtliches Feature ist hier der Garbage Collector und der Fakt das hier nicht mit Pointern (keine Sorge die gibt es auch noch) sondern mit Referenzen gearbeitet wird wenn eine Klasse instanziiert wird. Hier scheiden sich sicherlich die Geister denn was bei Systemprogrammierung durchaus Sinn macht, kann beim Programmieren von Applikationen schnell zur Katastrophe werden und in wirklich scheusslichen Speicherlecks enden (oder pro-aggressiven Einsätzen von auto_ptr, shared_ptr und Konsorten).

Was auch sehr viel Spass macht ist das Wegfallen von Forward-Declarations. So geht z.B. folgendes:


import std.stdio;

void foo() {
    bar();
}

void bar() {
    writefln("foobar");
}

void main(string[] args) {
    foo();
}

Kritikpunkte

D ist eine tolle Sprache und räumt mit einigen Sachen auf die bei C++ zu Verwirrung oder schlechtem Programmierstil führen auf. Dennoch ist die Unterstützung der Sprache noch mehr als dürftig da es im Endeffekt nur sehr wenige Compiler für sie gibt die im Grunde alle auf dem DMD von Digitalmars basieren. Auch fehlen mir einige In-Depth Einblicke die in für C++ zu Hauf gibt und gerade auf der Low-Level Seite von mir schmerzlich vermisst werden (bei Nachfrage wird man dann auch gerne mit der Standardantwort "read to code" abgefrühstückt). Auch ist die eine Aufspaltung der D Community durch 2 unterschiedliche "Standard"-Bibliotheken mehr als offensichtlich und auch nervig (Flamewars gibt es wirklich schon genug). Während ein Compiler Phobos nutzt kommt der andere nur mit Tango daher. Derzeit wird auch an D2.0 herumgeschustert und man kriegt langsam das Gefühl als werde auch diese Sprache immer überladener. Dennoch ist die Sprache so entworfen das einem nicht gleich pfundweise Fehlermeldungen um die Ohren geschleudert werden da gerade auf obskure veraltete Syntax verzichtet wurde. Für alle die aber etwas gesucht haben das so schnell wie C/C++ ist und mit viel vom Java/C# Komfort daherkommt ist diese Sprache sicherlich mal einen Blick wert. Java? Ja, D verzichtet unter anderem auf Multivererbung und setzt dafür auf Interfaces. Auch Schlüsselwörter wie final, abstract und synchronized sind oft einfach hilfreich wenn es darum geht schnell und leserlich das auszudrücken was man meint.

Das hier sind nur ein paar sehr kleine Details von dem was D ausmacht und bei weitem noch nicht alle. Sollte Interesse bestehen kann ich gerne auch noch etwas auf Details eingehen (vor allem Closures dürften dein ein oder anderen sicher interessieren, das sprengt hier aber glaub ich etwas den Rahmen ^^).

Twitscher twitscher!

2009-04-18T05:31:00.000-07:00

Aufgrund chronischem Spieltriebs hab ich mich einfach mal dazu entschlossen mich bei Twitter anzumelden. Da ich immer mal wieder Links finde die ich für mehr oder weniger für interessant erachte (und es irgendwie sinnlos ist jedesmal einen Blogartikel drüber zu schreiben) gibts die jetzt unter meinem neuen Twitteraccount. Follow me.... i know where they hide their cookies!

C++: ABI zur Laufzeit entwirren

2009-03-25T09:37:00.000-07:00

Die C++ typeinfo ist ja immer so eine Sache. Einige Compiler entwirren die Namen, andere wieder nicht. G++ gehört zu den Compilern die das nicht von sich aus machen, aber man kann sich leicht Abhilfe schaffen.


#include <typeinfo>
#include <iostream>
#include <cxxabi.h>

#define HAVE_CXA_DEMANGLE

#ifdef HAVE_CXA_DEMANGLE
const char* demangle(const char* name)
{
   char buf[1024];
   unsigned int size = 1024;
   int status;
   char* res;
   res = abi::__cxa_demangle(name,
     buf,
     &size,
     &status);
   return res;
}
#else
const char* demangle(const char* name)
{
   return name;
}
#endif

int main()
{
   std::cout << typeid(std::cout).name();
   std::cout << std::endl;
   std::cout << ::demangle(typeid(std::cout).name());
   std::cout << std::endl;
   return 0;
}

/* Ausgabe :
[raichoo@sparkster:~]> ./a.out 
So
std::ostream
*/

Haiku: A blast from the past

2009-02-15T13:38:00.000-08:00

Ich hab ja schon immer gerne mit Betriebssystemen der unterschiedlichsten Art rumgespielt und vor vielen Jahren bin ich auch mit BeOS in Berührung gekommen. Leider war die Liebe nicht von langer Dauer da Be irgendwann Geschichte war und damit auch dieses wunderbare Betriebssystem. Es war schon unglaublich was man damals aus einer Kiste an Performance rausholen konnte. Viele Systeme ächzen heute noch und dem was BeOS damals schon geleistet hat, und zwar auf weitaus schlechterer Hardware als heute. Umso mehr habe ich mich über das Projekt Haiku gefreut das es sich zur Aufgabe gemacht hat ein freies BeOS zu entwickeln. Was es mir besonders angetan hat ist die reichhaltige API. Keine kilometerlangen Abhängigkeitslisten mehr Haiku bietet alles was man braucht in sogenannten Kits. Alles ist sehr stark integriert und greift wunderbar ineinander. Vor allem der einheitlich Desktop hat seine Vorteile. Während Projekte wie KDE und Gnome darauf ausgelegt sind auf möglichst vielen unterschiedlichen Systemen zu laufen hat Haiku "nur" eine Oberfläche welche sämtliche Vorteile des darunterliegenden Systems nutzen kann. Dies ist bei anderen Desktop nicht ohne weiters mögliche da sie sonst ihre Portierbarkeit verlieren würden. Ein weiterer Vorteil ist das das starten von Applikationen einfach rasend schnell wird. Wer gerne mit Systemen herumspielt sollte auf jeden Fall einen Stop bei Haiku einlegen. ;)

Testphase für 2009.04 hat begonnen

2009-01-09T12:45:00.000-08:00

Mit der Veröffentlichung von Build 105 für OpenSolaris geht es jetzt los mit der Entwicklung für den nächsten Release der Distribution, um auf das Developer Repository zuzugreifen genügt der folgende Befehl:


$pfexec pkg set-authority -O http://pkg.opensolaris.org/dev opensolaris.org

Mit Build 105 wird ZFS auf die neuste Version 14 gebracht (Vorsicht: ein Upgrade führt dazu das ältere Versionen und BEs von OpenSolaris nicht mehr auf die Daten zugreifen können!), des weiteren wird die NIC-Virtualisierung Crossbow eingeführt mit der es möglich ist komplette virtuelle Netzwerkkarten (inklusive eigener MAC-Addresse) zu erstellen.

Ruby 1.9.1 Preview2 selberbacken

2008-12-21T15:18:00.001-08:00

Im Moment spiele ich mal wieder mit diversen Skriptsprachen herum von denen eine Ruby ist. Leider läßt sich der aktuelle Preview nur mit ein paar Umwegen unter OpenSolaris backen. Darum hier ein kleines Patch damit Vorgang durchläuft. Ich übernehme wie immer keine Verantwortung für eventuelle Probleme ^^.


--- ext/curses/curses.c Tue Nov 11 12:00:39 2008
+++ ext/curses/curses.c Sun Dec 21 17:00:44 2008
@@ -410,6 +410,9 @@
 static VALUE
 curses_getch(VALUE obj)
 {
+#if defined(__sun)
+ eucwidth_t wp;
+#endif
     int c;
 
     rb_read_check(stdin);
@@ -416,7 +419,12 @@
     curses_stdscr();
     c = getch();
     if (c == EOF) return Qnil;
+#if defined( __sun)
+ getwidth(&wp);
+    if (ISPRINT(c, wp)) {
+#else
     if (ISPRINT(c)) {
+#endif
  char ch = (char)c;
 
  return rb_locale_str_new(&ch, 1);
@@ -1105,12 +1113,20 @@
 {
     struct windata *winp;
     int c;
+#if defined(__sun)
+ eucwidth_t wp;
+#endif
 
     rb_read_check(stdin);
     GetWINDOW(obj, winp);
     c = wgetch(winp->window);
     if (c == EOF) return Qnil;
+#if defined(__sun)
+ getwidth(&wp);
+    if (ISPRINT(c, wp)) {
+#else
     if (ISPRINT(c)) {
+#endif
  char ch = (char)c;
 
  return rb_locale_str_new(&ch, 1);

Aktivismus: "The Yes Men"

2008-12-14T05:58:00.000-08:00

Ich bin heute über einen sehr interessanten Link gestolpert der ausnahmsweise mal nichts mit Technik zu tun hat. Wirklich sehr sehenswert: The Yes Men

Schon krass was man unter dem Motiv der Gewinnmaximierung den Leuten alles verkaufen kann...

Nahtloses 64-Bit

2008-12-13T02:43:00.000-08:00

Mir fallen immer wieder Fragen auf die sich auf die 64-Bit Fähigkeit von OpenSolaris beziehen. Wie z.B. "Wo krieg ich die 64-Bit ISO?" oder "Unterstützt Solaris das überhaupt?".
Ja, Solaris baut sich je nach vorliegender Architektur passend zusammen (ein Vorteil der durch die hohe Modularisierung möglich ist), soll heißen: Die OpenSolaris Installations CD ist beides (bootet als LiveCD afaik aber nur im 32-bit Modus). Um herauszufinden ob die eigene Solarisinstallation auch 64-Bit unterstützt reichen folgende Befehle:


$ isainfo
amd64 i386
$ isainfo -vk
64-bit amd64 kernel modules

Mein System unterstützt also i386 und amd64 und die Kernelkomponenten nutzen das 64-Bit Instruktionsset. Ich kann nahtlos 32 und 64-Bit Programme miteinander mischen ohne das ich irgendwas besonderes dafür tun muss (der Grund warum es auf 64-Bit Solaris Systemen auch schon seit Ewigkeiten die Möglichkeit gibt Flash zu nutzen), es läuft einfach.

Amilo gone wild

2008-12-05T06:35:00.000-08:00

Seit einigen Wochen schlage ich mich schon mit meinem alten Amilo Pi1505 und OpenSolaris herum. Irgendwann hat es sich dazu entschlossen sich im Kreis zu drehen sobald es größere Mengen an Daten geschrieben oder gelesen hat. Wer sich für ein Tagebuch dieser Schnitzeljagd quer durch den Quellcode interessiert kann das Ganze auf defect.opensolaris.org nachlesen.
Lange Rede, kurzer Unsinn. Der Hund lag in der NCQ begraben. MDB lieferte mir folgende Werte:


uint32_t ahciport_pending_tags = 0x1
...
struct sata_pkt *[32] ahciport_slot_pkts = [ 0, 0, 0, 0, 0, usw.

Dieser Zustand ist allerdings recht beknackt. ahciport_pending_tags sagt uns das ein Kommando in Slot 0 noch aussteht, Slot 0 zeigt aber auf 0 was wiederum heißt: Nichts steht aus. Und da beißt sich die Katze in den Schwanz und die ankommende Anfrage dreht sich immer im Kreis.
Lösung dieses Problems ist es NCQ zu deaktivieren. Das geht über 2 Wege

Der erste geht über MDB. Wir booten dazu OpenSolaris mit der Kerneloption -kd. Das versetzt uns beim Bootvorgang sofort in den Debugger. Hier setzen wir folgenden Breakpunkt und gehen wie folgt vor:


::bp ahci`ahci_attach
::cont
....
sata`sata_func_enable/W 5
::cont

Das deaktiviert NCQ und das Problem ist Geschichte.

Jetzt hat man allerdings nicht wirklich Lust jedesmal solche Klimmzüge zu machen und für sowas ist die /etc/system da mit der wir bestimmte Kernelvariablen einfach selber setzen können ohne etwas neu zu kompilieren. Um das oben genannte festzuschreiben braucht man nicht mehr als folgende Zeile an die /etc/system anhängen:


set sata:sata_func_enable = 5

Des weiteren mag diese Kiste wohl den Bootsplash und den HCI1394 Treiber nicht, darum sollte man im Textmode booten und die Bootoption -B disable-hci1394=true anhängen. So gibt dann auch endlich mein Sorgenkind Ruhe ;)

Wireless LAN auf dem Thinkpad SL500

2008-12-05T06:24:00.000-08:00

Ich habe mir ja vor einiger Zeit ein Thinkpad SL500 zugelegt um es mit OpenSolaris zu bestücken, seltsamerweise wurde der WLAN Chip (Intel 5100 AGN) allerdings nicht erkannt obwohl der Treiber bereits seit einigen Wochen bereitsteht. Naja, so seltsam dann auch wieder nicht. Es fehlte einfach die Zuordnung zwischen ID und Treiber. Also erst mal herausfinden wie sich unser Chip zu erkennen gibt, dazu haben wir ja scanpci:


pci bus 0x0002 cardnum 0x00 function 0x00: vendor 0x8086 device 0x4237
 Intel Corporation PRO/Wireless 5100 AGN [Shiloh] Network Connection
 CardVendor 0x8086 card 0x1211 (Intel Corporation, Card unknown)
  STATUS    0x0010  COMMAND 0x0046
  CLASS     0x02 0x80 0x00  REVISION 0x00
  BIST      0x00  HEADER 0x00  LATENCY 0x00  CACHE 0x08
  BASE0     0x00000000fe1fe004  addr 0x00000000fe1fe000  MEM 64BIT
  MAX_LAT   0x00  MIN_GNT 0x00  INT_PIN 0x01  INT_LINE 0x05

Jetzt nur noch die passenden Werte in die /etc/driver_aliases übertragen.


# update_drv -a -i '"pciex8086,4237"' iwh

Viola, Wireless auf dem SL500 :)

OpenSolaris 2008.11: Interview und Präsentation

2008-12-04T14:48:00.000-08:00

Hier sind zwei nicht ganz uninteressante Videos die ich auf dem Blog von Redmonk gefunden habe.

Screencast: What's new in OpenSolaris 2008.11

2008-12-04T03:45:00.001-08:00

Ein zwölfminütiger Screencast über einige der neuen Features die OpenSolaris 2008.11 zu bieten hat mit Schwerpunkt auf Desktopfunktionalitäten.

OpenSolaris 2008.11 erschienen

2008-12-02T09:41:00.000-08:00

Nach über 6 Monaten Wartezeit ist OpenSolaris 2008.11 nun auf www.opensolaris.com erhältlich und es hat sich eine ganze Menge verändert. Während der erste Release noch sehr rudimentär war hat sich diese Version dem Desktop sehr viel mehr angenähert. Aktuellere Software, mehr Treiber und vor allem sind große Lücken in der Liste der Applikationen gefüllt worden. Ein paar der Highlights werde ich hier auflisten, dennoch ist dies nur ein kleiner Teil von dem was sich wirklich alles getan hat. Noch mehr neues hat Glynn Foster aufgelistet.

Einführungen zu OpenSolaris Technologien gibt wie Dtrace, ZFS und Beadm gibt es auf diesem Blog ebenfalls zu finden.

Gnome 2.24

Mit dem neuen Release wurde jetzt auch Gnome auf den neusten Stand gebracht. Für den inzwischen typischen Solaris Look sorgt natürlich wieder das Nimbus Theme

Firefox 3 und Openoffice 3

Ebenfalls mit von der Partie sind der neuste Firefox und die allerneuste Version von OpenOffice

Timeslider

Eines der Highlights ist sicherlich Timeslider. Im 15 Minuten Abstand werden Snapshots erstellt. Über den Tag verteilt werden diese dann jeweils stündlich archiviert, sowie täglich und wöchentlich. Wenn es zu eng auf der Platte wird räumt Timeslider einfach auf (Snapshots nehmen lediglich den Unterschied zwischen Filesystem und dem archiviertem Zustand an Blöcken in Anspruch). Um die Snapshots selber kümmern sich im Hintergrund diverse SMF Services, es wird also nicht nur der eingeloggte Benutzer versorgt sondern alle gewünschten Filesysteme (sehr praktisch für die beliebte Aufgabe gelöschte Dateien wiederherzustellen ;) )

Packagemanager mit neuen Repositories

Zu dem überarbeiteten Paketmanager kommen jetzt auch zusätzliche Repositories welche unter anderem Developer Releases, Sicherheitsupdates oder Community Pakete zur Verfügung stellen.

Network Automagic

Network Automagic wurde einem kompletten Facelift unterzogen. Auch wurde die Funktionalität erweitert. WLAN läßt sich nun genauso unkompliziert verwalten wie auch mehrere Netzwerkschnittstellen (was bei der alten Version nicht wirklich der Fall war).

SunStudio und Dtrace

Mit SunStudio Express enthält OpenSolaris eine komplette Entwicklungsumgebung mit Netbeans und den Sun Compilern und Debuggern. Netbeans enthält jetzt ebenso eine grafische Oberfläche für Dtrace mit dem Namen D-Light. Dtrace selber hat über die letzten Monate ebenso einige Updates erhalten wie z.B. den IP-Provider zum tracen von Netzwerkstack Aktivitäten.

ZFS 13 mit L2ARC

Auch ZFS ist in der Version 13 enthalten und unterstützt jetzt auch die L2ARC von OpenStorage die es einem unter anderem ermöglicht die Vorteile von SSD und HDD Platten zu vereinen indem einige wenige SSD Platten (oder auch nur eine) als Cache vor viele HDD Platten geschaltet werden. Somit kann man die Zugriffsgeschwindigkeit von SSD nutzen aber hat die Speichermasse von kostengünstigen HDD Platten.

Viele neue Treiber und Pakete

Dazu sind viele neue Treiber gekommen, vor allem Intel Chipsätze jeder Art werden inzwischen sehr gut unterstützt. Gleiches gilt inzwischen für erste SD-Card Reader und auch einige Webcams. Sollte das dennoch nicht reichen gibt es zusätzliche freie Netzwerkkarten Treiber bei Freenic und Audiotreiber bei Open Sound.

Also, viel Spass ;)

Newslinks: Golem, Heise, Distrowatch, OSNews, OpenSolaris 2008.11: Das neue "Sonnensystem"

OpenSolaris in den HPC Top 500

2008-11-29T06:54:00.000-08:00

Der erste OpenSolaris HPC ist in den Top 500 aufgetaucht und auf Platz 221 eingezogen. Bei dem guten Stück handelt es sich um ein Fujitsu System der Japan Aerospace Exploration Agency. Mehr dazu auf dem Sun HPC Blog.

Solaris Cluster: Jetzt mit Indersicherung!

2008-11-27T05:14:00.000-08:00

Gerade auf Youtube gesehen... einfach zu gut ^^

Compiz unter OpenSolaris

2008-11-27T03:19:00.001-08:00

Und nun wieder mal was für die Kategorie "Cool aber nutzlos". Compiz ist nicht gerade ein Auswahlkriterium für mich wenn es um Betriebssysteme geht, aber es ist schon sehr hübsch anzuschauen. Darum habe ich mich mal hingesetzt und mein System etwas getrimmt.

Als erstes erstellen wir einfach eine xorg.conf. Xorg macht das automatisch wenn man als root Xorg -configure eingibt. Die erstellte config dann einfach nach /etc/X11/xorg.conf kopieren.

Nun haben wir folgendes Problem: Diese config verwendet als voreingestellte Beschleunigung EXA. Das ist auf meinem Intel Chip mehr als lahm und alles andere als weich und flüssig. Ein anderes Problem ist das in der Xorg Version von OpenSolaris die OffscreenPixmap Funktion per default aktiv ist, das sorgt für teilweise richtig eklige Grafikfehler. Also tragen wir folgendes in die Device Section ein:


Option      "AccelMethod"           "XAA"
Option      "XAANoOffscreenPixmaps" "true"

Ok, jetzt einfach den X-Server neu starten und Compiz unter den visuellen Effekten aktivieren. Und voila: Es wird prollig ;)

Es könnte sein das man anstatt der Schatten am Panel große weiße Balken sieht. Die kann man aber loswerden indem man einfach die Schattengröße in den Compiz Einstellungen anpasst

Uni Münster migriert zu ZFS

2008-11-26T04:28:00.000-08:00

Nachdem wir neulich die Ankündigung bekommen haben das unsere Homeverzeichnisse an der Uni umziehen werden und wir in Zukunft einen gewaltigen Performanceboost kriegen, war ich doch mal neugierig was das zu bedeuten hat. Ein kleiner Blick auf unseren Fileserver hat mir folgendes gezeigt:


  pool: pool
 state: ONLINE
 scrub: none requested
config:

        NAME          STATE     READ WRITE CKSUM
        pool          ONLINE       0     0     0
          mirror      ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0

errors: No known data errors

  pool: pool2
 state: ONLINE
 scrub: none requested
config:

        NAME          STATE     READ WRITE CKSUM
        pool2         ONLINE       0     0     0
          raidz1      ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
          raidz1      ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0
            cxtxdxsx  ONLINE       0     0     0

errors: No known data errors
NAME              SIZE    USED   AVAIL    CAP  HEALTH     ALTROOT
pool             1.02T    321G    719G    30%  ONLINE     /
pool2            17.4T   1.59T   15.8T     9%  ONLINE     /

YAY!!!! Nuff said! :P (btw die Daten sind natürlich verfremdet ;)

OpenSolaris 2008.11 RC2 erschienen

2008-11-24T05:05:00.000-08:00

Das ganze gibts auf www.genunix.org zum Runterladen. Bugs bitte auf defect.opensolaris.org melden.

Happy testing :)

Papa's got a brandnew pigbag!

2008-11-10T13:08:00.000-08:00

Nachdem sich bei mir geradezu ein Rechnermaßensterben zugetragen hat, habe ich mir endlich ein neues Notebook geleistet. Das Lenovo Thinkpad SL500 hochgerüstet auf 4GB RAM: Das perfekte OpenSolaris Notebook. Das einzige was derzeit nicht unterstützt wird ist der Intel 5100 Wlan Chip und für den gibt es bereits Treiber (muss wohl nur noch lernen auch meine Karte zu erkennen, Bugreport ist bereits verschickt und akzeptiert :) ). Ansonsten geht wirklich alles vom Fingerabdruckscanner (naja... als wenns was bringen würde) bis zur Webcam :).

Anmerkung: Ja, den Desktop gibts auch in deutsch. Ich hab meinen allerdings immer englisch, sieht einfach besser aus.

Screencast: ZFS Selbstheilung

2008-11-05T14:31:00.001-08:00

Wie ich schon in einem Artikel erwähnt habe, hat ZFS die Möglichkeit Fehler zu erkennen und diese auch selbst zu heilen. Für alle die das mal gerne in Aktion sehen wollen gibt es da einen interessanten Screencast ;). Man brauch auch nicht unbedingt einen Mirror dafür sondern kann einem ZFS sagen das es mehrere Kopien der Daten transparent angelegen soll (mit zfs set copies=n myzfs erzeugt das Filesystem myzfs n Kopien der Daten und kann korrumpierte Daten in Notfall rekonstruieren).

Screencast: ZFS Basics

2008-11-05T05:10:00.000-08:00

Passend zu meiner Einführung in ZFS ist jetzt auch ein Screencast erschienen der ein paar der Funktionen von ZFS live zeigt. Immer wieder beeindruckend zu sehen wie schnell ZFS ist.

Mythbusting: $FOOFS + LVM = ZFS

2008-11-04T04:50:00.001-08:00

Man hört es ja immer wieder wenn man ZFS erwähnt: "Das kann ich doch auch mit LVM machen!" oder "ZFS verletzt ja den ganzen Layergedanken, das gehört getrennt weils ja sonst total Bloatware ist". Damit möchte ich gerne mal in ein paar Punkten aufräumen, vor allem aber auch zeigen das diese Designentscheidung alles andere als willkürlich ist. Dazu werde ich 2 klassische ZFS Beispiele besprechen: Selbstheilung und Intelligentes Prefetching

Sehen wir uns erst einmal an wie ein Mirror auf herkömmliche Art und Weise angelegt ist:

Hier liegt eine klassische Trennung von Filesystem und Volumemanager vor. Das Filesystem hat keinerlei Ahnung das es auf einem Mirror arbeitet der Volumemanager liefert ihm einfach ein virtuelles Device und veranstaltet sein spiegeln unbemerkt vom Filesystem. Auf der anderen Seite kennt der Volumemanager sich aber auch nicht mit dem Filesystem aus, er arbeitet einfach nur mit abstrakten Daten die er wegschreibt und er nicht versteht da er keinerlei Bezug zum Filesystem hat.

ZFS ist hier in 3 Schichten aufgeteilt:

Dem ZFS Posix Layer (ZPL) welcher die normale Posix API zur Verfügung stellt (open,close,read,write etc) darunter liegt direkt das ZFS welches einzelne Transaktionen (ZFS arbeitet NUR mit Transaktionen, dass heißt das das Filesystem nie in einen inkonsistenten Zustand kommt) an die Data Management Unit (DMU) weitergibt welche viele Transaktionen zu einer großen zusammenfasst und der Storage Pool Allocator (SPA) welcher Kenntnis von den Platten (die in unserem Beispiel gespiegelt sind) hat.

Jetzt wollen wir als Beispiel auf einem Spiegel einen fehlerhaften Block haben welcher gelesen wird, sagen wir einfach mal es handelt sich hier um Metadaten welche durch äußere Einwirkungen (Erschütterung, Strahlung, statische Entladung etc) verändert wurden. Der Volumemanager hat hier keine Ahnung ob die Daten korrekt sind und reicht sie ans Filesystem weiter. Im schlimmsten Fall kommt es jetzt zu einer Kernelpanic im weniger schlimmen werden falsche Daten gelesen und die Applikation liefert falsche Ergebnisse oder stürzt ab. Da das Filesystem allerdings keinerlei Ahnung hat das es auf einem Mirror arbeitet kann es selbst wenn es bemerkt das die Daten falsch sind ja nicht wissen das evtl ein Mirror mit richtigen Daten existiert und keine korrekten Daten anfordern (da Volumemanager und Filesystem nun einmal voneinander getrennt sind).

Wie macht ZFS das nun? Als Erstes räumt das Design von ZFS mit dem immer noch verbreiteten Glauben auf das Prüfsummen teuer sind. Bei den heuten Rechnergeschwindigkeiten ist die Berechnung einer solchen Summe zeitlich gesehen zu vernachlässigen. Dies macht sich ZFS zu nutze und sichert JEDEN Block mit einer Prüfsumme (default 256-bit). ZFS erkennt also immer ob ein Block immer noch in dem gleichen Zustand auf der Platte liegt wie es ihn geschrieben hat.
Wir lesen nun den gleichen Block aus dem oberen Beispiel noch einmal. Durch die Prüfsumme erkennen wir das der Block falsch ist und da ZFS selber Kenntnis darüber hat das es auf einem Mirror arbeitet fordert es den gleichen Block von der anderen Platte erneut an. Dieser ist in unserem Beispiel korrekt worauf er an die Applikation weitergereicht wird während der andere fehlerhafte Block verworfen wird und mit dem korrekten von der anderen Platte automatisch überschrieben wird. Die Applikation merkt davon nicht das geringste. (Es ist sogar möglich eine der beiden Platte während eines Lese/Schreibvorgangs mit dd if=/dev/random zu überschreiben ohne das die Applikation fehlerhafte Daten zu sehen kriegt, gleichzeitig wird der Schaden den dd anrichtet transparent geheilt)

Hat man nur eine Festplatte zu Verfügung kann man durch zfs set copies=n filesystem veranlassen das alle Datenblöcke n-fach geschrieben werden. Tritt nun ein Fehler auf wird dieser genauso geheilt wie auf einem Mirror. Man kann so ein extra Filesystem für sehr sensible Daten absichern ohne mehrere Platten zur Verfügung zu haben (z.b. auf Notebooks).

Ein anderes beliebtes Beispiel ist der intelligente Prefetchmechanismus. Nehmen wir folgendes an: Auf einem Filesystem liegt eine Videodatei die gleichzeitig von mehreren Benutzern gelesen wird. Alles in allem sind dies sequentielle Lesezugriffe, da alle diese User jedoch eine andere Stelle der Datei lesen kann man hier mit der herkömmlichen Aufteilung kein sequentielles Pattern erkennen, hier kann also kein Prefetch stattfinden da nicht erkannt wird welcher Block als nächstes gelesen wird. Da ZFS allerdings den Userkontext hat kann es erkennen das es sich hier um mehrere sequentielle Reads handelt und dementsprechend optimieren für normale Filesysteme + Volumemanager bleibt dies aufgrund des mangelnden Kontexts eine zufällige Leseabfolge.

Dies sind nur ein paar Beispiele welche Vorteile das Zusammenlegen von Volumemanager und Filesystem hat, unter anderem kann man damit auch dynamische Stripes haben etc.

ZFS räumt mit Annahmen auf die inzwischen 20 oder 30 Jahre alt sind, es ist komplett neu entwickelt worden mit Blick auf die Computerwelt wie sie heute ist, in der Storagekapazitäten gigantische Ausmaße annehmen und Fehler aufgrund von großen Datendurchsatz sehr leicht auftreten können und möglichst transparent repariert werden sollten. Unter anderem hat ZFS auch die on-disk Struktur stark vereinfacht (Metadaten,inodes welche hier znodes heissen, Daten etc werden gleich behandelt) oder Vorgänge wie formatieren und partitionieren abgeschafft (wer will heute schon 100TB formatieren und auf derartigen Speichermengen noch mit grow und shrink rumhantieren ;) ).

Ergo: Myth BUSTED!

Die CDDL ist nicht OpenSource?

2008-11-02T01:51:00.000-07:00

Anscheinend gibt es immer noch Leute die meinen deratige Parolen schwingen zu müssen (über den Ton den man anderen Personen gegenüber da an den Tag legt will ich hier gar nicht reden). Dabei wiegen Links und andere Beweise wohl anscheinend weniger als "neeeeeeee, wenn ich das sage ist das so". Halten wir die Sache kurz, mit einem Auszug aus der Wikipedia:

Die CDDL wurde am 1. Dezember 2004 der Open Source Initiative zur Abklärung zugesandt und Mitte Januar 2005 für Open-Source-kompatibel befunden. Die CDDL ist auch von der Free Software Foundation (FSF) als freie Lizenz anerkannt.

Und einem Link auf opensource.org.

Langsam nerven diese "heiligen Kriege"...

ZFS: Eine Einführung

2008-11-01T07:57:00.000-07:00

Krank sein nervt, aber wenn man im Bett liegt kann man sich mit ein paar Sachen befassen die man sonst eher selten macht. Ich hab die letzten Tage die ich mit Grippe im Bett gelegen hab einfach mal damit verbracht mich in einige ZFS Features einzuarbeiten und mir Gedanken darüber zu machen wie man sie in einem Blog packt. Damit auch die Linuxwelt etwas davon hat hab ich mich auch gleich noch darum gekümmert ZFS unter Ubuntu zum fliegen zu bringen.

Naja lange Rede kurzer Unsinn.

ZFS! Immer wieder hört man das es sich hierbei "nur" um ein Filesystem handelt. Ich will heute mal zeigen das das zwar stimmt, ZFS aber sehr viel mehr ist. Es ist praktisch ein Storage Werkzeugkoffer der fast alles abdeckt was einem in Sachen Storage so über den Weg laufen kann. Das Element mit dem alles anfängt ist der sogenannte zpool. In einem zpool packen wir alles was wir an Storage so nutzen wollen: Festplatte, USB-Sticks, einfach nur Dateien und was weiß ich noch für Devices. Ich werde hier aufgrund eines notorischen Festplattenmangels einfach ganz normale Files nehmen die jeweils 100MB Größe haben.

ZPools

Als erstes werden wir einfach mal die einfachste Sorte von zpools anlegen, nämlich solche die nur aus einem Datenträger bestehen.


[root@itzkoatl:zfsdemo]> zpool create tank $PWD/disk1 
[root@itzkoatl:zfsdemo]> zpool list
NAME    SIZE   USED  AVAIL    CAP  HEALTH  ALTROOT
tank   95.5M  73.5K  95.4M     0%  ONLINE  -
[root@itzkoatl:zfsdemo]> zpool status tank
  pool: tank
 state: ONLINE
 scrub: none requested
config:

 NAME                                  STATE     READ WRITE CKSUM
 tank                                  ONLINE       0     0     0
   /export/home/raichoo/zfsdemo/disk1  ONLINE       0     0     0

errors: No known data errors

Das wars eigentlich schon. Alleine durch die Eingabe von zpool create tank $PWD/disk1 haben wir einen neuen zpool erstellt. Kein formatieren, kein mounten. Das File wurde direkt mit einem ZFS Filesystem auf dem mountpunkt /tank angehängt. Das dauert nur wenige Sekunden.
Was aber machen wenn man mehrere Festplatten hat und deren Platz in einem pool verwenden will?


[root@itzkoatl:zfsdemo]> zpool add tank $PWD/disk2   
[root@itzkoatl:zfsdemo]> zpool status tank
  pool: tank
 state: ONLINE
 scrub: none requested
config:

 NAME                                  STATE     READ WRITE CKSUM
 tank                                  ONLINE       0     0     0
   /export/home/raichoo/zfsdemo/disk1  ONLINE       0     0     0
   /export/home/raichoo/zfsdemo/disk2  ONLINE       0     0     0

errors: No known data errors
[root@itzkoatl:zfsdemo]> zpool list 
NAME    SIZE   USED  AVAIL    CAP  HEALTH  ALTROOT
tank    191M  82.5K   191M     0%  ONLINE  -

Wir haben die neue Platte einfach durch add in den zpool eingefügt und wir zpool list zeigt hat sich die Kapazität von tank verdoppelt.
Wir können aber auch zpool mit RAID Fähigkeiten erstellen, dazu gibt es die subkommandos mirror, raidz und raidz2.


[root@itzkoatl:zfsdemo]> zpool create tank mirror $PWD/disk1 $PWD/disk2
[root@itzkoatl:zfsdemo]> zpool status tank
  pool: tank
 state: ONLINE
 scrub: none requested
config:

 NAME                                    STATE     READ WRITE CKSUM
 tank                                    ONLINE       0     0     0
   mirror                                ONLINE       0     0     0
     /export/home/raichoo/zfsdemo/disk1  ONLINE       0     0     0
     /export/home/raichoo/zfsdemo/disk2  ONLINE       0     0     0

errors: No known data errors
...
[root@itzkoatl:zfsdemo]> zpool create tank raidz2 $PWD/disk1 $PWD/disk2 $PWD/disk3 $PWD/disk4
[root@itzkoatl:zfsdemo]> zpool status tank                                    
  pool: tank
 state: ONLINE
 scrub: none requested
config:

 NAME                                    STATE     READ WRITE CKSUM
 tank                                    ONLINE       0     0     0
   raidz2                                ONLINE       0     0     0
     /export/home/raichoo/zfsdemo/disk1  ONLINE       0     0     0
     /export/home/raichoo/zfsdemo/disk2  ONLINE       0     0     0
     /export/home/raichoo/zfsdemo/disk3  ONLINE       0     0     0
     /export/home/raichoo/zfsdemo/disk4  ONLINE       0     0     0

errors: No known data errors

Man kann noch sehr viel mehr mit zpools anstellen, aber das reicht fürs erste ;).

Filesysteme

Das erste Filesystem haben wir ja schon mit dem Erstellen des zpools angelegt. Es trägt den Namen tank und ist unter /tank gemountet.


[root@itzkoatl:zfsdemo]> zfs list
NAME   USED  AVAIL  REFER  MOUNTPOINT
tank  98.6K   158M  26.9K  /tank

Wir tun jetzt einfach mal so als würden wir eine Art home-Struktur anlegen wollen. Dazu legen wir ein separates home-Filesystem und ein Filesystem für jeden Benutzer an. ZFS Filesysteme sind in etwa vergleichbar mit dem was man unter herkömmlichen Filesystemen als Partitionen bezeichnet, nur das sie sich in ihrer Größe dem Inhalt anpassen. Ein ZFS Filesystem in dem also nichts liegt wird auch praktisch nichts an Plattenplatz belegen.


[root@itzkoatl:zfsdemo]> zfs create tank/home
[root@itzkoatl:zfsdemo]> zfs create tank/user1
[root@itzkoatl:zfsdemo]> zfs create tank/user2
[root@itzkoatl:zfsdemo]> zfs create tank/user3
[root@itzkoatl:zfsdemo]> zfs list
NAME         USED  AVAIL  REFER  MOUNTPOINT
tank         247K   158M  34.4K  /tank
tank/home   26.9K   158M  26.9K  /tank/home
tank/user1  26.9K   158M  26.9K  /tank/user1
tank/user2  26.9K   158M  26.9K  /tank/user2
tank/user3  26.9K   158M  26.9K  /tank/user3

So wir haben unsere Filesysteme erstellt aber UPS! unsere User sind ja gar nicht an der richtigen Stelle gemountet, eigentlich gehören die ja nach /tank/home. Kein Problem, wir können den Mountpoint im Nachhinein einfach setzen


[root@itzkoatl:tank]> zfs set mountpoint=/tank/home/user1 tank/user1
[root@itzkoatl:tank]> zfs rename tank/user1 tank/home/user1
[root@itzkoatl:tank]> zfs list
NAME              USED  AVAIL  REFER  MOUNTPOINT
tank              258K   158M  32.9K  /tank
tank/home        55.3K   158M  28.4K  /tank/home
tank/home/user1  26.9K   158M  26.9K  /tank/home/user1
tank/user2       26.9K   158M  26.9K  /tank/user2
tank/user3       26.9K   158M  26.9K  /tank/user3

Das rename ist eigentlich nicht nötig, ich habe es allerdings hier aus Schönheitsgründen mal gemacht ;). Durch das Umsetzen des Mountpoints wird das Filesystem von seinem alten Standort ausgehängt und am neuen Mountpoint eingehängt, alles automatisch.
Wir räumen jetzt einfach mal die anderen Filesysteme weg und arbeiten nur noch mit user1 weiter.


[root@itzkoatl:tank]> zfs destroy tank/user2
[root@itzkoatl:tank]> zfs destroy tank/user3

Filesystem Attribute

Jetzt zu ein paar interessanten Attributen die man mit set und get setzen und auslesen kann. Ich werde nur ein paar davon zeigen weil es wirklich eine ganze Menge sind, aber ich halte diese für die praktischsten.

Reservation

Hiermit läßt sich Plattenplatz aus dem zpool reservieren. Dem Filesystem wird also eine bestimmte Menge Storage zugesichert, wie man unten sieht hat tank/home/user1 10MB mehr Speicher zur Verfügung als alle anderen Filesysteme.


[root@itzkoatl:tank]> zfs set reservation=10m tank/home/user1
[root@itzkoatl:tank]> zfs list
NAME               USED  AVAIL  REFER  MOUNTPOINT
tank              10.2M   148M  28.4K  /tank
tank/home         10.0M   148M  28.4K  /tank/home
tank/home/user1   26.9K   158M  26.9K  /tank/home/user1

Quotas

Was man reservieren kann, kann man aus begrenzen. Mit Quotas lassen sich Filesysteme klein halten.


[root@itzkoatl:tank]> zfs set quota=10m tank/home/user1
[root@itzkoatl:tank]> zfs list                         
NAME              USED  AVAIL  REFER  MOUNTPOINT
tank             10.2M   148M  28.4K  /tank
tank/home        10.0M   148M  28.4K  /tank/home
tank/home/user1  26.9K  9.97M  26.9K  /tank/home/user1

Compression

Der Name sagt es schon. Filesysteme lassen sich transparent komprimieren. Es gibt unterschiedliche Algorithmen wir nehmen hier gzip als Beispiel.


[root@itzkoatl:tank]> zfs set compression=gzip tank/home/user1
[root@itzkoatl:tank]> zfs get compression tank/home/user1
NAME             PROPERTY     VALUE            SOURCE
tank/home/user1  compression  gzip             local

Hier sollte man daran denken das nur Dateien komprimiert werden die nachträglich im Filesystem erstellt werden. Auch zeigt ls nicht die komprimierte sondern die reale Größe der Datei an.

NFS

Besonders praktisch ist NFS Sharing. Ich werde hier nur die einfachste Form zeigen, aber anstatt on lassen sich die normalen NFS Optionen für das Filesystem angeben. Unter Solaris wird hier alles automatisch eingerichtet und gestartet so das das eingeben einer einzige Zeile reicht um Filesysteme zu sharen (keine Ahnung wie das unter anderem Systemen ist).


[root@itzkoatl:tank]> zfs set sharenfs=on tank/home/user1

Das sind nur ein paar der vielen Attribute die ZFS bietet, alle zu zeigen würden den Rahmen sprengen ;)

Snapshots

Kommen wir zu einem meiner Lieblingsfeatures: Snapshots. Mit Snapshots lassen sich Filesysteme zu einem bestimmten Zeitpunkt einfrieren und auch wieder zurückspielen (und das innerhalb von ein paar Sekunden und ohne das es extra Plattenplatz belegt). Es ist ebenfalls jederzeit möglich in angelegt Snapshots reinzugucken. Wir werden jetzt einfach mal folgendes machen: Wie legen eine Datei mit dem Text "Das ist ein Test" an, danach erstellen wir einen Snapshot und werden die Datei verändern.


[root@itzkoatl:user1]> echo "Das ist ein Test" > text
[root@itzkoatl:user1]> ls
text
[root@itzkoatl:user1]> cat text
Das ist ein Test
[root@itzkoatl:user1]> zfs snapshot tank/home/user1@kleinertest

Ok wir haben den Zustand unseres Filesystems jetzt unter dem Snapshot mit dem Namen kleinertest gesichert. Nun wollen wir unsere Datei mal kaputtmachen und alles wieder herstellen.

[root@itzkoatl:user1]> echo "Ich mach alles kaputt!" >| text 
[root@itzkoatl:user1]> cat text 
Ich mach alles kaputt!
[root@itzkoatl:user1]> cat .zfs/snapshot/kleinertest/text 
Das ist ein Test
[root@itzkoatl:user1]> zfs rollback tank/home/user1@kleinertest
[root@itzkoatl:user1]> cat text                                
Das ist ein Test

Wie man sieht existiert ein versteckter Ordner .zfs, dieser wird nicht von ls -a angezeigt (Es sei denn man setzt ein bestimmtes Attribut) sondern praktisch on-the-fly erstellt wenn man explizit auf ihn zugreift. Mit zfs rollback spulen wir das Filesystem wieder zu dem Zeitpunkt zurück an dem wir den Snapshot kleinertest erstellt haben (der Snapshot selber existiert weiter). Snapshot sind nicht beschreibbar aber es lassen sich mit zfs clone schreibbare Filesysteme aus einem Snapshot erstellen.

Serialisieren

Ein Filesystem läßt sich in eine einzelne Datei ausgeben die sich dann verschicken läßt und woanders wieder in ein Filesystem umwandeln läßt (sehr praktisch für Backups). Dazu brauchen wir erst einmal einen Snapshot, dieser läßt sich mit zfs send serialisieren und mit zfs receive wieder "entpacken".


[root@itzkoatl:user1]> zfs send tank/home/user1@kleinertest > /tank/dump
[root@itzkoatl:user1]> ls -l /tank/dump
-rw-r--r--   1 root     root       15680 Nov  1 17:29 /tank/dump
[root@itzkoatl:user1]> zfs receive tank/home/user2 < /tank/dump
[root@itzkoatl:user1]> cat /tank/home/user2/text 
Das ist ein Test
[root@itzkoatl:user1]> zfs list
NAME               USED  AVAIL  REFER  MOUNTPOINT
tank              10.2M   148M  45.6K  /tank
tank/home         10.1M   148M  31.4K  /tank/home
tank/home/user1   29.1K  9.97M  29.1K  /tank/home/user1
tank/home/user2   27.6K   148M  27.6K  /tank/home/user2

Wir haben also nun aus der dump-datei einfach ein neues Userverzeichnis erstellt welches den Zeitpunkt wiederspiegelt an dem wir kleinertest erstellt haben. Snapshots lassen sich auch separat mit zfs list -t snapshot anzeigen


[root@itzkoatl:user1]> zfs list -t snapshot
NAME                          USED  AVAIL  REFER  MOUNTPOINT
tank/home/user1@kleinertest      0      -  29.1K  -
tank/home/user2@kleinertest      0      -  27.6K  -

Wie man sieht waren in unserem dump sogar alle Snapshots des Filesystems erhalten (user2 hat ebenfalls einen Snapshot kleinertest)

Import und Export

Filesysteme müssen manchmal mobil sein, z.b. wenn sie auf USB-Sticks liegen. Hierzu kann man zpools einfach exportieren. Exportierte zpools sind ohne das man sie wieder importiert nicht benutzbar (sie werden auch automatisch ausgehängt etc). Steckt man z.b. einen USB-Stick mit einem zpool in das System ein, reicht unter Solaris ein zpool import und alle exportierten Ports werden angezeigt. Ohne Paramter durchsucht dieser Befehl automatisch alle Datenträger nach exportierten zpools im /dev Filesystem.
Da unsere disk Dateien jetzt aber keine echten Devices sind müssen wir den Ort an dem zpool import suchen soll explizit angeben.


[root@itzkoatl:~]> zpool export tank
[root@itzkoatl:~]> zpool import -d ./zfsdemo
  pool: tank
    id: 14691414290482700440
 state: ONLINE
action: The pool can be imported using its name or numeric identifier.
config:

 tank                                    ONLINE
   raidz2                                ONLINE
     /export/home/raichoo/zfsdemo/disk1  ONLINE
     /export/home/raichoo/zfsdemo/disk2  ONLINE
     /export/home/raichoo/zfsdemo/disk3  ONLINE
     /export/home/raichoo/zfsdemo/disk4  ONLINE
[root@itzkoatl:~]> zpool import -d ./zfsdemo tank

Das war ein kleiner aber recht umfangreicher Ausflug in die Welt von ZFS. Und vielen dürfte jetzt klar sein das ZFS mehr ist als nur Volumemanager und Filesystem in einem, es ist ein Storage Verwaltungstools. ZFS ist inzwischen neben Solaris auf FreeBSD, MacOSX und Linux (nur über FUSE) verfügbar. An weiteren Ports wird gearbeitet.

ZFS unter Ubuntu Intrepid Ibex

2008-11-01T06:22:00.001-07:00

ZFS und Linux ist ja leider ein Thema für sich, aber mit ein paar Handgriffen kann man es sich zumindest so zurechtbiegen das es unter FUSE im Userspace rennt. Auch wenn das nicht gerade die performanteste Lösung auf Erden ist kann man so wenigstens seine zpools unter Linux benutzen.

Um die aktuelle Version 0.5.0 zu kompilieren muss man lediglich die folgenden Pakete nachinstallieren:
build-essential libfuse-dev libaio-dev zlib1g-dev scons

Die aktuelle "ZFS on FUSE" Version findet man hier. Übersetzen und installieren läßt sich das ganze nachdem wir die oben genannten Pakete installiert haben:


raichoo@tensaiga:Projects$ tar xfvj zfs-fuse-0.5.0.tar.bz2
...
raichoo@tensaiga:Projects$ cd zfs-fuse-0.5.0/src
raichoo@tensaiga:Projects$ scons
...
raichoo@tensaiga:Projects$ sudo scons install

Mit sudo zfs-fuse starten wir den Userspace Prozess der ZFS verwaltet.

Leider schmeißt der Code sehr viele Warnings und es ist gleichzeitig das -Werror Flag gesetzt welches ein kompilieren in diesem Fall unmöglich macht. Also entfernen wir dieses Flag aus der src/SConstruct aus dem CFLAGS Eintrage. Das ganze sieht dann so aus:


env['CCFLAGS'] = Split('-pipe -Wall -std=c99 -Wno-switch
-Wno-unused -Wno-missing-braces -Wno-parentheses
-Wno-uninitialized -fno-strict-aliasing -D_GNU_SOURCE
-D_FILE_OFFSET_BITS=64 -D_REENTRANT 
-DTEXT_DOMAIN=\\"zfs-fuse\\" -DLINUX_AIO')

Ich weiß das ist unschön und gehört eigentlich verboten... vielleicht kennt jemand einen besseren Weg, ich würde mich sehr über Tipps freuen.

Ich plane im Moment eine kleine ZFS Einführung an der jetzt hoffentlich auch die Linuxuser ihren Spaß haben werden.

Interview mit Ian Murdock

2008-10-26T06:50:00.001-07:00

Ein interessantes Interview vom Linuxtag mit dem Gründer von Debian.

Wie ZFS das Booten verändert

2008-10-26T05:50:00.000-07:00

ZFS ändert nicht nur die Art und Weise wie wir mit Filesystemen umgehen (kein Partitionieren und Formatieren mehr etc.) sondern auch wie wir booten. Wie das alles technisch funktioniert und welche Möglichkeiten das eröffnet hat Lori Alt in einem sehr sehenswerten Vortrag erläutert. Die Beispiele sind auf Solaris 10 bezogen. Unter der OpenSolaris Distro verwenden wir nicht die LU Tools sondern BEadm.

Ein kleiner Preview auf 2008.11

2008-10-26T03:55:00.000-07:00

Gman hat hier auf ein Video Review zum Thema OpenSolaris geantwortet und ein paar interessante Ankündigungen für 2008.11 gemacht. Besonders interessant finde ich den automatisierten Installer und den "Distribution Creator" mit dem man sich seine eigene Distro maßschneidern kann (Mit KDE4 Paketen könnte man sich dann eine KDE OpenSolaris Distro selberbacken ^^). Es bleibt also wie immer spannend.

Constantin Gonzalez zeigt wie's geht

2008-10-25T07:19:00.000-07:00

Solaris hat ja immer den Ruf ziemlich benutzerunfreundlich gewesen zu sein, mit der OpenSolaris Distribution von Sun soll sich das jetzt ändern mit der derzeitigen Version 2008.05 hat sich zwar schon vieles verbessert aber sicherlich bleibt noch einiges zu tun (2008.11 welches gegen Ende November erscheint wird da allerdings sehr viel neues dazubringen ;).
Für alle die einfach mal sehen wollen wie "schwer" es ist OpenSolaris zu installieren hier einfach mal ein kleiner Video Podcast von SunVision.tv

Besonders praktisch ist das Device Utility welches gleich auf dem Desktop liegt und gleich anzeigt welche Geräte unterstützt werden (hat mir bei meiner Entscheidung welches Notebook ich kaufen will seeeeeeehr geholfen ^^). Sollte mit der aktuellen LiveCD einiges nicht klappen kann man auch einfach auf den aktuellen Build auf Genunix.org zurückgreifen (im Moment ist Build 99 aktuell). Diese Builds erscheinen meistens alle 2 Wochen und erhalten jedesmal jede Menge Bugfixes, neue Features und auch neue Treiber und lassen sich wie die normale OpenSolaris CD als LiveCD nutzen.

OpenSolaris Usergroup Münster/Bielefeld/Osnabrück

2008-10-25T04:32:00.000-07:00

Ich nehme hiermit einfach mal die Freiheit eine OpenSolaris Usergroup für den Bereich Münster, Bielefeld und Osnabrück auszurufen. Frei nach Jim's 10 Punkte Plan für eine erfolgreiche Usergroup geht es erst einmal darum Interessenten zu finden und einen kleinen Stammtisch zu organisieren. Als Anlaufpunkt kann man sich gerne bei mir melden oder ihr schaut einfach in unserem Community Channel #opensolaris-de auf Freenode vorbei. Jeder ist willkommen, egal ob Profi oder einfach nur Neugieriger. Alles ist noch offen für neue Ideen und Anregungen ;)

"Less know Solaris Features" Handbuch zum Download

2008-10-24T13:10:00.000-07:00

Für alle die sowas wie das FreeBSD Handbuch für Solaris suchen gibt es jetzt etwas interessantes auf http://www.c0t0d0s0.org. Auch sonst ein durchaus lesenswerter Blog ;)

ZFS für Linux kriegt ein Upgrade

2008-10-17T23:57:00.000-07:00

Totgesagte leben länger heißt es ja so schön. So ist in dem ganzen Rummel um das Datenbank-Filesystem Btrfs und die neue ext Version wohl untergegangen das es schon im letzten Monat ein Upgrade für ZFS on Fuse. Die neue Version unterstützt unter anderem ZFS Pools der Version 13 und beseitigt kritische Bugs. Das eröffnet die Möglichkeit ZFS Wechseldatenträger jetzt auf Mac OS X, FreeBSD, Linux und natürlich Solaris zu nutzen (wenn Windows jetzt noch ZFS kriegen würde könnte man endlich auf FAT verzichten... *träum*). Weitere Open Source Betriebssysteme wie NetBSD und DragonflyBSD arbeiten ebenfalls an einer Portierung. Natives ZFS unter Linux ist derzeit nicht möglich da die GPL das mischen mit Open Source Code der nicht unter GPL steht verbietet (bei Nvidia-Treibern scheint es zu gehen... ein Schelm wer Böses denkt ;) ).

Mich persönlich würde interessieren wie hoch der Performanceverlust ist wenn man ein derartig komplexes Filesystem im Userspace laufen läßt. Falls Linux-user mit ZFS Erfahrung das lesen würde mich ein Feedback interessieren.

Spaß mit Solaris-Zones

2008-10-17T13:59:00.000-07:00

Zones werden immer wieder als eins von den Killer Features von Solaris genannt. Es handelt sich hierbei um eine Art leichtgewichtige Virtualisierung ähnlich den FreeBSD Jails, nur sehr viel mächtiger. Unter anderem ist es auch möglich sogenannte "branded zones", welche z.B. Linux virtualisieren, anzulegen.
Ich werde heute erst einmal zeigen wie man eine Zone vom Typ ipkg anlegt, dies sind einfache Instanzen von Solaris. Sie laufen völlig abgeschottet vom Rest das Systems. In ihnen lassen sich separate Services fahren und man kann ihnen unter anderem eingeschränkte Ressourcen (z.b. eine einzelne CPU von einem SMP System) zuweisen.
Ein Beispiel: In einer Zone läuft ein Webserver auf den ein Angriff gelingt. Der Angreifer hat sich jetzt zwar Zugriff auf die Zone verschafft, kann aber nicht auf andere Services in anderen Zones zugreifen oder auf das Hauptsystem welches von der Zone aus nicht sichtbar ist. Eine DoS Attacke die z.b. versucht alle Ressourcen des Systems aufzubrauchen schlägt fehl da diese beschränkt sind.
Um Zones anzulegen und zu verwalten greift man auf die Tools zonecfg und zoneadm zurück.
Als erstes listen wir einfach mal alle Zonen auf die wir haben:


[root@itzkoatl:zones]> zoneadm list -cv          
  ID NAME             STATUS     PATH                           BRAND    IP    
   0 global           running    /                              native   shared

global steht für unser Hauptsystem. Die Option -c zeigt uns Zonen an die im Status configured sind, dazu aber später.
Nun wollen wir unser System fit für Zones machen. Ich lege dazu einfach ein zusätzliches ZFS Filesystem im Ordner /export an. Dies geschieht einfach durch den Befehl zfs create rpool/export/zones. (Zones brauchen anscheinend ein separates Filesystem auf dem sie angelegt werden).
Originell wie wir sind legen wir jetzt eine Zone mit dem Namen "test" an:


[root@itzkoatl:~]> zonecfg -z test
test: No such zone configured
Use 'create' to begin configuring a new zone.
zonecfg:test> create
zonecfg:test> set zonepath=/export/zones/test
zonecfg:test> verify
zonecfg:test> commit
zonecfg:test> exit
[root@itzkoatl:~]> zoneadm list -cv                      
  ID NAME             STATUS     PATH                           BRAND    IP    
   0 global           running    /                              native   shared
   - test             configured /export/zones/test             ipkg     shared

Mit create lege ich die Zone an, nun muss ich lediglich einen Pfad angeben in dem die Zone beherbergt werden soll (dafür haben wir ja gerade unser ZFS Filesystem errpool/export/zones erstellt). Mit verify überprüfen wir ob auch alles ok ist und mit commit legen wir dann die Konfiguration an (Für alle die es interessiert: die Konfiguration wird in /etc/zones/test.xml gespeichert).
Unsere Zone befindet sich nun im Status configured, das bedeutet das wir jetzt ein System in die Zone installieren können. Nachdem wir das System erfolgreich in die Zone installiert haben läßt sie sich wie ein separater Rechner booten und wir können uns mit zlogin einloggen.


[root@itzkoatl:~]> zoneadm -z test install
A ZFS file system has been created for this zone.
  Authority: Using http://pkg.opensolaris.org:80/.
      Image: Preparing at /export/zones/test/root ... done.
      Cache: Using /var/pkg/download.
 Installing: (output follows)
DOWNLOAD                                    PKGS       FILES     XFER (MB)
Completed                                  52/52   7842/7842   75.32/75.32 

PHASE                                        ACTIONS
Install Phase                            12903/12903 
PHASE                                          ITEMS
Reading Existing Index                           9/9 
Indexing Packages                              52/52 

       Note: Man pages can be obtained by installing SUNWman
Postinstall: Copying SMF seed repository ... done.
Postinstall: Working around http://defect.opensolaris.org/bz/show_bug.cgi?id=741
       Done: Installation completed in 268.109 seconds.

 Next Steps: Boot the zone, then log into the zone console
             (zlogin -C) to complete the configuration process
[root@itzkoatl:~]> zoneadm -z test boot 
[root@itzkoatl:~]> zlogin -C test
[Connected to zone 'test' console]
(hier hab ich noch mal ENTER drücken müssen)

You did not enter a selection.
What type of terminal are you using?
 1) ANSI Standard CRT
 2) DEC VT100
 3) PC Console
 4) Sun Command Tool
 5) Sun Workstation
 6) X Terminal Emulator (xterms)
 7) Other
Type the number of your choice and press Return: 
...
test console login: root
Password: 
Oct 17 14:53:45 test login: ROOT LOGIN /dev/console
Sun Microsystems Inc.   SunOS 5.11      snv_99  November 2008
root@test:~#

Jetzt werden wir durch eine Installationsroutine geführt (Zum Fortfahren einfach ESC-2 drücken). Danach läuft eine virtualisierte Instanz von Solaris auf unserem System. Übrigens beim erstellen einer neuen Zone wird pkg eventuell einige Pakete herunterladen, dies geschieht aber nur einmal und zukünftige Zones werden sich die Pakete einfach aus dem Package-cache ziehen.

Jetzt wollen wir als kleines i-Tüpfelchen noch eine virtuelle Netzwerkkarte hinzufügen und unserer Zone eine eigene IP geben ;)
Dazu machen wir im Hostsystem folgendes:


[root@itzkoatl:export]> zonecfg -z test
zonecfg:test> add net
zonecfg:test:net> set physical=rtls0
zonecfg:test:net> set address=192.168.1.111
zonecfg:test:net> end
zonecfg:test> verify
zonecfg:test> commit
zonecfg:test> exit
[root@itzkoatl:export]> zoneadm -z test reboot 
zone 'test': WARNING: rtls0:1: no matching subnet found in netmasks(4) for 192.168.1.111; using default of 255.255.255.0.

Wie man sieht sorgen Zones sogar für Abhilfe wenn man vergessen hat die Subnetzmaske einzugeben ;). (Für alle die mit rtls0 nichts anfangen können: das ist der Name der Netzwerkkarte, in diesem Fall eine Realtek)
Unsere Zone ist jetzt im gesamten Netzwerk unter 192.168.1.111 erreichbar ;)

Wozu kann man Zones denn jetzt alles missbrauchen? Mit "branded zones" kann man z.B. Linux Applikationen ausführen (dazu eventuell später mal), oder man kann einfach eine abgeschottete Zone für Entwicklung einrichten, warum nicht einfach jedem seiner Freunde eine eigene Zone auf eurem Solaris Server geben? ;)

OpenSolaris 2008.11 ermöglicht Zeitreisen

2008-10-13T23:29:00.000-07:00

Jeder der sich schon mal einen Mac angesehen hat kennt vermutlich Time Machine: das mitgelieferte Backup Tool von Apple. Ein ziemlich praktisches Feature, das in ähnlicher Form für den nächsten Release von OpenSolaris im November angekündigt ist. Das Ganze wird mit Hilfe von ZFS realisiert (schon mal ein großer Vorteil gegenüber Mac OS X welches IIRC rsync nutzt) und in Nautilus eingebettet, ein SMF Service sorgt im Hintergrund für regelmäßige Snapshots die sich dann per "Time Slider" durchforsten lassen.
Ob es irgendwann auch ein funky Compiz Plugin geben wird das wie auf dem Mac einen Flug durch einen Zeittunnel realisiert bleibt wohl abzuwarten ^^.

Mehr Informationen finden sich hier.

Update: Mir wurde gerade gesagt das Mac OS X doch kein rysnc verwendet sondern "die FSEvent API" (was immer das ist ^^). Danke Okona ;)

OpenSolaris und Multimedia

2008-10-13T12:41:00.000-07:00

Multimedia ist ja unter OpenSolaris anfangs eine ziemliche leidige Sache gewesen: kein mplayer, xine.... irgendwie konnte man nur sehr beschränkt out-of-the-box Multimediadateien abspielen. Im Paketkatalog fand man auch nicht wirklich Abhilfe. Inzwischen haben sich aber ein paar fleißige Japaner daran gemacht bewegte Bilder auch noch in die OpenSolaris Welt zu bringen. Life with Solaris heißt das ganze und bietet mit ein paar Handgriffen alles das was man sich so wünscht. Einfach folgendes ausführen (mit root-Rechten versteht sich):


# pkg set-authority -O http://pkg.lifewithsolaris.jp:10000/ lifewithsolaris.jp
# pkg refresh --full

Schon hat man Zugriff auf die Pakete von Life with Solaris.
Weitergehende Informationen finden sich hier.

BEadm: Ich bin nicht eins, ich bin viele

2008-10-09T04:14:00.000-07:00

Ein Feature von OpenSolaris welches ich besonders liebe ist beadm, die Boot Environment Verwaltung. Hier mit kann man mehrere Instanzen des Systems auf seiner Platte installiert haben und benutzten. "Mooooment mal? Frisst das nicht unheimlich viel Plattenplatz wenn ich 3, 4 oder sogar mehr Versionen von OpenSolaris auf meiner Platte habe?" Genau das ist ja das schöne, NEIN! Unterschiedliche Bootumgebungen belegen nur Plattenplatz für die Unterschiede zwischen den Systemen, habe ich also nur kleine Änderungen vorgenommen belegt das System auch so gut wie keinen Plattenplatz. "Wie viele unterschiedliche Instanzen kann ich denn machen?" So viele wie man will! Ich selber habe immer noch eine Kopie des letzten Releases auf meiner Platte, auf meinem Notebook sogar noch eine Version von der frischen Installation welche ich im Notfall immer als eine Art "Rettungsversion" nutzen kann. Auf meinem Desktop sieht das ganze so aus:


[raichoo@itzkoatl:~]> beadm list
BE                Active Mountpoint Space  Policy Created          
--                ------ ---------- -----  ------ -------          
opensolaris_snv97 -      -          55.57M static 2008-09-12 15:44 
opensolaris_snv98 NR     /          10.32G static 2008-09-19 07:25

Das sind also 2 Bootumgebungen. Wie man sieht belegt opensolaris_snv97 nur 55,57 MB an Plattenplatz obwohl es den KOMPLETTEN Zustand meines Systems (Anmerkung: Nur das System, mein Homefilesystem bleibt davon unberührt und kann auf jeder Instanz genutzt werden) vor dem letzten Upgrade repräsentiert. Diese Umgebung kann ich jetzt nach belieben vervielfältigen und damit weiterarbeiten oder einfach löschen wenn ich sie nicht mehr brauche. Was allerdings am wichtigsten ist: ich kann auf sie jederzeit zugreifen. Dies funktioniert fast genauso wie das händische mounten eines Datenträgers:


[raichoo@itzkoatl:~]> su
Password: 
[root@itzkoatl:~]> mkdir /tmp/mountpoint
[root@itzkoatl:~]> beadm mount opensolaris_snv97 /tmp/mountpoint 
[root@itzkoatl:~]> cd /tmp/mountpoint/
[root@itzkoatl:mountpoint]> ls
a/                 etc/               mnt/               sbin/
bin@               export/            net/               system/
boot/              home/              opt/               tmp/
bootcd_microroot/  kernel/            platform/          usr/
cdrom/             lib/               proc/              var/
COPYRIGHT          LICENSE            rmdisk/
dev/               lost+found/        root/
devices/           media/             rpool/
[root@itzkoatl:mountpoint]> cd
[root@itzkoatl:~]> beadm unmount opensolaris_snv97

Man beachte das es hier unmount und nicht umount heißt ;)
Das erstellen und zerstören einer Bootumgebung ist ebenso einfach:


[root@itzkoatl:~]> beadm create donnerlutzi
[root@itzkoatl:~]> beadm list
BE                Active Mountpoint Space  Policy Created          
--                ------ ---------- -----  ------ -------          
donnerlutzi       -      -          80.5K  static 2008-10-09 13:39 
opensolaris_snv97 -      -          55.57M static 2008-09-12 15:44 
opensolaris_snv98 NR     /          10.32G static 2008-09-19 07:25

Voila, das wars. Der Vorgang dauert satte 3 Sekunden und wie man sieht belegt donnerlutzi nur 80.5 KB an Plattenplatz. "Hmm... brauch ich da nicht noch einen Eintrag im Bootmanager damit ich in das System booten kann?" Nö, das macht beadm schon von ganz alleine ;)


[root@itzkoatl:~]> cat /rpool/boot/grub/menu.lst
...
#============ End of LIBBE entry =============
title donnerlutzi
bootfs rpool/ROOT/donnerlutzi
kernel$ /platform/i86pc/kernel/$ISADIR/unix -B $ZFS-BOOTFS
module$ /platform/i86pc/$ISADIR/boot_archive
#============ End of LIBBE entry =============

Will ich donnerlutzi zu meinem Standardsystem machen reicht ein beadm activate donnerlutzi und es wird ab dem nächsten Booten immer als erste Wahl in Grub angezeigt.
Sehr praktisch ist das ich diese Bootumgebung auch separat aktualisieren oder komplett andere Software auf ihr installieren kann, da der Paketmanager damit umgehen kann (genauer genommen legt er sogar Sicherheitskopien meines Systems bei Updates an, so kann man immer wieder zurück wenn etwas schief geht. Dieses Verhalten kann man aber auch bei Bedarf umgehen).
Will ich jetzt eine Bootumgebung separat aktualisieren geht das wie folgt:


[root@itzkoatl:~]> beadm mount donnerlutzi /tmp/mountpoint 
[root@itzkoatl:~]> pkg -R /tmp/mountpoint image-update
...

Aber da ich eigentlich ganz zufrieden mit meinen 2 derzeitigen Systemen bin will ich donnerlutzi jetzt ganz gerne wieder loswerden:


[root@itzkoatl:~]> beadm unmount donnerlutzi
[root@itzkoatl:~]> beadm destroy donnerlutzi
Are you sure you want to destroy donnerlutzi? This action cannot be undone(y/[n]): y
[root@itzkoatl:~]> beadm list
BE                Active Mountpoint Space  Policy Created          
--                ------ ---------- -----  ------ -------          
opensolaris_snv97 -      -          55.57M static 2008-09-12 15:44 
opensolaris_snv98 NR     /          10.32G static 2008-09-19 07:25

"Wozu braucht man so etwas jetzt?" Der erste Punkt ist sicherlich das man sich so sehr gut absichern kann wenn man mal sein System total zerbastelt oder Software installiert die stark ins System eingreift. Man kann immer wieder zurück und das mit Hilfe von ein paar Handgriffen ohne zeitaufwendiges Zurückspielen des Systems durch ein herkömmliches Backup. Man kann auch gleichzeitig die stabile und die Entwicklerversion des Systems auf meiner Platte haben ohne das sich beide in die Quere kommen. So kann man vorher schon testen was neue Versionen bringen werden ohne auf sein stabiles System verzichten zu müssen oder irgendwelche LiveCDs zu benutzen auf denen das testen meist eh nur eingeschränkt funktioniert.

"Wie funktioniert das ganze?" Beadm selbst ist in Python geschrieben und greift nur auf Möglichkeiten zurück die ZFS zur Verfügung stellt, also keine ekligen Hacks die irgendwelche großen Dumpdateien anlegen und dann irgendwie über 3 Ecken mounten, alles ist bereits sauber im System integriert. Beadm selber hat noch ein paar Funktionen die ich hier nicht erwähnt habe, ein Blick in die Manpage schafft hier aber Abhilfe.

Na dann viel Spaß beim hemmungslosen Basteln! Jetzt ohne Angst das danach nichts mehr funktioniert :)

AMP: Webentwicklungsumgebung für OpenSolaris

2008-10-09T04:00:00.000-07:00

Für alle Web-Entwickler gibt es jetzt unter OpenSolaris eine umfangreiche Zusammenstellung an Entwicklungstools. Besonders interessant dürfte das zusammen mit Zones sein (einem Thema dem ich mich noch annehmen muss). Wie man AMP installiert und was es beinhaltet wird hier ausführlich erklärt. Das zusammen Dtrace (welches auch über PHP, JavaScript, Java, Python und Ruby tracing verfügt), ZFS und den bereits erwähnten Zones ergibt ein ziemliches Killerpaket.

ZFS Screencast

2008-10-08T13:00:00.000-07:00

Ich habe auf Youtube gerade einen ganz interessanten ZFS Screencast gefunden. Leider verhaut sich der Präsentator ständig mit den Kommandos, dennoch nicht uninteressant wenn man ZFS noch nie im Einsatz auf einer WIRKLICH großen Kiste gesehen hat ;)

Adrian de Groot: KDE4 on OpenSolaris

2008-10-04T06:04:00.000-07:00

Adrian De Groot presents...KDE 4 on Open Solaris from Phil Whitehouse on Vimeo

ZSH Patch gegen fieses Memory Leak

2008-09-13T19:45:00.000-07:00

Ich bin neulich auf einen unschönen Bug in ZSH gestoßen. Bei aktiviertem compinit wird bei jeder Vervollständigung ein Segment anonymer Speicher angelegt und nicht wieder richtig freigegeben. Ein kleines dtrace Skript hat das Problem entlarvt.


#!/usr/sbin/dtrace -s

BEGIN
{
 printf("\nTarget is : %d\nSegement is %X\n",$target, $1);
}

syscall::mmap64:return
/arg1 == $1 && pid == $target/
{
 printf("mmap returns: %x",arg1);
 self->triggered = 1;
}

pid$target:zsh:dupstring:return
/self->triggered == 1/
{
 /*printf("Dupstring: %s",copyinstr(arg1));*/
 self->triggered = 0;
}

syscall::mmap64:entry
/pid == $target/
{
 printf("mmap size: %d",arg1);
}

syscall::munmap:entry
/arg0 == $1 && pid == $target/
{
 printf("munmap size: %d\n",arg1);
 ustack();
 self->munmapping = 1;
}

syscall::munmap:return
/self->munmapping/
{
 printf("Result of munmapping the segment in question was: %d",arg1);
 self->munmapping = 0;
}

fbt::as_removeseg:entry
/execname == "zsh" && ((struct seg*)arg1)->s_base == (caddr_t)$1/
{
 printf("\nGot removed");
 ustack();
 stack();
 exit(0);
}

fbt::as_addseg:entry
/execname == "zsh" && ((struct seg*)arg1)->s_base == (caddr_t)$1/
{
 printf("\nGot added");
 ustack();
 stack();
}

Danke an das ZSH-Team für das Überprüfen meines Patches.


Index: Src/mem.c
===================================================================
RCS file: /cvsroot/zsh/zsh/Src/mem.c,v
retrieving revision 1.16
diff -u -p -r1.16 mem.c
--- Src/mem.c   17 May 2008 17:55:38 -0000      1.16
+++ Src/mem.c   7 Sep 2008 09:23:32 -0000
@@ -153,9 +153,9 @@ old_heaps(Heap old)
        n = h->next;
        DPUTS(h->sp, "BUG: old_heaps() with pushed heaps");
 #ifdef USE_MMAP
-       munmap((void *) h, sizeof(*h));
+       munmap((void *) h, h->size);
 #else
-       zfree(h, sizeof(*h));
+       zfree(h, HEAPSIZE);
 #endif
     }
     heaps = old;

ZSH: IPS Completion Skript

2008-09-13T19:01:00.000-07:00

So ich hab mich mal hingesetzt und ein Vervollständigungsskript für IPS in der ZSH geschrieben. Das ganze ist noch relativ frisch und deswegen klappt vielleicht noch nicht alles so wie es soll, also gilt wie immer: PATCHES WELCOME ;)

IPS Completion

Um es zu nutzen: einfach als _pkg in /usr/share/zsh/site-functions speichern (compinit muss dafür aktiviert sein)

Gegebenenfalls werde ich das Skript natürlich aktualisieren. Ich habe leider noch nicht rausbekommen wie man Google Docs verbieten kann die Einrückung einfach zu verschlucken, also sieht das ganze dementsprechend schrecklich aus. Ich hoffe mal das es trotzdem noch ohne Probleme funktionieren wird.

Dtrace im Kampfeinsatz: ZSH debuggen

2008-08-24T19:12:00.000-07:00

Ich bin ja vor kurzem auf die wunderbare ZSH umgestiegen und leider Gottes habe ich den ein oder anderen Bug gefunden der ziemlich nervig ist. Es wurde mir verweigert selbst geschriebene Widgets an die menuselect Keymap zu binden. Naja, was macht man da? Ganz einfach, Sourcecode besorgen und dtrace durchstarten lassen. Nach kurzer Zeit hatte ich das Problem eingekreist und konnte mich ohne Probleme auf den relevanten Teil konzentrieren ohne erst großartig den Code zu lesen. In einem Fenster hatte ich die zu debuggende Shell in der anderen lief dtrace und hat mir angezeigt was passiert während ich tippe.

Hier sind ein paar Skripte die ich verwendet habe:

Was passiert gerade im Z-Lineeditor:


#!/usr/sbin/dtrace -s

#pragma D option flowindent

pid$target:zle.so::entry,
pid$target:zle.so::return
{
}

Der Userstack Backtrace sobald selectkeymap aufgerufen wird, inklusive der Information um welche Keymap es sich handelt:


#!/usr/sbin/dtrace -s

pid$target:zle.so:selectkeymap:entry
{
        ustack();
        printf("%s",copyinstr(arg0));
}

Und das ganze nochmal für selectlocalmap:


#!/usr/sbin/dtrace -s

pid$target:zle.so:selectlocalmap:entry
/arg0 != 0/
{
    ustack();
    printf("%p",arg0);
}

Das ganze lief am Ende darauf hinaus das im aktuellen Source der Version 4.3.6 einfach die Zeile 2315 in der Datei complist.c von selectlocalmap(mskeymap) in selectkeymap("menuselect",1) geändert werden musste. Da das ganze ein ziemlicher Quickhack ist, übernehme ich aber für nichts die Garantie ;).

Auf jeden Fall kann ich jetzt selbst geschriebene Widgets an die menuselect Keymap binden und $KEYMAP wird beim Wechsel auch richtig gesetzt, alles ohne viel Aufwand oder einer Debugversion von ZSH :D. Mal sehen was Upstream dazu sagt.

Ich sage dazu nur: DTRACE ROCKT!

ZSH: vi-mode reloaded

2008-08-23T15:21:00.000-07:00

Hmmmmm, vi Kommandos in der Shell. Sowas macht doch Spaß. Allerdings hab ich es gerne wenn mir der aktuelle Mode angezeigt und der Shellprompt ausgeblendet wird sobald ich im Kommando-Modus bin. Dafür hab ich meine .zshrc etwas erweitert. Allerdings gibt es ein kleines Problem: Der RPROMPT wird nur angepasst wenn die Shell mindestens ein Kommando ausgeführt hat. Mal sehen was die ZSH-Mailinglist dazu sagt.


zle-line-init zle-keymap-select()
{
    RPROMPT=${${KEYMAP/vicmd/-- COMMAND --}/main/}
    PROMPT=${${KEYMAP/main/$SAVEDPROMPT}/vicmd/}
    zle reset-prompt
}

zle -N zle-line-init
zle -N zle-keymap-select

setopt TRANSIENTRPROMPT

bindkey -M vicmd "^M" down-line-or-history

ZSH: Fit for fun

2008-08-21T19:25:00.000-07:00

Heute hab ich mich von der guten alten BASH verabschiedet und mein System auf ZSH umgestellt. Und da so eine mächtige Shell auch hübsch aussehen soll habe ich ihr auch gleich einen netten Look verpasst.

Für alle die es interessiert, hier die .zshrc:


# Lines configured by zsh-newuser-install
HISTSIZE=1000
SAVEHIST=1000
# End of lines configured by zsh-newuser-install
PATH="/usr/bin:\
/usr/X11/bin:\
/usr/sbin:/sbin:\
/opt/SunStudioExpress/bin:\
/opt/netbeans-6.0/bin:\
/opt/DTT/Bin:\
/usr/sfw/bin:\
/usr/gnu/bin"
MANPATH="/usr/share/man:\
/usr/X11/share/man:\
/opt/SunStudioExpress/man:\
/opt/DTT/Man:\
/usr/sfw/share/man:\
/usr/gnu/share/man"

if ((EUID != 0));
then
 PROMPT="[%{$(echo -n '\e[1;32m')%}%n\
%{$(echo -n '\e[0;00m')%}@\
%{$(echo -n '\e[0;33m')%}%m\
%{$(echo -n '\e[0;00m')%}:\
%{$(echo -n '\e[0;34m')%}%1~\
%{$(echo -n '\e[0;00m')%}]\
%{$(echo -n '\e[0;34m')%}> \
%{$(echo -n '\e[0;00m')%}"
 HISTFILE=~/.histfile
else 
   PROMPT="[%{$(echo -n '\e[0;31m')%}%n\
%{$(echo -n '\e[0;00m')%}@\
%{$(echo -n '\e[0;33m')%}%m\
%{$(echo -n '\e[0;00m')%}:\
%{$(echo -n '\e[0;34m')%}%~\
%{$(echo -n '\e[0;00m')%}]\
%{$(echo -n '\e[0;31m')%}> \
%{$(echo -n '\e[0;00m')%}"
 HISTFILE="/root/.histfile"
fi

ls()
{
 if [[ ${1[0,2]} != "-v" ]] && [[ (${1[0,2]} != "-V") ]];
 then
  /bin/dir $argv --color=always
 else
  /bin/ls $argv
 fi
}
setopt HIST_IGNORE_DUPS
setopt VI
unsetopt flowcontrol

bindkey "^[[3~" delete-char

Als kleine Besonderheit habe ich ls so umgestellt das es im Normalfall das GNU dir nimmt (weil das so schön bunt ist :P) und sobald ich die Option -v oder -V verwende das Solaris ls (weil das mit NFSv4 ACLs klarkommt welche ZFS-Standard sind)

Dtrace Workshop - Teil 4: Userspace tracen mit dem PID-Provider

2008-08-20T14:19:00.000-07:00

Nachdem wir uns in den letzten drei Teilen eigentlich nur mit Kerneltracing befasst haben, wird es Zeit sich dem Userspace zu widmen. Hierfür liefert dtrace den PID-Provider mit dem wir jede Funktion innerhalb eines Prozesses genauso unter die Lupe nehmen können wie wir es auch schon beim Kernel gelernt haben. Diesen Provider werde ich jetzt anhand eines einfachen C-Programms vorstellen.


#include <stdio.h>

void a(int i)
{
   printf("a\n");
   return;
}

void b(int i)
{
   printf("b\n");
   a(3);
}

void c(int i)
{
   printf("c\n");
   b(2);
}

int main()
{
   c(1);
   return 0;
}

Dieses Programm werden wir komplett ohne Debugsymbole übersetzen und userspace nennen. Wir wollen jetzt mit dem PID-Provider sehen welche Funktionen innerhalb des Programms ausgeführt werden. Dazu schreiben wir ein einfaches D Skript.


#!/usr/sbin/dtrace -s

#pragma D option flowindent

pid$target:userspace::return,
pid$target:userspace::entry
{
}

Die Variable $target bezieht sich auf das Programm das wir für dtrace als Ziel angeben. Dieses können wir mir der -c Option für ein spezifisches Kommando, oder mit -p für eine bestimmte PID angeben. Normal setzt sich der PID-Provider aus dem Wort pid und einer PID zusammen (z.B. pid2342), mit der Zielvariablen ist unser Skript allerdings sehr viel dynamischer. Als Modul haben wir hier userspace angegeben. Das ist der Name unseres Programms. Wir werden also nur Funktionen tracen die wir innerhalb unseres Programms definiert haben. Mit dtrace -l -p pidPID kann man sich übrigens alle tracebaren Funktionen eines bestimmten Prozesses ausgeben lassen (aber vorsicht, das ist meistens echt viel ;) ).


raichoo@itzkoatl:~/Projects# ./userspacetrace.d -c ./userspace
dtrace: script './userspacetrace.d' matched 13 probes
c
b
a
CPU FUNCTION
  0  -> _start
  0    -> __fsr
  0    <- __fsr
  0    -> main
  0      -> c
  0        -> b
  0          -> a
  0          <- a
  0        <- b
  0      <- c
  0    <- main
dtrace: pid 697 has exited

Jetzt würden wir aber gerne noch unsere printfs mittracen, dazu erweitern wir unser Skript einfach um die Tupel pid$target:libc.so.1:printf:entry und pid$target:libc.so.1:printf:return um die in libc.so.1 definierte printf Funktion zu tracen (das geht auch für jede andere gelinkte lib). Wir erhalten nun folgende Ausgabe:


dtrace: script './userspacetrace.d' matched 15 probes
c
b
a
CPU FUNCTION
  0  -> _start
  0    -> __fsr
  0    <- __fsr
  0    -> main
  0      -> c
  0        -> printf
  0        <- printf
  0        -> b
  0          -> printf
  0          <- printf
  0          -> a
  0            -> printf
  0            <- printf
  0          <- a
  0        <- b
  0      <- c
  0    <- main
dtrace: pid 714 has exited

Somit können wir jetzt jede Userspace Funktion tracen. Zum Abschluss will ich noch zeigen wie wir hier auch Probeargumente anwenden können:


#!/usr/sbin/dtrace -s

#pragma D option flowindent

pid$target:userspace::entry
{
   printf("Funktionsargument %d",arg0);
}


pid$target:userspace::return,
pid$target:libc.so.1:printf:return
{
}

pid$target:libc.so.1:printf:entry
{
   printf("Funktionsargument %s",copyinstr(arg0));
}

Dtrace Workshop - Teil 3: Der FBT-Provider und erste dtrace-Skripte

2008-08-19T12:30:00.000-07:00

In Teil 1 angekündigt und in Teil 2 aufgeschoben will ich jetzt endlich zum FBT-Provider kommen. Hiermit kann man sich wie gesagt jede Funktion die es im Kernel gibt ausgeben lassen. Als Beispiel werden wir uns hier angucken was im Kernel passiert wenn wir bestimmte Systemcalls ausführen. Da unsere dtrace Anweisungen aber inzwischen immer komplexer werden, wird es langsam Zeit das wir uns damit befassen wie man dtrace Skripte schreibt.

Wie bereits mehrmals gesagt wurde handelt es sich bei D um eine eigene Programmiersprache handelt welche sich an AWK und C anlehnt. D ist eventgesteuert, das heißt das bei bestimmten Ereignissen etwas ausgeführt wird und der Code nicht einfach durchlaufen wird. Als ersten sehen wir und mal ein einfaches dtrace Skript an. Wir greifen dabei auf eine der ersten Lektionen zurück die wir hatten, nämlich wie man sich anzeigen läßt welcher Prozess gerade welchen Systemcall ausführt.


#!/usr/sbin/dtrace -s

syscall:::entry
{
   trace(execname);
}

Wir speichern das ganze unter syscall.d und machen es mit chmod +x syscall.d ausführbar. Das Resultat sieht dann wie folgt aus:


raichoo@itzkoatl:~# ./syscall.d
dtrace: script './syscall.d' matched 233 probes
CPU     ID                    FUNCTION:NAME
  0  68998                      ioctl:entry   dtrace
  0  68998                      ioctl:entry   dtrace
  0  69134                  sysconfig:entry   dtrace
  0  69134                  sysconfig:entry   dtrace
  0  69266                   schedctl:entry   dtrace
  0  69068                  sigaction:entry   dtrace
  0  69068                  sigaction:entry   dtrace
  0  69068                  sigaction:entry   dtrace
  0  69068                  sigaction:entry   dtrace
...

Voila, schon haben wir unsere "Mühe" permanent in ein Skript gepackt, immer wieder abrufbar :).

Wollen wir uns jetzt mal ein etwas komplexeres D Skript ansehen. Hier werden wir uns ansehen was beim mmap Syscall alles im Kernel passiert.


#!/usr/sbin/dtrace -s

syscall::mmap:entry
{
   self->verfolgen = 1;
}

fbt:::entry,
fbt:::return
/self->verfolgen/
{
}

syscall::mmap:return
{
   self->verfolgen = 0;
   exit(0);
}

Ok das ist jetzt etwas viel auf einmal. Besonders mysteriös ist hier die Zeile self->verfolgen = 1. Hierbei handelt es sich um eine theadlokale Variable. Ruft ein Thread mmap auf wird verfolgen für diesen Thread auf 1 gesetzt, das wird wichtig wenn wir die Bedingung für unsere FBT Probes ansehen, diese wird nämlich nur ausgeführt wenn self->verfolgen gesetzt ist. Erinnern wir uns: in Teil 1 haben wir festgestellt das D Events wie folgt aufgebaut sind:


probe-tupel
/Bedingung/
{
   Funktionskörper
}

Sobald der mmap Systemcall zurückkehrt (mit syscall::mmap:return) wird die Variabel auf 0 gesetzt und das Skript beendet. Gucken wir uns mal die Ausgabe dieses Skripts an:


raichoo@itzkoatl:~# ./mmap.d
dtrace: script './mmap.d' matched 66380 probes
CPU     ID                    FUNCTION:NAME
  0  31880                    smmap32:entry
  0  23175               smmap_common:entry
  0  27816               as_rangelock:entry
  0  27817              as_rangelock:return
  0  23173                       zmap:entry
  0  31698                choose_addr:entry
  0  21835                   map_addr:entry
...
  0  29853                    as_map:return
  0  23174                      zmap:return
  0  29415             as_rangeunlock:entry
  0  29952                  cv_signal:entry
  0  29953                 cv_signal:return
  0  29416            as_rangeunlock:return
  0  23176              smmap_common:return
  0  31881                   smmap32:return
  0  69093                      mmap:return

Ok das ist ein ziemlicher Rattenschwanz (natürlich habe ich die Ausgabe hier gekürzt ;) )und leider auch sehr unübersichtlich, aber das alles passiert innerhalb eines mmap Syscalls im Kernel. Es wäre aber doch viel schöner wenn man die Ausgabe etwas einrücken könnte und damit besser lesbar. Das erreichen wir durch eine zusätzliche Zeile in unserem Skript.


#!/usr/sbin/dtrace -s

#pragma D option flowindent

syscall::mmap:entry
{
   self->verfolgen = 1;
}

fbt:::entry,
fbt:::return
/self->verfolgen/
{
}

syscall::mmap:return
{
   self->verfolgen = 0;
   exit(0);
}

Durch die Anweisung #pragma D option flowindent veranlassen wir dtrace unsere Ausgabe je nach entry oder return einzurücken und somit sehr viel lesbarer zu machen.
Hier nochmal die gleiche Ausagebe mit flowindent:


raichoo@itzkoatl:~# ./mmap.d
dtrace: script './mmap.d' matched 66380 probes
CPU FUNCTION
  0  -> smmap32
  0    -> smmap_common
  0      -> as_rangelock
  0      <- as_rangelock
  0      -> zmap
  0        -> choose_addr
  0          -> map_addr
...
  0      <- zmap
  0      -> as_rangeunlock
  0        -> cv_signal
  0        <- cv_signal
  0      <- as_rangeunlock
  0    <- smmap_common
  0  <- smmap32
  0  <= mmap

Jetzt kann man sicher sagen: "Ok... das sagt mir zwar jetzt welche Funktionen ausgeführt werden, aber was passiert denn jetzt genau". Stimmt, ohne Code sagt uns das jetzt recht wenig. Sun hat allerdings unter http://src.opensolaris.org/source/ den gesamten veröffentlichen Code durchsuchbar gemacht. Wir brauchen uns also nur eine Funktion von Interesse aussuchen, ihren Namen unter Definition eingeben und schon kriegen wir die Datei angegeben in der sie definiert ist und können sie uns auch online ansehen. Zugegeben ist das keine leichte Kost, aber das ist Kernelcode eigentlich fast nie. Hier kann man ihn aber live in Aktion sehen was das Verständnis um einiges erleichtert. :)

Warum OpenSolaris?

2008-08-18T05:35:00.000-07:00

Ich muss zugeben das mir diese Frage in den letzten Wochen ziemlich oft gestellt wurde, vor allem da man mich seit 12 Jahren eigentlich als überzeugten Linuxuser kannte. Zugegeben hat mich das ganze selbst ziemlich unerwartet getroffen, da ich OpenSolaris bis auf ZFS eigentlich als ziemlich uninteressant empfunden habe und teilweise sogar belächelt. Aber mit Betriebssystemen ist es manchmal wie mit Menschen: "Wenn man es erst einmal kennengelernt hat, ist es eigentlich richtig cool".

"Aber warum nicht Linux?"

, hört man aus der Linuxecke (bei den BSDler ist es oft ähnlich ^^). Die Frage ist sicherlich nicht ganz unberechtigt, verfügt Linux doch über sehr viel mehr Treiber und je nach Distribution derzeit noch über sehr viel mehr Pakete. Das mit den Treiber ist tatsächlich immer wieder ein Argument welches mir begegnet. Die Sache mit Treiber ist allerdings: Man braucht sie nur wenn man die Hardware hat. Und 99% der unterstützten Hardware besitze ich nun mal nicht und ich habe genauso wenig vor sie zu kaufen, also ist das Treiberargument hinfällig. Außerdem erinnere ich mich noch an eine Zeit als ich unter Linux weder Sound noch einen brauchbaren Browser hatte und trotzdem habe ich es benutzt weil es eben das gemacht hat was ich von ihm verlangt habe.
Und genau das ist es was OpenSolaris jetzt für mich macht, derzeit allerdings noch mehr als Entwicklungsumgebung und noch nicht als mein Alltagsdesktop da es unter anderem noch an einer gewissen Multimediafähigkeit mangelt. Da OpenSolaris in dieser Form allerdings erst seit Mai existiert und es dafür schon eine sehr vollständige Figur macht, kann ich darüber ersteinmal hinwegsehen. Außerdem ist besagtes für den nächsten Release im November in Arbeit.

"Aber was macht OpenSolaris denn jetzt besser als Linux?"

Erstmal: Es handelt sich hier um persönliche Präferenzen. Ich kann hier noch soviel von Features schwärmen, aber letztendlich muss man diese Features auch nutzen. Hier einfach mal ein kleiner Einblick:

ZFS

In den letzten Monaten ist ZFS schon fast zum Buzzword geworden. Irgendwie redet jeder davon aber selten wird wirklich mal erklärt was ZFS eigentlich kann. Für alle Interessenten kann ist jedem Mal den ZFS Podcast vom Chaosradio ans Herz legen. Ein besonders tolles Feature bei ZFS ist die Möglichkeit Snapshots von seinen Filesystemen anzulegen und damit sein System ähnlich wie bei modernen Versionskontrollsystemen zu verzweigen. Hier ein Beispiel von meinem System.


raichoo@itzkoatl:~$ beadm list

BE                Active Active on Mountpoint Space
Name                     reboot               Used
----              ------ --------- ---------- -----
opensolaris       no     no        -          14.58M
opensolaris_snv95 yes    yes       /          6.40G

Es verfügt über 2 sogenannte Bootumgebungen. opensolaris und opensolaris_snv95. Auf der ersten liegt das Ursystem, mit anderen Worten die Version von OpenSolaris mit der ich installiert habe. Mit der Zeit kamen allerdings mehrere Updates und wie heißt es so schön: "Never change a winning Team". Also habe ich eine zusätzliche Bootumgebung mit dem Namen opensolaris_snv95 angelegt. Nachdem man diese erzeugt hat, besitzt man eine exakte Kopie seines Systems welche man dann separat updaten kann. Das ganze funktioniert so:


raichoo@itzkoatl:~# beadm create opensolaris_snv95
raichoo@itzkoatl:~# mkdir /tmp/mein_neues_system
raichoo@itzkoatl:~# beadm mount opensolaris_snv95 /tmp/mein_neues_system
raichoo@itzkoatl:~# pkg -R /tmp/mein_neues_system image-update
...
raichoo@itzkoatl:~# beadm unmount opensolaris_snv95
raichoo@itzkoatl:~# beadm activate opensolaris_snv95

Mit pkg habe ich die Kopie meines Systems auf den neusten Stand gebracht und mit activate habe ich dafür gesorgt das sie beim nächsten booten als Standard ausgewählt wird. Besonders praktisch ist hier das beadm auch schon grub eingerichtet hat und ich jetzt für jede Version einen Eintrag hat. Dazu kommt noch das die Kopie meines Systems nur den Unterschied zwischen beiden Systemen an Plattenplatz belegt. So kann man immer ohne Risiko an seinem System herumschrauben und mit einem Handgriff zurück. Aber ZFS kann noch mehr, unter anderem auch unglaublich mächtige Backupfunktionen, sehr komfortables NFS und Samba-Management, Raidfunktionen die weit über die Möglichkeit von traditionellem Hardwareraid hinausgehen, transparente Kompression und bald auch transparente Verschlüsselung, Selbstheilung und alles läßt sich mit zwei Befehlen einfach und intuitiv aus der Konsole steuern. Wers nicht glaubt, hier die manpages zu zpool und zfs.

Dtrace und MDB

Ich bin jemand der gerne versteht was in seinem System vorgeht. Das schließt Userspace Programme genauso ein wie Kernelspace Aktivitäten. Aus diesem Grund sammel ich auch Bücher die sich mit den jeweiligen Kerneln befassen. Zu Linux besitze ich das Buch "Understanding the Linux Kernel", und auch wenn es in vielerlei Hinsicht nicht uninteressant ist hat es einen gravierenden Nachteil: Ich kann so gut wie nichts davon live beobachten und mir bringt das Wissen um den Kernel und seine Funktionsweise relativ wenig, da nachdem er übersetzt ist er sich für mich in eine Blackbox verwandelt. Mit dtrace und dem Modular Debugger mdb kann ich jederzeit in den Kernel hineinsehen und nachvollziehen was passiert. Ich kann mein Wissen über den Kernel einsetzen um an die Informationen heranzukommen die ich brauche. Ein extremer Vorteil wenn man Probleme sucht, oder einfach nur verstehen will was eigentlich vor sich geht. Zu dtrace haben ich, wie einige vielleicht schon bemerkt haben, einen Workshop auf meinem Blog, eventuell werde ich das gleiche auch noch für mdb machen.

IPS

Über die Jahre gab es viele Paketsysteme und inzwischen sind die etablierten mehr oder weniger veraltet. Rpm soll überholt werden und apt ist für meinem Geschmack einfach zu kompliziert wenn es ums schnüren von Paketen geht. Ich will meine Software einfach nur übersetzen und dann freigeben können. Genau das macht IPS für mich. Ich muss mich nicht damit befassen Skripte zu schreiben um ein Paket zu erschaffen sondern kann meine Software einfach in mein eigenes Repository hochladen, das ganze ist in der Funktionalität wieder stark an moderne Versionskontrollsysteme angelehnt. Alles wunderbar ist dokumentiert auf der OpenSolaris Seite.

Dokumentation

Womit wir auch gleich schon zum nächsten Punkt kommen. Als Developer hasst man es sie zu schreiben, als Anwender liebt man es sie zu haben. Dokumentation. Was mich bei praktisch allen Linux Distributionen immer gestört hat war der Mangel an aktueller tiefgreifender Dokumentation, die auch zugegebenermaßen bei den vielen Änderungen (ob nötig oder nicht sei mal dahingestellt) oft nicht auf dem neusten Stand ist oder teilweise einfach nur oberflächlich am Problem kratzt. Meistens provoziert ein sogenanntes Howto noch weitere Fragen die wieder dazu führen das man suchen muss. Das ganze artet oft in eine Art Schnitzeljagd im Netz aus, die nicht immer vom Erfolg gekrönt ist und gerade bei komplexen Fragen oft im Nichts endet.
Zu Solaris gibt es allerdings einen zentralen Dokumentationsserver. http://docs.sun.com wartet mit einem Berg an Büchern auf (ja, ganze Bücher keine Howtos)die alle frei zum herunterladen angeboten werden. Alles im handlichen PDF Format, sprengt das Angebot ohne Probleme die 10.000 Seiten Grenze (vermutlich sogar weit darüber hinaus). Alles wird verständlich mit Beispielen erklärt und sollte doch mal eine Frage auftauchen existiert meistens schon ein Link zum Buch das diese Frage klärt.

Stabile ABI

Etwas vor dem sich Linux leider bis heute fürchtet oder ablehnt. Oft sind nach 2 oder 3 Versionen Treiber im Binärformat nicht mehr zu gebrauchen und man muss praktisch alles neu kompilieren. Nutzt man eine vorgefertigte Distribution hat man dieses Problem nicht, aber kommerzielle Anbieter schrecken davor zurück Treiber für Linux herzustellen da die Binärkompatibilität nicht gewährleistet ist. Auch wenn ich prinzipiell gegen sogenannte Blobs bin ist es für viele Anbieter ein Grund keine Treiber für Linux zu veröffentlichen, da der Wartungsaufwand in keinerlei Bezug zum Nutzen wäre. Unter Solaris 10 z.B. ist es allerdings immer noch möglich einen Netzwerktreiber zu laden der für Solaris 8 geschrieben wurde.

Es gibt noch viele weitere Grunde wie das SMF System, Zones, die SunStudio Entwicklungsumgebung, die p*-Tools usw. Die mich dazu gebracht haben auf Solaris zu wechseln, aber auch hier gilt: Ein Feature ist nur dann sinnvoll wenn man es nutzt. Mir macht es auf jeden Fall das Leben ungeahnt leichter :)

Wer jetzt neugierig ist kann sich auch einmal den Podcast von pofacs.de (eine allgemein sehr lohnenswerte Seite) zu OpenSolaris anhören.

Dtrace Workshop - Teil 2: Probeargumente und Aufzählungen

2008-08-17T12:23:00.001-07:00

In Teil 1 dieses Workshops haben wir uns mit grundlegenden Funktionen von dtrace befasst. Heute will ich mich mit Probeargumenten und Aufzählungen befassen.

Wie ich letztes mal schon festgestellt habe, arbeitet man bei dtrace mit der Programmiersprache D. Diese Sprache verfügt unter anderem über Datentypen. Ein besonderer Datentyp ist die Aufzählung. Ich will hier mal in einem kleinen Beispiel zeigen wie das funktioniert indem ich dtrace Systemcalls aufzählen lasse.


raichoo@itzkoatl:~# dtrace -n 'syscall:::entry{@[probefunc] = count();}'
dtrace: description 'syscall:::entry' matched 233 probes
^C

  fstat64                                                           1
  mmap                                                              1
  schedctl                                                          1
  sigpending                                                        1
  nanosleep                                                         2
  stat64                                                            2
  pset                                                              3
  sysconfig                                                         3
  c2audit                                                           4
  dup                                                               4
  fcntl                                                             4
  open                                                              4
  sigaction                                                         4
  brk                                                               6
  close                                                             8
  gtime                                                            10
  clock_gettime                                                    11
  writev                                                           12
  setcontext                                                       13
  lwp_sigmask                                                      15
  setitimer                                                        25
  p_online                                                         32
  portfs                                                           84
  write                                                           133
  getpid                                                          169
  read                                                            171
  doorfs                                                          252
  lwp_park                                                        320
  pollsys                                                         496
  ioctl                                                           648

Wollen wir mal der Aufzählung auseinandernehmen:
Mit dem @ zeigen wir an das wir etwas aufzählen wollen. Was das genau ist geben wir in eckigen Klammern an, in diesem Fall ist das die Probefunktion. probefunc ist eine vordefinierte Variable die uns sagt welche Probe "gefeuert" hat. Kommen wir nun zum = count(). Dieser Teil sagt uns WIE wir aufzählen wollen. count() zählt einfach nur wie oft ein Ereignis eingetreten ist. Später werden wir uns genauer unterschiedlichen Aufzählungsarten befassen.
Als Anmerkung bleibt wohl noch zu sagen das dtrace während der Ausführung nichts ausgibt sondern erst wenn wir es mit Strg-C beenden.

Als nächstes wollen wir uns zur Vertiefung noch einen dtrace-Aufruf ansehen der uns anzeigt welche Programme den mmap Systemcall aufrufen und wie oft.


raichoo@itzkoatl:~# dtrace -n 'syscall::mmap:entry{@[execname] = count();}'
dtrace: description 'syscall::mmap:entry' matched 1 probe
^C

  dtrace                                                            1
  hostname                                                         16
  utmp_update                                                      16
  bash                                                             33

Hier zählen wir nicht nach probefunc sondern nach execname auf. Außerdem haben wir das Probetupel genauer spezifiziert.

Wir wollen uns jetzt mal genauer angucken was ein Systemcall so macht. Als Beispiel nehme ich hier den open Systemcall. Gucken wir uns die Funktionsdefinition in der dazugehörigen Manpage an:


int open(const char *path, int oflag, /* mode_t mode */);

Diese Informationen werden an den open Syscall übergeben und wenn man ehrlich ist, würde man da eigentlich auch ganz gerne drankommen wenn man dtrace benutzt. Und das geht auch. Wir haben mit execname und probefunc bereits 2 vordefinierte Variablen kennengelernt, jetzt kommen die Variablen arg0 bis arg9 hinzu. Jede gibt uns Zugang zu einem Argument der jeweiligen Probe.
Als Beisiel konstruieren wir hier mal einen dtrace Aufruf der uns anzeigt welche Dateien unser System gerade öffnet.


raichoo@itzkoatl:~# dtrace -n 'syscall::open:entry{printf("%s",copyinstr(arg0));}'
dtrace: description 'syscall::open:entry' matched 1 probe
CPU     ID                    FUNCTION:NAME
  0  69268                       open:entry /export/home/raichoo/.icons/Neutral_Plus_Inv/cursors/xterm
  0  69268                       open:entry /export/home/raichoo/.icons/Neutral_Plus_Inv/index.theme
  0  69268                       open:entry /usr/share/icons/Neutral_Plus_Inv/cursors/xterm
  0  69268                       open:entry /export/home/raichoo/.icons/Neutral_Plus_Inv/cursors/xterm
  0  69268                       open:entry /export/home/raichoo/.icons/Neutral_Plus_Inv/index.theme
  0  69268                       open:entry /usr/share/icons/Neutral_Plus_Inv/cursors/xterm
  0  69268                       open:entry /export/home/raichoo/.icons/Neutral_Plus_Inv/cursors/xterm
  0  69268                       open:entry /export/home/raichoo/.icons/Neutral_Plus_Inv/index.theme
  0  69268                       open:entry /usr/share/icons/Neutral_Plus_Inv/cursors/xterm
  0  69268                       open:entry /export/home/raichoo/.icons/Neutral_Plus_Inv/cursors/xterm
  0  69268                       open:entry /export/home/raichoo/.icons/Neutral_Plus_Inv/index.theme
  0  69268                       open:entry /usr/share/icons/Neutral_Plus_Inv/cursors/xterm
  0  69268                       open:entry /export/home/raichoo/.icons/Neutral_Plus_Inv/cursors/xterm

Zu printf werde ich hier nicht viel verlieren sondern auf die C Manpage verweisen, da sich die dtrace Funktion genauso verhält. Wir wollen und das erste Argument der Probe ansehen, wie wir oben schon gesehen haben ist das erste Argument const char *path der Pfad der zur öffnenden Datei. Um dieses auszulesen benutzen wir das Probeargument arg0. Da wir uns in einem Systemcall befinden müssen wir die Informationen aus dem Kerneladressraum in den Userspaceaddressraum kopieren, dazu ist die copyinstr() Funktion da.

Eigentlich wollte ich noch etwas auf den FBT-Provider eingehen, aber ich glaube das ist erstmal genug Input für heute, also werde ich mir das für später aufbewahren.

Dtrace Workshop - Teil 1: Einführung

2008-08-14T17:35:00.001-07:00

Nachdem ich ja immer so viel von dtrace schwärme möchte ich den Menschen auch gerne mal dieses extrem praktische Tool nahe bringen. Das dieses Thema extrem umfangreich ist werde ich es in verschiedene Sektionen aufteilen und von Zeit zu Zeit immer mal wieder etwas dazu posten.

Was ist dtrace überhaupt? Der beste Vergleich den ich kenne ist wie folgt:
Stell dir vor du hast Probleme mit deinem Auto. Es macht komische Geräusche wenn du schnell fährst. Und nun stell dir vor du fährst auf die Autobahn, beschleunigst auf 200 Sachen und steigst gemütlich aus, öffnest die Motorhaube und baust die Kiste auseinander ohne das diese aufhört zu arbeiten. Du kannst dir jede Schraube jeden Schlauch und jedes noch so komplexe Teil ansehen und herausfinden wo es Probleme gibt. Genau das macht Dtrace mit deinem Betriebssystem und alle Programmen die darauf laufen.

Jetzt kann man sicherlich sagen. Naja in meine Programme konnte ich aber schon immer mit einem Debugger reingucken. Klar konnte man das, aber nur in einzelne Prozesse. Dtrace ermöglicht systemweites Debuggen ohne das man das System in ein großes Performanceloch schmeißt wie das mit Tools wie strace und truss z.B. der Fall ist.

Wie funktioniert das Ganze? Dtrace verfügt über sogenannte Provider, welche in der Lage sind das System zu "instrumentalisieren". Das heißt: Sie kennen Punkte im System an dem sie Messungen durchführen können.

Listen wir erst mal unsere Messpunkte auf:


raichoo@itzkoatl:~# dtrace -l
   ID   PROVIDER            MODULE                          FUNCTION NAME
    1     dtrace                                                     BEGIN
    2     dtrace                                                     END
    3     dtrace                                                     ERROR
    4        fbt              fcsm         fcsm_job_cache_destructor entry
    5        fbt              fcsm         fcsm_job_cache_destructor return
    6        fbt              fcsm        fcsm_job_cache_constructor entry
    7        fbt              fcsm        fcsm_job_cache_constructor return
    8        fbt              fcsm                      fcsm_display entry
    9        fbt              fcsm                      fcsm_display return
...
69649   lockstat           genunix                   lock_clear_splx spin-release
69650   lockstat           genunix                      CLOCK_UNLOCK spin-release
69651   lockstat           genunix                          rw_enter rw-acquire
69652   lockstat           genunix                          rw_enter rw-block
69653   lockstat           genunix                           rw_exit rw-release
69654   lockstat           genunix                       rw_tryenter rw-acquire
69655   lockstat           genunix                     rw_tryupgrade rw-upgrade
69656   lockstat           genunix                      rw_downgrade rw-downgrade
69657   lockstat           genunix                       thread_lock thread-spin
69658   lockstat           genunix                  thread_lock_high thread-spin

Ok, hier wurden wir gerade mit verdammt vielen Messpunkten oder auch Probes erschlagen. Wie man sieht ist jede Probe einem Provider, einem Modul, einer Funktion und einem Namen zugeordnet. Mit diesen Tupeln sind wir in der Lage jeden Messpunkt zu spezifizieren und damit anzusprechen. Gucken wir einfach mal wie viele Probes uns unser System so zur Verfügung stellt.


raichoo@itzkoatl:~# uname -a
SunOS itzkoatl 5.11 snv_95 i86pc i386 i86pc
raichoo@itzkoatl:~# dtrace -l | wc -l
   69659

Alleine auf meinem System stehen mir fast 70.000 Probes zur Verfügung. Und das sind noch lange nicht alle, es gibt noch ein paar spezielle Provider (z.B. den PID-Provider und auch Provider für so ziemlich jedes Skriptsprache z.B. Python, Ruby, PHP, JavaScript und und und) die einem noch mehr Transparenz geben.

Ok, jetzt da wir wissen das wir wirklich viel messen können wollen wir mal loslegen! Als Einführungsbeispiel will ich hier den Syscallprovider vorstellen. Dieser Provider weiß wie man Systemcalls instrumentalisiert. Systemcalls sind Funktionen bei deren Ausführung ein Programm ein Aufgabe an den Kernel abgibt z.B. öffne eine Datei, mappe mir etwas in den virtuellen Speicher, schicke ein Signal an einen anderen Prozess.

Als erstes wollen wir erst mal jeden Syscall-Entry anzeigen lassen.


raichoo@itzkoatl:~# dtrace -n syscall:::entry
...
  0  69480                    pollsys:entry
  0  69166                      write:entry
  0  69450                lwp_sigmask:entry
  0  69450                lwp_sigmask:entry
  0  69164                       read:entry
  0  69480                    pollsys:entry
  0  69450                lwp_sigmask:entry
  0  69450                lwp_sigmask:entry
  0  69166                      write:entry
  0  69480                    pollsys:entry
  0  69166                      write:entry
  0  69450                lwp_sigmask:entry
  0  69450                lwp_sigmask:entry
  0  69164                       read:entry
  0  69480                    pollsys:entry
  0  69450                lwp_sigmask:entry
  0  69450                lwp_sigmask:entry
  0  69166                      write:entry

Jetzt werden uns in Echtzeit alle Systemcall-Entrys auf dem System gezeigt ohne das das System ausgebremst wird. Diese Information ist allerdings eher unspannend. Wir wollen ja auch wissen WER das macht, also erweitern wir unser Kommando:


raichoo@itzkoatl:~# dtrace -n 'syscall:::entry{trace(execname);}'
...
  0  69258                      ioctl:entry   dtrace
  0  69258                      ioctl:entry   dtrace
  0  69258                      ioctl:entry   dtrace
  0  69258                      ioctl:entry   dtrace
  0  69258                      ioctl:entry   dtrace
  0  69258                      ioctl:entry   dtrace
  0  69258                      ioctl:entry   dtrace
  0  69258                      ioctl:entry   dtrace
  0  69258                      ioctl:entry   dtrace
  0  69258                      ioctl:entry   dtrace
  0  69352                       mmap:entry   dtrace
  0  69286                   lwp_park:entry   dtrace
  0  69450                lwp_sigmask:entry   sshd
  0  69450                lwp_sigmask:entry   sshd
  0  69164                       read:entry   sshd
  0  69480                    pollsys:entry   sshd
  0  69450                lwp_sigmask:entry   sshd
  0  69450                lwp_sigmask:entry   sshd
  0  69166                      write:entry   sshd
  0  69480                    pollsys:entry   sshd
  0  69450                lwp_sigmask:entry   sshd
  0  69450                lwp_sigmask:entry   sshd
  0  69164                       read:entry   sshd
  0  69480                    pollsys:entry   sshd
  0  69450                lwp_sigmask:entry   sshd
  0  69450                lwp_sigmask:entry   sshd
  0  69166                      write:entry   sshd
  0  69480                    pollsys:entry   sshd
  0  69330                 sigpending:entry   dtrace
  0  69450                lwp_sigmask:entry   dtrace
  0  69332                 setcontext:entry   dtrace
  0  69166                      write:entry   dtrace
  0  69450                lwp_sigmask:entry   sshd
  0  69450                lwp_sigmask:entry   sshd
  0  69164                       read:entry   sshd
  0  69480                    pollsys:entry   sshd
  0  69450                lwp_sigmask:entry   sshd
  0  69450                lwp_sigmask:entry   sshd
  0  69166                      write:entry   sshd
  0  69480                    pollsys:entry   sshd
  0  69258                      ioctl:entry   dtrace

Mit trace(execname) geben wir an das wir uns für das Programm interessieren das den Systemcall tätigt. execname ist eine vordefinierte Variable von der es eine ganze Menge gibt.

Aber was genau sehen wir da jetzt? Einige werden es sicher schon ahnen. Ich bin über SSH mit meinem Solarisrechner verbunden und alles was wir jetzt sehen sind die Systemcalls die das System braucht um all die Informationen für mich sichtbar zu machen. Wir gucken also dem System zu wie es uns sagt das es etwas sagt.

Wollen wir also unsere "Observation" weiter einschränken. Wir können ein Bedingung angeben die uns nur in bestimmeten Fällen einen Messwert liefert. Das geht wie folgt.


raichoo@itzkoatl:~# dtrace -n 'syscall:::entry/execname == "gdm-binary"/{}'
dtrace: description 'syscall:::entry' matched 233 probes
CPU     ID                    FUNCTION:NAME
  0  69164                       read:entry
  0  69164                       read:entry
  0  69164                       read:entry
  0  69166                      write:entry
  0  69412                      yield:entry
  0  69164                       read:entry
  0  69164                       read:entry
  0  69486                    c2audit:entry
  0  69368                      xstat:entry
  0  69312                   readlink:entry
  0  69486                    c2audit:entry
  0  69450                lwp_sigmask:entry
  0  69450                lwp_sigmask:entry
  0  69450                lwp_sigmask:entry
  0  69450                lwp_sigmask:entry
  0  69356                     munmap:entry
  0  69356                     munmap:entry
...

Hier werden uns nur Informationen ausgegeben wenn das ausführende Programm gdm-binary ist.

Unsere Abfrage ist also wie folgt aufgebaut:


dtrace -n probe-tupel
/Bedingung/
{
    Funktionskörper
}

Wie man sieht stellt dtrace eine kleine Programmiersprache zur Verfügung. Diese Sprache hat den Namen D und ist stark mit AWK und C verwand.

Das war nur ein extrem kleiner Einblick in das was dtrace kann. Als nächstes werde ich mich mit Probe-Argumenten, dem FBT-Provider (welcher jede Funktion im Kernel tracen kann) und dtrace-Skripten befassen. Wer bis dahin nicht warten kann, kann sich auch den Vortrag von Brian Cantrill über dtrace ansehen (SEHR SEHENSWERT!) oder einfach mal im Dtrace User's Guide schmöckern.

Dtrace kann man auch auf der OpenSolaris LiveCD benutzen. Als Anmerkung gilt zu sagen das man root-Rechte braucht (oder bestimmte RBAC-Rechte auf einem Produktivsystem)

Pimp my Blog

2008-08-14T17:13:00.000-07:00

Nachdem es irgendwie recht defaultmässig auf meinem Blog zugegangen ist hab ich mir mal ein paar zusätzliche Einstellungen gegönnt im das gute Stück hier etwas persönlicher und auch übersichtlicher zu gestallten. :)

Der widerspenstigen Zähmung

2008-08-04T03:38:00.000-07:00

Da vi/vim unter manchen Systemen die nervige Angewohnheit hat im Insert-Mode etwas eigensinnig mit den Pfeiltasten umzugehen, hier ein kleiner Patch um dem guten Stück Beine zu machen:

Wir schreiben folgendes in unsere .exrc und .vimrc:

set t_ku=[strg-v][pfeil-hoch]
set t_kd=[strg-v][pfeil-runter]
set t_kr=[strg-v][pfeil-rechts]
set t_kl=[strg-v][pfeil-links]

(Anmerkung: Das was in den eckigen Klammern steht nicht abtippen sondern machen ;) )

Um das ganze im Nachhinein noch etwas aufzupeppen kann man auch noch "set showmode" und "syntax on" hinzufügen um den aktuellen Mode anzeigen zu lassen und das Syntaxhighlighting zu aktivieren.

Dtrace überall

2008-08-03T13:37:00.000-07:00

In den letzten Jahren hat dtrace, das dynamische Tracingtool von OpenSolaris, für eine Menge aufsehen gesorgt und inzwischen findet es auf immer mehr Plattformen ein zuhause. Ports existieren bereits für Mac OS X und QNX. Derzeit werden auch vom FreeBSD (man munkelt auch über einen NetBSD Port) Team Anstrengungen unternommen es zu portieren und vor einigen Monaten wurde der erste Code in den CURRENT Zweig commited.
Unter Linux gab es allerdings Probleme da die CDDL-Lizenz, unter der dtrace steht, nicht kompatibel zur GPL ist. Es wurden zwar mit systemtap Ansätze unternommen dtrace zu kopieren, doch ist es in keiner Weise vergleichbar da es unter anderem nicht in der Lage ist Userspace Prozesse zu tracen und die Stabilität des Systems beeinträchtigt da unter anderem das "Skripten" welches fast C ähnlich ist, völlig über das Ziel hinausschiesst und gefährlichen Code ermöglicht. Inzwischen ist das ftrace-Framework im Gespräch welches aber im Gegensatz zu dtrace und systemtap nicht skriptbar ist und damit extrem an Flexibilität einbüßt. Alles in allem eher spärliche Aussichten. Für ein Licht am Ende des Tunnels sorgt Paul Fox der sich daran gemacht hat dtrace auf Linux zu portieren. Ob es letztendlich möglich sein wird Linux Distributionen mit dtrace auszuliefern kann ich derzeit leider nicht sagen (da mir der ganze Lizenzkram langsam eh zu undurchschaubar wird), aber es bleibt die Hoffnung das es wenigstens ein Patchset geben wird das dieses unglaublich mächtige Tool in die Linuxwelt bringen wird.

Der Solaris Kerneldebugger: Ein Beispiel

2008-07-30T15:56:00.000-07:00

Mein Notebook hat die unangenehme Angewohnheit das es unter Solaris gerne einen NMI produziert (Non Maskable Interrupts sind etwas unangenehme Zeitgenossen die z.b. bei Hardwarefehlern auftreten). Nach ein bisschen schmökern im Sourcecode von Solaris ist mir dann aufgefallen das es dort folgende Varibale im pcie Modul gibt:

uint32_t pcie_serr_disable_flag = 0;    /* Disable SERR */

In einem Kommentar wird erwähnt das bei aktiviertem SERR eventuell ein NMI entsteht (welcher aber nicht behandelt wird). Jetzt wollen wir den Inhalt dieser Variable also auf 1 haben damit SERR deaktiviert wird und wir den NMI los sind. Dazu nehmen wir den Kerneldebugger. Durch einfaches Anhängen von -kd im Kerneleintrag von Grub landet man gleich zu Anfang am Debugprompt. Wir wollen jetzt zu dem Punkt springen an dem unser pcie Modul geladen wird, das erreichen wir indem wir dem Debugger sagen das es an diesem Punkt halten soll.


::bp pcie`_init
::cont

Damit wird ein so genannter Breakpoint gesetzt. Wird dieser erreicht halten wir an und gelangen wieder an den Prompt. ::cont sagt dem Debugger einfach
das das Programm weiterlaufen soll.

Wir erreichen nun unseren Breakpoint. Jetzt können wir den Inhalt unserer Variable einfach mit

pcie_serr_disable_flag/W 1

auf 1 setzen und mit ::cont weiterbooten ohne das der NMI auftaucht.

Praktische Sache oder? ;)

Spaß mit DLL-Injection

2008-07-28T05:02:00.000-07:00

Heute will ich mich mal mit einer sehr interessanten Debug-Technik befassen: der DLL-Injektion.
Jeder der schon mal in C++ oder ähnlichem gecodet hat kennt sicherlich das Konzept des Überladen von Funktionen. Die Frage ist jetzt: Kann man das ganze auch noch machen wenn ein Programm schon fertig gebacken ist? Otto würde jetzt sagen "Yiiiaaaaaaaaaah ih ih ih ih" *rumhüpf*

Als Beispiel werde ich hier mal etwas fehlerhaften C-Code kompilieren und im Nachhinein die verantwortliche Funktion mit etwas harmlosen überladen.

Hier erst mal unser fehlerhafter code

#include <unistd.h>
#include <stdio.h>

int main()
{
        char buffer[256];
        vscanf("%s",buffer);
        return 0;
}

Das Ganze segelt in einem herrlichen Segfault ab ^^. Ok, jetzt wollen wir einfach mal die Funktion vscanf mit etwas harmlosen "überschreiben". Dazu werden wir eine Dummy-lib schreiben und diese mit LD_PRELOAD dynamisch in unser Programm linken.

Der Code für unser Lib sieht erst mal so aus:


#include <unistd.h>
#include <stdio.h>

int vscanf(const char* format,va_list ap)
{
        printf("override\n");
        return 0;
}

Voila, wir haben die Zutaten. Jetzt wird es Zeit für das Rezept:


[raichoo@tessaiga ~]$ gcc test.c -o karpott
[raichoo@tessaiga ~]$ ./karpott
test
Segmentation fault: 11 (core dumped)
[raichoo@tessaiga ~]$ gcc -shared -o override.so override.c
[raichoo@tessaiga ~]$ LD_PRELOAD=./override.so ./karpott
override

Guten Appetit!

KDE4 unter FreeBSD

2008-07-23T02:34:00.000-07:00

Letzte Woche war es soweit: Für all die, denen kompilieren immer zu mühseelig ist, gibt es seit Donnerstag KDE4 Pakete für FreeBSD. Das Ganze dient derzeit noch zum testen, läuft aber bis auf einige Kleinigkeiten ziemlich rund. Die Porter rufen derzeit zur regen Bugjagd auf um KDE4 für FreeBSD fit zu machen.

Vielen Dank an Miwi fürs portieren und die Starthilfe ;)