fs/dcookies.c

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