--- /dev/null
+/*
+ * arch/ubicom32/mach-common/profile.c
+ * Implementation for Ubicom32 Profiler
+ *
+ * (C) Copyright 2009, Ubicom, Inc.
+ *
+ * This file is part of the Ubicom32 Linux Kernel Port.
+ *
+ * The Ubicom32 Linux Kernel Port is free software: you can redistribute
+ * it and/or modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * The Ubicom32 Linux Kernel Port is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with the Ubicom32 Linux Kernel Port. If not,
+ * see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/platform_device.h>
+#include "profile.h"
+#include <linux/seq_file.h>
+#include <linux/proc_fs.h>
+#include <linux/mm.h>
+#include <linux/mmzone.h>
+#include <linux/fs.h>
+#include <linux/page-flags.h>
+#include <asm/uaccess.h>
+#include <asm/devtree.h>
+#include <asm/profilesample.h>
+#include <asm/memory_map.h>
+#include <asm/page.h>
+#include <asm/ip5000.h>
+
+/*
+ * spacs for all memory blocks so we can hold locks for short time when walking tables
+ */
+#define PROFILE_NUM_MAPS 5000
+static struct profile_map profile_pm[PROFILE_NUM_MAPS];
+
+static struct profilenode *node = NULL;
+static int profile_first_packet = 1;
+
+static int profile_open(struct inode *inode, struct file *filp)
+{
+ if (!node) {
+ return -ENOENT;
+ }
+ node->busy = 1;
+ if (!node->enabled) {
+ node->enabled = 1;
+ node->busy = 0;
+ profile_first_packet = 1;
+ return 0;
+ }
+ node->busy = 0;
+ return -EBUSY;
+}
+
+static int profile_sequence_num;
+
+/*
+ * make a packet full of sample data
+ */
+static int profile_make_data_packet(char *buf, int count)
+{
+ int samples; /* number of samples requested */
+ int i;
+ struct profile_header ph;
+ char *ptr;
+
+ if (count < sizeof(struct profile_header) + sizeof(struct profile_sample)) {
+ return -EINVAL;
+ }
+
+ /*
+ * fill in the packet header
+ */
+ memset(&ph, 0, sizeof(struct profile_header));
+ ph.magic = PROF_MAGIC + PROFILE_VERSION;
+ ph.header_size = sizeof(struct profile_header);
+ ph.clocks = node->clocks;
+ for (i = 0; i < PROFILE_MAX_THREADS; ++i) {
+ ph.instruction_count[i] = node->inst_count[i];
+ }
+ ph.profile_instructions = 0;
+ ph.enabled = node->enabled_threads;
+ ph.hrt = node->hrt;
+ ph.high = 0;
+ ph.profiler_thread = node->profiler_thread;
+ ph.clock_freq = node->clock_freq;
+ ph.seq_num = profile_sequence_num++;
+ ph.cpu_id = node->cpu_id;
+ ph.perf_counters[0] = node->stats[0];
+ ph.perf_counters[1] = node->stats[1];
+ ph.perf_counters[2] = node->stats[2];
+ ph.perf_counters[3] = node->stats[3];
+ ph.ddr_freq = node->ddr_freq;
+
+ ptr = buf + sizeof(struct profile_header);
+
+ samples = (count - sizeof(struct profile_header)) / sizeof(struct profile_sample);
+ for (i = 0; i < samples && node->count; ++i) {
+ if (copy_to_user(ptr, &node->samples[node->tail], sizeof(struct profile_sample)) != 0) {
+ return -EFAULT;
+ }
+ node->count--;
+ node->tail++;
+ if (node->tail >= node->max_samples) {
+ node->tail = 0;
+ }
+ ptr += sizeof(struct profile_sample);
+ }
+ ph.sample_count = i;
+ if (copy_to_user(buf, &ph, sizeof(struct profile_header)) != 0) {
+ return -EFAULT;
+ }
+ if (ph.sample_count == 0)
+ return 0;
+ else
+ return sizeof(struct profile_header) + ph.sample_count * sizeof(struct profile_sample);
+}
+
+static void profile_get_memory_stats(unsigned int *total_free, unsigned int *max_free)
+{
+ struct list_head *p;
+ struct zone *zone;
+ unsigned int size;
+
+ *total_free = 0;
+ *max_free = 0;
+
+ /*
+ * get all the free regions. In each zone, the array of free_area lists contains the first page of each frame of size 1 << order
+ */
+ for_each_zone(zone) {
+ unsigned long order, flags, i;
+
+ if (!populated_zone(zone))
+ continue;
+
+ if (!is_normal(zone))
+ continue;
+
+ spin_lock_irqsave(&zone->lock, flags);
+ for_each_migratetype_order(order, i) {
+ size = ((1 << order) << PAGE_SHIFT) >> 10;
+ list_for_each(p, &(zone->free_area[order].free_list[i])) {
+ if (size > *max_free) {
+ *max_free = size;
+ }
+ *total_free += size;
+ }
+ }
+ spin_unlock_irqrestore(&zone->lock, flags);
+ }
+}
+
+struct profile_counter_pkt profile_builtin_stats[] =
+{
+ {
+ "Free memory(KB)", 0
+ },
+ {
+ "Max free Block(KB)", 0
+ }
+};
+
+/*
+ * make a packet full of performance counters
+ */
+static char prof_pkt[PROFILE_MAX_PACKET_SIZE];
+static int profile_make_stats_packet(char *buf, int count)
+{
+ char *ptr = prof_pkt;
+ struct profile_header_counters hdr;
+ int stat_count = 0;
+ int i;
+ unsigned int total_free, max_free;
+ int builtin_count = sizeof(profile_builtin_stats) / sizeof(struct profile_counter_pkt);
+
+ if (count > PROFILE_MAX_PACKET_SIZE) {
+ count = PROFILE_MAX_PACKET_SIZE;
+ }
+ stat_count = (count - sizeof(struct profile_header_counters)) / sizeof (struct profile_counter_pkt);
+ stat_count -= builtin_count;
+
+ if (stat_count <= 0) {
+ return 0;
+ }
+
+ if (stat_count > node->num_counters) {
+ stat_count = node->num_counters;
+ }
+
+ hdr.magic = PROF_MAGIC_COUNTERS;
+ hdr.ultra_sample_time = node->clocks;
+ hdr.ultra_count = stat_count;
+ hdr.linux_sample_time = UBICOM32_IO_TIMER->sysval;
+ hdr.linux_count = builtin_count;
+ memcpy(ptr, (void *)&hdr, sizeof(struct profile_header_counters));
+ ptr += sizeof(struct profile_header_counters);
+
+
+ for (i = 0; i < stat_count; ++i) {
+ memcpy(ptr, (void *)(&(node->counters[i])), sizeof(struct profile_counter));
+ ptr += sizeof(struct profile_counter);
+ }
+
+ /*
+ * built in statistics
+ */
+ profile_get_memory_stats(&total_free, &max_free);
+ profile_builtin_stats[0].value = total_free;
+ profile_builtin_stats[1].value = max_free;
+ memcpy(ptr, (void *)profile_builtin_stats, sizeof(profile_builtin_stats));
+ ptr += sizeof(profile_builtin_stats);
+
+ if (copy_to_user(buf, prof_pkt, ptr - prof_pkt) != 0) {
+ return -EFAULT;
+ }
+ return ptr - prof_pkt;
+}
+
+/*
+ * return a udp packet ready to send to the profiler tool
+ * when there are no packets left to make, return 0
+ */
+static int profile_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
+{
+ int result = 0;
+ if (!node) {
+ return -ENOENT;
+ }
+ node->busy = 1;
+ if (!node->enabled) {
+ node->busy = 0;
+ return -EPERM;
+ }
+ if (!node->samples) {
+ node->busy = 0;
+ return -ENOMEM;
+ }
+
+ if (profile_first_packet) {
+ result = profile_make_stats_packet(buf, count);
+ profile_first_packet = 0;
+ }
+ if (result == 0) {
+ result = profile_make_data_packet(buf, count);
+ if (result == 0) {
+ profile_first_packet = 1;
+ }
+ }
+ node->busy = 0;
+ return result;
+
+}
+
+static int profile_release(struct inode *inode, struct file *filp)
+{
+ if (!node) {
+ return -ENOENT;
+ }
+ node->busy = 1;
+ if (node->enabled) {
+ node->enabled = 0;
+ node->count = 0;
+ node->tail = node->head;
+ node->busy = 0;
+ return 0;
+ }
+ node->busy = 0;
+ profile_first_packet = 1;
+ return -EBADF;
+}
+
+static const struct file_operations profile_fops = {
+ .open = profile_open,
+ .read = profile_read,
+ .release = profile_release,
+};
+
+static int page_aligned(void *x)
+{
+ return !((unsigned int)x & ((1 << PAGE_SHIFT) - 1));
+}
+
+static int profile_maps_open(struct inode *inode, struct file *filp)
+{
+ struct rb_node *rb;
+ int num = 0;
+ int slab_start;
+ struct vm_area_struct *vma;
+ int type = PROFILE_MAP_TYPE_UNKNOWN;
+ int flags, i;
+ struct list_head *p;
+ struct zone *zone;
+
+ /*
+ * get the slab data (first so dups will show up as vmas)
+ */
+ slab_start = num;
+ num += kmem_cache_block_info("size-512", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
+ num += kmem_cache_block_info("size-1024", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
+ num += kmem_cache_block_info("size-2048", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
+ num += kmem_cache_block_info("size-4096", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
+ num += kmem_cache_block_info("size-8192", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
+
+ for (i = slab_start; i < num; ++i) {
+ profile_pm[i].type_size |= PROFILE_MAP_TYPE_SMALL << PROFILE_MAP_TYPE_SHIFT;
+ }
+
+ slab_start = num;
+ num += kmem_cache_block_info("dentry", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
+ num += kmem_cache_block_info("inode_cache", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
+ num += kmem_cache_block_info("sysfs_dir_cache", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
+ num += kmem_cache_block_info("proc_inode_cache", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
+
+ for (i = slab_start; i < num; ++i) {
+ profile_pm[i].type_size |= PROFILE_MAP_TYPE_FS << PROFILE_MAP_TYPE_SHIFT;
+ }
+
+ /*
+ * get all the vma regions (allocated by mmap, most likely
+ */
+#if 0
+ down_read(&nommu_vma_sem);
+ for (rb = rb_first(&nommu_vma_tree); rb && num < PROFILE_NUM_MAPS; rb = rb_next(rb)) {
+ vma = rb_entry(rb, struct vm_area_struct, vm_rb);
+ profile_pm[num].start = (vma->vm_start - SDRAMSTART) >> PAGE_SHIFT;
+ profile_pm[num].type_size = (vma->vm_end - vma->vm_start + (1 << PAGE_SHIFT) - 1) >> PAGE_SHIFT;
+ flags = vma->vm_flags & 0xf;
+ if (flags == (VM_READ | VM_EXEC)) {
+ type = PROFILE_MAP_TYPE_TEXT;
+ } else if (flags == (VM_READ | VM_WRITE | VM_EXEC)) {
+ type = PROFILE_MAP_TYPE_STACK;
+ } else if (flags == (VM_READ | VM_WRITE)) {
+ type = PROFILE_MAP_TYPE_APP_DATA;
+ }
+ profile_pm[num].type_size |= type << PROFILE_MAP_TYPE_SHIFT;
+ num++;
+ }
+ up_read(&nommu_vma_sem);
+ if (rb) {
+ return -ENOMEM;
+ }
+#endif
+
+ /*
+ * get all the free regions. In each zone, the array of free_area lists contains the first page of each frame of size 1 << order
+ */
+ for_each_zone(zone) {
+ unsigned long order, flags, i;
+ struct page *page;
+
+ if (!populated_zone(zone))
+ continue;
+
+ if (!is_normal(zone))
+ continue;
+
+ spin_lock_irqsave(&zone->lock, flags);
+ for_each_migratetype_order(order, i) {
+ list_for_each(p, &(zone->free_area[order].free_list[i])) {
+ page = list_entry(p, struct page, lru);
+ profile_pm[num].start = ((page_to_phys(page) - SDRAMSTART) >> PAGE_SHIFT) - 0x40;
+ profile_pm[num].type_size = (PROFILE_MAP_TYPE_FREE << PROFILE_MAP_TYPE_SHIFT) | order;
+ num++;
+ if (num >= PROFILE_NUM_MAPS) {
+ spin_unlock_irqrestore(&zone->lock, flags);
+ return -ENOMEM;
+ }
+ }
+ }
+ spin_unlock_irqrestore(&zone->lock, flags);
+ }
+
+ /*
+ * get the filesystem inodes
+ */
+ list_for_each(p, &(super_blocks)) {
+ struct super_block *sb;
+ struct list_head *q;
+ if (num >= PROFILE_NUM_MAPS)
+ break;
+ sb = list_entry(p, struct super_block, s_list);
+ if (page_aligned(sb)) {
+ profile_pm[num].start = ((unsigned int)sb - SDRAMSTART) >> PAGE_SHIFT;
+ profile_pm[num].type_size = (PROFILE_MAP_TYPE_FS << PROFILE_MAP_TYPE_SHIFT);
+ num++;
+ }
+ list_for_each(q, &(sb->s_inodes)) {
+ struct inode *in;
+ if (num >= PROFILE_NUM_MAPS)
+ break;
+ in = list_entry(q, struct inode, i_sb_list);
+ if (page_aligned(in)) {
+ profile_pm[num].start = ((unsigned int)in - SDRAMSTART) >> PAGE_SHIFT;
+ profile_pm[num].type_size = (PROFILE_MAP_TYPE_FS << PROFILE_MAP_TYPE_SHIFT);
+ num++;
+ }
+ }
+ }
+
+ /*
+ * get the buffer cache pages
+ */
+ for (i = 0; i < num_physpages && num < PROFILE_NUM_MAPS; ++i) {
+ if ((mem_map + i)->flags & (1 << PG_lru)) {
+ int start = i;
+ while ((mem_map + i)->flags & (1 << PG_lru) && i < num_physpages)
+ i++;
+ profile_pm[num].start = start;
+ profile_pm[num].type_size = (i - start) | (PROFILE_MAP_TYPE_CACHE << PROFILE_MAP_TYPE_SHIFT);
+ num++;
+ }
+ }
+
+ filp->private_data = (void *)num;
+ return 0;
+}
+
+/*
+ * return one packet of map data, or 0 if all maps have been returned already
+ */
+static int profile_maps_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
+{
+ struct profile_header_maps header;
+ char *p = buf + sizeof(header);
+ int total = (int)filp->private_data;
+
+ header.count = (count - sizeof(header)) / sizeof(struct profile_map);
+ if (header.count > PROFILE_MAX_MAPS) {
+ header.count = PROFILE_MAX_MAPS;;
+ }
+ if (header.count > total - *f_pos) {
+ header.count = total - *f_pos;
+ }
+
+ if (header.count == 0) {
+ return 0;
+ }
+
+ header.magic = PROF_MAGIC_MAPS;
+ header.page_shift = PAGE_SHIFT;
+
+ if (copy_to_user(buf, &header, sizeof(header)) != 0) {
+ return -EFAULT;
+ }
+ if (copy_to_user(p, (void *)&profile_pm[*f_pos], sizeof(struct profile_map) * header.count) != 0) {
+ return -EFAULT;
+ }
+ *f_pos += header.count;
+
+ return sizeof(header) + sizeof(struct profile_map) * header.count;
+}
+
+static int profile_maps_release(struct inode *inode, struct file *filp)
+{
+ return 0;
+}
+
+static const struct file_operations profile_maps_fops = {
+ .open = profile_maps_open,
+ .read = profile_maps_read,
+ .release = profile_maps_release,
+};
+
+static int profile_rate_show(struct seq_file *m, void *v)
+{
+ if (node) {
+ seq_printf(m, "%d samples per second. %d virtual counters.\n", node->rate, node->num_counters);
+ } else {
+ seq_printf(m, "Profiler is not initialized.\n");
+ }
+ return 0;
+}
+
+static int profile_rate_open(struct inode *inode, struct file *filp)
+{
+ return single_open(filp, profile_rate_show, NULL);
+}
+
+static int profile_rate_write(struct file *filp, const char *buf, size_t len, loff_t *off)
+{
+ *off = 0;
+ return 0;
+}
+
+static const struct file_operations profile_rate_fops = {
+ .open = profile_rate_open,
+ .read = seq_read,
+ .llseek = seq_lseek,
+ .release = single_release,
+ .write = profile_rate_write,
+};
+
+int ubi32_profile_init_module(void)
+{
+ struct proc_dir_entry *pdir;
+
+ /*
+ * find the device
+ */
+ node = (struct profilenode *)devtree_find_node("profiler");
+ if (!node) {
+ printk(KERN_INFO "Profiler does not exist.\n");
+ return -ENODEV;
+ }
+
+ /*
+ * allocate the sample buffer
+ */
+ node->max_samples = PROFILE_MAX_SAMPLES;
+ node->samples = kmalloc(node->max_samples * sizeof(struct profile_sample), GFP_KERNEL);
+ if (!node->samples) {
+ printk(KERN_INFO "Profiler sample buffer kmalloc failed.\n");
+ return -ENOMEM;
+ }
+
+ /*
+ * connect to the file system
+ */
+ pdir = proc_mkdir("profile", NULL);
+ if (!pdir) {
+ return -ENOMEM;
+ }
+ if (!proc_create("data", 0, pdir, &profile_fops)) {
+ return -ENOMEM;
+ }
+ if (!proc_create("rate", 0, pdir, &profile_rate_fops)) {
+ return -ENOMEM;
+ }
+ if (!proc_create("maps", 0, pdir, &profile_maps_fops)) {
+ return -ENOMEM;
+ }
+ return 0;
+}
+
+
+module_init(ubi32_profile_init_module);
+
+MODULE_AUTHOR("David Fotland");
+MODULE_LICENSE("GPL");
projects / openwrt / svn-archive / archive.git / blobdiff