gpu: ion: Update print format in Ion.
[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 #define pr_fmt(fmt)     "%s():%d: " fmt, __func__, __LINE__
18
19 #include <linux/device.h>
20 #include <linux/file.h>
21 #include <linux/fs.h>
22 #include <linux/anon_inodes.h>
23 #include <linux/ion.h>
24 #include <linux/list.h>
25 #include <linux/miscdevice.h>
26 #include <linux/mm.h>
27 #include <linux/mm_types.h>
28 #include <linux/rbtree.h>
29 #include <linux/sched.h>
30 #include <linux/slab.h>
31 #include <linux/seq_file.h>
32 #include <linux/uaccess.h>
33 #include <linux/debugfs.h>
34
35 #include "ion_priv.h"
36 #define DEBUG
37
38 /* this function should only be called while dev->lock is held */
39 static void ion_buffer_add(struct ion_device *dev,
40                            struct ion_buffer *buffer)
41 {
42         struct rb_node **p = &dev->buffers.rb_node;
43         struct rb_node *parent = NULL;
44         struct ion_buffer *entry;
45
46         while (*p) {
47                 parent = *p;
48                 entry = rb_entry(parent, struct ion_buffer, node);
49
50                 if (buffer < entry) {
51                         p = &(*p)->rb_left;
52                 } else if (buffer > entry) {
53                         p = &(*p)->rb_right;
54                 } else {
55                         pr_err("buffer already found.");
56                         BUG();
57                 }
58         }
59
60         rb_link_node(&buffer->node, parent, p);
61         rb_insert_color(&buffer->node, &dev->buffers);
62 }
63
64 /* this function should only be called while dev->lock is held */
65 static struct ion_buffer *ion_buffer_create(struct ion_heap *heap,
66                                      struct ion_device *dev,
67                                      unsigned long len,
68                                      unsigned long align,
69                                      unsigned long flags)
70 {
71         struct ion_buffer *buffer;
72         int ret;
73
74         buffer = kzalloc(sizeof(struct ion_buffer), GFP_KERNEL);
75         if (!buffer)
76                 return ERR_PTR(-ENOMEM);
77
78         buffer->heap = heap;
79         kref_init(&buffer->ref);
80
81         ret = heap->ops->allocate(heap, buffer, len, align, flags);
82         if (ret) {
83                 kfree(buffer);
84                 return ERR_PTR(ret);
85         }
86         buffer->dev = dev;
87         buffer->size = len;
88         mutex_init(&buffer->lock);
89         ion_buffer_add(dev, buffer);
90         return buffer;
91 }
92
93 static void ion_buffer_destroy(struct kref *kref)
94 {
95         struct ion_buffer *buffer = container_of(kref, struct ion_buffer, ref);
96         struct ion_device *dev = buffer->dev;
97
98         buffer->heap->ops->free(buffer);
99         mutex_lock(&dev->lock);
100         rb_erase(&buffer->node, &dev->buffers);
101         mutex_unlock(&dev->lock);
102         kfree(buffer);
103 }
104
105 void ion_buffer_get(struct ion_buffer *buffer)
106 {
107         kref_get(&buffer->ref);
108 }
109
110 static int ion_buffer_put(struct ion_buffer *buffer)
111 {
112         return kref_put(&buffer->ref, ion_buffer_destroy);
113 }
114
115 struct ion_handle *ion_handle_create(struct ion_client *client,
116                                      struct ion_buffer *buffer)
117 {
118         struct ion_handle *handle;
119
120         handle = kzalloc(sizeof(struct ion_handle), GFP_KERNEL);
121         if (!handle)
122                 return ERR_PTR(-ENOMEM);
123         kref_init(&handle->ref);
124         rb_init_node(&handle->node);
125         handle->client = client;
126         ion_buffer_get(buffer);
127         handle->buffer = buffer;
128
129         return handle;
130 }
131
132 static void ion_handle_destroy(struct kref *kref)
133 {
134         struct ion_handle *handle = container_of(kref, struct ion_handle, ref);
135         /* XXX Can a handle be destroyed while it's map count is non-zero?:
136            if (handle->map_cnt) unmap
137          */
138         ion_buffer_put(handle->buffer);
139         mutex_lock(&handle->client->lock);
140         if (!RB_EMPTY_NODE(&handle->node))
141                 rb_erase(&handle->node, &handle->client->handles);
142         mutex_unlock(&handle->client->lock);
143         kfree(handle);
144 }
145
146 struct ion_buffer *ion_handle_buffer(struct ion_handle *handle)
147 {
148         return handle->buffer;
149 }
150
151 void ion_handle_get(struct ion_handle *handle)
152 {
153         kref_get(&handle->ref);
154 }
155
156 int ion_handle_put(struct ion_handle *handle)
157 {
158         return kref_put(&handle->ref, ion_handle_destroy);
159 }
160
161 static struct ion_handle *ion_handle_lookup(struct ion_client *client,
162                                             struct ion_buffer *buffer)
163 {
164         struct rb_node *n;
165
166         for (n = rb_first(&client->handles); n; n = rb_next(n)) {
167                 struct ion_handle *handle = rb_entry(n, struct ion_handle,
168                                                      node);
169                 if (handle->buffer == buffer)
170                         return handle;
171         }
172         return NULL;
173 }
174
175 bool ion_handle_validate(struct ion_client *client, struct ion_handle *handle)
176 {
177         struct rb_node *n = client->handles.rb_node;
178
179         while (n) {
180                 struct ion_handle *handle_node = rb_entry(n, struct ion_handle,
181                                                           node);
182                 if (handle < handle_node)
183                         n = n->rb_left;
184                 else if (handle > handle_node)
185                         n = n->rb_right;
186                 else
187                         return true;
188         }
189         WARN(1, "invalid handle passed h=0x%x,comm=%d\n", handle,
190                 current->group_leader->comm);
191         return false;
192 }
193
194 void ion_handle_add(struct ion_client *client, struct ion_handle *handle)
195 {
196         struct rb_node **p = &client->handles.rb_node;
197         struct rb_node *parent = NULL;
198         struct ion_handle *entry;
199
200         while (*p) {
201                 parent = *p;
202                 entry = rb_entry(parent, struct ion_handle, node);
203
204                 if (handle < entry)
205                         p = &(*p)->rb_left;
206                 else if (handle > entry)
207                         p = &(*p)->rb_right;
208                 else
209                         WARN(1, "%s: buffer already found.", __func__);
210         }
211
212         rb_link_node(&handle->node, parent, p);
213         rb_insert_color(&handle->node, &client->handles);
214 }
215
216 struct ion_handle *ion_alloc(struct ion_client *client, size_t len,
217                              size_t align, unsigned int flags)
218 {
219         struct rb_node *n;
220         struct ion_handle *handle;
221         struct ion_device *dev = client->dev;
222         struct ion_buffer *buffer = NULL;
223
224         /*
225          * traverse the list of heaps available in this system in priority
226          * order.  If the heap type is supported by the client, and matches the
227          * request of the caller allocate from it.  Repeat until allocate has
228          * succeeded or all heaps have been tried
229          */
230         mutex_lock(&dev->lock);
231         for (n = rb_first(&dev->heaps); n != NULL; n = rb_next(n)) {
232                 struct ion_heap *heap = rb_entry(n, struct ion_heap, node);
233                 /* if the client doesn't support this heap type */
234                 if (!((1 << heap->type) & client->heap_mask))
235                         continue;
236                 /* if the caller didn't specify this heap type */
237                 if (!((1 << heap->id) & flags))
238                         continue;
239                 buffer = ion_buffer_create(heap, dev, len, align, flags);
240                 if (!IS_ERR_OR_NULL(buffer))
241                         break;
242         }
243         mutex_unlock(&dev->lock);
244
245         if (IS_ERR_OR_NULL(buffer))
246                 return ERR_PTR(PTR_ERR(buffer));
247
248         handle = ion_handle_create(client, buffer);
249
250         if (IS_ERR_OR_NULL(handle))
251                 goto end;
252
253         /*
254          * ion_buffer_create will create a buffer with a ref_cnt of 1,
255          * and ion_handle_create will take a second reference, drop one here
256          */
257         ion_buffer_put(buffer);
258
259         mutex_lock(&client->lock);
260         ion_handle_add(client, handle);
261         mutex_unlock(&client->lock);
262         return handle;
263
264 end:
265         ion_buffer_put(buffer);
266         return handle;
267 }
268
269 void ion_free(struct ion_client *client, struct ion_handle *handle)
270 {
271         bool valid_handle;
272
273         BUG_ON(client != handle->client);
274
275         mutex_lock(&client->lock);
276         valid_handle = ion_handle_validate(client, handle);
277         mutex_unlock(&client->lock);
278
279         if (!valid_handle) {
280                 WARN(1, "%s: invalid handle passed to free.\n", __func__);
281                 return;
282         }
283         ion_handle_put(handle);
284 }
285
286 static bool _ion_map(int *buffer_cnt, int *handle_cnt)
287 {
288         bool map;
289
290         BUG_ON(*handle_cnt != 0 && *buffer_cnt == 0);
291
292         if (*buffer_cnt)
293                 map = false;
294         else
295                 map = true;
296         if (*handle_cnt == 0)
297                 (*buffer_cnt)++;
298         (*handle_cnt)++;
299         return map;
300 }
301
302 static bool _ion_unmap(int *buffer_cnt, int *handle_cnt)
303 {
304         BUG_ON(*handle_cnt == 0);
305         (*handle_cnt)--;
306         if (*handle_cnt != 0)
307                 return false;
308         BUG_ON(*buffer_cnt == 0);
309         (*buffer_cnt)--;
310         if (*buffer_cnt == 0)
311                 return true;
312         return false;
313 }
314
315 int ion_phys(struct ion_client *client, struct ion_handle *handle,
316              ion_phys_addr_t *addr, size_t *len)
317 {
318         struct ion_buffer *buffer;
319         int ret;
320
321         mutex_lock(&client->lock);
322         if (!ion_handle_validate(client, handle)) {
323                 mutex_unlock(&client->lock);
324                 return -EINVAL;
325         }
326
327         buffer = handle->buffer;
328
329         if (!buffer->heap->ops->phys) {
330                 pr_err("ion_phys is not implemented by this heap.\n");
331                 mutex_unlock(&client->lock);
332                 return -ENODEV;
333         }
334         mutex_unlock(&client->lock);
335         ret = buffer->heap->ops->phys(buffer->heap, buffer, addr, len);
336         return ret;
337 }
338
339 void *ion_map_kernel(struct ion_client *client, struct ion_handle *handle)
340 {
341         struct ion_buffer *buffer;
342         void *vaddr;
343
344         mutex_lock(&client->lock);
345         if (!ion_handle_validate(client, handle)) {
346                 WARN(1, "invalid handle passed to map_kernel.\n");
347                 mutex_unlock(&client->lock);
348                 return ERR_PTR(-EINVAL);
349         }
350
351         buffer = handle->buffer;
352         mutex_lock(&buffer->lock);
353
354         if (!handle->buffer->heap->ops->map_kernel) {
355                 pr_err("map_kernel is not implemented by this heap.\n");
356                 mutex_unlock(&buffer->lock);
357                 mutex_unlock(&client->lock);
358                 return ERR_PTR(-ENODEV);
359         }
360
361         if (_ion_map(&buffer->kmap_cnt, &handle->kmap_cnt)) {
362                 vaddr = buffer->heap->ops->map_kernel(buffer->heap, buffer);
363                 if (IS_ERR_OR_NULL(vaddr))
364                         _ion_unmap(&buffer->kmap_cnt, &handle->kmap_cnt);
365                 buffer->vaddr = vaddr;
366         } else {
367                 vaddr = buffer->vaddr;
368         }
369         mutex_unlock(&buffer->lock);
370         mutex_unlock(&client->lock);
371         return vaddr;
372 }
373
374 struct scatterlist *ion_map_dma(struct ion_client *client,
375                                 struct ion_handle *handle)
376 {
377         struct ion_buffer *buffer;
378         struct scatterlist *sglist;
379
380         mutex_lock(&client->lock);
381         if (!ion_handle_validate(client, handle)) {
382                 WARN(1, "invalid handle passed to map_dma.\n");
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("map_kernel is not implemented by this heap.\n");
391                 mutex_unlock(&buffer->lock);
392                 mutex_unlock(&client->lock);
393                 return ERR_PTR(-ENODEV);
394         }
395         if (_ion_map(&buffer->dmap_cnt, &handle->dmap_cnt)) {
396                 sglist = buffer->heap->ops->map_dma(buffer->heap, buffer);
397                 if (IS_ERR_OR_NULL(sglist))
398                         _ion_unmap(&buffer->dmap_cnt, &handle->dmap_cnt);
399                 buffer->sglist = sglist;
400         } else {
401                 sglist = buffer->sglist;
402         }
403         mutex_unlock(&buffer->lock);
404         mutex_unlock(&client->lock);
405         return sglist;
406 }
407
408 void ion_unmap_kernel(struct ion_client *client, struct ion_handle *handle)
409 {
410         struct ion_buffer *buffer;
411
412         mutex_lock(&client->lock);
413         buffer = handle->buffer;
414         mutex_lock(&buffer->lock);
415         if (_ion_unmap(&buffer->kmap_cnt, &handle->kmap_cnt)) {
416                 buffer->heap->ops->unmap_kernel(buffer->heap, buffer);
417                 buffer->vaddr = NULL;
418         }
419         mutex_unlock(&buffer->lock);
420         mutex_unlock(&client->lock);
421 }
422
423 void ion_unmap_dma(struct ion_client *client, struct ion_handle *handle)
424 {
425         struct ion_buffer *buffer;
426
427         mutex_lock(&client->lock);
428         buffer = handle->buffer;
429         mutex_lock(&buffer->lock);
430         if (_ion_unmap(&buffer->dmap_cnt, &handle->dmap_cnt)) {
431                 buffer->heap->ops->unmap_dma(buffer->heap, buffer);
432                 buffer->sglist = NULL;
433         }
434         mutex_unlock(&buffer->lock);
435         mutex_unlock(&client->lock);
436 }
437
438
439 struct ion_buffer *ion_share(struct ion_client *client,
440                                  struct ion_handle *handle)
441 {
442         bool valid_handle;
443
444         mutex_lock(&client->lock);
445         valid_handle = ion_handle_validate(client, handle);
446         mutex_unlock(&client->lock);
447         if (!valid_handle) {
448                 WARN(1, "%s: invalid handle passed to share.\n", __func__);
449                 return ERR_PTR(-EINVAL);
450         }
451
452         /* do not take an extra reference here, the burden is on the caller
453          * to make sure the buffer doesn't go away while it's passing it
454          * to another client -- ion_free should not be called on this handle
455          * until the buffer has been imported into the other client
456          */
457         return handle->buffer;
458 }
459
460 struct ion_handle *ion_import(struct ion_client *client,
461                               struct ion_buffer *buffer)
462 {
463         struct ion_handle *handle = NULL;
464
465         mutex_lock(&client->lock);
466         /* if a handle exists for this buffer just take a reference to it */
467         handle = ion_handle_lookup(client, buffer);
468         if (!IS_ERR_OR_NULL(handle)) {
469                 ion_handle_get(handle);
470                 goto end;
471         }
472         handle = ion_handle_create(client, buffer);
473         if (IS_ERR_OR_NULL(handle)) {
474                 pr_err("error during handle create\n");
475                 goto end;
476         }
477         ion_handle_add(client, handle);
478 end:
479         mutex_unlock(&client->lock);
480         return handle;
481 }
482
483 static const struct file_operations ion_share_fops;
484
485 struct ion_handle *ion_import_fd(struct ion_client *client, int fd)
486 {
487         struct file *file = fget(fd);
488         struct ion_handle *handle;
489
490         if (!file) {
491                 pr_err("imported fd not found in file table.\n");
492                 return ERR_PTR(-EINVAL);
493         }
494         if (file->f_op != &ion_share_fops) {
495                 pr_err("imported file is not a shared ion file.\n");
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("\n");
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("\n");
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("\n");
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("client_cnt %d handle_cnt %d alloc_cnt %d\n",
728                  atomic_read(&client->ref.refcount),
729                  atomic_read(&handle->ref.refcount),
730                  atomic_read(&buffer->ref.refcount));
731 }
732
733 static void ion_vma_close(struct vm_area_struct *vma)
734 {
735         struct ion_handle *handle = vma->vm_private_data;
736         struct ion_buffer *buffer = vma->vm_file->private_data;
737         struct ion_client *client;
738
739         pr_debug("\n");
740         /* this indicates the client is gone, nothing to do here */
741         if (!handle)
742                 return;
743         client = handle->client;
744         pr_debug("client_cnt %d handle_cnt %d alloc_cnt %d\n",
745                  atomic_read(&client->ref.refcount),
746                  atomic_read(&handle->ref.refcount),
747                  atomic_read(&buffer->ref.refcount));
748         ion_handle_put(handle);
749         ion_client_put(client);
750         ion_buffer_put(buffer);
751         pr_debug("client_cnt %d handle_cnt %d alloc_cnt %d\n",
752                  atomic_read(&client->ref.refcount),
753                  atomic_read(&handle->ref.refcount),
754                  atomic_read(&buffer->ref.refcount));
755 }
756
757 static struct vm_operations_struct ion_vm_ops = {
758         .open = ion_vma_open,
759         .close = ion_vma_close,
760 };
761
762 static int ion_share_mmap(struct file *file, struct vm_area_struct *vma)
763 {
764         struct ion_buffer *buffer = file->private_data;
765         unsigned long size = vma->vm_end - vma->vm_start;
766         struct ion_client *client;
767         struct ion_handle *handle;
768         int ret;
769
770         pr_debug("\n");
771         /* make sure the client still exists, it's possible for the client to
772            have gone away but the map/share fd still to be around, take
773            a reference to it so it can't go away while this mapping exists */
774         client = ion_client_lookup(buffer->dev, current->group_leader);
775         if (IS_ERR_OR_NULL(client)) {
776                 WARN(1, "trying to mmap an ion handle in a process with no "
777                        "ion client\n");
778                 return -EINVAL;
779         }
780
781         if ((size > buffer->size) || (size + (vma->vm_pgoff << PAGE_SHIFT) >
782                                      buffer->size)) {
783                 WARN(1, "trying to map larger area than handle has available"
784                        "\n");
785                 ret = -EINVAL;
786                 goto err;
787         }
788
789         /* find the handle and take a reference to it */
790         handle = ion_import(client, buffer);
791         if (IS_ERR_OR_NULL(handle)) {
792                 ret = -EINVAL;
793                 goto err;
794         }
795         ion_buffer_get(buffer);
796
797         if (!handle->buffer->heap->ops->map_user) {
798                 pr_err("this heap does not define a method for mapping "
799                        "to userspace\n");
800                 ret = -EINVAL;
801                 goto err1;
802         }
803
804         mutex_lock(&buffer->lock);
805         /* now map it to userspace */
806         ret = buffer->heap->ops->map_user(buffer->heap, buffer, vma);
807         mutex_unlock(&buffer->lock);
808         if (ret) {
809                 pr_err("failure mapping buffer to userspace\n");
810                 goto err1;
811         }
812
813         vma->vm_ops = &ion_vm_ops;
814         /* move the handle into the vm_private_data so we can access it from
815            vma_open/close */
816         vma->vm_private_data = handle;
817         pr_debug("client_cnt %d handle_cnt %d alloc_cnt %d\n",
818                  atomic_read(&client->ref.refcount),
819                  atomic_read(&handle->ref.refcount),
820                  atomic_read(&buffer->ref.refcount));
821         return 0;
822
823 err1:
824         /* drop the reference to the handle */
825         ion_handle_put(handle);
826 err:
827         /* drop the reference to the client */
828         ion_client_put(client);
829         return ret;
830 }
831
832 static const struct file_operations ion_share_fops = {
833         .owner          = THIS_MODULE,
834         .release        = ion_share_release,
835         .mmap           = ion_share_mmap,
836 };
837
838 static int ion_ioctl_share(struct file *parent, struct ion_client *client,
839                            struct ion_handle *handle)
840 {
841         int fd = get_unused_fd();
842         struct file *file;
843
844         if (fd < 0)
845                 return -ENFILE;
846
847         file = anon_inode_getfile("ion_share_fd", &ion_share_fops,
848                                   handle->buffer, O_RDWR);
849         if (IS_ERR_OR_NULL(file))
850                 goto err;
851         ion_buffer_get(handle->buffer);
852         fd_install(fd, file);
853
854         return fd;
855
856 err:
857         put_unused_fd(fd);
858         return -ENFILE;
859 }
860
861 static long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
862 {
863         struct ion_client *client = filp->private_data;
864
865         switch (cmd) {
866         case ION_IOC_ALLOC:
867         {
868                 struct ion_allocation_data data;
869
870                 if (copy_from_user(&data, (void __user *)arg, sizeof(data)))
871                         return -EFAULT;
872                 data.handle = ion_alloc(client, data.len, data.align,
873                                              data.flags);
874                 if (copy_to_user((void __user *)arg, &data, sizeof(data)))
875                         return -EFAULT;
876                 break;
877         }
878         case ION_IOC_FREE:
879         {
880                 struct ion_handle_data data;
881                 bool valid;
882
883                 if (copy_from_user(&data, (void __user *)arg,
884                                    sizeof(struct ion_handle_data)))
885                         return -EFAULT;
886                 mutex_lock(&client->lock);
887                 valid = ion_handle_validate(client, data.handle);
888                 mutex_unlock(&client->lock);
889                 if (!valid)
890                         return -EINVAL;
891                 ion_free(client, data.handle);
892                 break;
893         }
894         case ION_IOC_MAP:
895         case ION_IOC_SHARE:
896         {
897                 struct ion_fd_data data;
898
899                 if (copy_from_user(&data, (void __user *)arg, sizeof(data)))
900                         return -EFAULT;
901                 mutex_lock(&client->lock);
902                 if (!ion_handle_validate(client, data.handle)) {
903                         WARN(1, "invalid handle passed to share ioctl.\n");
904                         mutex_unlock(&client->lock);
905                         return -EINVAL;
906                 }
907                 data.fd = ion_ioctl_share(filp, client, data.handle);
908                 mutex_unlock(&client->lock);
909                 if (copy_to_user((void __user *)arg, &data, sizeof(data)))
910                         return -EFAULT;
911                 break;
912         }
913         case ION_IOC_IMPORT:
914         {
915                 struct ion_fd_data data;
916                 if (copy_from_user(&data, (void __user *)arg,
917                                    sizeof(struct ion_fd_data)))
918                         return -EFAULT;
919
920                 data.handle = ion_import_fd(client, data.fd);
921                 if (IS_ERR(data.handle))
922                         data.handle = NULL;
923                 if (copy_to_user((void __user *)arg, &data,
924                                  sizeof(struct ion_fd_data)))
925                         return -EFAULT;
926                 break;
927         }
928         case ION_IOC_CUSTOM:
929         {
930                 struct ion_device *dev = client->dev;
931                 struct ion_custom_data data;
932
933                 if (!dev->custom_ioctl)
934                         return -ENOTTY;
935                 if (copy_from_user(&data, (void __user *)arg,
936                                 sizeof(struct ion_custom_data)))
937                         return -EFAULT;
938                 return dev->custom_ioctl(client, data.cmd, data.arg);
939         }
940         default:
941                 return -ENOTTY;
942         }
943         return 0;
944 }
945
946 static int ion_release(struct inode *inode, struct file *file)
947 {
948         struct ion_client *client = file->private_data;
949
950         pr_debug("\n");
951         ion_client_put(client);
952         return 0;
953 }
954
955 static int ion_open(struct inode *inode, struct file *file)
956 {
957         struct miscdevice *miscdev = file->private_data;
958         struct ion_device *dev = container_of(miscdev, struct ion_device, dev);
959         struct ion_client *client;
960
961         pr_debug("\n");
962         client = ion_client_create(dev, -1, "user");
963         if (IS_ERR_OR_NULL(client))
964                 return PTR_ERR(client);
965         file->private_data = client;
966
967         return 0;
968 }
969
970 static const struct file_operations ion_fops = {
971         .owner          = THIS_MODULE,
972         .open           = ion_open,
973         .release        = ion_release,
974         .unlocked_ioctl = ion_ioctl,
975 };
976
977 static size_t ion_debug_heap_total(struct ion_client *client,
978                                    enum ion_heap_type type)
979 {
980         size_t size = 0;
981         struct rb_node *n;
982
983         mutex_lock(&client->lock);
984         for (n = rb_first(&client->handles); n; n = rb_next(n)) {
985                 struct ion_handle *handle = rb_entry(n,
986                                                      struct ion_handle,
987                                                      node);
988                 if (handle->buffer->heap->type == type)
989                         size += handle->buffer->size;
990         }
991         mutex_unlock(&client->lock);
992         return size;
993 }
994
995 static int ion_debug_heap_show(struct seq_file *s, void *unused)
996 {
997         struct ion_heap *heap = s->private;
998         struct ion_device *dev = heap->dev;
999         struct rb_node *n;
1000
1001         seq_printf(s, "%16.s %16.s %16.s\n", "client", "pid", "size");
1002         for (n = rb_first(&dev->user_clients); n; n = rb_next(n)) {
1003                 struct ion_client *client = rb_entry(n, struct ion_client,
1004                                                      node);
1005                 char task_comm[TASK_COMM_LEN];
1006                 size_t size = ion_debug_heap_total(client, heap->type);
1007                 if (!size)
1008                         continue;
1009
1010                 get_task_comm(task_comm, client->task);
1011                 seq_printf(s, "%16.s %16u %16u\n", task_comm, client->pid,
1012                            size);
1013         }
1014
1015         for (n = rb_first(&dev->kernel_clients); n; n = rb_next(n)) {
1016                 struct ion_client *client = rb_entry(n, struct ion_client,
1017                                                      node);
1018                 size_t size = ion_debug_heap_total(client, heap->type);
1019                 if (!size)
1020                         continue;
1021                 seq_printf(s, "%16.s %16u %16u\n", client->name, client->pid,
1022                            size);
1023         }
1024         return 0;
1025 }
1026
1027 static int ion_debug_heap_open(struct inode *inode, struct file *file)
1028 {
1029         return single_open(file, ion_debug_heap_show, inode->i_private);
1030 }
1031
1032 static const struct file_operations debug_heap_fops = {
1033         .open = ion_debug_heap_open,
1034         .read = seq_read,
1035         .llseek = seq_lseek,
1036         .release = single_release,
1037 };
1038
1039 void ion_device_add_heap(struct ion_device *dev, struct ion_heap *heap)
1040 {
1041         struct rb_node **p = &dev->heaps.rb_node;
1042         struct rb_node *parent = NULL;
1043         struct ion_heap *entry;
1044
1045         heap->dev = dev;
1046         mutex_lock(&dev->lock);
1047         while (*p) {
1048                 parent = *p;
1049                 entry = rb_entry(parent, struct ion_heap, node);
1050
1051                 if (heap->id < entry->id) {
1052                         p = &(*p)->rb_left;
1053                 } else if (heap->id > entry->id ) {
1054                         p = &(*p)->rb_right;
1055                 } else {
1056                         pr_err("can not insert multiple heaps with "
1057                                 "id %d\n", heap->id);
1058                         goto end;
1059                 }
1060         }
1061
1062         rb_link_node(&heap->node, parent, p);
1063         rb_insert_color(&heap->node, &dev->heaps);
1064         debugfs_create_file(heap->name, 0664, dev->debug_root, heap,
1065                             &debug_heap_fops);
1066 end:
1067         mutex_unlock(&dev->lock);
1068 }
1069
1070 struct ion_device *ion_device_create(long (*custom_ioctl)
1071                                      (struct ion_client *client,
1072                                       unsigned int cmd,
1073                                       unsigned long arg))
1074 {
1075         struct ion_device *idev;
1076         int ret;
1077
1078         idev = kzalloc(sizeof(struct ion_device), GFP_KERNEL);
1079         if (!idev)
1080                 return ERR_PTR(-ENOMEM);
1081
1082         idev->dev.minor = MISC_DYNAMIC_MINOR;
1083         idev->dev.name = "ion";
1084         idev->dev.fops = &ion_fops;
1085         idev->dev.parent = NULL;
1086         ret = misc_register(&idev->dev);
1087         if (ret) {
1088                 pr_err("ion: failed to register misc device.\n");
1089                 return ERR_PTR(ret);
1090         }
1091
1092         idev->debug_root = debugfs_create_dir("ion", NULL);
1093         if (IS_ERR_OR_NULL(idev->debug_root))
1094                 pr_err("ion: failed to create debug files.\n");
1095
1096         idev->custom_ioctl = custom_ioctl;
1097         idev->buffers = RB_ROOT;
1098         mutex_init(&idev->lock);
1099         idev->heaps = RB_ROOT;
1100         idev->user_clients = RB_ROOT;
1101         idev->kernel_clients = RB_ROOT;
1102         return idev;
1103 }
1104
1105 void ion_device_destroy(struct ion_device *dev)
1106 {
1107         misc_deregister(&dev->dev);
1108         /* XXX need to free the heaps and clients ? */
1109         kfree(dev);
1110 }
1111
1112 struct ion_client *ion_client_get_file(int fd)
1113 {
1114         struct ion_client *client = ERR_PTR(-EFAULT);
1115         struct file *f = fget(fd);
1116         if (!f)
1117                 return ERR_PTR(-EINVAL);
1118
1119         if (f->f_op == &ion_fops) {
1120                 client = f->private_data;
1121                 ion_client_get(client);
1122         }
1123
1124         fput(f);
1125         return client;
1126 }