lib.c

Go to the documentation of this file.

/*
 * AppArmor security module
 *
 * This file contains basic common functions used in AppArmor
 *
 * Copyright (C) 1998-2008 Novell/SUSE
 * Copyright 2009-2010 Canonical Ltd.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, version 2 of the
 * License.
 */

#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/vmalloc.h>

#include "include/audit.h"
#include "include/apparmor.h"


char *aa_split_fqname(char *fqname, char **ns_name)
{
    char *name = strim(fqname);

    *ns_name = NULL;
    if (name[0] == ':') {
        char *split = strchr(&name[1], ':');
        *ns_name = skip_spaces(&name[1]);
        if (split) {
            /* overwrite ':' with \0 */
            *split = 0;
            name = skip_spaces(split + 1);
        } else
            /* a ns name without a following profile is allowed */
            name = NULL;
    }
    if (name && *name == 0)
        name = NULL;

    return name;
}

void aa_info_message(const char *str)
{
    if (audit_enabled) {
        struct common_audit_data sa;
        struct apparmor_audit_data aad = {0,};
        sa.type = LSM_AUDIT_DATA_NONE;
        sa.aad = &aad;
        aad.info = str;
        aa_audit_msg(AUDIT_APPARMOR_STATUS, &sa, NULL);
    }
    printk(KERN_INFO "AppArmor: %s\n", str);
}

void *kvmalloc(size_t size)
{
    void *buffer = NULL;

    if (size == 0)
        return NULL;

    /* do not attempt kmalloc if we need more than 16 pages at once */
    if (size <= (16*PAGE_SIZE))
        buffer = kmalloc(size, GFP_NOIO | __GFP_NOWARN);
    if (!buffer) {
        /* see kvfree for why size must be at least work_struct size
         * when allocated via vmalloc
         */
        if (size < sizeof(struct work_struct))
            size = sizeof(struct work_struct);
        buffer = vmalloc(size);
    }
    return buffer;
}

static void do_vfree(struct work_struct *work)
{
    vfree(work);
}

void kvfree(void *buffer)
{
    if (is_vmalloc_addr(buffer)) {
        /* Data is no longer valid so just use the allocated space
         * as the work_struct
         */
        struct work_struct *work = (struct work_struct *) buffer;
        INIT_WORK(work, do_vfree);
        schedule_work(work);
    } else
        kfree(buffer);
}