~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/platforms/pseries/dtl.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Virtual Processor Dispatch Trace Log
  3  *
  4  * (C) Copyright IBM Corporation 2009
  5  *
  6  * Author: Jeremy Kerr <jk@ozlabs.org>
  7  *
  8  * This program is free software; you can redistribute it and/or modify
  9  * it under the terms of the GNU General Public License as published by
 10  * the Free Software Foundation; either version 2, or (at your option)
 11  * any later version.
 12  *
 13  * This program is distributed in the hope that it will be useful,
 14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16  * GNU General Public License for more details.
 17  *
 18  * You should have received a copy of the GNU General Public License
 19  * along with this program; if not, write to the Free Software
 20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 21  */
 22 
 23 #include <linux/slab.h>
 24 #include <linux/debugfs.h>
 25 #include <linux/spinlock.h>
 26 #include <asm/smp.h>
 27 #include <asm/uaccess.h>
 28 #include <asm/firmware.h>
 29 #include <asm/lppaca.h>
 30 #include <asm/debug.h>
 31 #include <asm/plpar_wrappers.h>
 32 
 33 struct dtl {
 34         struct dtl_entry        *buf;
 35         struct dentry           *file;
 36         int                     cpu;
 37         int                     buf_entries;
 38         u64                     last_idx;
 39         spinlock_t              lock;
 40 };
 41 static DEFINE_PER_CPU(struct dtl, cpu_dtl);
 42 
 43 /*
 44  * Dispatch trace log event mask:
 45  * 0x7: 0x1: voluntary virtual processor waits
 46  *      0x2: time-slice preempts
 47  *      0x4: virtual partition memory page faults
 48  */
 49 static u8 dtl_event_mask = 0x7;
 50 
 51 
 52 /*
 53  * Size of per-cpu log buffers. Firmware requires that the buffer does
 54  * not cross a 4k boundary.
 55  */
 56 static int dtl_buf_entries = N_DISPATCH_LOG;
 57 
 58 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
 59 struct dtl_ring {
 60         u64     write_index;
 61         struct dtl_entry *write_ptr;
 62         struct dtl_entry *buf;
 63         struct dtl_entry *buf_end;
 64         u8      saved_dtl_mask;
 65 };
 66 
 67 static DEFINE_PER_CPU(struct dtl_ring, dtl_rings);
 68 
 69 static atomic_t dtl_count;
 70 
 71 /*
 72  * The cpu accounting code controls the DTL ring buffer, and we get
 73  * given entries as they are processed.
 74  */
 75 static void consume_dtle(struct dtl_entry *dtle, u64 index)
 76 {
 77         struct dtl_ring *dtlr = &__get_cpu_var(dtl_rings);
 78         struct dtl_entry *wp = dtlr->write_ptr;
 79         struct lppaca *vpa = local_paca->lppaca_ptr;
 80 
 81         if (!wp)
 82                 return;
 83 
 84         *wp = *dtle;
 85         barrier();
 86 
 87         /* check for hypervisor ring buffer overflow, ignore this entry if so */
 88         if (index + N_DISPATCH_LOG < be64_to_cpu(vpa->dtl_idx))
 89                 return;
 90 
 91         ++wp;
 92         if (wp == dtlr->buf_end)
 93                 wp = dtlr->buf;
 94         dtlr->write_ptr = wp;
 95 
 96         /* incrementing write_index makes the new entry visible */
 97         smp_wmb();
 98         ++dtlr->write_index;
 99 }
100 
101 static int dtl_start(struct dtl *dtl)
102 {
103         struct dtl_ring *dtlr = &per_cpu(dtl_rings, dtl->cpu);
104 
105         dtlr->buf = dtl->buf;
106         dtlr->buf_end = dtl->buf + dtl->buf_entries;
107         dtlr->write_index = 0;
108 
109         /* setting write_ptr enables logging into our buffer */
110         smp_wmb();
111         dtlr->write_ptr = dtl->buf;
112 
113         /* enable event logging */
114         dtlr->saved_dtl_mask = lppaca_of(dtl->cpu).dtl_enable_mask;
115         lppaca_of(dtl->cpu).dtl_enable_mask |= dtl_event_mask;
116 
117         dtl_consumer = consume_dtle;
118         atomic_inc(&dtl_count);
119         return 0;
120 }
121 
122 static void dtl_stop(struct dtl *dtl)
123 {
124         struct dtl_ring *dtlr = &per_cpu(dtl_rings, dtl->cpu);
125 
126         dtlr->write_ptr = NULL;
127         smp_wmb();
128 
129         dtlr->buf = NULL;
130 
131         /* restore dtl_enable_mask */
132         lppaca_of(dtl->cpu).dtl_enable_mask = dtlr->saved_dtl_mask;
133 
134         if (atomic_dec_and_test(&dtl_count))
135                 dtl_consumer = NULL;
136 }
137 
138 static u64 dtl_current_index(struct dtl *dtl)
139 {
140         return per_cpu(dtl_rings, dtl->cpu).write_index;
141 }
142 
143 #else /* CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
144 
145 static int dtl_start(struct dtl *dtl)
146 {
147         unsigned long addr;
148         int ret, hwcpu;
149 
150         /* Register our dtl buffer with the hypervisor. The HV expects the
151          * buffer size to be passed in the second word of the buffer */
152         ((u32 *)dtl->buf)[1] = DISPATCH_LOG_BYTES;
153 
154         hwcpu = get_hard_smp_processor_id(dtl->cpu);
155         addr = __pa(dtl->buf);
156         ret = register_dtl(hwcpu, addr);
157         if (ret) {
158                 printk(KERN_WARNING "%s: DTL registration for cpu %d (hw %d) "
159                        "failed with %d\n", __func__, dtl->cpu, hwcpu, ret);
160                 return -EIO;
161         }
162 
163         /* set our initial buffer indices */
164         lppaca_of(dtl->cpu).dtl_idx = 0;
165 
166         /* ensure that our updates to the lppaca fields have occurred before
167          * we actually enable the logging */
168         smp_wmb();
169 
170         /* enable event logging */
171         lppaca_of(dtl->cpu).dtl_enable_mask = dtl_event_mask;
172 
173         return 0;
174 }
175 
176 static void dtl_stop(struct dtl *dtl)
177 {
178         int hwcpu = get_hard_smp_processor_id(dtl->cpu);
179 
180         lppaca_of(dtl->cpu).dtl_enable_mask = 0x0;
181 
182         unregister_dtl(hwcpu);
183 }
184 
185 static u64 dtl_current_index(struct dtl *dtl)
186 {
187         return lppaca_of(dtl->cpu).dtl_idx;
188 }
189 #endif /* CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
190 
191 static int dtl_enable(struct dtl *dtl)
192 {
193         long int n_entries;
194         long int rc;
195         struct dtl_entry *buf = NULL;
196 
197         if (!dtl_cache)
198                 return -ENOMEM;
199 
200         /* only allow one reader */
201         if (dtl->buf)
202                 return -EBUSY;
203 
204         n_entries = dtl_buf_entries;
205         buf = kmem_cache_alloc_node(dtl_cache, GFP_KERNEL, cpu_to_node(dtl->cpu));
206         if (!buf) {
207                 printk(KERN_WARNING "%s: buffer alloc failed for cpu %d\n",
208                                 __func__, dtl->cpu);
209                 return -ENOMEM;
210         }
211 
212         spin_lock(&dtl->lock);
213         rc = -EBUSY;
214         if (!dtl->buf) {
215                 /* store the original allocation size for use during read */
216                 dtl->buf_entries = n_entries;
217                 dtl->buf = buf;
218                 dtl->last_idx = 0;
219                 rc = dtl_start(dtl);
220                 if (rc)
221                         dtl->buf = NULL;
222         }
223         spin_unlock(&dtl->lock);
224 
225         if (rc)
226                 kmem_cache_free(dtl_cache, buf);
227         return rc;
228 }
229 
230 static void dtl_disable(struct dtl *dtl)
231 {
232         spin_lock(&dtl->lock);
233         dtl_stop(dtl);
234         kmem_cache_free(dtl_cache, dtl->buf);
235         dtl->buf = NULL;
236         dtl->buf_entries = 0;
237         spin_unlock(&dtl->lock);
238 }
239 
240 /* file interface */
241 
242 static int dtl_file_open(struct inode *inode, struct file *filp)
243 {
244         struct dtl *dtl = inode->i_private;
245         int rc;
246 
247         rc = dtl_enable(dtl);
248         if (rc)
249                 return rc;
250 
251         filp->private_data = dtl;
252         return 0;
253 }
254 
255 static int dtl_file_release(struct inode *inode, struct file *filp)
256 {
257         struct dtl *dtl = inode->i_private;
258         dtl_disable(dtl);
259         return 0;
260 }
261 
262 static ssize_t dtl_file_read(struct file *filp, char __user *buf, size_t len,
263                 loff_t *pos)
264 {
265         long int rc, n_read, n_req, read_size;
266         struct dtl *dtl;
267         u64 cur_idx, last_idx, i;
268 
269         if ((len % sizeof(struct dtl_entry)) != 0)
270                 return -EINVAL;
271 
272         dtl = filp->private_data;
273 
274         /* requested number of entries to read */
275         n_req = len / sizeof(struct dtl_entry);
276 
277         /* actual number of entries read */
278         n_read = 0;
279 
280         spin_lock(&dtl->lock);
281 
282         cur_idx = dtl_current_index(dtl);
283         last_idx = dtl->last_idx;
284 
285         if (last_idx + dtl->buf_entries <= cur_idx)
286                 last_idx = cur_idx - dtl->buf_entries + 1;
287 
288         if (last_idx + n_req > cur_idx)
289                 n_req = cur_idx - last_idx;
290 
291         if (n_req > 0)
292                 dtl->last_idx = last_idx + n_req;
293 
294         spin_unlock(&dtl->lock);
295 
296         if (n_req <= 0)
297                 return 0;
298 
299         i = last_idx % dtl->buf_entries;
300 
301         /* read the tail of the buffer if we've wrapped */
302         if (i + n_req > dtl->buf_entries) {
303                 read_size = dtl->buf_entries - i;
304 
305                 rc = copy_to_user(buf, &dtl->buf[i],
306                                 read_size * sizeof(struct dtl_entry));
307                 if (rc)
308                         return -EFAULT;
309 
310                 i = 0;
311                 n_req -= read_size;
312                 n_read += read_size;
313                 buf += read_size * sizeof(struct dtl_entry);
314         }
315 
316         /* .. and now the head */
317         rc = copy_to_user(buf, &dtl->buf[i], n_req * sizeof(struct dtl_entry));
318         if (rc)
319                 return -EFAULT;
320 
321         n_read += n_req;
322 
323         return n_read * sizeof(struct dtl_entry);
324 }
325 
326 static const struct file_operations dtl_fops = {
327         .open           = dtl_file_open,
328         .release        = dtl_file_release,
329         .read           = dtl_file_read,
330         .llseek         = no_llseek,
331 };
332 
333 static struct dentry *dtl_dir;
334 
335 static int dtl_setup_file(struct dtl *dtl)
336 {
337         char name[10];
338 
339         sprintf(name, "cpu-%d", dtl->cpu);
340 
341         dtl->file = debugfs_create_file(name, 0400, dtl_dir, dtl, &dtl_fops);
342         if (!dtl->file)
343                 return -ENOMEM;
344 
345         return 0;
346 }
347 
348 static int dtl_init(void)
349 {
350         struct dentry *event_mask_file, *buf_entries_file;
351         int rc, i;
352 
353         if (!firmware_has_feature(FW_FEATURE_SPLPAR))
354                 return -ENODEV;
355 
356         /* set up common debugfs structure */
357 
358         rc = -ENOMEM;
359         dtl_dir = debugfs_create_dir("dtl", powerpc_debugfs_root);
360         if (!dtl_dir) {
361                 printk(KERN_WARNING "%s: can't create dtl root dir\n",
362                                 __func__);
363                 goto err;
364         }
365 
366         event_mask_file = debugfs_create_x8("dtl_event_mask", 0600,
367                                 dtl_dir, &dtl_event_mask);
368         buf_entries_file = debugfs_create_u32("dtl_buf_entries", 0400,
369                                 dtl_dir, &dtl_buf_entries);
370 
371         if (!event_mask_file || !buf_entries_file) {
372                 printk(KERN_WARNING "%s: can't create dtl files\n", __func__);
373                 goto err_remove_dir;
374         }
375 
376         /* set up the per-cpu log structures */
377         for_each_possible_cpu(i) {
378                 struct dtl *dtl = &per_cpu(cpu_dtl, i);
379                 spin_lock_init(&dtl->lock);
380                 dtl->cpu = i;
381 
382                 rc = dtl_setup_file(dtl);
383                 if (rc)
384                         goto err_remove_dir;
385         }
386 
387         return 0;
388 
389 err_remove_dir:
390         debugfs_remove_recursive(dtl_dir);
391 err:
392         return rc;
393 }
394 arch_initcall(dtl_init);
395 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp