linux-imx

/* AFS security handling

 *

 * Copyright (C) 2007, 2017 Red Hat, Inc. All Rights Reserved.

 * Written by David Howells (dhowells@redhat.com)

 *

 * 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; either version

 * 2 of the License, or (at your option) any later version.

 */

​

#include <linux/init.h>

#include <linux/slab.h>

#include <linux/fs.h>

#include <linux/ctype.h>

#include <linux/sched.h>

#include <linux/hashtable.h>

#include <keys/rxrpc-type.h>

#include "internal.h"

​

static DEFINE_HASHTABLE(afs_permits_cache, 10);

static DEFINE_SPINLOCK(afs_permits_lock);

​

/*

 * get a key

 */

struct key *afs_request_key(struct afs_cell *cell)

{

    struct key *key;

​

    _enter("{%x}", key_serial(cell->anonymous_key));

​

    _debug("key %s", cell->anonymous_key->description);

    key = request_key(&key_type_rxrpc, cell->anonymous_key->description,

              NULL);

    if (IS_ERR(key)) {

        if (PTR_ERR(key) != -ENOKEY) {

            _leave(" = %ld", PTR_ERR(key));

            return key;

        }

​

        /* act as anonymous user */

        _leave(" = {%x} [anon]", key_serial(cell->anonymous_key));

        return key_get(cell->anonymous_key);

    } else {

        /* act as authorised user */

        _leave(" = {%x} [auth]", key_serial(key));

        return key;

    }

}

​

/*

 * Dispose of a list of permits.

 */

static void afs_permits_rcu(struct rcu_head *rcu)

{

    struct afs_permits *permits =

        container_of(rcu, struct afs_permits, rcu);

    int i;

​

    for (i = 0; i < permits->nr_permits; i++)

        key_put(permits->permits[i].key);

    kfree(permits);

}

​

/*

 * Discard a permission cache.

 */

void afs_put_permits(struct afs_permits *permits)

{

    if (permits && refcount_dec_and_test(&permits->usage)) {

        spin_lock(&afs_permits_lock);

        hash_del_rcu(&permits->hash_node);

        spin_unlock(&afs_permits_lock);

        call_rcu(&permits->rcu, afs_permits_rcu);

    }

}

​

/*

 * Clear a permit cache on callback break.

 */

void afs_clear_permits(struct afs_vnode *vnode)

{

    struct afs_permits *permits;

​

    spin_lock(&vnode->lock);

    permits = rcu_dereference_protected(vnode->permit_cache,

                        lockdep_is_held(&vnode->lock));

    RCU_INIT_POINTER(vnode->permit_cache, NULL);

    vnode->cb_break++;

    spin_unlock(&vnode->lock);

​