Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 21143a07 authored by Linux Build Service Account's avatar Linux Build Service Account Committed by Gerrit - the friendly Code Review server
Browse files

Merge "msm: kgsl: add egl_surface/egl_image usage count in debugfs"

parents 394e309d a0232647

drivers/gpu/msm/kgsl.c

+41 −0
Original line number Diff line number Diff line
@@ -2434,6 +2434,8 @@ static int kgsl_setup_dma_buf(struct kgsl_device *device, 
	meta->dmabuf = dmabuf;

	meta->attach = attach;



	attach->priv = entry;



	entry->priv_data = meta;

	entry->memdesc.pagetable = pagetable;

	entry->memdesc.size = 0;
@@ -2484,6 +2486,45 @@ out: 
}

#endif



#ifdef CONFIG_DMA_SHARED_BUFFER

void kgsl_get_egl_counts(struct kgsl_mem_entry *entry,

		int *egl_surface_count, int *egl_image_count)

{

	struct kgsl_dma_buf_meta *meta = entry->priv_data;

	struct dma_buf *dmabuf = meta->dmabuf;

	struct dma_buf_attachment *mem_entry_buf_attachment = meta->attach;

	struct device *buf_attachment_dev = mem_entry_buf_attachment->dev;

	struct dma_buf_attachment *attachment = NULL;



	mutex_lock(&dmabuf->lock);

	list_for_each_entry(attachment, &dmabuf->attachments, node) {

		struct kgsl_mem_entry *scan_mem_entry = NULL;



		if (attachment->dev != buf_attachment_dev)

			continue;



		scan_mem_entry = attachment->priv;

		if (!scan_mem_entry)

			continue;



		switch (kgsl_memdesc_get_memtype(&scan_mem_entry->memdesc)) {

		case KGSL_MEMTYPE_EGL_SURFACE:

			(*egl_surface_count)++;

			break;

		case KGSL_MEMTYPE_EGL_IMAGE:

			(*egl_image_count)++;

			break;

		}

	}

	mutex_unlock(&dmabuf->lock);

}

#else

void kgsl_get_egl_counts(struct kgsl_mem_entry *entry,

		int *egl_surface_count, int *egl_image_count)

{

}

#endif



long kgsl_ioctl_map_user_mem(struct kgsl_device_private *dev_priv,

				     unsigned int cmd, void *data)

{

drivers/gpu/msm/kgsl.h

+3 −0
Original line number Diff line number Diff line
@@ -379,6 +379,9 @@ long kgsl_ioctl_gpuobj_set_info(struct kgsl_device_private *dev_priv, 


void kgsl_mem_entry_destroy(struct kref *kref);



void kgsl_get_egl_counts(struct kgsl_mem_entry *entry,

			int *egl_surface_count, int *egl_image_count);



struct kgsl_mem_entry * __must_check

kgsl_sharedmem_find(struct kgsl_process_private *private, uint64_t gpuaddr);

drivers/gpu/msm/kgsl_debugfs.c

+81 −12
Original line number Diff line number Diff line
@@ -125,13 +125,15 @@ static char get_cacheflag(const struct kgsl_memdesc *m) 
}





static int print_mem_entry(int id, void *ptr, void *data)

static int print_mem_entry(void *data, void *ptr)

{

	struct seq_file *s = data;

	struct kgsl_mem_entry *entry = ptr;

	char flags[9];

	char usage[16];

	struct kgsl_memdesc *m = &entry->memdesc;

	unsigned int usermem_type = kgsl_memdesc_usermem_type(m);

	int egl_surface_count = 0, egl_image_count = 0;



	flags[0] = kgsl_memdesc_is_global(m) ?  'g' : '-';

	flags[1] = '-';
@@ -145,12 +147,17 @@ static int print_mem_entry(int id, void *ptr, void *data) 


	kgsl_get_memory_usage(usage, sizeof(usage), m->flags);



	seq_printf(s, "%pK %pK %16llu %5d %9s %10s %16s %5d %16llu",

	if (usermem_type == KGSL_MEM_ENTRY_ION)

		kgsl_get_egl_counts(entry, &egl_surface_count,

						&egl_image_count);



	seq_printf(s, "%pK %pK %16llu %5d %9s %10s %16s %5d %16llu %6d %6d",

			(uint64_t *)(uintptr_t) m->gpuaddr,

			(unsigned long *) m->useraddr,

			m->size, entry->id, flags,

			memtype_str(kgsl_memdesc_usermem_type(m)),

			usage, (m->sgt ? m->sgt->nents : 0), m->mapsize);

			memtype_str(usermem_type),

			usage, (m->sgt ? m->sgt->nents : 0), m->mapsize,

			egl_surface_count, egl_image_count);



	if (entry->metadata[0] != 0)

		seq_printf(s, " %s", entry->metadata);
@@ -160,25 +167,83 @@ static int print_mem_entry(int id, void *ptr, void *data) 
	return 0;

}



static int process_mem_print(struct seq_file *s, void *unused)

static struct kgsl_mem_entry *process_mem_seq_find(struct seq_file *s,

						void *ptr, loff_t pos)

{

	struct kgsl_mem_entry *entry = ptr;

	struct kgsl_process_private *private = s->private;

	int id = 0;

	loff_t temp_pos = 1;



	seq_printf(s, "%16s %16s %16s %5s %9s %10s %16s %5s %16s\n",

		   "gpuaddr", "useraddr", "size", "id", "flags", "type",

		   "usage", "sglen", "mapsize");

	if (entry != SEQ_START_TOKEN)

		id = entry->id + 1;



	spin_lock(&private->mem_lock);

	idr_for_each(&private->mem_idr, print_mem_entry, s);

	for (entry = idr_get_next(&private->mem_idr, &id); entry;

		id++, entry = idr_get_next(&private->mem_idr, &id),

							temp_pos++) {

		if (temp_pos == pos && kgsl_mem_entry_get(entry)) {

			spin_unlock(&private->mem_lock);

			goto found;

		}

	}

	spin_unlock(&private->mem_lock);



	entry = NULL;

found:

	if (ptr != SEQ_START_TOKEN)

		kgsl_mem_entry_put(ptr);



	return entry;

}



static void *process_mem_seq_start(struct seq_file *s, loff_t *pos)

{

	loff_t seq_file_offset = *pos;



	if (seq_file_offset == 0)

		return SEQ_START_TOKEN;

	else

		return process_mem_seq_find(s, SEQ_START_TOKEN,

						seq_file_offset);

}



static void process_mem_seq_stop(struct seq_file *s, void *ptr)

{

	if (ptr && ptr != SEQ_START_TOKEN)

		kgsl_mem_entry_put(ptr);

}



static void *process_mem_seq_next(struct seq_file *s, void *ptr,

							loff_t *pos)

{

	++*pos;

	return process_mem_seq_find(s, ptr, 1);

}



static int process_mem_seq_show(struct seq_file *s, void *ptr)

{

	if (ptr == SEQ_START_TOKEN) {

		seq_printf(s, "%16s %16s %16s %5s %9s %10s %16s %5s %16s %6s %6s\n",

			"gpuaddr", "useraddr", "size", "id", "flags", "type",

			"usage", "sglen", "mapsize", "eglsrf", "eglimg");

		return 0;

	} else

		return print_mem_entry(s, ptr);

}



static const struct seq_operations process_mem_seq_fops = {

	.start = process_mem_seq_start,

	.stop = process_mem_seq_stop,

	.next = process_mem_seq_next,

	.show = process_mem_seq_show,

};



static int process_mem_open(struct inode *inode, struct file *file)

{

	int ret;

	pid_t pid = (pid_t) (unsigned long) inode->i_private;

	struct seq_file *s = NULL;

	struct kgsl_process_private *private = NULL;



	private = kgsl_process_private_find(pid);
@@ -186,9 +251,13 @@ static int process_mem_open(struct inode *inode, struct file *file) 
	if (!private)

		return -ENODEV;



	ret = single_open(file, process_mem_print, private);

	ret = seq_open(file, &process_mem_seq_fops);

	if (ret)

		kgsl_process_private_put(private);

	else {

		s = file->private_data;

		s->private = private;

	}



	return ret;

}
@@ -201,7 +270,7 @@ static int process_mem_release(struct inode *inode, struct file *file) 
	if (private)

		kgsl_process_private_put(private);



	return single_release(inode, file);

	return seq_release(inode, file);

}



static const struct file_operations process_mem_fops = {