gpu: ion: Add api to get client from file id.
[linux-2.6.git] / drivers / gpu / ion / ion.c
1 /*
2  * drivers/gpu/ion/ion.c
3  *
4  * Copyright (C) 2011 Google, Inc.
5  *
6  * This software is licensed under the terms of the GNU General Public
7  * License version 2, as published by the Free Software Foundation, and
8  * may be copied, distributed, and modified under those terms.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  */
16
17 #include <linux/device.h>
18 #include <linux/file.h>
19 #include <linux/fs.h>
20 #include <linux/anon_inodes.h>
21 #include <linux/ion.h>
22 #include <linux/list.h>
23 #include <linux/miscdevice.h>
24 #include <linux/mm.h>
25 #include <linux/mm_types.h>
26 #include <linux/rbtree.h>
27 #include <linux/sched.h>
28 #include <linux/slab.h>
29 #include <linux/seq_file.h>
30 #include <linux/uaccess.h>
31 #include <linux/debugfs.h>
32
33 #include "ion_priv.h"
34 #define DEBUG
35
36 /* this function should only be called while dev->lock is held */
37 static void ion_buffer_add(struct ion_device *dev,
38                            struct ion_buffer *buffer)
39 {
40         struct rb_node **p = &dev->buffers.rb_node;
41         struct rb_node *parent = NULL;
42         struct ion_buffer *entry;
43
44         while (*p) {
45                 parent = *p;
46                 entry = rb_entry(parent, struct ion_buffer, node);
47
48                 if (buffer < entry) {
49                         p = &(*p)->rb_left;
50                 } else if (buffer > entry) {
51                         p = &(*p)->rb_right;
52                 } else {
53                         pr_err("%s: buffer already found.", __func__);
54                         BUG();
55                 }
56         }
57
58         rb_link_node(&buffer->node, parent, p);
59         rb_insert_color(&buffer->node, &dev->buffers);
60 }
61
62 /* this function should only be called while dev->lock is held */
63 static struct ion_buffer *ion_buffer_create(struct ion_heap *heap,
64                                      struct ion_device *dev,
65                                      unsigned long len,
66                                      unsigned long align,
67                                      unsigned long flags)
68 {
69         struct ion_buffer *buffer;
70         int ret;
71
72         buffer = kzalloc(sizeof(struct ion_buffer), GFP_KERNEL);
73         if (!buffer)
74                 return ERR_PTR(-ENOMEM);
75
76         buffer->heap = heap;
77         kref_init(&buffer->ref);
78
79         ret = heap->ops->allocate(heap, buffer, len, align, flags);
80         if (ret) {
81                 kfree(buffer);
82                 return ERR_PTR(ret);
83         }
84         buffer->dev = dev;
85         buffer->size = len;
86         mutex_init(&buffer->lock);
87         ion_buffer_add(dev, buffer);
88         return buffer;
89 }
90
91 static void ion_buffer_destroy(struct kref *kref)
92 {
93         struct ion_buffer *buffer = container_of(kref, struct ion_buffer, ref);
94         struct ion_device *dev = buffer->dev;
95
96         buffer->heap->ops->free(buffer);
97         mutex_lock(&dev->lock);
98         rb_erase(&buffer->node, &dev->buffers);
99         mutex_unlock(&dev->lock);
100         kfree(buffer);
101 }
102
103 void ion_buffer_get(struct ion_buffer *buffer)
104 {
105         kref_get(&buffer->ref);
106 }
107
108 static int ion_buffer_put(struct ion_buffer *buffer)
109 {
110         return kref_put(&buffer->ref, ion_buffer_destroy);
111 }
112
113 struct ion_handle *ion_handle_create(struct ion_client *client,
114                                      struct ion_buffer *buffer)
115 {
116         struct ion_handle *handle;
117
118         handle = kzalloc(sizeof(struct ion_handle), GFP_KERNEL);
119         if (!handle)
120                 return ERR_PTR(-ENOMEM);
121         kref_init(&handle->ref);
122         rb_init_node(&handle->node);
123         handle->client = client;
124         ion_buffer_get(buffer);
125         handle->buffer = buffer;
126
127         return handle;
128 }
129
130 static void ion_handle_destroy(struct kref *kref)
131 {
132         struct ion_handle *handle = container_of(kref, struct ion_handle, ref);
133         /* XXX Can a handle be destroyed while it's map count is non-zero?:
134            if (handle->map_cnt) unmap
135          */
136         ion_buffer_put(handle->buffer);
137         mutex_lock(&handle->client->lock);
138         if (!RB_EMPTY_NODE(&handle->node))
139                 rb_erase(&handle->node, &handle->client->handles);
140         mutex_unlock(&handle->client->lock);
141         kfree(handle);
142 }
143
144 struct ion_buffer *ion_handle_buffer(struct ion_handle *handle)
145 {
146         return handle->buffer;
147 }
148
149 void ion_handle_get(struct ion_handle *handle)
150 {
151         kref_get(&handle->ref);
152 }
153
154 int ion_handle_put(struct ion_handle *handle)
155 {
156         return kref_put(&handle->ref, ion_handle_destroy);
157 }
158
159 static struct ion_handle *ion_handle_lookup(struct ion_client *client,
160                                             struct ion_buffer *buffer)
161 {
162         struct rb_node *n;
163
164         for (n = rb_first(&client->handles); n; n = rb_next(n)) {
165                 struct ion_handle *handle = rb_entry(n, struct ion_handle,
166                                                      node);
167                 if (handle->buffer == buffer)
168                         return handle;
169         }
170         return NULL;
171 }
172
173 bool ion_handle_validate(struct ion_client *client, struct ion_handle *handle)
174 {
175         struct rb_node *n = client->handles.rb_node;
176
177         while (n) {
178                 struct ion_handle *handle_node = rb_entry(n, struct ion_handle,
179                                                           node);
180                 if (handle < handle_node)
181                         n = n->rb_left;
182                 else if (handle > handle_node)
183                         n = n->rb_right;
184                 else
185                         return true;
186         }
187         return false;
188 }
189
190 void ion_handle_add(struct ion_client *client, struct ion_handle *handle)
191 {
192         struct rb_node **p = &client->handles.rb_node;
193         struct rb_node *parent = NULL;
194         struct ion_handle *entry;
195
196         while (*p) {
197                 parent = *p;
198                 entry = rb_entry(parent, struct ion_handle, node);
199
200                 if (handle < entry)
201                         p = &(*p)->rb_left;
202                 else if (handle > entry)
203                         p = &(*p)->rb_right;
204                 else
205                         WARN(1, "%s: buffer already found.", __func__);
206         }
207
208         rb_link_node(&handle->node, parent, p);
209         rb_insert_color(&handle->node, &client->handles);
210 }
211
212 struct ion_handle *ion_alloc(struct ion_client *client, size_t len,
213                              size_t align, unsigned int flags)
214 {
215         struct rb_node *n;
216         struct ion_handle *handle;
217         struct ion_device *dev = client->dev;
218         struct ion_buffer *buffer = NULL;
219
220         /*
221          * traverse the list of heaps available in this system in priority
222          * order.  If the heap type is supported by the client, and matches the
223          * request of the caller allocate from it.  Repeat until allocate has
224          * succeeded or all heaps have been tried
225          */
226         mutex_lock(&dev->lock);
227         for (n = rb_first(&dev->heaps); n != NULL; n = rb_next(n)) {
228                 struct ion_heap *heap = rb_entry(n, struct ion_heap, node);
229                 /* if the client doesn't support this heap type */
230                 if (!((1 << heap->type) & client->heap_mask))
231                         continue;
232                 /* if the caller didn't specify this heap type */
233                 if (!((1 << heap->id) & flags))
234                         continue;
235                 buffer = ion_buffer_create(heap, dev, len, align, flags);
236                 if (!IS_ERR_OR_NULL(buffer))
237                         break;
238         }
239         mutex_unlock(&dev->lock);
240
241         if (IS_ERR_OR_NULL(buffer))
242                 return ERR_PTR(PTR_ERR(buffer));
243
244         handle = ion_handle_create(client, buffer);
245
246         if (IS_ERR_OR_NULL(handle))
247                 goto end;
248
249         /*
250          * ion_buffer_create will create a buffer with a ref_cnt of 1,
251          * and ion_handle_create will take a second reference, drop one here
252          */
253         ion_buffer_put(buffer);
254
255         mutex_lock(&client->lock);
256         ion_handle_add(client, handle);
257         mutex_unlock(&client->lock);
258         return handle;
259
260 end:
261         ion_buffer_put(buffer);
262         return handle;
263 }
264
265 void ion_free(struct ion_client *client, struct ion_handle *handle)
266 {
267         bool valid_handle;
268
269         BUG_ON(client != handle->client);
270
271         mutex_lock(&client->lock);
272         valid_handle = ion_handle_validate(client, handle);
273         mutex_unlock(&client->lock);
274
275         if (!valid_handle) {
276                 WARN("%s: invalid handle passed to free.\n", __func__);
277                 return;
278         }
279         ion_handle_put(handle);
280 }
281
282 static bool _ion_map(int *buffer_cnt, int *handle_cnt)
283 {
284         bool map;
285
286         BUG_ON(*handle_cnt != 0 && *buffer_cnt == 0);
287
288         if (*buffer_cnt)
289                 map = false;
290         else
291                 map = true;
292         if (*handle_cnt == 0)
293                 (*buffer_cnt)++;
294         (*handle_cnt)++;
295         return map;
296 }
297
298 static bool _ion_unmap(int *buffer_cnt, int *handle_cnt)
299 {
300         BUG_ON(*handle_cnt == 0);
301         (*handle_cnt)--;
302         if (*handle_cnt != 0)
303                 return false;
304         BUG_ON(*buffer_cnt == 0);
305         (*buffer_cnt)--;
306         if (*buffer_cnt == 0)
307                 return true;
308         return false;
309 }
310
311 int ion_phys(struct ion_client *client, struct ion_handle *handle,
312              ion_phys_addr_t *addr, size_t *len)
313 {
314         struct ion_buffer *buffer;
315         int ret;
316
317         mutex_lock(&client->lock);
318         if (!ion_handle_validate(client, handle)) {
319                 mutex_unlock(&client->lock);
320                 return -EINVAL;
321         }
322
323         buffer = handle->buffer;
324
325         if (!buffer->heap->ops->phys) {
326                 pr_err("%s: ion_phys is not implemented by this heap.\n",
327                        __func__);
328                 mutex_unlock(&client->lock);
329                 return -ENODEV;
330         }
331         mutex_unlock(&client->lock);
332         ret = buffer->heap->ops->phys(buffer->heap, buffer, addr, len);
333         return ret;
334 }
335
336 void *ion_map_kernel(struct ion_client *client, struct ion_handle *handle)
337 {
338         struct ion_buffer *buffer;
339         void *vaddr;
340
341         mutex_lock(&client->lock);
342         if (!ion_handle_validate(client, handle)) {
343                 pr_err("%s: invalid handle passed to map_kernel.\n",
344                        __func__);
345                 mutex_unlock(&client->lock);
346                 return ERR_PTR(-EINVAL);
347         }
348
349         buffer = handle->buffer;
350         mutex_lock(&buffer->lock);
351
352         if (!handle->buffer->heap->ops->map_kernel) {
353                 pr_err("%s: map_kernel is not implemented by this heap.\n",
354                        __func__);
355                 mutex_unlock(&buffer->lock);
356                 mutex_unlock(&client->lock);
357                 return ERR_PTR(-ENODEV);
358         }
359
360         if (_ion_map(&buffer->kmap_cnt, &handle->kmap_cnt)) {
361                 vaddr = buffer->heap->ops->map_kernel(buffer->heap, buffer);
362                 if (IS_ERR_OR_NULL(vaddr))
363                         _ion_unmap(&buffer->kmap_cnt, &handle->kmap_cnt);
364                 buffer->vaddr = vaddr;
365         } else {
366                 vaddr = buffer->vaddr;
367         }
368         mutex_unlock(&buffer->lock);
369         mutex_unlock(&client->lock);
370         return vaddr;
371 }
372
373 struct scatterlist *ion_map_dma(struct ion_client *client,
374                                 struct ion_handle *handle)
375 {
376         struct ion_buffer *buffer;
377         struct scatterlist *sglist;
378
379         mutex_lock(&client->lock);
380         if (!ion_handle_validate(client, handle)) {
381                 pr_err("%s: invalid handle passed to map_dma.\n",
382                        __func__);
383                 mutex_unlock(&client->lock);
384                 return ERR_PTR(-EINVAL);
385         }
386         buffer = handle->buffer;
387         mutex_lock(&buffer->lock);
388
389         if (!handle->buffer->heap->ops->map_dma) {
390                 pr_err("%s: map_kernel is not implemented by this heap.\n",
391                        __func__);
392                 mutex_unlock(&buffer->lock);
393                 mutex_unlock(&client->lock);
394                 return ERR_PTR(-ENODEV);
395         }
396         if (_ion_map(&buffer->dmap_cnt, &handle->dmap_cnt)) {
397                 sglist = buffer->heap->ops->map_dma(buffer->heap, buffer);
398                 if (IS_ERR_OR_NULL(sglist))
399                         _ion_unmap(&buffer->dmap_cnt, &handle->dmap_cnt);
400                 buffer->sglist = sglist;
401         } else {
402                 sglist = buffer->sglist;
403         }
404         mutex_unlock(&buffer->lock);
405         mutex_unlock(&client->lock);
406         return sglist;
407 }
408
409 void ion_unmap_kernel(struct ion_client *client, struct ion_handle *handle)
410 {
411         struct ion_buffer *buffer;
412
413         mutex_lock(&client->lock);
414         buffer = handle->buffer;
415         mutex_lock(&buffer->lock);
416         if (_ion_unmap(&buffer->kmap_cnt, &handle->kmap_cnt)) {
417                 buffer->heap->ops->unmap_kernel(buffer->heap, buffer);
418                 buffer->vaddr = NULL;
419         }
420         mutex_unlock(&buffer->lock);
421         mutex_unlock(&client->lock);
422 }
423
424 void ion_unmap_dma(struct ion_client *client, struct ion_handle *handle)
425 {
426         struct ion_buffer *buffer;
427
428         mutex_lock(&client->lock);
429         buffer = handle->buffer;
430         mutex_lock(&buffer->lock);
431         if (_ion_unmap(&buffer->dmap_cnt, &handle->dmap_cnt)) {
432                 buffer->heap->ops->unmap_dma(buffer->heap, buffer);
433                 buffer->sglist = NULL;
434         }
435         mutex_unlock(&buffer->lock);
436         mutex_unlock(&client->lock);
437 }
438
439
440 struct ion_buffer *ion_share(struct ion_client *client,
441                                  struct ion_handle *handle)
442 {
443         bool valid_handle;
444
445         mutex_lock(&client->lock);
446         valid_handle = ion_handle_validate(client, handle);
447         mutex_unlock(&client->lock);
448         if (!valid_handle) {
449                 WARN("%s: invalid handle passed to share.\n", __func__);
450                 return ERR_PTR(-EINVAL);
451         }
452
453         /* do not take an extra reference here, the burden is on the caller
454          * to make sure the buffer doesn't go away while it's passing it
455          * to another client -- ion_free should not be called on this handle
456          * until the buffer has been imported into the other client
457          */
458         return handle->buffer;
459 }
460
461 struct ion_handle *ion_import(struct ion_client *client,
462                               struct ion_buffer *buffer)
463 {
464         struct ion_handle *handle = NULL;
465
466         mutex_lock(&client->lock);
467         /* if a handle exists for this buffer just take a reference to it */
468         handle = ion_handle_lookup(client, buffer);
469         if (!IS_ERR_OR_NULL(handle)) {
470                 ion_handle_get(handle);
471                 goto end;
472         }
473         handle = ion_handle_create(client, buffer);
474         if (IS_ERR_OR_NULL(handle))
475                 goto end;
476         ion_handle_add(client, handle);
477 end:
478         mutex_unlock(&client->lock);
479         return handle;
480 }
481
482 static const struct file_operations ion_share_fops;
483
484 struct ion_handle *ion_import_fd(struct ion_client *client, int fd)
485 {
486         struct file *file = fget(fd);
487         struct ion_handle *handle;
488
489         if (!file) {
490                 pr_err("%s: imported fd not found in file table.\n", __func__);
491                 return ERR_PTR(-EINVAL);
492         }
493         if (file->f_op != &ion_share_fops) {
494                 pr_err("%s: imported file is not a shared ion file.\n",
495                        __func__);
496                 handle = ERR_PTR(-EINVAL);
497                 goto end;
498         }
499         handle = ion_import(client, file->private_data);
500 end:
501         fput(file);
502         return handle;
503 }
504
505 static int ion_debug_client_show(struct seq_file *s, void *unused)
506 {
507         struct ion_client *client = s->private;
508         struct rb_node *n;
509         size_t sizes[ION_NUM_HEAPS] = {0};
510         const char *names[ION_NUM_HEAPS] = {0};
511         int i;
512
513         mutex_lock(&client->lock);
514         for (n = rb_first(&client->handles); n; n = rb_next(n)) {
515                 struct ion_handle *handle = rb_entry(n, struct ion_handle,
516                                                      node);
517                 enum ion_heap_type type = handle->buffer->heap->type;
518
519                 if (!names[type])
520                         names[type] = handle->buffer->heap->name;
521                 sizes[type] += handle->buffer->size;
522         }
523         mutex_unlock(&client->lock);
524
525         seq_printf(s, "%16.16s: %16.16s\n", "heap_name", "size_in_bytes");
526         for (i = 0; i < ION_NUM_HEAPS; i++) {
527                 if (!names[i])
528                         continue;
529                 seq_printf(s, "%16.16s: %16u %d\n", names[i], sizes[i],
530                            atomic_read(&client->ref.refcount));
531         }
532         return 0;
533 }
534
535 static int ion_debug_client_open(struct inode *inode, struct file *file)
536 {
537         return single_open(file, ion_debug_client_show, inode->i_private);
538 }
539
540 static const struct file_operations debug_client_fops = {
541         .open = ion_debug_client_open,
542         .read = seq_read,
543         .llseek = seq_lseek,
544         .release = single_release,
545 };
546
547 static struct ion_client *ion_client_lookup(struct ion_device *dev,
548                                             struct task_struct *task)
549 {
550         struct rb_node *n = dev->user_clients.rb_node;
551         struct ion_client *client;
552
553         mutex_lock(&dev->lock);
554         while (n) {
555                 client = rb_entry(n, struct ion_client, node);
556                 if (task == client->task) {
557                         ion_client_get(client);
558                         mutex_unlock(&dev->lock);
559                         return client;
560                 } else if (task < client->task) {
561                         n = n->rb_left;
562                 } else if (task > client->task) {
563                         n = n->rb_right;
564                 }
565         }
566         mutex_unlock(&dev->lock);
567         return NULL;
568 }
569
570 struct ion_client *ion_client_create(struct ion_device *dev,
571                                      unsigned int heap_mask,
572                                      const char *name)
573 {
574         struct ion_client *client;
575         struct task_struct *task;
576         struct rb_node **p;
577         struct rb_node *parent = NULL;
578         struct ion_client *entry;
579         char debug_name[64];
580         pid_t pid;
581
582         get_task_struct(current->group_leader);
583         task_lock(current->group_leader);
584         pid = task_pid_nr(current->group_leader);
585         /* don't bother to store task struct for kernel threads,
586            they can't be killed anyway */
587         if (current->group_leader->flags & PF_KTHREAD) {
588                 put_task_struct(current->group_leader);
589                 task = NULL;
590         } else {
591                 task = current->group_leader;
592         }
593         task_unlock(current->group_leader);
594
595         /* if this isn't a kernel thread, see if a client already
596            exists */
597         if (task) {
598                 client = ion_client_lookup(dev, task);
599                 if (!IS_ERR_OR_NULL(client)) {
600                         put_task_struct(current->group_leader);
601                         return client;
602                 }
603         }
604
605         client = kzalloc(sizeof(struct ion_client), GFP_KERNEL);
606         if (!client) {
607                 put_task_struct(current->group_leader);
608                 return ERR_PTR(-ENOMEM);
609         }
610
611         client->dev = dev;
612         client->handles = RB_ROOT;
613         mutex_init(&client->lock);
614         client->name = name;
615         client->heap_mask = heap_mask;
616         client->task = task;
617         client->pid = pid;
618         kref_init(&client->ref);
619
620         mutex_lock(&dev->lock);
621         if (task) {
622                 p = &dev->user_clients.rb_node;
623                 while (*p) {
624                         parent = *p;
625                         entry = rb_entry(parent, struct ion_client, node);
626
627                         if (task < entry->task)
628                                 p = &(*p)->rb_left;
629                         else if (task > entry->task)
630                                 p = &(*p)->rb_right;
631                 }
632                 rb_link_node(&client->node, parent, p);
633                 rb_insert_color(&client->node, &dev->user_clients);
634         } else {
635                 p = &dev->kernel_clients.rb_node;
636                 while (*p) {
637                         parent = *p;
638                         entry = rb_entry(parent, struct ion_client, node);
639
640                         if (client < entry)
641                                 p = &(*p)->rb_left;
642                         else if (client > entry)
643                                 p = &(*p)->rb_right;
644                 }
645                 rb_link_node(&client->node, parent, p);
646                 rb_insert_color(&client->node, &dev->kernel_clients);
647         }
648
649         snprintf(debug_name, 64, "%u", client->pid);
650         client->debug_root = debugfs_create_file(debug_name, 0664,
651                                                  dev->debug_root, client,
652                                                  &debug_client_fops);
653         mutex_unlock(&dev->lock);
654
655         return client;
656 }
657
658 static void _ion_client_destroy(struct kref *kref)
659 {
660         struct ion_client *client = container_of(kref, struct ion_client, ref);
661         struct ion_device *dev = client->dev;
662         struct rb_node *n;
663
664         pr_debug("%s: %d\n", __func__, __LINE__);
665         while ((n = rb_first(&client->handles))) {
666                 struct ion_handle *handle = rb_entry(n, struct ion_handle,
667                                                      node);
668                 ion_handle_destroy(&handle->ref);
669         }
670         mutex_lock(&dev->lock);
671         if (client->task) {
672                 rb_erase(&client->node, &dev->user_clients);
673                 put_task_struct(client->task);
674         } else {
675                 rb_erase(&client->node, &dev->kernel_clients);
676         }
677         debugfs_remove_recursive(client->debug_root);
678         mutex_unlock(&dev->lock);
679
680         kfree(client);
681 }
682
683 void ion_client_get(struct ion_client *client)
684 {
685         kref_get(&client->ref);
686 }
687
688 int ion_client_put(struct ion_client *client)
689 {
690         return kref_put(&client->ref, _ion_client_destroy);
691 }
692
693 void ion_client_destroy(struct ion_client *client)
694 {
695         ion_client_put(client);
696 }
697
698 static int ion_share_release(struct inode *inode, struct file* file)
699 {
700         struct ion_buffer *buffer = file->private_data;
701
702         pr_debug("%s: %d\n", __func__, __LINE__);
703         /* drop the reference to the buffer -- this prevents the
704            buffer from going away because the client holding it exited
705            while it was being passed */
706         ion_buffer_put(buffer);
707         return 0;
708 }
709
710 static void ion_vma_open(struct vm_area_struct *vma)
711 {
712
713         struct ion_buffer *buffer = vma->vm_file->private_data;
714         struct ion_handle *handle = vma->vm_private_data;
715         struct ion_client *client;
716
717         pr_debug("%s: %d\n", __func__, __LINE__);
718         /* check that the client still exists and take a reference so
719            it can't go away until this vma is closed */
720         client = ion_client_lookup(buffer->dev, current->group_leader);
721         if (IS_ERR_OR_NULL(client)) {
722                 vma->vm_private_data = NULL;
723                 return;
724         }
725         ion_buffer_get(buffer);
726         ion_handle_get(handle);
727         pr_debug("%s: %d client_cnt %d handle_cnt %d alloc_cnt %d\n",
728                  __func__, __LINE__,
729                  atomic_read(&client->ref.refcount),
730                  atomic_read(&handle->ref.refcount),
731                  atomic_read(&buffer->ref.refcount));
732 }
733
734 static void ion_vma_close(struct vm_area_struct *vma)
735 {
736         struct ion_handle *handle = vma->vm_private_data;
737         struct ion_buffer *buffer = vma->vm_file->private_data;
738         struct ion_client *client;
739
740         pr_debug("%s: %d\n", __func__, __LINE__);
741         /* this indicates the client is gone, nothing to do here */
742         if (!handle)
743                 return;
744         client = handle->client;
745         pr_debug("%s: %d client_cnt %d handle_cnt %d alloc_cnt %d\n",
746                  __func__, __LINE__,
747                  atomic_read(&client->ref.refcount),
748                  atomic_read(&handle->ref.refcount),
749                  atomic_read(&buffer->ref.refcount));
750         ion_handle_put(handle);
751         ion_client_put(client);
752         ion_buffer_put(buffer);
753         pr_debug("%s: %d client_cnt %d handle_cnt %d alloc_cnt %d\n",
754                  __func__, __LINE__,
755                  atomic_read(&client->ref.refcount),
756                  atomic_read(&handle->ref.refcount),
757                  atomic_read(&buffer->ref.refcount));
758 }
759
760 static struct vm_operations_struct ion_vm_ops = {
761         .open = ion_vma_open,
762         .close = ion_vma_close,
763 };
764
765 static int ion_share_mmap(struct file *file, struct vm_area_struct *vma)
766 {
767         struct ion_buffer *buffer = file->private_data;
768         unsigned long size = vma->vm_end - vma->vm_start;
769         struct ion_client *client;
770         struct ion_handle *handle;
771         int ret;
772
773         pr_debug("%s: %d\n", __func__, __LINE__);
774         /* make sure the client still exists, it's possible for the client to
775            have gone away but the map/share fd still to be around, take
776            a reference to it so it can't go away while this mapping exists */
777         client = ion_client_lookup(buffer->dev, current->group_leader);
778         if (IS_ERR_OR_NULL(client)) {
779                 pr_err("%s: trying to mmap an ion handle in a process with no "
780                        "ion client\n", __func__);
781                 return -EINVAL;
782         }
783
784         if ((size > buffer->size) || (size + (vma->vm_pgoff << PAGE_SHIFT) >
785                                      buffer->size)) {
786                 pr_err("%s: trying to map larger area than handle has available"
787                        "\n", __func__);
788                 ret = -EINVAL;
789                 goto err;
790         }
791
792         /* find the handle and take a reference to it */
793         handle = ion_import(client, buffer);
794         if (IS_ERR_OR_NULL(handle)) {
795                 ret = -EINVAL;
796                 goto err;
797         }
798         ion_buffer_get(buffer);
799
800         if (!handle->buffer->heap->ops->map_user) {
801                 pr_err("%s: this heap does not define a method for mapping "
802                        "to userspace\n", __func__);
803                 ret = -EINVAL;
804                 goto err1;
805         }
806
807         mutex_lock(&buffer->lock);
808         /* now map it to userspace */
809         ret = buffer->heap->ops->map_user(buffer->heap, buffer, vma);
810         mutex_unlock(&buffer->lock);
811         if (ret) {
812                 pr_err("%s: failure mapping buffer to userspace\n",
813                        __func__);
814                 goto err1;
815         }
816
817         vma->vm_ops = &ion_vm_ops;
818         /* move the handle into the vm_private_data so we can access it from
819            vma_open/close */
820         vma->vm_private_data = handle;
821         pr_debug("%s: %d client_cnt %d handle_cnt %d alloc_cnt %d\n",
822                  __func__, __LINE__,
823                  atomic_read(&client->ref.refcount),
824                  atomic_read(&handle->ref.refcount),
825                  atomic_read(&buffer->ref.refcount));
826         return 0;
827
828 err1:
829         /* drop the reference to the handle */
830         ion_handle_put(handle);
831 err:
832         /* drop the reference to the client */
833         ion_client_put(client);
834         return ret;
835 }
836
837 static const struct file_operations ion_share_fops = {
838         .owner          = THIS_MODULE,
839         .release        = ion_share_release,
840         .mmap           = ion_share_mmap,
841 };
842
843 static int ion_ioctl_share(struct file *parent, struct ion_client *client,
844                            struct ion_handle *handle)
845 {
846         int fd = get_unused_fd();
847         struct file *file;
848
849         if (fd < 0)
850                 return -ENFILE;
851
852         file = anon_inode_getfile("ion_share_fd", &ion_share_fops,
853                                   handle->buffer, O_RDWR);
854         if (IS_ERR_OR_NULL(file))
855                 goto err;
856         ion_buffer_get(handle->buffer);
857         fd_install(fd, file);
858
859         return fd;
860
861 err:
862         put_unused_fd(fd);
863         return -ENFILE;
864 }
865
866 static long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
867 {
868         struct ion_client *client = filp->private_data;
869
870         switch (cmd) {
871         case ION_IOC_ALLOC:
872         {
873                 struct ion_allocation_data data;
874
875                 if (copy_from_user(&data, (void __user *)arg, sizeof(data)))
876                         return -EFAULT;
877                 data.handle = ion_alloc(client, data.len, data.align,
878                                              data.flags);
879                 if (copy_to_user((void __user *)arg, &data, sizeof(data)))
880                         return -EFAULT;
881                 break;
882         }
883         case ION_IOC_FREE:
884         {
885                 struct ion_handle_data data;
886                 bool valid;
887
888                 if (copy_from_user(&data, (void __user *)arg,
889                                    sizeof(struct ion_handle_data)))
890                         return -EFAULT;
891                 mutex_lock(&client->lock);
892                 valid = ion_handle_validate(client, data.handle);
893                 mutex_unlock(&client->lock);
894                 if (!valid)
895                         return -EINVAL;
896                 ion_free(client, data.handle);
897                 break;
898         }
899         case ION_IOC_MAP:
900         case ION_IOC_SHARE:
901         {
902                 struct ion_fd_data data;
903
904                 if (copy_from_user(&data, (void __user *)arg, sizeof(data)))
905                         return -EFAULT;
906                 mutex_lock(&client->lock);
907                 if (!ion_handle_validate(client, data.handle)) {
908                         pr_err("%s: invalid handle passed to share ioctl.\n",
909                                __func__);
910                         mutex_unlock(&client->lock);
911                         return -EINVAL;
912                 }
913                 data.fd = ion_ioctl_share(filp, client, data.handle);
914                 mutex_unlock(&client->lock);
915                 if (copy_to_user((void __user *)arg, &data, sizeof(data)))
916                         return -EFAULT;
917                 break;
918         }
919         case ION_IOC_IMPORT:
920         {
921                 struct ion_fd_data data;
922                 if (copy_from_user(&data, (void __user *)arg,
923                                    sizeof(struct ion_fd_data)))
924                         return -EFAULT;
925
926                 data.handle = ion_import_fd(client, data.fd);
927                 if (IS_ERR(data.handle))
928                         data.handle = NULL;
929                 if (copy_to_user((void __user *)arg, &data,
930                                  sizeof(struct ion_fd_data)))
931                         return -EFAULT;
932                 break;
933         }
934         case ION_IOC_CUSTOM:
935         {
936                 struct ion_device *dev = client->dev;
937                 struct ion_custom_data data;
938
939                 if (!dev->custom_ioctl)
940                         return -ENOTTY;
941                 if (copy_from_user(&data, (void __user *)arg,
942                                 sizeof(struct ion_custom_data)))
943                         return -EFAULT;
944                 return dev->custom_ioctl(client, data.cmd, data.arg);
945         }
946         default:
947                 return -ENOTTY;
948         }
949         return 0;
950 }
951
952 static int ion_release(struct inode *inode, struct file *file)
953 {
954         struct ion_client *client = file->private_data;
955
956         pr_debug("%s: %d\n", __func__, __LINE__);
957         ion_client_put(client);
958         return 0;
959 }
960
961 static int ion_open(struct inode *inode, struct file *file)
962 {
963         struct miscdevice *miscdev = file->private_data;
964         struct ion_device *dev = container_of(miscdev, struct ion_device, dev);
965         struct ion_client *client;
966
967         pr_debug("%s: %d\n", __func__, __LINE__);
968         client = ion_client_create(dev, -1, "user");
969         if (IS_ERR_OR_NULL(client))
970                 return PTR_ERR(client);
971         file->private_data = client;
972
973         return 0;
974 }
975
976 static const struct file_operations ion_fops = {
977         .owner          = THIS_MODULE,
978         .open           = ion_open,
979         .release        = ion_release,
980         .unlocked_ioctl = ion_ioctl,
981 };
982
983 static size_t ion_debug_heap_total(struct ion_client *client,
984                                    enum ion_heap_type type)
985 {
986         size_t size = 0;
987         struct rb_node *n;
988
989         mutex_lock(&client->lock);
990         for (n = rb_first(&client->handles); n; n = rb_next(n)) {
991                 struct ion_handle *handle = rb_entry(n,
992                                                      struct ion_handle,
993                                                      node);
994                 if (handle->buffer->heap->type == type)
995                         size += handle->buffer->size;
996         }
997         mutex_unlock(&client->lock);
998         return size;
999 }
1000
1001 static int ion_debug_heap_show(struct seq_file *s, void *unused)
1002 {
1003         struct ion_heap *heap = s->private;
1004         struct ion_device *dev = heap->dev;
1005         struct rb_node *n;
1006
1007         seq_printf(s, "%16.s %16.s %16.s\n", "client", "pid", "size");
1008         for (n = rb_first(&dev->user_clients); n; n = rb_next(n)) {
1009                 struct ion_client *client = rb_entry(n, struct ion_client,
1010                                                      node);
1011                 char task_comm[TASK_COMM_LEN];
1012                 size_t size = ion_debug_heap_total(client, heap->type);
1013                 if (!size)
1014                         continue;
1015
1016                 get_task_comm(task_comm, client->task);
1017                 seq_printf(s, "%16.s %16u %16u\n", task_comm, client->pid,
1018                            size);
1019         }
1020
1021         for (n = rb_first(&dev->kernel_clients); n; n = rb_next(n)) {
1022                 struct ion_client *client = rb_entry(n, struct ion_client,
1023                                                      node);
1024                 size_t size = ion_debug_heap_total(client, heap->type);
1025                 if (!size)
1026                         continue;
1027                 seq_printf(s, "%16.s %16u %16u\n", client->name, client->pid,
1028                            size);
1029         }
1030         return 0;
1031 }
1032
1033 static int ion_debug_heap_open(struct inode *inode, struct file *file)
1034 {
1035         return single_open(file, ion_debug_heap_show, inode->i_private);
1036 }
1037
1038 static const struct file_operations debug_heap_fops = {
1039         .open = ion_debug_heap_open,
1040         .read = seq_read,
1041         .llseek = seq_lseek,
1042         .release = single_release,
1043 };
1044
1045 void ion_device_add_heap(struct ion_device *dev, struct ion_heap *heap)
1046 {
1047         struct rb_node **p = &dev->heaps.rb_node;
1048         struct rb_node *parent = NULL;
1049         struct ion_heap *entry;
1050
1051         heap->dev = dev;
1052         mutex_lock(&dev->lock);
1053         while (*p) {
1054                 parent = *p;
1055                 entry = rb_entry(parent, struct ion_heap, node);
1056
1057                 if (heap->id < entry->id) {
1058                         p = &(*p)->rb_left;
1059                 } else if (heap->id > entry->id ) {
1060                         p = &(*p)->rb_right;
1061                 } else {
1062                         pr_err("%s: can not insert multiple heaps with "
1063                                 "id %d\n", __func__, heap->id);
1064                         goto end;
1065                 }
1066         }
1067
1068         rb_link_node(&heap->node, parent, p);
1069         rb_insert_color(&heap->node, &dev->heaps);
1070         debugfs_create_file(heap->name, 0664, dev->debug_root, heap,
1071                             &debug_heap_fops);
1072 end:
1073         mutex_unlock(&dev->lock);
1074 }
1075
1076 struct ion_device *ion_device_create(long (*custom_ioctl)
1077                                      (struct ion_client *client,
1078                                       unsigned int cmd,
1079                                       unsigned long arg))
1080 {
1081         struct ion_device *idev;
1082         int ret;
1083
1084         idev = kzalloc(sizeof(struct ion_device), GFP_KERNEL);
1085         if (!idev)
1086                 return ERR_PTR(-ENOMEM);
1087
1088         idev->dev.minor = MISC_DYNAMIC_MINOR;
1089         idev->dev.name = "ion";
1090         idev->dev.fops = &ion_fops;
1091         idev->dev.parent = NULL;
1092         ret = misc_register(&idev->dev);
1093         if (ret) {
1094                 pr_err("ion: failed to register misc device.\n");
1095                 return ERR_PTR(ret);
1096         }
1097
1098         idev->debug_root = debugfs_create_dir("ion", NULL);
1099         if (IS_ERR_OR_NULL(idev->debug_root))
1100                 pr_err("ion: failed to create debug files.\n");
1101
1102         idev->custom_ioctl = custom_ioctl;
1103         idev->buffers = RB_ROOT;
1104         mutex_init(&idev->lock);
1105         idev->heaps = RB_ROOT;
1106         idev->user_clients = RB_ROOT;
1107         idev->kernel_clients = RB_ROOT;
1108         return idev;
1109 }
1110
1111 void ion_device_destroy(struct ion_device *dev)
1112 {
1113         misc_deregister(&dev->dev);
1114         /* XXX need to free the heaps and clients ? */
1115         kfree(dev);
1116 }
1117
1118 struct ion_client *ion_client_get_file(int fd)
1119 {
1120         struct ion_client *client = ERR_PTR(-EFAULT);
1121         struct file *f = fget(fd);
1122         if (!f)
1123                 return ERR_PTR(-EINVAL);
1124
1125         if (f->f_op == &ion_fops) {
1126                 client = f->private_data;
1127                 ion_client_get(client);
1128         }
1129
1130         fput(f);
1131         return client;
1132 }