2 * Hypervisor filesystem for Linux on s390. z/VM implementation.
4 * Copyright (C) IBM Corp. 2006
5 * Author(s): Michael Holzheu <holzheu@de.ibm.com>
8 #include <linux/types.h>
9 #include <linux/errno.h>
10 #include <linux/string.h>
11 #include <linux/vmalloc.h>
12 #include <asm/ebcdic.h>
13 #include <asm/timex.h>
17 #define DBFS_D2FC_HDR_VERSION 0
19 static char local_guest[] = " ";
20 static char all_guests[] = "* ";
21 static char *guest_query;
23 static struct dentry *dbfs_d2fc_file;
46 char guest_name[NAME_LEN];
49 struct diag2fc_parm_list {
50 char userid[NAME_LEN];
51 char aci_grp[NAME_LEN];
57 static int diag2fc(int size, char* query, void *addr)
59 unsigned long residual_cnt;
61 struct diag2fc_parm_list parm_list;
63 memcpy(parm_list.userid, query, NAME_LEN);
64 ASCEBC(parm_list.userid, NAME_LEN);
65 parm_list.addr = (unsigned long) addr ;
66 parm_list.size = size;
68 memset(parm_list.aci_grp, 0x40, NAME_LEN);
75 : "=d" (residual_cnt), "+d" (rc) : "0" (&parm_list) : "memory");
77 if ((rc != 0 ) && (rc != -2))
84 * Allocate buffer for "query" and store diag 2fc at "offset"
86 static void *diag2fc_store(char *query, unsigned int *count, int offset)
92 size = diag2fc(0, query, NULL);
94 return ERR_PTR(-EACCES);
95 data = vmalloc(size + offset);
97 return ERR_PTR(-ENOMEM);
98 if (diag2fc(size, query, data + offset) == 0)
102 *count = (size / sizeof(struct diag2fc_data));
107 static void diag2fc_free(void *data)
112 #define ATTRIBUTE(sb, dir, name, member) \
115 rc = hypfs_create_u64(sb, dir, name, member); \
117 return PTR_ERR(rc); \
120 static int hpyfs_vm_create_guest(struct super_block *sb,
121 struct dentry *systems_dir,
122 struct diag2fc_data *data)
124 char guest_name[NAME_LEN + 1] = {};
125 struct dentry *guest_dir, *cpus_dir, *samples_dir, *mem_dir;
126 int dedicated_flag, capped_value;
128 capped_value = (data->flags & 0x00000006) >> 1;
129 dedicated_flag = (data->flags & 0x00000008) >> 3;
132 memcpy(guest_name, data->guest_name, NAME_LEN);
133 EBCASC(guest_name, NAME_LEN);
135 guest_dir = hypfs_mkdir(sb, systems_dir, guest_name);
136 if (IS_ERR(guest_dir))
137 return PTR_ERR(guest_dir);
138 ATTRIBUTE(sb, guest_dir, "onlinetime_us", data->el_time);
140 /* logical cpu information */
141 cpus_dir = hypfs_mkdir(sb, guest_dir, "cpus");
142 if (IS_ERR(cpus_dir))
143 return PTR_ERR(cpus_dir);
144 ATTRIBUTE(sb, cpus_dir, "cputime_us", data->used_cpu);
145 ATTRIBUTE(sb, cpus_dir, "capped", capped_value);
146 ATTRIBUTE(sb, cpus_dir, "dedicated", dedicated_flag);
147 ATTRIBUTE(sb, cpus_dir, "count", data->vcpus);
148 ATTRIBUTE(sb, cpus_dir, "weight_min", data->cpu_min);
149 ATTRIBUTE(sb, cpus_dir, "weight_max", data->cpu_max);
150 ATTRIBUTE(sb, cpus_dir, "weight_cur", data->cpu_shares);
152 /* memory information */
153 mem_dir = hypfs_mkdir(sb, guest_dir, "mem");
155 return PTR_ERR(mem_dir);
156 ATTRIBUTE(sb, mem_dir, "min_KiB", data->mem_min_kb);
157 ATTRIBUTE(sb, mem_dir, "max_KiB", data->mem_max_kb);
158 ATTRIBUTE(sb, mem_dir, "used_KiB", data->mem_used_kb);
159 ATTRIBUTE(sb, mem_dir, "share_KiB", data->mem_share_kb);
162 samples_dir = hypfs_mkdir(sb, guest_dir, "samples");
163 if (IS_ERR(samples_dir))
164 return PTR_ERR(samples_dir);
165 ATTRIBUTE(sb, samples_dir, "cpu_using", data->cpu_use_samp);
166 ATTRIBUTE(sb, samples_dir, "cpu_delay", data->cpu_delay_samp);
167 ATTRIBUTE(sb, samples_dir, "mem_delay", data->page_wait_samp);
168 ATTRIBUTE(sb, samples_dir, "idle", data->idle_samp);
169 ATTRIBUTE(sb, samples_dir, "other", data->other_samp);
170 ATTRIBUTE(sb, samples_dir, "total", data->total_samp);
174 int hypfs_vm_create_files(struct super_block *sb, struct dentry *root)
176 struct dentry *dir, *file;
177 struct diag2fc_data *data;
178 unsigned int count = 0;
181 data = diag2fc_store(guest_query, &count, 0);
183 return PTR_ERR(data);
186 dir = hypfs_mkdir(sb, root, "hyp");
191 file = hypfs_create_str(sb, dir, "type", "z/VM Hypervisor");
198 dir = hypfs_mkdir(sb, root, "cpus");
203 file = hypfs_create_u64(sb, dir, "count", data->lcpus);
210 dir = hypfs_mkdir(sb, root, "systems");
216 for (i = 0; i < count; i++) {
217 rc = hpyfs_vm_create_guest(sb, dir, &(data[i]));
229 struct dbfs_d2fc_hdr {
230 u64 len; /* Length of d2fc buffer without header */
231 u16 version; /* Version of header */
232 char tod_ext[16]; /* TOD clock for d2fc */
233 u64 count; /* Number of VM guests in d2fc buffer */
235 } __attribute__ ((packed));
238 struct dbfs_d2fc_hdr hdr; /* 64 byte header */
239 char buf[]; /* d2fc buffer */
240 } __attribute__ ((packed));
242 static int dbfs_d2fc_open(struct inode *inode, struct file *file)
244 struct dbfs_d2fc *data;
247 data = diag2fc_store(guest_query, &count, sizeof(data->hdr));
249 return PTR_ERR(data);
250 get_clock_ext(data->hdr.tod_ext);
251 data->hdr.len = count * sizeof(struct diag2fc_data);
252 data->hdr.version = DBFS_D2FC_HDR_VERSION;
253 data->hdr.count = count;
254 memset(&data->hdr.reserved, 0, sizeof(data->hdr.reserved));
255 file->private_data = data;
256 return nonseekable_open(inode, file);
259 static int dbfs_d2fc_release(struct inode *inode, struct file *file)
261 diag2fc_free(file->private_data);
265 static ssize_t dbfs_d2fc_read(struct file *file, char __user *buf,
266 size_t size, loff_t *ppos)
268 struct dbfs_d2fc *data = file->private_data;
270 return simple_read_from_buffer(buf, size, ppos, data, data->hdr.len +
271 sizeof(struct dbfs_d2fc_hdr));
274 static const struct file_operations dbfs_d2fc_ops = {
275 .open = dbfs_d2fc_open,
276 .read = dbfs_d2fc_read,
277 .release = dbfs_d2fc_release,
280 int hypfs_vm_init(void)
284 if (diag2fc(0, all_guests, NULL) > 0)
285 guest_query = all_guests;
286 else if (diag2fc(0, local_guest, NULL) > 0)
287 guest_query = local_guest;
291 dbfs_d2fc_file = debugfs_create_file("diag_2fc", 0400, hypfs_dbfs_dir,
292 NULL, &dbfs_d2fc_ops);
293 if (IS_ERR(dbfs_d2fc_file))
294 return PTR_ERR(dbfs_d2fc_file);
299 void hypfs_vm_exit(void)
303 debugfs_remove(dbfs_d2fc_file);