1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#define pr_fmt(fmt) "ashmem: " fmt
20
21#include <linux/init.h>
22#include <linux/export.h>
23#include <linux/file.h>
24#include <linux/fs.h>
25#include <linux/falloc.h>
26#include <linux/miscdevice.h>
27#include <linux/security.h>
28#include <linux/mm.h>
29#include <linux/mman.h>
30#include <linux/uaccess.h>
31#include <linux/personality.h>
32#include <linux/bitops.h>
33#include <linux/mutex.h>
34#include <linux/shmem_fs.h>
35#include "ashmem.h"
36
37#define ASHMEM_NAME_PREFIX "dev/ashmem/"
38#define ASHMEM_NAME_PREFIX_LEN (sizeof(ASHMEM_NAME_PREFIX) - 1)
39#define ASHMEM_FULL_NAME_LEN (ASHMEM_NAME_LEN + ASHMEM_NAME_PREFIX_LEN)
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54struct ashmem_area {
55 char name[ASHMEM_FULL_NAME_LEN];
56 struct list_head unpinned_list;
57 struct file *file;
58 size_t size;
59 unsigned long prot_mask;
60};
61
62
63
64
65
66
67
68
69
70
71
72
73
74struct ashmem_range {
75 struct list_head lru;
76 struct list_head unpinned;
77 struct ashmem_area *asma;
78 size_t pgstart;
79 size_t pgend;
80 unsigned int purged;
81};
82
83
84static LIST_HEAD(ashmem_lru_list);
85
86
87
88
89
90
91static unsigned long lru_count;
92
93
94
95
96
97
98static DEFINE_MUTEX(ashmem_mutex);
99
100static struct kmem_cache *ashmem_area_cachep __read_mostly;
101static struct kmem_cache *ashmem_range_cachep __read_mostly;
102
103static inline unsigned long range_size(struct ashmem_range *range)
104{
105 return range->pgend - range->pgstart + 1;
106}
107
108static inline bool range_on_lru(struct ashmem_range *range)
109{
110 return range->purged == ASHMEM_NOT_PURGED;
111}
112
113static inline bool page_range_subsumes_range(struct ashmem_range *range,
114 size_t start, size_t end)
115{
116 return (range->pgstart >= start) && (range->pgend <= end);
117}
118
119static inline bool page_range_subsumed_by_range(struct ashmem_range *range,
120 size_t start, size_t end)
121{
122 return (range->pgstart <= start) && (range->pgend >= end);
123}
124
125static inline bool page_in_range(struct ashmem_range *range, size_t page)
126{
127 return (range->pgstart <= page) && (range->pgend >= page);
128}
129
130static inline bool page_range_in_range(struct ashmem_range *range,
131 size_t start, size_t end)
132{
133 return page_in_range(range, start) || page_in_range(range, end) ||
134 page_range_subsumes_range(range, start, end);
135}
136
137static inline bool range_before_page(struct ashmem_range *range, size_t page)
138{
139 return range->pgend < page;
140}
141
142#define PROT_MASK (PROT_EXEC | PROT_READ | PROT_WRITE)
143
144
145
146
147
148
149
150
151static inline void lru_add(struct ashmem_range *range)
152{
153 list_add_tail(&range->lru, &ashmem_lru_list);
154 lru_count += range_size(range);
155}
156
157
158
159
160
161
162
163
164static inline void lru_del(struct ashmem_range *range)
165{
166 list_del(&range->lru);
167 lru_count -= range_size(range);
168}
169
170
171
172
173
174
175
176
177
178
179
180
181
182static int range_alloc(struct ashmem_area *asma,
183 struct ashmem_range *prev_range, unsigned int purged,
184 size_t start, size_t end)
185{
186 struct ashmem_range *range;
187
188 range = kmem_cache_zalloc(ashmem_range_cachep, GFP_KERNEL);
189 if (unlikely(!range))
190 return -ENOMEM;
191
192 range->asma = asma;
193 range->pgstart = start;
194 range->pgend = end;
195 range->purged = purged;
196
197 list_add_tail(&range->unpinned, &prev_range->unpinned);
198
199 if (range_on_lru(range))
200 lru_add(range);
201
202 return 0;
203}
204
205
206
207
208
209static void range_del(struct ashmem_range *range)
210{
211 list_del(&range->unpinned);
212 if (range_on_lru(range))
213 lru_del(range);
214 kmem_cache_free(ashmem_range_cachep, range);
215}
216
217
218
219
220
221
222
223
224
225
226
227
228
229static inline void range_shrink(struct ashmem_range *range,
230 size_t start, size_t end)
231{
232 size_t pre = range_size(range);
233
234 range->pgstart = start;
235 range->pgend = end;
236
237 if (range_on_lru(range))
238 lru_count -= pre - range_size(range);
239}
240
241
242
243
244
245
246
247
248
249
250
251static int ashmem_open(struct inode *inode, struct file *file)
252{
253 struct ashmem_area *asma;
254 int ret;
255
256 ret = generic_file_open(inode, file);
257 if (unlikely(ret))
258 return ret;
259
260 asma = kmem_cache_zalloc(ashmem_area_cachep, GFP_KERNEL);
261 if (unlikely(!asma))
262 return -ENOMEM;
263
264 INIT_LIST_HEAD(&asma->unpinned_list);
265 memcpy(asma->name, ASHMEM_NAME_PREFIX, ASHMEM_NAME_PREFIX_LEN);
266 asma->prot_mask = PROT_MASK;
267 file->private_data = asma;
268
269 return 0;
270}
271
272
273
274
275
276
277
278
279
280static int ashmem_release(struct inode *ignored, struct file *file)
281{
282 struct ashmem_area *asma = file->private_data;
283 struct ashmem_range *range, *next;
284
285 mutex_lock(&ashmem_mutex);
286 list_for_each_entry_safe(range, next, &asma->unpinned_list, unpinned)
287 range_del(range);
288 mutex_unlock(&ashmem_mutex);
289
290 if (asma->file)
291 fput(asma->file);
292 kmem_cache_free(ashmem_area_cachep, asma);
293
294 return 0;
295}
296
297static ssize_t ashmem_read_iter(struct kiocb *iocb, struct iov_iter *iter)
298{
299 struct ashmem_area *asma = iocb->ki_filp->private_data;
300 int ret = 0;
301
302 mutex_lock(&ashmem_mutex);
303
304
305 if (asma->size == 0)
306 goto out_unlock;
307
308 if (!asma->file) {
309 ret = -EBADF;
310 goto out_unlock;
311 }
312
313
314
315
316
317
318
319 mutex_unlock(&ashmem_mutex);
320 ret = vfs_iter_read(asma->file, iter, &iocb->ki_pos, 0);
321 mutex_lock(&ashmem_mutex);
322 if (ret > 0)
323 asma->file->f_pos = iocb->ki_pos;
324out_unlock:
325 mutex_unlock(&ashmem_mutex);
326 return ret;
327}
328
329static loff_t ashmem_llseek(struct file *file, loff_t offset, int origin)
330{
331 struct ashmem_area *asma = file->private_data;
332 int ret;
333
334 mutex_lock(&ashmem_mutex);
335
336 if (asma->size == 0) {
337 ret = -EINVAL;
338 goto out;
339 }
340
341 if (!asma->file) {
342 ret = -EBADF;
343 goto out;
344 }
345
346 ret = vfs_llseek(asma->file, offset, origin);
347 if (ret < 0)
348 goto out;
349
350
351 file->f_pos = asma->file->f_pos;
352
353out:
354 mutex_unlock(&ashmem_mutex);
355 return ret;
356}
357
358static inline vm_flags_t calc_vm_may_flags(unsigned long prot)
359{
360 return _calc_vm_trans(prot, PROT_READ, VM_MAYREAD) |
361 _calc_vm_trans(prot, PROT_WRITE, VM_MAYWRITE) |
362 _calc_vm_trans(prot, PROT_EXEC, VM_MAYEXEC);
363}
364
365static int ashmem_mmap(struct file *file, struct vm_area_struct *vma)
366{
367 struct ashmem_area *asma = file->private_data;
368 int ret = 0;
369
370 mutex_lock(&ashmem_mutex);
371
372
373 if (unlikely(!asma->size)) {
374 ret = -EINVAL;
375 goto out;
376 }
377
378
379 if (unlikely((vma->vm_flags & ~calc_vm_prot_bits(asma->prot_mask, 0)) &
380 calc_vm_prot_bits(PROT_MASK, 0))) {
381 ret = -EPERM;
382 goto out;
383 }
384 vma->vm_flags &= ~calc_vm_may_flags(~asma->prot_mask);
385
386 if (!asma->file) {
387 char *name = ASHMEM_NAME_DEF;
388 struct file *vmfile;
389
390 if (asma->name[ASHMEM_NAME_PREFIX_LEN] != '\0')
391 name = asma->name;
392
393
394 vmfile = shmem_file_setup(name, asma->size, vma->vm_flags);
395 if (IS_ERR(vmfile)) {
396 ret = PTR_ERR(vmfile);
397 goto out;
398 }
399 vmfile->f_mode |= FMODE_LSEEK;
400 asma->file = vmfile;
401 }
402 get_file(asma->file);
403
404
405
406
407
408 if (vma->vm_flags & VM_SHARED) {
409 ret = shmem_zero_setup(vma);
410 if (ret) {
411 fput(asma->file);
412 goto out;
413 }
414 }
415
416 if (vma->vm_file)
417 fput(vma->vm_file);
418 vma->vm_file = asma->file;
419
420out:
421 mutex_unlock(&ashmem_mutex);
422 return ret;
423}
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439static unsigned long
440ashmem_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
441{
442 struct ashmem_range *range, *next;
443 unsigned long freed = 0;
444
445
446 if (!(sc->gfp_mask & __GFP_FS))
447 return SHRINK_STOP;
448
449 if (!mutex_trylock(&ashmem_mutex))
450 return -1;
451
452 list_for_each_entry_safe(range, next, &ashmem_lru_list, lru) {
453 loff_t start = range->pgstart * PAGE_SIZE;
454 loff_t end = (range->pgend + 1) * PAGE_SIZE;
455
456 vfs_fallocate(range->asma->file,
457 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
458 start, end - start);
459 range->purged = ASHMEM_WAS_PURGED;
460 lru_del(range);
461
462 freed += range_size(range);
463 if (--sc->nr_to_scan <= 0)
464 break;
465 }
466 mutex_unlock(&ashmem_mutex);
467 return freed;
468}
469
470static unsigned long
471ashmem_shrink_count(struct shrinker *shrink, struct shrink_control *sc)
472{
473
474
475
476
477
478 return lru_count;
479}
480
481static struct shrinker ashmem_shrinker = {
482 .count_objects = ashmem_shrink_count,
483 .scan_objects = ashmem_shrink_scan,
484
485
486
487
488 .seeks = DEFAULT_SEEKS * 4,
489};
490
491static int set_prot_mask(struct ashmem_area *asma, unsigned long prot)
492{
493 int ret = 0;
494
495 mutex_lock(&ashmem_mutex);
496
497
498 if (unlikely((asma->prot_mask & prot) != prot)) {
499 ret = -EINVAL;
500 goto out;
501 }
502
503
504 if ((prot & PROT_READ) && (current->personality & READ_IMPLIES_EXEC))
505 prot |= PROT_EXEC;
506
507 asma->prot_mask = prot;
508
509out:
510 mutex_unlock(&ashmem_mutex);
511 return ret;
512}
513
514static int set_name(struct ashmem_area *asma, void __user *name)
515{
516 int len;
517 int ret = 0;
518 char local_name[ASHMEM_NAME_LEN];
519
520
521
522
523
524
525
526
527
528
529 len = strncpy_from_user(local_name, name, ASHMEM_NAME_LEN);
530 if (len < 0)
531 return len;
532 if (len == ASHMEM_NAME_LEN)
533 local_name[ASHMEM_NAME_LEN - 1] = '\0';
534 mutex_lock(&ashmem_mutex);
535
536 if (unlikely(asma->file))
537 ret = -EINVAL;
538 else
539 strcpy(asma->name + ASHMEM_NAME_PREFIX_LEN, local_name);
540
541 mutex_unlock(&ashmem_mutex);
542 return ret;
543}
544
545static int get_name(struct ashmem_area *asma, void __user *name)
546{
547 int ret = 0;
548 size_t len;
549
550
551
552
553
554
555 char local_name[ASHMEM_NAME_LEN];
556
557 mutex_lock(&ashmem_mutex);
558 if (asma->name[ASHMEM_NAME_PREFIX_LEN] != '\0') {
559
560
561
562
563 len = strlen(asma->name + ASHMEM_NAME_PREFIX_LEN) + 1;
564 memcpy(local_name, asma->name + ASHMEM_NAME_PREFIX_LEN, len);
565 } else {
566 len = sizeof(ASHMEM_NAME_DEF);
567 memcpy(local_name, ASHMEM_NAME_DEF, len);
568 }
569 mutex_unlock(&ashmem_mutex);
570
571
572
573
574
575 if (unlikely(copy_to_user(name, local_name, len)))
576 ret = -EFAULT;
577 return ret;
578}
579
580
581
582
583
584
585
586static int ashmem_pin(struct ashmem_area *asma, size_t pgstart, size_t pgend)
587{
588 struct ashmem_range *range, *next;
589 int ret = ASHMEM_NOT_PURGED;
590
591 list_for_each_entry_safe(range, next, &asma->unpinned_list, unpinned) {
592
593 if (range_before_page(range, pgstart))
594 break;
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611 if (page_range_in_range(range, pgstart, pgend)) {
612 ret |= range->purged;
613
614
615 if (page_range_subsumes_range(range, pgstart, pgend)) {
616 range_del(range);
617 continue;
618 }
619
620
621 if (range->pgstart >= pgstart) {
622 range_shrink(range, pgend + 1, range->pgend);
623 continue;
624 }
625
626
627 if (range->pgend <= pgend) {
628 range_shrink(range, range->pgstart,
629 pgstart - 1);
630 continue;
631 }
632
633
634
635
636
637
638 range_alloc(asma, range, range->purged,
639 pgend + 1, range->pgend);
640 range_shrink(range, range->pgstart, pgstart - 1);
641 break;
642 }
643 }
644
645 return ret;
646}
647
648
649
650
651
652
653static int ashmem_unpin(struct ashmem_area *asma, size_t pgstart, size_t pgend)
654{
655 struct ashmem_range *range, *next;
656 unsigned int purged = ASHMEM_NOT_PURGED;
657
658restart:
659 list_for_each_entry_safe(range, next, &asma->unpinned_list, unpinned) {
660
661 if (range_before_page(range, pgstart))
662 break;
663
664
665
666
667
668 if (page_range_subsumed_by_range(range, pgstart, pgend))
669 return 0;
670 if (page_range_in_range(range, pgstart, pgend)) {
671 pgstart = min(range->pgstart, pgstart);
672 pgend = max(range->pgend, pgend);
673 purged |= range->purged;
674 range_del(range);
675 goto restart;
676 }
677 }
678
679 return range_alloc(asma, range, purged, pgstart, pgend);
680}
681
682
683
684
685
686
687
688static int ashmem_get_pin_status(struct ashmem_area *asma, size_t pgstart,
689 size_t pgend)
690{
691 struct ashmem_range *range;
692 int ret = ASHMEM_IS_PINNED;
693
694 list_for_each_entry(range, &asma->unpinned_list, unpinned) {
695 if (range_before_page(range, pgstart))
696 break;
697 if (page_range_in_range(range, pgstart, pgend)) {
698 ret = ASHMEM_IS_UNPINNED;
699 break;
700 }
701 }
702
703 return ret;
704}
705
706static int ashmem_pin_unpin(struct ashmem_area *asma, unsigned long cmd,
707 void __user *p)
708{
709 struct ashmem_pin pin;
710 size_t pgstart, pgend;
711 int ret = -EINVAL;
712
713 if (unlikely(!asma->file))
714 return -EINVAL;
715
716 if (unlikely(copy_from_user(&pin, p, sizeof(pin))))
717 return -EFAULT;
718
719
720 if (!pin.len)
721 pin.len = PAGE_ALIGN(asma->size) - pin.offset;
722
723 if (unlikely((pin.offset | pin.len) & ~PAGE_MASK))
724 return -EINVAL;
725
726 if (unlikely(((__u32)-1) - pin.offset < pin.len))
727 return -EINVAL;
728
729 if (unlikely(PAGE_ALIGN(asma->size) < pin.offset + pin.len))
730 return -EINVAL;
731
732 pgstart = pin.offset / PAGE_SIZE;
733 pgend = pgstart + (pin.len / PAGE_SIZE) - 1;
734
735 mutex_lock(&ashmem_mutex);
736
737 switch (cmd) {
738 case ASHMEM_PIN:
739 ret = ashmem_pin(asma, pgstart, pgend);
740 break;
741 case ASHMEM_UNPIN:
742 ret = ashmem_unpin(asma, pgstart, pgend);
743 break;
744 case ASHMEM_GET_PIN_STATUS:
745 ret = ashmem_get_pin_status(asma, pgstart, pgend);
746 break;
747 }
748
749 mutex_unlock(&ashmem_mutex);
750
751 return ret;
752}
753
754static long ashmem_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
755{
756 struct ashmem_area *asma = file->private_data;
757 long ret = -ENOTTY;
758
759 switch (cmd) {
760 case ASHMEM_SET_NAME:
761 ret = set_name(asma, (void __user *)arg);
762 break;
763 case ASHMEM_GET_NAME:
764 ret = get_name(asma, (void __user *)arg);
765 break;
766 case ASHMEM_SET_SIZE:
767 ret = -EINVAL;
768 if (!asma->file) {
769 ret = 0;
770 asma->size = (size_t)arg;
771 }
772 break;
773 case ASHMEM_GET_SIZE:
774 ret = asma->size;
775 break;
776 case ASHMEM_SET_PROT_MASK:
777 ret = set_prot_mask(asma, arg);
778 break;
779 case ASHMEM_GET_PROT_MASK:
780 ret = asma->prot_mask;
781 break;
782 case ASHMEM_PIN:
783 case ASHMEM_UNPIN:
784 case ASHMEM_GET_PIN_STATUS:
785 ret = ashmem_pin_unpin(asma, cmd, (void __user *)arg);
786 break;
787 case ASHMEM_PURGE_ALL_CACHES:
788 ret = -EPERM;
789 if (capable(CAP_SYS_ADMIN)) {
790 struct shrink_control sc = {
791 .gfp_mask = GFP_KERNEL,
792 .nr_to_scan = LONG_MAX,
793 };
794 ret = ashmem_shrink_count(&ashmem_shrinker, &sc);
795 ashmem_shrink_scan(&ashmem_shrinker, &sc);
796 }
797 break;
798 }
799
800 return ret;
801}
802
803
804#ifdef CONFIG_COMPAT
805static long compat_ashmem_ioctl(struct file *file, unsigned int cmd,
806 unsigned long arg)
807{
808 switch (cmd) {
809 case COMPAT_ASHMEM_SET_SIZE:
810 cmd = ASHMEM_SET_SIZE;
811 break;
812 case COMPAT_ASHMEM_SET_PROT_MASK:
813 cmd = ASHMEM_SET_PROT_MASK;
814 break;
815 }
816 return ashmem_ioctl(file, cmd, arg);
817}
818#endif
819
820static const struct file_operations ashmem_fops = {
821 .owner = THIS_MODULE,
822 .open = ashmem_open,
823 .release = ashmem_release,
824 .read_iter = ashmem_read_iter,
825 .llseek = ashmem_llseek,
826 .mmap = ashmem_mmap,
827 .unlocked_ioctl = ashmem_ioctl,
828#ifdef CONFIG_COMPAT
829 .compat_ioctl = compat_ashmem_ioctl,
830#endif
831};
832
833static struct miscdevice ashmem_misc = {
834 .minor = MISC_DYNAMIC_MINOR,
835 .name = "ashmem",
836 .fops = &ashmem_fops,
837};
838
839static int __init ashmem_init(void)
840{
841 int ret = -ENOMEM;
842
843 ashmem_area_cachep = kmem_cache_create("ashmem_area_cache",
844 sizeof(struct ashmem_area),
845 0, 0, NULL);
846 if (unlikely(!ashmem_area_cachep)) {
847 pr_err("failed to create slab cache\n");
848 goto out;
849 }
850
851 ashmem_range_cachep = kmem_cache_create("ashmem_range_cache",
852 sizeof(struct ashmem_range),
853 0, 0, NULL);
854 if (unlikely(!ashmem_range_cachep)) {
855 pr_err("failed to create slab cache\n");
856 goto out_free1;
857 }
858
859 ret = misc_register(&ashmem_misc);
860 if (unlikely(ret)) {
861 pr_err("failed to register misc device!\n");
862 goto out_free2;
863 }
864
865 register_shrinker(&ashmem_shrinker);
866
867 pr_info("initialized\n");
868
869 return 0;
870
871out_free2:
872 kmem_cache_destroy(ashmem_range_cachep);
873out_free1:
874 kmem_cache_destroy(ashmem_area_cachep);
875out:
876 return ret;
877}
878device_initcall(ashmem_init);
879