mm/ashmem.c

   1 /* mm/ashmem.c
   2 **
   3 ** Anonymous Shared Memory Subsystem, ashmem
   4 **
   5 ** Copyright (C) 2008 Google, Inc.
   6 **
   7 ** Robert Love <rlove@google.com>
   8 **
   9 ** This software is licensed under the terms of the GNU General Public
  10 ** License version 2, as published by the Free Software Foundation, and
  11 ** may be copied, distributed, and modified under those terms.
  12 **
  13 ** This program is distributed in the hope that it will be useful,
  14 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 ** GNU General Public License for more details.
  17 */
  18
  19 #include <linux/module.h>
  20 #include <linux/file.h>
  21 #include <linux/fs.h>
  22 #include <linux/miscdevice.h>
  23 #include <linux/security.h>
  24 #include <linux/mm.h>
  25 #include <linux/mman.h>
  26 #include <linux/uaccess.h>
  27 #include <linux/personality.h>
  28 #include <linux/bitops.h>
  29 #include <linux/mutex.h>
  30 #include <linux/shmem_fs.h>
  31 #include <linux/ashmem.h>
  32
  33 #define ASHMEM_NAME_PREFIX "dev/ashmem/"
  34 #define ASHMEM_NAME_PREFIX_LEN (sizeof(ASHMEM_NAME_PREFIX) - 1)
  35 #define ASHMEM_FULL_NAME_LEN (ASHMEM_NAME_LEN + ASHMEM_NAME_PREFIX_LEN)
  36
  37 /*
  38  * ashmem_area - anonymous shared memory area
  39  * Lifecycle: From our parent file's open() until its release()
  40  * Locking: Protected by `ashmem_mutex'
  41  * Big Note: Mappings do NOT pin this structure; it dies on close()
  42  */
  43 struct ashmem_area {
  44         char name[ASHMEM_FULL_NAME_LEN];/* optional name for /proc/pid/maps */
  45         struct list_head unpinned_list; /* list of all ashmem areas */
  46         struct file *file;              /* the shmem-based backing file */
  47         size_t size;                    /* size of the mapping, in bytes */
  48         unsigned long prot_mask;        /* allowed prot bits, as vm_flags */
  49 };
  50
  51 /*
  52  * ashmem_range - represents an interval of unpinned (evictable) pages
  53  * Lifecycle: From unpin to pin
  54  * Locking: Protected by `ashmem_mutex'
  55  */
  56 struct ashmem_range {
  57         struct list_head lru;           /* entry in LRU list */
  58         struct list_head unpinned;      /* entry in its area's unpinned list */
  59         struct ashmem_area *asma;       /* associated area */
  60         size_t pgstart;                 /* starting page, inclusive */
  61         size_t pgend;                   /* ending page, inclusive */
  62         unsigned int purged;            /* ASHMEM_NOT or ASHMEM_WAS_PURGED */
  63 };
  64
  65 /* LRU list of unpinned pages, protected by ashmem_mutex */
  66 static LIST_HEAD(ashmem_lru_list);
  67
  68 /* Count of pages on our LRU list, protected by ashmem_mutex */
  69 static unsigned long lru_count;
  70
  71 /*
  72  * ashmem_mutex - protects the list of and each individual ashmem_area
  73  *
  74  * Lock Ordering: ashmex_mutex -> i_mutex -> i_alloc_sem
  75  */
  76 static DEFINE_MUTEX(ashmem_mutex);
  77
  78 static struct kmem_cache *ashmem_area_cachep __read_mostly;
  79 static struct kmem_cache *ashmem_range_cachep __read_mostly;
  80
  81 #define range_size(range) \
  82   ((range)->pgend - (range)->pgstart + 1)
  83
  84 #define range_on_lru(range) \
  85   ((range)->purged == ASHMEM_NOT_PURGED)
  86
  87 #define page_range_subsumes_range(range, start, end) \
  88   (((range)->pgstart >= (start)) && ((range)->pgend <= (end)))
  89
  90 #define page_range_subsumed_by_range(range, start, end) \
  91   (((range)->pgstart <= (start)) && ((range)->pgend >= (end)))
  92
  93 #define page_in_range(range, page) \
  94  (((range)->pgstart <= (page)) && ((range)->pgend >= (page)))
  95
  96 #define page_range_in_range(range, start, end) \
  97   (page_in_range(range, start) || page_in_range(range, end) || \
  98    page_range_subsumes_range(range, start, end))
  99
 100 #define range_before_page(range, page) \
 101   ((range)->pgend < (page))
 102
 103 #define PROT_MASK               (PROT_EXEC | PROT_READ | PROT_WRITE)
 104
 105 static inline void lru_add(struct ashmem_range *range)
 106 {
 107         list_add_tail(&range->lru, &ashmem_lru_list);
 108         lru_count += range_size(range);
 109 }
 110
 111 static inline void lru_del(struct ashmem_range *range)
 112 {
 113         list_del(&range->lru);
 114         lru_count -= range_size(range);
 115 }
 116
 117 /*
 118  * range_alloc - allocate and initialize a new ashmem_range structure
 119  *
 120  * 'asma' - associated ashmem_area
 121  * 'prev_range' - the previous ashmem_range in the sorted asma->unpinned list
 122  * 'purged' - initial purge value (ASMEM_NOT_PURGED or ASHMEM_WAS_PURGED)
 123  * 'start' - starting page, inclusive
 124  * 'end' - ending page, inclusive
 125  *
 126  * Caller must hold ashmem_mutex.
 127  */
 128 static int range_alloc(struct ashmem_area *asma,
 129                        struct ashmem_range *prev_range, unsigned int purged,
 130                        size_t start, size_t end)
 131 {
 132         struct ashmem_range *range;
 133
 134         range = kmem_cache_zalloc(ashmem_range_cachep, GFP_KERNEL);
 135         if (unlikely(!range))
 136                 return -ENOMEM;
 137
 138         range->asma = asma;
 139         range->pgstart = start;
 140         range->pgend = end;
 141         range->purged = purged;
 142
 143         list_add_tail(&range->unpinned, &prev_range->unpinned);
 144
 145         if (range_on_lru(range))
 146                 lru_add(range);
 147
 148         return 0;
 149 }
 150
 151 static void range_del(struct ashmem_range *range)
 152 {
 153         list_del(&range->unpinned);
 154         if (range_on_lru(range))
 155                 lru_del(range);
 156         kmem_cache_free(ashmem_range_cachep, range);
 157 }
 158
 159 /*
 160  * range_shrink - shrinks a range
 161  *
 162  * Caller must hold ashmem_mutex.
 163  */
 164 static inline void range_shrink(struct ashmem_range *range,
 165                                 size_t start, size_t end)
 166 {
 167         size_t pre = range_size(range);
 168
 169         range->pgstart = start;
 170         range->pgend = end;
 171
 172         if (range_on_lru(range))
 173                 lru_count -= pre - range_size(range);
 174 }
 175
 176 static int ashmem_open(struct inode *inode, struct file *file)
 177 {
 178         struct ashmem_area *asma;
 179         int ret;
 180
 181         ret = nonseekable_open(inode, file);
 182         if (unlikely(ret))
 183                 return ret;
 184
 185         asma = kmem_cache_zalloc(ashmem_area_cachep, GFP_KERNEL);
 186         if (unlikely(!asma))
 187                 return -ENOMEM;
 188
 189         INIT_LIST_HEAD(&asma->unpinned_list);
 190         memcpy(asma->name, ASHMEM_NAME_PREFIX, ASHMEM_NAME_PREFIX_LEN);
 191         asma->prot_mask = PROT_MASK;
 192         file->private_data = asma;
 193
 194         return 0;
 195 }
 196
 197 static int ashmem_release(struct inode *ignored, struct file *file)
 198 {
 199         struct ashmem_area *asma = file->private_data;
 200         struct ashmem_range *range, *next;
 201
 202         mutex_lock(&ashmem_mutex);
 203         list_for_each_entry_safe(range, next, &asma->unpinned_list, unpinned)
 204                 range_del(range);
 205         mutex_unlock(&ashmem_mutex);
 206
 207         if (asma->file)
 208                 fput(asma->file);
 209         kmem_cache_free(ashmem_area_cachep, asma);
 210
 211         return 0;
 212 }
 213
 214 static ssize_t ashmem_read(struct file *file, char __user *buf,
 215                            size_t len, loff_t *pos)
 216 {
 217         struct ashmem_area *asma = file->private_data;
 218         int ret = 0;
 219
 220         mutex_lock(&ashmem_mutex);
 221
 222         /* If size is not set, or set to 0, always return EOF. */
 223         if (asma->size == 0) {
 224                 goto out;
 225         }
 226
 227         if (!asma->file) {
 228                 ret = -EBADF;
 229                 goto out;
 230         }
 231
 232         ret = asma->file->f_op->read(asma->file, buf, len, pos);
 233
 234 out:
 235         mutex_unlock(&ashmem_mutex);
 236         return ret;
 237 }
 238
 239 static inline unsigned long
 240 calc_vm_may_flags(unsigned long prot)
 241 {
 242         return _calc_vm_trans(prot, PROT_READ,  VM_MAYREAD ) |
 243                _calc_vm_trans(prot, PROT_WRITE, VM_MAYWRITE) |
 244                _calc_vm_trans(prot, PROT_EXEC,  VM_MAYEXEC);
 245 }
 246
 247 static int ashmem_mmap(struct file *file, struct vm_area_struct *vma)
 248 {
 249         struct ashmem_area *asma = file->private_data;
 250         int ret = 0;
 251
 252         mutex_lock(&ashmem_mutex);
 253
 254         /* user needs to SET_SIZE before mapping */
 255         if (unlikely(!asma->size)) {
 256                 ret = -EINVAL;
 257                 goto out;
 258         }
 259
 260         /* requested protection bits must match our allowed protection mask */
 261         if (unlikely((vma->vm_flags & ~calc_vm_prot_bits(asma->prot_mask)) &
 262                                                 calc_vm_prot_bits(PROT_MASK))) {
 263                 ret = -EPERM;
 264                 goto out;
 265         }
 266         vma->vm_flags &= ~calc_vm_may_flags(~asma->prot_mask);
 267
 268         if (!asma->file) {
 269                 char *name = ASHMEM_NAME_DEF;
 270                 struct file *vmfile;
 271
 272                 if (asma->name[ASHMEM_NAME_PREFIX_LEN] != '\0')
 273                         name = asma->name;
 274
 275                 /* ... and allocate the backing shmem file */
 276                 vmfile = shmem_file_setup(name, asma->size, vma->vm_flags);
 277                 if (unlikely(IS_ERR(vmfile))) {
 278                         ret = PTR_ERR(vmfile);
 279                         goto out;
 280                 }
 281                 asma->file = vmfile;
 282         }
 283         get_file(asma->file);
 284
 285         if (vma->vm_flags & VM_SHARED)
 286                 shmem_set_file(vma, asma->file);
 287         else {
 288                 if (vma->vm_file)
 289                         fput(vma->vm_file);
 290                 vma->vm_file = asma->file;
 291         }
 292         vma->vm_flags |= VM_CAN_NONLINEAR;
 293
 294 out:
 295         mutex_unlock(&ashmem_mutex);
 296         return ret;
 297 }
 298
 299 /*
 300  * ashmem_shrink - our cache shrinker, called from mm/vmscan.c :: shrink_slab
 301  *
 302  * 'nr_to_scan' is the number of objects (pages) to prune, or 0 to query how
 303  * many objects (pages) we have in total.
 304  *
 305  * 'gfp_mask' is the mask of the allocation that got us into this mess.
 306  *
 307  * Return value is the number of objects (pages) remaining, or -1 if we cannot
 308  * proceed without risk of deadlock (due to gfp_mask).
 309  *
 310  * We approximate LRU via least-recently-unpinned, jettisoning unpinned partial
 311  * chunks of ashmem regions LRU-wise one-at-a-time until we hit 'nr_to_scan'
 312  * pages freed.
 313  */
 314 static int ashmem_shrink(int nr_to_scan, gfp_t gfp_mask)
 315 {
 316         struct ashmem_range *range, *next;
 317
 318         /* We might recurse into filesystem code, so bail out if necessary */
 319         if (nr_to_scan && !(gfp_mask & __GFP_FS))
 320                 return -1;
 321         if (!nr_to_scan)
 322                 return lru_count;
 323
 324         mutex_lock(&ashmem_mutex);
 325         list_for_each_entry_safe(range, next, &ashmem_lru_list, lru) {
 326                 struct inode *inode = range->asma->file->f_dentry->d_inode;
 327                 loff_t start = range->pgstart * PAGE_SIZE;
 328                 loff_t end = (range->pgend + 1) * PAGE_SIZE - 1;
 329
 330                 vmtruncate_range(inode, start, end);
 331                 range->purged = ASHMEM_WAS_PURGED;
 332                 lru_del(range);
 333
 334                 nr_to_scan -= range_size(range);
 335                 if (nr_to_scan <= 0)
 336                         break;
 337         }
 338         mutex_unlock(&ashmem_mutex);
 339
 340         return lru_count;
 341 }
 342
 343 static struct shrinker ashmem_shrinker = {
 344         .shrink = ashmem_shrink,
 345         .seeks = DEFAULT_SEEKS * 4,
 346 };
 347
 348 static int set_prot_mask(struct ashmem_area *asma, unsigned long prot)
 349 {
 350         int ret = 0;
 351
 352         mutex_lock(&ashmem_mutex);
 353
 354         /* the user can only remove, not add, protection bits */
 355         if (unlikely((asma->prot_mask & prot) != prot)) {
 356                 ret = -EINVAL;
 357                 goto out;
 358         }
 359
 360         /* does the application expect PROT_READ to imply PROT_EXEC? */
 361         if ((prot & PROT_READ) && (current->personality & READ_IMPLIES_EXEC))
 362                 prot |= PROT_EXEC;
 363
 364         asma->prot_mask = prot;
 365
 366 out:
 367         mutex_unlock(&ashmem_mutex);
 368         return ret;
 369 }
 370
 371 static int set_name(struct ashmem_area *asma, void __user *name)
 372 {
 373         int ret = 0;
 374
 375         mutex_lock(&ashmem_mutex);
 376
 377         /* cannot change an existing mapping's name */
 378         if (unlikely(asma->file)) {
 379                 ret = -EINVAL;
 380                 goto out;
 381         }
 382
 383         if (unlikely(copy_from_user(asma->name + ASHMEM_NAME_PREFIX_LEN,
 384                                     name, ASHMEM_NAME_LEN)))
 385                 ret = -EFAULT;
 386         asma->name[ASHMEM_FULL_NAME_LEN-1] = '\0';
 387
 388 out:
 389         mutex_unlock(&ashmem_mutex);
 390
 391         return ret;
 392 }
 393
 394 static int get_name(struct ashmem_area *asma, void __user *name)
 395 {
 396         int ret = 0;
 397
 398         mutex_lock(&ashmem_mutex);
 399         if (asma->name[ASHMEM_NAME_PREFIX_LEN] != '\0') {
 400                 size_t len;
 401
 402                 /*
 403                  * Copying only `len', instead of ASHMEM_NAME_LEN, bytes
 404                  * prevents us from revealing one user's stack to another.
 405                  */
 406                 len = strlen(asma->name + ASHMEM_NAME_PREFIX_LEN) + 1;
 407                 if (unlikely(copy_to_user(name,
 408                                 asma->name + ASHMEM_NAME_PREFIX_LEN, len)))
 409                         ret = -EFAULT;
 410         } else {
 411                 if (unlikely(copy_to_user(name, ASHMEM_NAME_DEF,
 412                                           sizeof(ASHMEM_NAME_DEF))))
 413                         ret = -EFAULT;
 414         }
 415         mutex_unlock(&ashmem_mutex);
 416
 417         return ret;
 418 }
 419
 420 /*
 421  * ashmem_pin - pin the given ashmem region, returning whether it was
 422  * previously purged (ASHMEM_WAS_PURGED) or not (ASHMEM_NOT_PURGED).
 423  *
 424  * Caller must hold ashmem_mutex.
 425  */
 426 static int ashmem_pin(struct ashmem_area *asma, size_t pgstart, size_t pgend)
 427 {
 428         struct ashmem_range *range, *next;
 429         int ret = ASHMEM_NOT_PURGED;
 430
 431         list_for_each_entry_safe(range, next, &asma->unpinned_list, unpinned) {
 432                 /* moved past last applicable page; we can short circuit */
 433                 if (range_before_page(range, pgstart))
 434                         break;
 435
 436                 /*
 437                  * The user can ask us to pin pages that span multiple ranges,
 438                  * or to pin pages that aren't even unpinned, so this is messy.
 439                  *
 440                  * Four cases:
 441                  * 1. The requested range subsumes an existing range, so we
 442                  *    just remove the entire matching range.
 443                  * 2. The requested range overlaps the start of an existing
 444                  *    range, so we just update that range.
 445                  * 3. The requested range overlaps the end of an existing
 446                  *    range, so we just update that range.
 447                  * 4. The requested range punches a hole in an existing range,
 448                  *    so we have to update one side of the range and then
 449                  *    create a new range for the other side.
 450                  */
 451                 if (page_range_in_range(range, pgstart, pgend)) {
 452                         ret |= range->purged;
 453
 454                         /* Case #1: Easy. Just nuke the whole thing. */
 455                         if (page_range_subsumes_range(range, pgstart, pgend)) {
 456                                 range_del(range);
 457                                 continue;
 458                         }
 459
 460                         /* Case #2: We overlap from the start, so adjust it */
 461                         if (range->pgstart >= pgstart) {
 462                                 range_shrink(range, pgend + 1, range->pgend);
 463                                 continue;
 464                         }
 465
 466                         /* Case #3: We overlap from the rear, so adjust it */
 467                         if (range->pgend <= pgend) {
 468                                 range_shrink(range, range->pgstart, pgstart-1);
 469                                 continue;
 470                         }
 471
 472                         /*
 473                          * Case #4: We eat a chunk out of the middle. A bit
 474                          * more complicated, we allocate a new range for the
 475                          * second half and adjust the first chunk's endpoint.
 476                          */
 477                         range_alloc(asma, range, range->purged,
 478                                     pgend + 1, range->pgend);
 479                         range_shrink(range, range->pgstart, pgstart - 1);
 480                         break;
 481                 }
 482         }
 483
 484         return ret;
 485 }
 486
 487 /*
 488  * ashmem_unpin - unpin the given range of pages. Returns zero on success.
 489  *
 490  * Caller must hold ashmem_mutex.
 491  */
 492 static int ashmem_unpin(struct ashmem_area *asma, size_t pgstart, size_t pgend)
 493 {
 494         struct ashmem_range *range, *next;
 495         unsigned int purged = ASHMEM_NOT_PURGED;
 496
 497 restart:
 498         list_for_each_entry_safe(range, next, &asma->unpinned_list, unpinned) {
 499                 /* short circuit: this is our insertion point */
 500                 if (range_before_page(range, pgstart))
 501                         break;
 502
 503                 /*
 504                  * The user can ask us to unpin pages that are already entirely
 505                  * or partially pinned. We handle those two cases here.
 506                  */
 507                 if (page_range_subsumed_by_range(range, pgstart, pgend))
 508                         return 0;
 509                 if (page_range_in_range(range, pgstart, pgend)) {
 510                         pgstart = min_t(size_t, range->pgstart, pgstart),
 511                         pgend = max_t(size_t, range->pgend, pgend);
 512                         purged |= range->purged;
 513                         range_del(range);
 514                         goto restart;
 515                 }
 516         }
 517
 518         return range_alloc(asma, range, purged, pgstart, pgend);
 519 }
 520
 521 /*
 522  * ashmem_get_pin_status - Returns ASHMEM_IS_UNPINNED if _any_ pages in the
 523  * given interval are unpinned and ASHMEM_IS_PINNED otherwise.
 524  *
 525  * Caller must hold ashmem_mutex.
 526  */
 527 static int ashmem_get_pin_status(struct ashmem_area *asma, size_t pgstart,
 528                                  size_t pgend)
 529 {
 530         struct ashmem_range *range;
 531         int ret = ASHMEM_IS_PINNED;
 532
 533         list_for_each_entry(range, &asma->unpinned_list, unpinned) {
 534                 if (range_before_page(range, pgstart))
 535                         break;
 536                 if (page_range_in_range(range, pgstart, pgend)) {
 537                         ret = ASHMEM_IS_UNPINNED;
 538                         break;
 539                 }
 540         }
 541
 542         return ret;
 543 }
 544
 545 static int ashmem_pin_unpin(struct ashmem_area *asma, unsigned long cmd,
 546                             void __user *p)
 547 {
 548         struct ashmem_pin pin;
 549         size_t pgstart, pgend;
 550         int ret = -EINVAL;
 551
 552         if (unlikely(!asma->file))
 553                 return -EINVAL;
 554
 555         if (unlikely(copy_from_user(&pin, p, sizeof(pin))))
 556                 return -EFAULT;
 557
 558         /* per custom, you can pass zero for len to mean "everything onward" */
 559         if (!pin.len)
 560                 pin.len = PAGE_ALIGN(asma->size) - pin.offset;
 561
 562         if (unlikely((pin.offset | pin.len) & ~PAGE_MASK))
 563                 return -EINVAL;
 564
 565         if (unlikely(((__u32) -1) - pin.offset < pin.len))
 566                 return -EINVAL;
 567
 568         if (unlikely(PAGE_ALIGN(asma->size) < pin.offset + pin.len))
 569                 return -EINVAL;
 570
 571         pgstart = pin.offset / PAGE_SIZE;
 572         pgend = pgstart + (pin.len / PAGE_SIZE) - 1;
 573
 574         mutex_lock(&ashmem_mutex);
 575
 576         switch (cmd) {
 577         case ASHMEM_PIN:
 578                 ret = ashmem_pin(asma, pgstart, pgend);
 579                 break;
 580         case ASHMEM_UNPIN:
 581                 ret = ashmem_unpin(asma, pgstart, pgend);
 582                 break;
 583         case ASHMEM_GET_PIN_STATUS:
 584                 ret = ashmem_get_pin_status(asma, pgstart, pgend);
 585                 break;
 586         }
 587
 588         mutex_unlock(&ashmem_mutex);
 589
 590         return ret;
 591 }
 592
 593 static long ashmem_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 594 {
 595         struct ashmem_area *asma = file->private_data;
 596         long ret = -ENOTTY;
 597
 598         switch (cmd) {
 599         case ASHMEM_SET_NAME:
 600                 ret = set_name(asma, (void __user *) arg);
 601                 break;
 602         case ASHMEM_GET_NAME:
 603                 ret = get_name(asma, (void __user *) arg);
 604                 break;
 605         case ASHMEM_SET_SIZE:
 606                 ret = -EINVAL;
 607                 if (!asma->file) {
 608                         ret = 0;
 609                         asma->size = (size_t) arg;
 610                 }
 611                 break;
 612         case ASHMEM_GET_SIZE:
 613                 ret = asma->size;
 614                 break;
 615         case ASHMEM_SET_PROT_MASK:
 616                 ret = set_prot_mask(asma, arg);
 617                 break;
 618         case ASHMEM_GET_PROT_MASK:
 619                 ret = asma->prot_mask;
 620                 break;
 621         case ASHMEM_PIN:
 622         case ASHMEM_UNPIN:
 623         case ASHMEM_GET_PIN_STATUS:
 624                 ret = ashmem_pin_unpin(asma, cmd, (void __user *) arg);
 625                 break;
 626         case ASHMEM_PURGE_ALL_CACHES:
 627                 ret = -EPERM;
 628                 if (capable(CAP_SYS_ADMIN)) {
 629                         ret = ashmem_shrink(0, GFP_KERNEL);
 630                         ashmem_shrink(ret, GFP_KERNEL);
 631                 }
 632                 break;
 633         }
 634
 635         return ret;
 636 }
 637
 638 static struct file_operations ashmem_fops = {
 639         .owner = THIS_MODULE,
 640         .open = ashmem_open,
 641         .release = ashmem_release,
 642         .read = ashmem_read,
 643         .mmap = ashmem_mmap,
 644         .unlocked_ioctl = ashmem_ioctl,
 645         .compat_ioctl = ashmem_ioctl,
 646 };
 647
 648 static struct miscdevice ashmem_misc = {
 649         .minor = MISC_DYNAMIC_MINOR,
 650         .name = "ashmem",
 651         .fops = &ashmem_fops,
 652 };
 653
 654 static int __init ashmem_init(void)
 655 {
 656         int ret;
 657
 658         ashmem_area_cachep = kmem_cache_create("ashmem_area_cache",
 659                                           sizeof(struct ashmem_area),
 660                                           0, 0, NULL);
 661         if (unlikely(!ashmem_area_cachep)) {
 662                 printk(KERN_ERR "ashmem: failed to create slab cache\n");
 663                 return -ENOMEM;
 664         }
 665
 666         ashmem_range_cachep = kmem_cache_create("ashmem_range_cache",
 667                                           sizeof(struct ashmem_range),
 668                                           0, 0, NULL);
 669         if (unlikely(!ashmem_range_cachep)) {
 670                 printk(KERN_ERR "ashmem: failed to create slab cache\n");
 671                 return -ENOMEM;
 672         }
 673
 674         ret = misc_register(&ashmem_misc);
 675         if (unlikely(ret)) {
 676                 printk(KERN_ERR "ashmem: failed to register misc device!\n");
 677                 return ret;
 678         }
 679
 680         register_shrinker(&ashmem_shrinker);
 681
 682         printk(KERN_INFO "ashmem: initialized\n");
 683
 684         return 0;
 685 }
 686
 687 static void __exit ashmem_exit(void)
 688 {
 689         int ret;
 690
 691         unregister_shrinker(&ashmem_shrinker);
 692
 693         ret = misc_deregister(&ashmem_misc);
 694         if (unlikely(ret))
 695                 printk(KERN_ERR "ashmem: failed to unregister misc device!\n");
 696
 697         kmem_cache_destroy(ashmem_range_cachep);
 698         kmem_cache_destroy(ashmem_area_cachep);
 699
 700         printk(KERN_INFO "ashmem: unloaded\n");
 701 }
 702
 703 module_init(ashmem_init);
 704 module_exit(ashmem_exit);
 705
 706 MODULE_LICENSE("GPL");