linux/sound/core/seq/seq_ports.c
<<
>>
Prefs
   1/*
   2 *   ALSA sequencer Ports
   3 *   Copyright (c) 1998 by Frank van de Pol <fvdpol@coil.demon.nl>
   4 *                         Jaroslav Kysela <perex@perex.cz>
   5 *
   6 *
   7 *   This program is free software; you can redistribute it and/or modify
   8 *   it under the terms of the GNU General Public License as published by
   9 *   the Free Software Foundation; either version 2 of the License, or
  10 *   (at your option) any later version.
  11 *
  12 *   This program is distributed in the hope that it will be useful,
  13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 *   GNU General Public License for more details.
  16 *
  17 *   You should have received a copy of the GNU General Public License
  18 *   along with this program; if not, write to the Free Software
  19 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20 *
  21 */
  22
  23#include <sound/core.h>
  24#include <linux/slab.h>
  25#include "seq_system.h"
  26#include "seq_ports.h"
  27#include "seq_clientmgr.h"
  28
  29/*
  30
  31   registration of client ports
  32
  33 */
  34
  35
  36/* 
  37
  38NOTE: the current implementation of the port structure as a linked list is
  39not optimal for clients that have many ports. For sending messages to all
  40subscribers of a port we first need to find the address of the port
  41structure, which means we have to traverse the list. A direct access table
  42(array) would be better, but big preallocated arrays waste memory.
  43
  44Possible actions:
  45
  461) leave it this way, a client does normaly does not have more than a few
  47ports
  48
  492) replace the linked list of ports by a array of pointers which is
  50dynamicly kmalloced. When a port is added or deleted we can simply allocate
  51a new array, copy the corresponding pointers, and delete the old one. We
  52then only need a pointer to this array, and an integer that tells us how
  53much elements are in array.
  54
  55*/
  56
  57/* return pointer to port structure - port is locked if found */
  58struct snd_seq_client_port *snd_seq_port_use_ptr(struct snd_seq_client *client,
  59                                                 int num)
  60{
  61        struct snd_seq_client_port *port;
  62
  63        if (client == NULL)
  64                return NULL;
  65        read_lock(&client->ports_lock);
  66        list_for_each_entry(port, &client->ports_list_head, list) {
  67                if (port->addr.port == num) {
  68                        if (port->closing)
  69                                break; /* deleting now */
  70                        snd_use_lock_use(&port->use_lock);
  71                        read_unlock(&client->ports_lock);
  72                        return port;
  73                }
  74        }
  75        read_unlock(&client->ports_lock);
  76        return NULL;            /* not found */
  77}
  78
  79
  80/* search for the next port - port is locked if found */
  81struct snd_seq_client_port *snd_seq_port_query_nearest(struct snd_seq_client *client,
  82                                                       struct snd_seq_port_info *pinfo)
  83{
  84        int num;
  85        struct snd_seq_client_port *port, *found;
  86
  87        num = pinfo->addr.port;
  88        found = NULL;
  89        read_lock(&client->ports_lock);
  90        list_for_each_entry(port, &client->ports_list_head, list) {
  91                if (port->addr.port < num)
  92                        continue;
  93                if (port->addr.port == num) {
  94                        found = port;
  95                        break;
  96                }
  97                if (found == NULL || port->addr.port < found->addr.port)
  98                        found = port;
  99        }
 100        if (found) {
 101                if (found->closing)
 102                        found = NULL;
 103                else
 104                        snd_use_lock_use(&found->use_lock);
 105        }
 106        read_unlock(&client->ports_lock);
 107        return found;
 108}
 109
 110
 111/* initialize snd_seq_port_subs_info */
 112static void port_subs_info_init(struct snd_seq_port_subs_info *grp)
 113{
 114        INIT_LIST_HEAD(&grp->list_head);
 115        grp->count = 0;
 116        grp->exclusive = 0;
 117        rwlock_init(&grp->list_lock);
 118        init_rwsem(&grp->list_mutex);
 119        grp->open = NULL;
 120        grp->close = NULL;
 121}
 122
 123
 124/* create a port, port number is returned (-1 on failure) */
 125struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client,
 126                                                int port)
 127{
 128        unsigned long flags;
 129        struct snd_seq_client_port *new_port, *p;
 130        int num = -1;
 131        
 132        /* sanity check */
 133        if (snd_BUG_ON(!client))
 134                return NULL;
 135
 136        if (client->num_ports >= SNDRV_SEQ_MAX_PORTS - 1) {
 137                snd_printk(KERN_WARNING "too many ports for client %d\n", client->number);
 138                return NULL;
 139        }
 140
 141        /* create a new port */
 142        new_port = kzalloc(sizeof(*new_port), GFP_KERNEL);
 143        if (! new_port) {
 144                snd_printd("malloc failed for registering client port\n");
 145                return NULL;    /* failure, out of memory */
 146        }
 147        /* init port data */
 148        new_port->addr.client = client->number;
 149        new_port->addr.port = -1;
 150        new_port->owner = THIS_MODULE;
 151        sprintf(new_port->name, "port-%d", num);
 152        snd_use_lock_init(&new_port->use_lock);
 153        port_subs_info_init(&new_port->c_src);
 154        port_subs_info_init(&new_port->c_dest);
 155
 156        num = port >= 0 ? port : 0;
 157        mutex_lock(&client->ports_mutex);
 158        write_lock_irqsave(&client->ports_lock, flags);
 159        list_for_each_entry(p, &client->ports_list_head, list) {
 160                if (p->addr.port > num)
 161                        break;
 162                if (port < 0) /* auto-probe mode */
 163                        num = p->addr.port + 1;
 164        }
 165        /* insert the new port */
 166        list_add_tail(&new_port->list, &p->list);
 167        client->num_ports++;
 168        new_port->addr.port = num;      /* store the port number in the port */
 169        write_unlock_irqrestore(&client->ports_lock, flags);
 170        mutex_unlock(&client->ports_mutex);
 171        sprintf(new_port->name, "port-%d", num);
 172
 173        return new_port;
 174}
 175
 176/* */
 177enum group_type {
 178        SRC_LIST, DEST_LIST
 179};
 180
 181static int subscribe_port(struct snd_seq_client *client,
 182                          struct snd_seq_client_port *port,
 183                          struct snd_seq_port_subs_info *grp,
 184                          struct snd_seq_port_subscribe *info, int send_ack);
 185static int unsubscribe_port(struct snd_seq_client *client,
 186                            struct snd_seq_client_port *port,
 187                            struct snd_seq_port_subs_info *grp,
 188                            struct snd_seq_port_subscribe *info, int send_ack);
 189
 190
 191static struct snd_seq_client_port *get_client_port(struct snd_seq_addr *addr,
 192                                                   struct snd_seq_client **cp)
 193{
 194        struct snd_seq_client_port *p;
 195        *cp = snd_seq_client_use_ptr(addr->client);
 196        if (*cp) {
 197                p = snd_seq_port_use_ptr(*cp, addr->port);
 198                if (! p) {
 199                        snd_seq_client_unlock(*cp);
 200                        *cp = NULL;
 201                }
 202                return p;
 203        }
 204        return NULL;
 205}
 206
 207/*
 208 * remove all subscribers on the list
 209 * this is called from port_delete, for each src and dest list.
 210 */
 211static void clear_subscriber_list(struct snd_seq_client *client,
 212                                  struct snd_seq_client_port *port,
 213                                  struct snd_seq_port_subs_info *grp,
 214                                  int grptype)
 215{
 216        struct list_head *p, *n;
 217
 218        list_for_each_safe(p, n, &grp->list_head) {
 219                struct snd_seq_subscribers *subs;
 220                struct snd_seq_client *c;
 221                struct snd_seq_client_port *aport;
 222
 223                if (grptype == SRC_LIST) {
 224                        subs = list_entry(p, struct snd_seq_subscribers, src_list);
 225                        aport = get_client_port(&subs->info.dest, &c);
 226                } else {
 227                        subs = list_entry(p, struct snd_seq_subscribers, dest_list);
 228                        aport = get_client_port(&subs->info.sender, &c);
 229                }
 230                list_del(p);
 231                unsubscribe_port(client, port, grp, &subs->info, 0);
 232                if (!aport) {
 233                        /* looks like the connected port is being deleted.
 234                         * we decrease the counter, and when both ports are deleted
 235                         * remove the subscriber info
 236                         */
 237                        if (atomic_dec_and_test(&subs->ref_count))
 238                                kfree(subs);
 239                } else {
 240                        /* ok we got the connected port */
 241                        struct snd_seq_port_subs_info *agrp;
 242                        agrp = (grptype == SRC_LIST) ? &aport->c_dest : &aport->c_src;
 243                        down_write(&agrp->list_mutex);
 244                        if (grptype == SRC_LIST)
 245                                list_del(&subs->dest_list);
 246                        else
 247                                list_del(&subs->src_list);
 248                        up_write(&agrp->list_mutex);
 249                        unsubscribe_port(c, aport, agrp, &subs->info, 1);
 250                        kfree(subs);
 251                        snd_seq_port_unlock(aport);
 252                        snd_seq_client_unlock(c);
 253                }
 254        }
 255}
 256
 257/* delete port data */
 258static int port_delete(struct snd_seq_client *client,
 259                       struct snd_seq_client_port *port)
 260{
 261        /* set closing flag and wait for all port access are gone */
 262        port->closing = 1;
 263        snd_use_lock_sync(&port->use_lock); 
 264
 265        /* clear subscribers info */
 266        clear_subscriber_list(client, port, &port->c_src, SRC_LIST);
 267        clear_subscriber_list(client, port, &port->c_dest, DEST_LIST);
 268
 269        if (port->private_free)
 270                port->private_free(port->private_data);
 271
 272        snd_BUG_ON(port->c_src.count != 0);
 273        snd_BUG_ON(port->c_dest.count != 0);
 274
 275        kfree(port);
 276        return 0;
 277}
 278
 279
 280/* delete a port with the given port id */
 281int snd_seq_delete_port(struct snd_seq_client *client, int port)
 282{
 283        unsigned long flags;
 284        struct snd_seq_client_port *found = NULL, *p;
 285
 286        mutex_lock(&client->ports_mutex);
 287        write_lock_irqsave(&client->ports_lock, flags);
 288        list_for_each_entry(p, &client->ports_list_head, list) {
 289                if (p->addr.port == port) {
 290                        /* ok found.  delete from the list at first */
 291                        list_del(&p->list);
 292                        client->num_ports--;
 293                        found = p;
 294                        break;
 295                }
 296        }
 297        write_unlock_irqrestore(&client->ports_lock, flags);
 298        mutex_unlock(&client->ports_mutex);
 299        if (found)
 300                return port_delete(client, found);
 301        else
 302                return -ENOENT;
 303}
 304
 305/* delete the all ports belonging to the given client */
 306int snd_seq_delete_all_ports(struct snd_seq_client *client)
 307{
 308        unsigned long flags;
 309        struct list_head deleted_list;
 310        struct snd_seq_client_port *port, *tmp;
 311        
 312        /* move the port list to deleted_list, and
 313         * clear the port list in the client data.
 314         */
 315        mutex_lock(&client->ports_mutex);
 316        write_lock_irqsave(&client->ports_lock, flags);
 317        if (! list_empty(&client->ports_list_head)) {
 318                list_add(&deleted_list, &client->ports_list_head);
 319                list_del_init(&client->ports_list_head);
 320        } else {
 321                INIT_LIST_HEAD(&deleted_list);
 322        }
 323        client->num_ports = 0;
 324        write_unlock_irqrestore(&client->ports_lock, flags);
 325
 326        /* remove each port in deleted_list */
 327        list_for_each_entry_safe(port, tmp, &deleted_list, list) {
 328                list_del(&port->list);
 329                snd_seq_system_client_ev_port_exit(port->addr.client, port->addr.port);
 330                port_delete(client, port);
 331        }
 332        mutex_unlock(&client->ports_mutex);
 333        return 0;
 334}
 335
 336/* set port info fields */
 337int snd_seq_set_port_info(struct snd_seq_client_port * port,
 338                          struct snd_seq_port_info * info)
 339{
 340        if (snd_BUG_ON(!port || !info))
 341                return -EINVAL;
 342
 343        /* set port name */
 344        if (info->name[0])
 345                strlcpy(port->name, info->name, sizeof(port->name));
 346        
 347        /* set capabilities */
 348        port->capability = info->capability;
 349        
 350        /* get port type */
 351        port->type = info->type;
 352
 353        /* information about supported channels/voices */
 354        port->midi_channels = info->midi_channels;
 355        port->midi_voices = info->midi_voices;
 356        port->synth_voices = info->synth_voices;
 357
 358        /* timestamping */
 359        port->timestamping = (info->flags & SNDRV_SEQ_PORT_FLG_TIMESTAMP) ? 1 : 0;
 360        port->time_real = (info->flags & SNDRV_SEQ_PORT_FLG_TIME_REAL) ? 1 : 0;
 361        port->time_queue = info->time_queue;
 362
 363        return 0;
 364}
 365
 366/* get port info fields */
 367int snd_seq_get_port_info(struct snd_seq_client_port * port,
 368                          struct snd_seq_port_info * info)
 369{
 370        if (snd_BUG_ON(!port || !info))
 371                return -EINVAL;
 372
 373        /* get port name */
 374        strlcpy(info->name, port->name, sizeof(info->name));
 375        
 376        /* get capabilities */
 377        info->capability = port->capability;
 378
 379        /* get port type */
 380        info->type = port->type;
 381
 382        /* information about supported channels/voices */
 383        info->midi_channels = port->midi_channels;
 384        info->midi_voices = port->midi_voices;
 385        info->synth_voices = port->synth_voices;
 386
 387        /* get subscriber counts */
 388        info->read_use = port->c_src.count;
 389        info->write_use = port->c_dest.count;
 390        
 391        /* timestamping */
 392        info->flags = 0;
 393        if (port->timestamping) {
 394                info->flags |= SNDRV_SEQ_PORT_FLG_TIMESTAMP;
 395                if (port->time_real)
 396                        info->flags |= SNDRV_SEQ_PORT_FLG_TIME_REAL;
 397                info->time_queue = port->time_queue;
 398        }
 399
 400        return 0;
 401}
 402
 403
 404
 405/*
 406 * call callback functions (if any):
 407 * the callbacks are invoked only when the first (for connection) or
 408 * the last subscription (for disconnection) is done.  Second or later
 409 * subscription results in increment of counter, but no callback is
 410 * invoked.
 411 * This feature is useful if these callbacks are associated with
 412 * initialization or termination of devices (see seq_midi.c).
 413 *
 414 * If callback_all option is set, the callback function is invoked
 415 * at each connnection/disconnection. 
 416 */
 417
 418static int subscribe_port(struct snd_seq_client *client,
 419                          struct snd_seq_client_port *port,
 420                          struct snd_seq_port_subs_info *grp,
 421                          struct snd_seq_port_subscribe *info,
 422                          int send_ack)
 423{
 424        int err = 0;
 425
 426        if (!try_module_get(port->owner))
 427                return -EFAULT;
 428        grp->count++;
 429        if (grp->open && (port->callback_all || grp->count == 1)) {
 430                err = grp->open(port->private_data, info);
 431                if (err < 0) {
 432                        module_put(port->owner);
 433                        grp->count--;
 434                }
 435        }
 436        if (err >= 0 && send_ack && client->type == USER_CLIENT)
 437                snd_seq_client_notify_subscription(port->addr.client, port->addr.port,
 438                                                   info, SNDRV_SEQ_EVENT_PORT_SUBSCRIBED);
 439
 440        return err;
 441}
 442
 443static int unsubscribe_port(struct snd_seq_client *client,
 444                            struct snd_seq_client_port *port,
 445                            struct snd_seq_port_subs_info *grp,
 446                            struct snd_seq_port_subscribe *info,
 447                            int send_ack)
 448{
 449        int err = 0;
 450
 451        if (! grp->count)
 452                return -EINVAL;
 453        grp->count--;
 454        if (grp->close && (port->callback_all || grp->count == 0))
 455                err = grp->close(port->private_data, info);
 456        if (send_ack && client->type == USER_CLIENT)
 457                snd_seq_client_notify_subscription(port->addr.client, port->addr.port,
 458                                                   info, SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED);
 459        module_put(port->owner);
 460        return err;
 461}
 462
 463
 464
 465/* check if both addresses are identical */
 466static inline int addr_match(struct snd_seq_addr *r, struct snd_seq_addr *s)
 467{
 468        return (r->client == s->client) && (r->port == s->port);
 469}
 470
 471/* check the two subscribe info match */
 472/* if flags is zero, checks only sender and destination addresses */
 473static int match_subs_info(struct snd_seq_port_subscribe *r,
 474                           struct snd_seq_port_subscribe *s)
 475{
 476        if (addr_match(&r->sender, &s->sender) &&
 477            addr_match(&r->dest, &s->dest)) {
 478                if (r->flags && r->flags == s->flags)
 479                        return r->queue == s->queue;
 480                else if (! r->flags)
 481                        return 1;
 482        }
 483        return 0;
 484}
 485
 486
 487/* connect two ports */
 488int snd_seq_port_connect(struct snd_seq_client *connector,
 489                         struct snd_seq_client *src_client,
 490                         struct snd_seq_client_port *src_port,
 491                         struct snd_seq_client *dest_client,
 492                         struct snd_seq_client_port *dest_port,
 493                         struct snd_seq_port_subscribe *info)
 494{
 495        struct snd_seq_port_subs_info *src = &src_port->c_src;
 496        struct snd_seq_port_subs_info *dest = &dest_port->c_dest;
 497        struct snd_seq_subscribers *subs, *s;
 498        int err, src_called = 0;
 499        unsigned long flags;
 500        int exclusive;
 501
 502        subs = kzalloc(sizeof(*subs), GFP_KERNEL);
 503        if (! subs)
 504                return -ENOMEM;
 505
 506        subs->info = *info;
 507        atomic_set(&subs->ref_count, 2);
 508
 509        down_write(&src->list_mutex);
 510        down_write_nested(&dest->list_mutex, SINGLE_DEPTH_NESTING);
 511
 512        exclusive = info->flags & SNDRV_SEQ_PORT_SUBS_EXCLUSIVE ? 1 : 0;
 513        err = -EBUSY;
 514        if (exclusive) {
 515                if (! list_empty(&src->list_head) || ! list_empty(&dest->list_head))
 516                        goto __error;
 517        } else {
 518                if (src->exclusive || dest->exclusive)
 519                        goto __error;
 520                /* check whether already exists */
 521                list_for_each_entry(s, &src->list_head, src_list) {
 522                        if (match_subs_info(info, &s->info))
 523                                goto __error;
 524                }
 525                list_for_each_entry(s, &dest->list_head, dest_list) {
 526                        if (match_subs_info(info, &s->info))
 527                                goto __error;
 528                }
 529        }
 530
 531        if ((err = subscribe_port(src_client, src_port, src, info,
 532                                  connector->number != src_client->number)) < 0)
 533                goto __error;
 534        src_called = 1;
 535
 536        if ((err = subscribe_port(dest_client, dest_port, dest, info,
 537                                  connector->number != dest_client->number)) < 0)
 538                goto __error;
 539
 540        /* add to list */
 541        write_lock_irqsave(&src->list_lock, flags);
 542        // write_lock(&dest->list_lock); // no other lock yet
 543        list_add_tail(&subs->src_list, &src->list_head);
 544        list_add_tail(&subs->dest_list, &dest->list_head);
 545        // write_unlock(&dest->list_lock); // no other lock yet
 546        write_unlock_irqrestore(&src->list_lock, flags);
 547
 548        src->exclusive = dest->exclusive = exclusive;
 549
 550        up_write(&dest->list_mutex);
 551        up_write(&src->list_mutex);
 552        return 0;
 553
 554 __error:
 555        if (src_called)
 556                unsubscribe_port(src_client, src_port, src, info,
 557                                 connector->number != src_client->number);
 558        kfree(subs);
 559        up_write(&dest->list_mutex);
 560        up_write(&src->list_mutex);
 561        return err;
 562}
 563
 564
 565/* remove the connection */
 566int snd_seq_port_disconnect(struct snd_seq_client *connector,
 567                            struct snd_seq_client *src_client,
 568                            struct snd_seq_client_port *src_port,
 569                            struct snd_seq_client *dest_client,
 570                            struct snd_seq_client_port *dest_port,
 571                            struct snd_seq_port_subscribe *info)
 572{
 573        struct snd_seq_port_subs_info *src = &src_port->c_src;
 574        struct snd_seq_port_subs_info *dest = &dest_port->c_dest;
 575        struct snd_seq_subscribers *subs;
 576        int err = -ENOENT;
 577        unsigned long flags;
 578
 579        down_write(&src->list_mutex);
 580        down_write_nested(&dest->list_mutex, SINGLE_DEPTH_NESTING);
 581
 582        /* look for the connection */
 583        list_for_each_entry(subs, &src->list_head, src_list) {
 584                if (match_subs_info(info, &subs->info)) {
 585                        write_lock_irqsave(&src->list_lock, flags);
 586                        // write_lock(&dest->list_lock);  // no lock yet
 587                        list_del(&subs->src_list);
 588                        list_del(&subs->dest_list);
 589                        // write_unlock(&dest->list_lock);
 590                        write_unlock_irqrestore(&src->list_lock, flags);
 591                        src->exclusive = dest->exclusive = 0;
 592                        unsubscribe_port(src_client, src_port, src, info,
 593                                         connector->number != src_client->number);
 594                        unsubscribe_port(dest_client, dest_port, dest, info,
 595                                         connector->number != dest_client->number);
 596                        kfree(subs);
 597                        err = 0;
 598                        break;
 599                }
 600        }
 601
 602        up_write(&dest->list_mutex);
 603        up_write(&src->list_mutex);
 604        return err;
 605}
 606
 607
 608/* get matched subscriber */
 609struct snd_seq_subscribers *snd_seq_port_get_subscription(struct snd_seq_port_subs_info *src_grp,
 610                                                          struct snd_seq_addr *dest_addr)
 611{
 612        struct snd_seq_subscribers *s, *found = NULL;
 613
 614        down_read(&src_grp->list_mutex);
 615        list_for_each_entry(s, &src_grp->list_head, src_list) {
 616                if (addr_match(dest_addr, &s->info.dest)) {
 617                        found = s;
 618                        break;
 619                }
 620        }
 621        up_read(&src_grp->list_mutex);
 622        return found;
 623}
 624
 625/*
 626 * Attach a device driver that wants to receive events from the
 627 * sequencer.  Returns the new port number on success.
 628 * A driver that wants to receive the events converted to midi, will
 629 * use snd_seq_midisynth_register_port().
 630 */
 631/* exported */
 632int snd_seq_event_port_attach(int client,
 633                              struct snd_seq_port_callback *pcbp,
 634                              int cap, int type, int midi_channels,
 635                              int midi_voices, char *portname)
 636{
 637        struct snd_seq_port_info portinfo;
 638        int  ret;
 639
 640        /* Set up the port */
 641        memset(&portinfo, 0, sizeof(portinfo));
 642        portinfo.addr.client = client;
 643        strlcpy(portinfo.name, portname ? portname : "Unamed port",
 644                sizeof(portinfo.name));
 645
 646        portinfo.capability = cap;
 647        portinfo.type = type;
 648        portinfo.kernel = pcbp;
 649        portinfo.midi_channels = midi_channels;
 650        portinfo.midi_voices = midi_voices;
 651
 652        /* Create it */
 653        ret = snd_seq_kernel_client_ctl(client,
 654                                        SNDRV_SEQ_IOCTL_CREATE_PORT,
 655                                        &portinfo);
 656
 657        if (ret >= 0)
 658                ret = portinfo.addr.port;
 659
 660        return ret;
 661}
 662
 663EXPORT_SYMBOL(snd_seq_event_port_attach);
 664
 665/*
 666 * Detach the driver from a port.
 667 */
 668/* exported */
 669int snd_seq_event_port_detach(int client, int port)
 670{
 671        struct snd_seq_port_info portinfo;
 672        int  err;
 673
 674        memset(&portinfo, 0, sizeof(portinfo));
 675        portinfo.addr.client = client;
 676        portinfo.addr.port   = port;
 677        err = snd_seq_kernel_client_ctl(client,
 678                                        SNDRV_SEQ_IOCTL_DELETE_PORT,
 679                                        &portinfo);
 680
 681        return err;
 682}
 683
 684EXPORT_SYMBOL(snd_seq_event_port_detach);
 685
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.