Using drbd as a simple and reliable alternative to distributed block devices is quite common. Especially in primary/primary mode, it provides the possibility to host block devices for virtual machines on two different hosts.

However, there is one annoyance that any active user stumbles over at some point in time. After a network restart, it may happen, that the devices switch to standalone mode and do not even try to reconnect to their peer. The reason for this is, that when doing a network restart, the device is shut down for a short time. DRBD itself has no means to wait for hotplugging devices, and thus just cuts the network connection in that case.

I know of two methods to solve that issue on the operating system side.

1. Create a script in /etc/sysconfig/network/scripts/ifup.d that contains the necessary code to reconnect the drbd device to its peer
2. The easiest way I know about is to switch the network interface to startmode nfsroot.

To accomplish this, edit the configuration file of the device that is used to connect to the peer, like e.g. /etc/sysconfig/network/ifcfg-eth0 and change the line

STARTMODE='<auto|manual|onboot>'

to

STARTMODE='nfsroot'

This changes the behavior of the networking scripts to not shut down the interface during a network stop or restart event. However, when using this method, I still would recommend monitoring the connection state of drbd in /proc/drbd.

I’ve been working at Mozilla on Firefox Mobile for a few months now. One of the goals of the new native UI is to have liquid smooth scrolling and panning at all times. Unsurprisingly, we do this by drawing into an OpenGL texture and moving it around on the screen. This is pretty fast until you run out of content in the texture and need to update it. Gecko runs in a separate thread and can draw to a buffer there without blocking us, but uploading that data into the texture is where problems arise. Right now we use just one very large texture (usually 2048x2048), and glTexSubImage2D can take anywhere from 25ms to 60ms. Given that our target is 60fps, we have about 16ms to draw a frame. This means we’re guaranteed to miss at least one frame every time we upload, but likely more than that. What we need is a way of uploading texture data asynchronously (and preferably quicker). This is where direct textures can help.

If you haven’t read Dianne Hackborn’s recent posts on the Android graphics stack, you’re missing out (part 1, part 2). The window compositing system she describes (called SurfaceFlinger) is particularly interesting because it is close to the problem we have in Firefox. One of the pieces Android uses to to draw windows is the gralloc module. As you may have guessed, gralloc is short for ‘graphics alloc’. You can see the short and simple API for it here. Android has a wrapper class that encapsulates access to this called GraphicBuffer. It has an even nicer API, found here. Usage is very straightforward. Simply create the GraphicBuffer with whatever size and pixel format you need, lock it, write your bits, and unlock. One of the major wins here is that you can use the GraphicBuffer instance from any thread. So not only does this reduce a copy of your image, but it also means you can upload it without blocking the rendering loop!

To get it on the screen using OpenGL, you can create an EGLImageKHR from the GraphicBuffer and bind it to a texture:

#define EGL_NATIVE_BUFFER_ANDROID 0x3140
#define EGL_IMAGE_PRESERVED_KHR   0x30D2

GraphicBuffer* buffer = new GraphicBuffer(1024, 1024, PIXEL_FORMAT_RGB_565,
                                          GraphicBuffer::USAGE_SW_WRITE_OFTEN |
                                          GraphicBuffer::USAGE_HW_TEXTURE);

unsigned char* bits = NULL;
buffer->lock(GraphicBuffer::USAGE_SW_WRITE_OFTEN, (void**)&bits);

// Write bitmap data into 'bits' here

buffer->unlock();

// Create the EGLImageKHR from the native buffer
EGLint eglImgAttrs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE, EGL_NONE };
EGLImageKHR img = eglCreateImageKHR(eglGetDisplay(EGL_DEFAULT_DISPLAY), EGL_NO_CONTEXT,
                                    EGL_NATIVE_BUFFER_ANDROID,
                                    (EGLClientBuffer)buffer->getNativeBuffer(),
                                    eglImgAttrs);

// Create GL texture, bind to GL_TEXTURE_2D, etc.

// Attach the EGLImage to whatever texture is bound to GL_TEXTURE_2D
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, img);

The resulting texture can be used as a regular one, with one caveat. Whenever you manipulate pixel data, the changes will be reflected on the screen immediately after unlock. You probably want to double buffer in order to avoid problems here.

If you’ve ever used the Android NDK, it won’t be surprising that GraphicBuffer (or anything similar) doesn’t exist there. In order to use any of this in your app you’ll need to resort to dlopen hacks. It’s a pretty depressing situation. Google uses this all over the OS, but doesn’t seem to think that apps need a high performance API. But wait, it gets worse. Even after jumping through these hoops, some gralloc drivers don’t allow regular apps to play ball. So far, testing indicates that this is the case on Adreno and Mali GPUs. Thankfully, PowerVR and Tegra allow it, which covers a fair number of devices.

With any luck, I’ll land the patches that use this in Firefox Mobile today. The result should be a much smoother panning and zooming experience on devices where gralloc is allowed to work.

TL;DR: openSUSE as a project needs to raise its game, and the next openSUSE Board can guide the project to agree a tight set of goals for our releases and work to a higher standard on them. Otherwise we risk being an undirected mess of pet projects, bikeshedding discussions and bickering tribes.

Read more at my platform page. Then go and vote!

Some week ago, I’ve stumbled upon a very promising font project. It’s called the Exo Typeface Family and I think this could be a valuable addition to our distribution:

The sans serif font is beautifully crafted and contains 9(!) different width as you can see in the following graphic:

Natanael, the graphic designer, wrote about his font:

Today Exo is already a very mature font family, with over 700 characters supporting most Western, Central and Eastern European languages – and it can still go further! This coverage has been reached for all 9 weights, the maximum possible on the web. Each weight has an upright style and the corresponding ‘true’ italic style. Many ‘techno’ fonts have only the simple slanted oblique companion styles, but for the highest typographic quality it is essential to have true italics that are drawn specially.

Some unique OpenType features:

• small caps
• discretionary ligatures
• stylistic alternates
• old style figures, tabular figures, fractions
• a lot more…

If this project reaches its funding goal it will be published in Google Web Fonts under the SIL Open Font License. Currently, almost 80% is pledged, but only 18 days are left. If you find this project useful, please help Natanael and make the Web a more beautiful place. I already did so. Thanks!

Hi DocBook lovers,

browsed through a book, used your favorite search engine, or posted on LinkedIn, Xing, or the DocBook mailinglist to hunt for answers to your problems?

As an additional alternative, I’m happy to announce my latest project:

The DoCookBook Project
(released  under Creative Commons License)

The tongue-twisting name is a word play and picks up the two central topic about DocBook and cookbook.

What is the “DoCookBook Project”?

This project is a collection of problems and solution towards DocBook and the DocBook stylesheets. The book contains helpful topics with step-by-step instructions.

Why another project about DocBook?

Information about DocBook can be find in books or somewhere in the Internet. However, it can be an exhausting task to extract the necessary piece which fits to your problem. This project can help you to get your work done more quickly.

Is it done?

Not yet. Currently it is a draft. However, the structure is almost complete. The book contains some useful topics and it will be improved and extended over time.

Can I see the source code?

Sure! The source code of this book is published and maintained as a Mercurial repository.

Ok, you’ll get me! How can I support the project?

• Register on the project mailinglist to influence the direction or to get updates
• Point out typos, ambiguities, inconsistencies, or errors.
• Let me know what’s your favorite topic.
  Send me your topics directly or use the project’s ticket system (see Ticket#15).
  If you want to use the latter, you’ll have to register at Sourceforge
• Write your own topics.
• Create a cool new layout.
• Support this project and donate a small amount.

Have fun!

Watching software-center code changes, this one came into my attention: an effort from Giovanni Campagna into bringing Software Center to Fedora, using the PackageKit backend I’ve been working on this summer.

It’s nice to see someone showing interest, and also picking up the code .

I must definitely get the time to fix my experimental OBS build, and see the openSUSE version running again. For the record, there is room for improvement on the performance part (especially starting up speed).