linux/fs/dcookies.c
<<
>>
Prefs
   1/*
   2 * dcookies.c
   3 *
   4 * Copyright 2002 John Levon <levon@movementarian.org>
   5 *
   6 * Persistent cookie-path mappings. These are used by
   7 * profilers to convert a per-task EIP value into something
   8 * non-transitory that can be processed at a later date.
   9 * This is done by locking the dentry/vfsmnt pair in the
  10 * kernel until released by the tasks needing the persistent
  11 * objects. The tag is simply an unsigned long that refers
  12 * to the pair and can be looked up from userspace.
  13 */
  14
  15#include <linux/syscalls.h>
  16#include <linux/module.h>
  17#include <linux/slab.h>
  18#include <linux/list.h>
  19#include <linux/mount.h>
  20#include <linux/capability.h>
  21#include <linux/dcache.h>
  22#include <linux/mm.h>
  23#include <linux/err.h>
  24#include <linux/errno.h>
  25#include <linux/dcookies.h>
  26#include <linux/mutex.h>
  27#include <linux/path.h>
  28#include <asm/uaccess.h>
  29
  30/* The dcookies are allocated from a kmem_cache and
  31 * hashed onto a small number of lists. None of the
  32 * code here is particularly performance critical
  33 */
  34struct dcookie_struct {
  35        struct path path;
  36        struct list_head hash_list;
  37};
  38
  39static LIST_HEAD(dcookie_users);
  40static DEFINE_MUTEX(dcookie_mutex);
  41static struct kmem_cache *dcookie_cache __read_mostly;
  42static struct list_head *dcookie_hashtable __read_mostly;
  43static size_t hash_size __read_mostly;
  44
  45static inline int is_live(void)
  46{
  47        return !(list_empty(&dcookie_users));
  48}
  49
  50
  51/* The dentry is locked, its address will do for the cookie */
  52static inline unsigned long dcookie_value(struct dcookie_struct * dcs)
  53{
  54        return (unsigned long)dcs->path.dentry;
  55}
  56
  57
  58static size_t dcookie_hash(unsigned long dcookie)
  59{
  60        return (dcookie >> L1_CACHE_SHIFT) & (hash_size - 1);
  61}
  62
  63
  64static struct dcookie_struct * find_dcookie(unsigned long dcookie)
  65{
  66        struct dcookie_struct *found = NULL;
  67        struct dcookie_struct * dcs;
  68        struct list_head * pos;
  69        struct list_head * list;
  70
  71        list = dcookie_hashtable + dcookie_hash(dcookie);
  72
  73        list_for_each(pos, list) {
  74                dcs = list_entry(pos, struct dcookie_struct, hash_list);
  75                if (dcookie_value(dcs) == dcookie) {
  76                        found = dcs;
  77                        break;
  78                }
  79        }
  80
  81        return found;
  82}
  83
  84
  85static void hash_dcookie(struct dcookie_struct * dcs)
  86{
  87        struct list_head * list = dcookie_hashtable + dcookie_hash(dcookie_value(dcs));
  88        list_add(&dcs->hash_list, list);
  89}
  90
  91
  92static struct dcookie_struct *alloc_dcookie(struct path *path)
  93{
  94        struct dcookie_struct *dcs = kmem_cache_alloc(dcookie_cache,
  95                                                        GFP_KERNEL);
  96        if (!dcs)
  97                return NULL;
  98
  99        path->dentry->d_cookie = dcs;
 100        dcs->path = *path;
 101        path_get(path);
 102        hash_dcookie(dcs);
 103        return dcs;
 104}
 105
 106
 107/* This is the main kernel-side routine that retrieves the cookie
 108 * value for a dentry/vfsmnt pair.
 109 */
 110int get_dcookie(struct path *path, unsigned long *cookie)
 111{
 112        int err = 0;
 113        struct dcookie_struct * dcs;
 114
 115        mutex_lock(&dcookie_mutex);
 116
 117        if (!is_live()) {
 118                err = -EINVAL;
 119                goto out;
 120        }
 121
 122        dcs = path->dentry->d_cookie;
 123
 124        if (!dcs)
 125                dcs = alloc_dcookie(path);
 126
 127        if (!dcs) {
 128                err = -ENOMEM;
 129                goto out;
 130        }
 131
 132        *cookie = dcookie_value(dcs);
 133
 134out:
 135        mutex_unlock(&dcookie_mutex);
 136        return err;
 137}
 138
 139
 140/* And here is where the userspace process can look up the cookie value
 141 * to retrieve the path.
 142 */
 143SYSCALL_DEFINE(lookup_dcookie)(u64 cookie64, char __user * buf, size_t len)
 144{
 145        unsigned long cookie = (unsigned long)cookie64;
 146        int err = -EINVAL;
 147        char * kbuf;
 148        char * path;
 149        size_t pathlen;
 150        struct dcookie_struct * dcs;
 151
 152        /* we could leak path information to users
 153         * without dir read permission without this
 154         */
 155        if (!capable(CAP_SYS_ADMIN))
 156                return -EPERM;
 157
 158        mutex_lock(&dcookie_mutex);
 159
 160        if (!is_live()) {
 161                err = -EINVAL;
 162                goto out;
 163        }
 164
 165        if (!(dcs = find_dcookie(cookie)))
 166                goto out;
 167
 168        err = -ENOMEM;
 169        kbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 170        if (!kbuf)
 171                goto out;
 172
 173        /* FIXME: (deleted) ? */
 174        path = d_path(&dcs->path, kbuf, PAGE_SIZE);
 175
 176        if (IS_ERR(path)) {
 177                err = PTR_ERR(path);
 178                goto out_free;
 179        }
 180
 181        err = -ERANGE;
 182 
 183        pathlen = kbuf + PAGE_SIZE - path;
 184        if (pathlen <= len) {
 185                err = pathlen;
 186                if (copy_to_user(buf, path, pathlen))
 187                        err = -EFAULT;
 188        }
 189
 190out_free:
 191        kfree(kbuf);
 192out:
 193        mutex_unlock(&dcookie_mutex);
 194        return err;
 195}
 196#ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
 197asmlinkage long SyS_lookup_dcookie(u64 cookie64, long buf, long len)
 198{
 199        return SYSC_lookup_dcookie(cookie64, (char __user *) buf, (size_t) len);
 200}
 201SYSCALL_ALIAS(sys_lookup_dcookie, SyS_lookup_dcookie);
 202#endif
 203
 204static int dcookie_init(void)
 205{
 206        struct list_head * d;
 207        unsigned int i, hash_bits;
 208        int err = -ENOMEM;
 209
 210        dcookie_cache = kmem_cache_create("dcookie_cache",
 211                sizeof(struct dcookie_struct),
 212                0, 0, NULL);
 213
 214        if (!dcookie_cache)
 215                goto out;
 216
 217        dcookie_hashtable = kmalloc(PAGE_SIZE, GFP_KERNEL);
 218        if (!dcookie_hashtable)
 219                goto out_kmem;
 220
 221        err = 0;
 222
 223        /*
 224         * Find the power-of-two list-heads that can fit into the allocation..
 225         * We don't guarantee that "sizeof(struct list_head)" is necessarily
 226         * a power-of-two.
 227         */
 228        hash_size = PAGE_SIZE / sizeof(struct list_head);
 229        hash_bits = 0;
 230        do {
 231                hash_bits++;
 232        } while ((hash_size >> hash_bits) != 0);
 233        hash_bits--;
 234
 235        /*
 236         * Re-calculate the actual number of entries and the mask
 237         * from the number of bits we can fit.
 238         */
 239        hash_size = 1UL << hash_bits;
 240
 241        /* And initialize the newly allocated array */
 242        d = dcookie_hashtable;
 243        i = hash_size;
 244        do {
 245                INIT_LIST_HEAD(d);
 246                d++;
 247                i--;
 248        } while (i);
 249
 250out:
 251        return err;
 252out_kmem:
 253        kmem_cache_destroy(dcookie_cache);
 254        goto out;
 255}
 256
 257
 258static void free_dcookie(struct dcookie_struct * dcs)
 259{
 260        dcs->path.dentry->d_cookie = NULL;
 261        path_put(&dcs->path);
 262        kmem_cache_free(dcookie_cache, dcs);
 263}
 264
 265
 266static void dcookie_exit(void)
 267{
 268        struct list_head * list;
 269        struct list_head * pos;
 270        struct list_head * pos2;
 271        struct dcookie_struct * dcs;
 272        size_t i;
 273
 274        for (i = 0; i < hash_size; ++i) {
 275                list = dcookie_hashtable + i;
 276                list_for_each_safe(pos, pos2, list) {
 277                        dcs = list_entry(pos, struct dcookie_struct, hash_list);
 278                        list_del(&dcs->hash_list);
 279                        free_dcookie(dcs);
 280                }
 281        }
 282
 283        kfree(dcookie_hashtable);
 284        kmem_cache_destroy(dcookie_cache);
 285}
 286
 287
 288struct dcookie_user {
 289        struct list_head next;
 290};
 291 
 292struct dcookie_user * dcookie_register(void)
 293{
 294        struct dcookie_user * user;
 295
 296        mutex_lock(&dcookie_mutex);
 297
 298        user = kmalloc(sizeof(struct dcookie_user), GFP_KERNEL);
 299        if (!user)
 300                goto out;
 301
 302        if (!is_live() && dcookie_init())
 303                goto out_free;
 304
 305        list_add(&user->next, &dcookie_users);
 306
 307out:
 308        mutex_unlock(&dcookie_mutex);
 309        return user;
 310out_free:
 311        kfree(user);
 312        user = NULL;
 313        goto out;
 314}
 315
 316
 317void dcookie_unregister(struct dcookie_user * user)
 318{
 319        mutex_lock(&dcookie_mutex);
 320
 321        list_del(&user->next);
 322        kfree(user);
 323
 324        if (!is_live())
 325                dcookie_exit();
 326
 327        mutex_unlock(&dcookie_mutex);
 328}
 329
 330EXPORT_SYMBOL_GPL(dcookie_register);
 331EXPORT_SYMBOL_GPL(dcookie_unregister);
 332EXPORT_SYMBOL_GPL(get_dcookie);
 333