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