static int proc_write(struct file *filp, const char __user *buff,
unsigned long len, void *data)
{
unsigned int page_no = 0, clen = 0;
if (copy_from_user(&buffer, buff, len))
return -EFAULT;
sscanf(buffer, "%u %u", &page_no, &clen);
if (table[page_no]) {
used_size -= (unsigned long)ksize(table[page_no]);
kfree(table[page_no]);
}
if (!(table[page_no] = kmalloc(clen, GFP_KERNEL))) {
printk(KERN_INFO "Error allocating mem for page: %u\n", page_no);
} else {
used_size += (unsigned long)ksize(table[page_no]);
}
count++;
sprintf(buffer, "%lu %lu %lu\n", count, used_size, used_size >> 10);
relay_write(relay, buffer, strlen(buffer));
return len;
}
static ssize_t proc_write(struct file *filp, const char __user *buff,
unsigned long len, void *data)
{
unsigned int page_no = 0, clen = 0;
unsigned long used_size;
if (copy_from_user(&buffer, buff, len)) {
pr_info("Error copying buffer from user: len=%lu\n", len);
return -EFAULT;
}
//pr_info("buffer=[%s]\n", buffer);
sscanf(buffer, "%u %u", &page_no, &clen);
//temp
//buffer[len] = '\0';
if (table[page_no])
tlsf_free(table[page_no], mem_pool);
if (!(table[page_no] = tlsf_malloc(clen, mem_pool)))
pr_info("Error allocating mem for page: %u\n", page_no);
used_size = (unsigned long)tlsf_get_used_size(mem_pool);
count++;
//spin_lock(&write_lock);
//sprintf(buffer, "%lu\n", used_size);
sprintf(buffer, "%lu %lu %lu\n", count, used_size, used_size >> 10);
relay_write(relay, buffer, strlen(buffer));
//relay_write(relay, &used_size, sizeof(unsigned long));
//spin_unlock(&write_lock);
return len;
}
static void ath_debug_send_fft_sample(struct ath_softc *sc,
struct fft_sample_tlv *fft_sample_tlv)
{
int length;
if (!sc->rfs_chan_spec_scan)
return;
length = __be16_to_cpu(fft_sample_tlv->length) +
sizeof(*fft_sample_tlv);
relay_write(sc->rfs_chan_spec_scan, fft_sample_tlv, length);
}
int cmd_relay(int argc, char *argv[]) {
unsigned char pin,value;
unsigned short module;
module = MODULE1;
if(!(module_exists(module) && (module_profile_id(module) == PROFILE_RELAY))) {
cmd_print("No relay available.");
return(0);
}
if (argc == 2) {
pin = ustrtoul(argv[1],NULL,0);
cmd_print("\r\nrelay module: %d pin: %d value: %d",module,pin, relay_read(module,pin));
} else if (argc == 3) {
pin = ustrtoul(argv[1],NULL,0);
value = ustrtoul(argv[2],NULL,16);
relay_write(module,pin,value);
}
return(0);
}
static void kvm_add_trace(void *probe_private, void *call_data,
const char *format, va_list *args)
{
struct kvm_trace_probe *p = probe_private;
struct kvm_trace *kt = kvm_trace;
struct kvm_trace_rec rec;
struct kvm_vcpu *vcpu;
int i, size;
u32 extra;
if (unlikely(kt->trace_state != KVM_TRACE_STATE_RUNNING))
return;
rec.rec_val = TRACE_REC_EVENT_ID(va_arg(*args, u32));
vcpu = va_arg(*args, struct kvm_vcpu *);
rec.pid = current->tgid;
rec.vcpu_id = vcpu->vcpu_id;
extra = va_arg(*args, u32);
WARN_ON(!(extra <= KVM_TRC_EXTRA_MAX));
extra = min_t(u32, extra, KVM_TRC_EXTRA_MAX);
rec.rec_val |= TRACE_REC_TCS(p->timestamp_in)
| TRACE_REC_NUM_DATA_ARGS(extra);
if (p->timestamp_in) {
rec.u.timestamp.timestamp = ktime_to_ns(ktime_get());
for (i = 0; i < extra; i++)
rec.u.timestamp.extra_u32[i] = va_arg(*args, u32);
} else {
for (i = 0; i < extra; i++)
rec.u.notimestamp.extra_u32[i] = va_arg(*args, u32);
}
size = calc_rec_size(p->timestamp_in, extra * sizeof(u32));
relay_write(kt->rchan, &rec, size);
}
static int __init my_init(void)
{
int j, k;
char data[64];
spinlock_t dumb_lock;
mychan = relay_open(fname, NULL, SB_SIZE, N_SB, &relay_callbacks, NULL);
/* can't use smp_processor_id() properly otherwise */
spin_lock_init(&dumb_lock);
for (k = 0; k < 10; k++) { /* do this for a minute */
spin_lock(&dumb_lock);
for (j = 0; j < 10; j++) {
memset(data, 0, 64);
sprintf(data, "data=%d\n", j * k);
relay_write(mychan, data, 64);
}
printk(KERN_INFO "Relay Channel %s loaded on cpu=%d.\n", fname,
smp_processor_id());
spin_unlock(&dumb_lock);
msleep(6000);
}
return 0;
}
