Those of you who keep track of this blog, knows that we use it for two purposes: announcements about Codefidence and it’s activities, as well as sharing technical tips and tricks related to Linux and Open Source based software development for our consultancy and training customers to enjoy (and of course everyone else).

As these posts have been very successful, at least judging from the amount of positive responses we’ve been getting, we decided to give them some more elbow room, thus Tuxology was born.

Tuxology is a web site dedicated to the Linux training courses and consultancy provided by Codefidence and Hi-Tech College. It aims to provide an on-line counterpart to the courses material for students and and consultancy clients who wish to expand their knowledge and keep their skills up to date both during and after the training courses.

Tuxology was created as a result of our belief that training is a process and therefore should be conducted in the context of a long term relationship between the instructor and the students and not a one off transaction.

In the spirit of the Free and Open Source software world which Linux is a part of, all the site facilities are free for all to access and enjoy, including updated course slides, forums and articles about the different course topics.

So, if you liked the tecnical tips and tricks in we’ve been providing thus far on the Codefidence web site and blog, make sure to head over to Tuxology.net to get the full Monty.

Hope to see you there!
The Codefidence team

As the use of Linux in the embedded market is on the rise and it’s development continues at an extraordinary rate, the seminar will cover, as in previous years, a broad range of topics relevant to Linux based embedded system developers wishing to keep abreast of recent developments.

For further details, check out the seminar web page (in Hebrew).

See you all there,
Codefidence Team

Hello,

Thanks,
Anonymous Reader

So the question is: how to make a minimal set of dynamic libraries for a known set of executables that only contain the code for those symbols which the executables actually use, thus saving expensive storage?

The quite simple answer is that there exists a Python utility that does exactly what you want called mklibs - It produces cut-down shared libraries that contain only the routines required by a particular set of executables.

On Debian just go “sudo apt-get install mklibs”, or you can get the source straight from the Buildroot source repository here.

If you don’t like Python (you really should!) you can try an older, shell script based variation on the same theme found here.

Note that you can pass the cross compiler prefix with the “–target” option, which is of course needed for supporting cross compilation.

Hope you found it useful and if you have more questions about Linux development you’d like answered, just let us know.

The Codefidence team.

The move brings about a new shiny office with an amazing view, smack in the heart of the high tech district of Rehovot/Ness Ziona and within a relatively short driving distance from the Ben Gurion airport for our guests from abroad.

Please note that with the move we have also changed phone numbers. The new numbers are as follows:

Wish us a happy stay in our new offices.

CDT is the name of the C/C++ development plug-in. It includes a graphical GDB front end.

The following slides are a short visual “how to” demonstrating configuring and using CDT to debug a remote target with GDB.

eclipse_debug.pdf

A shared library is thus normally comprised of a set of global functions which may be called by applications (or other libraries) that link with the library.

Given the shared nature of shared libraries, it is often useful to provide a constructor for the code library which will run each time the library is loaded by an application. Doing this is very simple, using the GNU specific constructor attribute.

Here is a code example:

 
/* init_demo.c */
 
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
 
static void __attribute__ ((constructor)) \
  lib_init(void);
 
static void lib_init(void) {
 
  printf("Library ready. \n");
 
  return;
}

Then build the the shared library using the following GNU Makefile:

 
.PHONY: clean
 
libinitdemo.so.1.0.0: init_demo.c 
  $(CC) -fPIC init_demo.c -shared \
  -Wl,-soname,libinitdemo.so.1 -o \
  libinitdemo.so.1.0.0
 
clean:
  $(RM) -f libinitdemo.so.1.0.0

TIP
Combining a shared library constructor as shown above with use of LD_PRELOAD can be a powerful way to add construction code to existing programs without changing their source code and indeed, without requiring access to their source code at all.

An example for such cases is where an embedded Linux system has a management network interface and a separate regular network interface where regular traffic should go:

So long as the two interfaces use two different IP addresses from non overlapping network it is very easy - simply bind the management application socket to the management IP and let the routing table do the rest.

What to do, however, if product definition calls for supporting two different and separate, default gateway settings for management and media traffic? Although we can assign multiple default gateway routing table entries, how to make sure the management applications use one and all other traffic use another?

This is where the SO_BINDTODEVICE socket option comes to our rescue. We will install two default gateway entries: a normal one for the media traffic and another one for the management traffic, for which we will define a high metric so it will normally will not be used.

Then, we will set the SO_BINDTODEVICE socket option on sockets opened in management application, thus forcing the Linux networking stack to disregard any routing table entries not going through the specific device, but only for those specific sockets.

It looks something like this:

#include <sys/socket.h>
#include <net/if.h>
struct ifreq interface;
struct socket sock;
/* Management net interface name */
#define IFNAME "eth3"
 
/* Acquire socket here ... */
 
strncpy(interface.ifr_ifrn.ifrn_name, IFNAME, \
  IFNAMSIZ);
if (setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, \
  (char *)&interface, sizeof(interface))  < 0) {
       perror("SO_BINDTODEVICE failed");
      /* Deal with error... */
}

But wait! this is all well and good when we have the management application source code. This however is not always the case. Fear not! this too can be dealt with by hijacking the socket library call:

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <net/if.h>
#define __USE_GNU // Get RTLD_NEXT definition
#include <dlfcn.h>
 
/* Management interface */
#define IFNAME "eth3"
 
int socket(int domain, int type, int protocol) {
 
int (*origsock)(int domain, int type, int protocol);
char * error;
int sock;
 
origsock = dlsym(RTLD_NEXT, "socket");
if ((error = dlerror()) != NULL) {
fprintf (stderr, "%s\n", error);
exit(1);
}
 
sock = origsock(domain, type, protocol);
if(sock != -1) {
  struct ifreq interface;
  strncpy(interface.ifr_ifrn.ifrn_name, IFNAME, \
  IFNAMSIZ);
  if (setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, \
    (char *)&interface, sizeof(interface)) < 0) {
      perror("sendpacket: setting SO_BINDTODEVICE");
      exit(1);
   }
}
 
return sock;
}

Compile this small library with (or create a proper Makefile)

$ gcc sendto.c -fPIC -o sendto.so -ldl -shared

To use:

LD_PRELOAD=sendto.so ./management_app

The following code examples shows how this can be accomplished.

Some notes and caveats are due: the code does not deal with initializing the non volatile memory, if applicable. To use this example with NOR flash, as an example, code handling flash erasing will need to be added. In addition, this example does not display or clear saved messages and implementing this is left as an exercise to the reader.

Here is the Makefile:

default:
   $(MAKE) -C /lib/modules/`uname -r`/build \
      SUBDIRS=`pwd` modules
 
clean:
  $(MAKE) -C /lib/modules/`uname -r`/build \
      SUBDIRS=`pwd` clean

The simple Kbuild file is:

obj-m := panic_msg.o

And the panic_msg.c is:

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/notifier.h>
#include <linux/ioport.h>
#include <asm/io.h>
 
#define LOG_PREFIX "panic_msg: "
 
static unsigned long buf_address = 0;
module_param(buf_address, ulong, S_IRUSR);
MODULE_PARM_DESC(buf_address, 
  "The physical address of the panic message buffer.");
 
static unsigned long buf_size = 0;
module_param(buf_size, ulong, S_IRUSR);
MODULE_PARM_DESC(buf_size, 
  "The size in bytes of the panic message buffer.");
 
static unsigned int notifier_priority = INT_MAX;
module_param(notifier_priority, uint, S_IRUSR);
MODULE_PARM_DESC(notifier_priority, 
  "Notifier priority: INT_MAX &gt;= x &gt;= 0.");
 
static char * buf;
 
static int panic_msg_handler(
  struct notifier_block *this, 
  unsigned long event,void *msg)
{
  static unsigned int panic_event_handled = 0;
  unsigned int msg_size = min(strlen(msg), buf_size);
 
  if(!panic_event_handled) {
     panic_event_handled = 1;
     memcpy_toio((char *)msg, buf, msg_size);
  }
  return NOTIFY_OK;
}
 
static struct notifier_block panic_msg_notifier = {
  .notifier_call  = panic_msg_handler,
  .next           = NULL,
  .priority       = INT_MAX
};
 
static int __init panic_msg_init(void)
{
  int ret = 0;
  struct resource * res = NULL;
 
  if((!buf_address) || (!buf_size)) {
    printk(KERN_ERR LOG_PREFIX 
      "Address and size parameters are mandatory.\n", 
      buf_address, buf_size);
    ret = -EINVAL;
    goto error;
  }
 
  panic_msg_notifier.priority = notifier_priority;
 
  res = request_mem_region(buf_address, buf_size, 
    "Panic message handler");
 
  if(!res) {
    printk(KERN_ERR LOG_PREFIX 
      "Failed requesting panic message buffer " \
      "at address  0x%lx of size %ld.\n",
      buf_address, buf_size);
    ret = -EINVAL;
    goto error;
  }
 
  buf = ioremap(buf_address, buf_size);
 
  if(!buf) {
    printk(KERN_ERR LOG_PREFIX 
      "Failed mapping panic msg buf at address" \
      " 0x%lx of size %ld\n", 
      buf_address, buf_size);
    ret = -EINVAL;
    goto error;
  }
 
  if(atomic_notifier_chain_register(
     &panic_notifier_list, &panic_msg_notifier)) {
    printk(KERN_ERR LOG_PREFIX 
      "Failed registering panic message notifier.\n");
    ret = -EINVAL;
    goto error;
  }
 
  printk(KERN_INFO LOG_PREFIX 
   "Panic message buffer handler initialized.\n");
 
  return 0;
 
error:
  if(res) release_mem_region(buf_address, buf_size);
  if(buf) iounmap(buf);
  return ret;
}
 
static void __exit panic_msg_exit(void) {
 
  if(atomic_notifier_chain_unregister(
     &panic_notifier_list, &panic_msg_notifier)) {
    printk(KERN_ERR LOG_PREFIX 
      "Failed removing panic msg buf mapping.\n");
  }
  iounmap(buf);
  release_mem_region(buf_address, buf_size);
 
  printk(KERN_INFO LOG_PREFIX 
     "Panic message buffer handler unloaded.\n");
 
  return;
}
 
module_init(panic_msg_init);
module_exit(panic_msg_exit);
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Gilad Ben-Yossef" \
  " <gilad@codefidence.com>");
MODULE_DESCRIPTION("This module stores kernel  " \
   "panic messages in non volatile memory.");

Panic message example kernel module source code

Let’s Play The Weakest Link Slides (PDF)

The system calls are:

#include <sched.h>
 
int sched_setaffinity(pid_t  pid, unsigned int len, 
   unsigned long *mask);
 
int sched_getaffinity(pid_t pid, unsigned int len, 
   unsigned long *mask);

pid is the process id of the process to assign to certain CPUs. Use ‘0′ here to denote the current process.

len is the length of the CPU bit mask, and mask is a pointer to a bit mask denoting which CPU can the process run on.

For a good discussion and a code example, look here:

http://www-128.ibm.com/developerworks/linux/library/l-affinity.html