lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
Open Source and information security mailing list archives
| ||
|
Date: Wed, 1 Nov 2017 14:41:58 -0600 From: Mathieu Poirier <mathieu.poirier@...aro.org> To: Suzuki K Poulose <suzuki.poulose@....com> Cc: "linux-arm-kernel@...ts.infradead.org" <linux-arm-kernel@...ts.infradead.org>, "linux-kernel@...r.kernel.org" <linux-kernel@...r.kernel.org>, rob.walker@....com, Mike Leach <mike.leach@...aro.org>, coresight@...ts.linaro.org Subject: Re: [PATCH 05/17] coresight: Add support for TMC ETR SG unit On 19 October 2017 at 11:15, Suzuki K Poulose <suzuki.poulose@....com> wrote: > This patch adds support for setting up an SG table used by the > TMC ETR inbuilt SG unit. The TMC ETR uses 4K page sized tables > to hold pointers to the 4K data pages with the last entry in a > table pointing to the next table with the entries, by kind of > chaining. The 2 LSBs determine the type of the table entry, to > one of : > > Normal - Points to a 4KB data page. > Last - Points to a 4KB data page, but is the last entry in the > page table. > Link - Points to another 4KB table page with pointers to data. > > The code takes care of handling the system page size which could > be different than 4K. So we could end up putting multiple ETR > SG tables in a single system page, vice versa for the data pages. > > Cc: Mathieu Poirier <mathieu.poirier@...aro.org> > Signed-off-by: Suzuki K Poulose <suzuki.poulose@....com> > --- > drivers/hwtracing/coresight/coresight-tmc-etr.c | 256 ++++++++++++++++++++++++ > 1 file changed, 256 insertions(+) > > diff --git a/drivers/hwtracing/coresight/coresight-tmc-etr.c b/drivers/hwtracing/coresight/coresight-tmc-etr.c > index 4b9e2b276122..4424eb67a54c 100644 > --- a/drivers/hwtracing/coresight/coresight-tmc-etr.c > +++ b/drivers/hwtracing/coresight/coresight-tmc-etr.c > @@ -21,6 +21,89 @@ > #include "coresight-tmc.h" > > /* > + * The TMC ETR SG has a page size of 4K. The SG table contains pointers > + * to 4KB buffers. However, the OS may be use PAGE_SIZE different from > + * 4K (i.e, 16KB or 64KB). This implies that a single OS page could > + * contain more than one SG buffer and tables. > + * > + * A table entry has the following format: > + * > + * ---Bit31------------Bit4-------Bit1-----Bit0-- > + * | Address[39:12] | SBZ | Entry Type | > + * ---------------------------------------------- > + * > + * Address: Bits [39:12] of a physical page address. Bits [11:0] are > + * always zero. > + * > + * Entry type: > + * b00 - Reserved. > + * b01 - Last entry in the tables, points to 4K page buffer. > + * b10 - Normal entry, points to 4K page buffer. > + * b11 - Link. The address points to the base of next table. > + */ > + > +typedef u32 sgte_t; > + > +#define ETR_SG_PAGE_SHIFT 12 > +#define ETR_SG_PAGE_SIZE (1UL << ETR_SG_PAGE_SHIFT) > +#define ETR_SG_PAGES_PER_SYSPAGE (1UL << \ > + (PAGE_SHIFT - ETR_SG_PAGE_SHIFT)) > +#define ETR_SG_PTRS_PER_PAGE (ETR_SG_PAGE_SIZE / sizeof(sgte_t)) > +#define ETR_SG_PTRS_PER_SYSPAGE (PAGE_SIZE / sizeof(sgte_t)) > + > +#define ETR_SG_ET_MASK 0x3 > +#define ETR_SG_ET_LAST 0x1 > +#define ETR_SG_ET_NORMAL 0x2 > +#define ETR_SG_ET_LINK 0x3 > + > +#define ETR_SG_ADDR_SHIFT 4 > + > +#define ETR_SG_ENTRY(addr, type) \ > + (sgte_t)((((addr) >> ETR_SG_PAGE_SHIFT) << ETR_SG_ADDR_SHIFT) | \ > + (type & ETR_SG_ET_MASK)) > + > +#define ETR_SG_ADDR(entry) \ > + (((dma_addr_t)(entry) >> ETR_SG_ADDR_SHIFT) << ETR_SG_PAGE_SHIFT) > +#define ETR_SG_ET(entry) ((entry) & ETR_SG_ET_MASK) > + > +/* > + * struct etr_sg_table : ETR SG Table > + * @sg_table: Generic SG Table holding the data/table pages. > + * @hwaddr: hwaddress used by the TMC, which is the base > + * address of the table. > + */ > +struct etr_sg_table { > + struct tmc_sg_table *sg_table; > + dma_addr_t hwaddr; > +}; > + > +/* > + * tmc_etr_sg_table_entries: Total number of table entries required to map > + * @nr_pages system pages. > + * > + * We need to map @nr_pages * ETR_SG_PAGES_PER_SYSPAGE data pages. > + * Each TMC page can map (ETR_SG_PTRS_PER_PAGE - 1) buffer pointers, > + * with the last entry pointing to the page containing the table ... with the last entry pointing to another page of table entries. If we ... > + * entries. If we spill over to a new page for mapping 1 entry, > + * we could as well replace the link entry of the previous page > + * with the last entry. > + */ > +static inline unsigned long __attribute_const__ > +tmc_etr_sg_table_entries(int nr_pages) > +{ > + unsigned long nr_sgpages = nr_pages * ETR_SG_PAGES_PER_SYSPAGE; > + unsigned long nr_sglinks = nr_sgpages / (ETR_SG_PTRS_PER_PAGE - 1); > + /* > + * If we spill over to a new page for 1 entry, we could as well > + * make it the LAST entry in the previous page, skipping the Link > + * address. > + */ > + if (nr_sglinks && (nr_sgpages % (ETR_SG_PTRS_PER_PAGE - 1) < 2)) > + nr_sglinks--; > + return nr_sgpages + nr_sglinks; > +} > + > +/* > * tmc_pages_get_offset: Go through all the pages in the tmc_pages > * and map @phys_addr to an offset within the buffer. > */ > @@ -307,6 +390,179 @@ ssize_t tmc_sg_table_get_data(struct tmc_sg_table *sg_table, > return len; > } > > +#ifdef ETR_SG_DEBUG > +/* Map a dma address to virtual address */ > +static unsigned long > +tmc_sg_daddr_to_vaddr(struct tmc_sg_table *sg_table, > + dma_addr_t addr, bool table) > +{ > + long offset; > + unsigned long base; > + struct tmc_pages *tmc_pages; > + > + if (table) { > + tmc_pages = &sg_table->table_pages; > + base = (unsigned long)sg_table->table_vaddr; > + } else { > + tmc_pages = &sg_table->data_pages; > + base = (unsigned long)sg_table->data_vaddr; > + } > + > + offset = tmc_pages_get_offset(tmc_pages, addr); > + if (offset < 0) > + return 0; > + return base + offset; > +} > + > +/* Dump the given sg_table */ > +static void tmc_etr_sg_table_dump(struct etr_sg_table *etr_table) > +{ > + sgte_t *ptr; > + int i = 0; > + dma_addr_t addr; > + struct tmc_sg_table *sg_table = etr_table->sg_table; > + > + ptr = (sgte_t *)tmc_sg_daddr_to_vaddr(sg_table, > + etr_table->hwaddr, true); > + while (ptr) { > + addr = ETR_SG_ADDR(*ptr); > + switch (ETR_SG_ET(*ptr)) { > + case ETR_SG_ET_NORMAL: > + pr_debug("%05d: %p\t:[N] 0x%llx\n", i, ptr, addr); > + ptr++; > + break; > + case ETR_SG_ET_LINK: > + pr_debug("%05d: *** %p\t:{L} 0x%llx ***\n", > + i, ptr, addr); > + ptr = (sgte_t *)tmc_sg_daddr_to_vaddr(sg_table, > + addr, true); > + break; > + case ETR_SG_ET_LAST: > + pr_debug("%05d: ### %p\t:[L] 0x%llx ###\n", > + i, ptr, addr); > + return; > + } > + i++; > + } > + pr_debug("******* End of Table *****\n"); > +} > +#endif > + > +/* > + * Populate the SG Table page table entries from table/data > + * pages allocated. Each Data page has ETR_SG_PAGES_PER_SYSPAGE SG pages. > + * So does a Table page. So we keep track of indices of the tables > + * in each system page and move the pointers accordingly. > + */ > +#define INC_IDX_ROUND(idx, size) (idx = (idx + 1) % size) > +static void tmc_etr_sg_table_populate(struct etr_sg_table *etr_table) > +{ > + dma_addr_t paddr; > + int i, type, nr_entries; > + int tpidx = 0; /* index to the current system table_page */ > + int sgtidx = 0; /* index to the sg_table within the current syspage */ > + int sgtoffset = 0; /* offset to the next entry within the sg_table */ > + int dpidx = 0; /* index to the current system data_page */ > + int spidx = 0; /* index to the SG page within the current data page */ > + sgte_t *ptr; /* pointer to the table entry to fill */ > + struct tmc_sg_table *sg_table = etr_table->sg_table; > + dma_addr_t *table_daddrs = sg_table->table_pages.daddrs; > + dma_addr_t *data_daddrs = sg_table->data_pages.daddrs; > + > + nr_entries = tmc_etr_sg_table_entries(sg_table->data_pages.nr_pages); > + /* > + * Use the contiguous virtual address of the table to update entries. > + */ > + ptr = sg_table->table_vaddr; > + /* > + * Fill all the entries, except the last entry to avoid special > + * checks within the loop. > + */ > + for (i = 0; i < nr_entries - 1; i++) { > + if (sgtoffset == ETR_SG_PTRS_PER_PAGE - 1) { > + /* > + * Last entry in a sg_table page is a link address to > + * the next table page. If this sg_table is the last > + * one in the system page, it links to the first > + * sg_table in the next system page. Otherwise, it > + * links to the next sg_table page within the system > + * page. > + */ > + if (sgtidx == ETR_SG_PAGES_PER_SYSPAGE - 1) { > + paddr = table_daddrs[tpidx + 1]; > + } else { > + paddr = table_daddrs[tpidx] + > + (ETR_SG_PAGE_SIZE * (sgtidx + 1)); > + } > + type = ETR_SG_ET_LINK; > + } else { > + /* > + * Update the idices to the data_pages to point to the > + * next sg_page in the data buffer. > + */ > + type = ETR_SG_ET_NORMAL; > + paddr = data_daddrs[dpidx] + spidx * ETR_SG_PAGE_SIZE; > + if (!INC_IDX_ROUND(spidx, ETR_SG_PAGES_PER_SYSPAGE)) > + dpidx++; > + } > + *ptr++ = ETR_SG_ENTRY(paddr, type); > + /* > + * Move to the next table pointer, moving the table page index > + * if necessary > + */ > + if (!INC_IDX_ROUND(sgtoffset, ETR_SG_PTRS_PER_PAGE)) { > + if (!INC_IDX_ROUND(sgtidx, ETR_SG_PAGES_PER_SYSPAGE)) > + tpidx++; > + } > + } > + > + /* Set up the last entry, which is always a data pointer */ > + paddr = data_daddrs[dpidx] + spidx * ETR_SG_PAGE_SIZE; > + *ptr++ = ETR_SG_ENTRY(paddr, ETR_SG_ET_LAST); > +} > + > +/* > + * tmc_init_etr_sg_table: Allocate a TMC ETR SG table, data buffer of @size and > + * populate the table. > + * > + * @dev - Device pointer for the TMC > + * @node - NUMA node where the memory should be allocated > + * @size - Total size of the data buffer > + * @pages - Optional list of page virtual address > + */ > +static struct etr_sg_table __maybe_unused * > +tmc_init_etr_sg_table(struct device *dev, int node, > + unsigned long size, void **pages) > +{ > + int nr_entries, nr_tpages; > + int nr_dpages = size >> PAGE_SHIFT; > + struct tmc_sg_table *sg_table; > + struct etr_sg_table *etr_table; > + > + etr_table = kzalloc(sizeof(*etr_table), GFP_KERNEL); > + if (!etr_table) > + return ERR_PTR(-ENOMEM); > + nr_entries = tmc_etr_sg_table_entries(nr_dpages); > + nr_tpages = DIV_ROUND_UP(nr_entries, ETR_SG_PTRS_PER_SYSPAGE); > + > + sg_table = tmc_alloc_sg_table(dev, node, nr_tpages, nr_dpages, pages); > + if (IS_ERR(sg_table)) { > + kfree(etr_table); > + return ERR_PTR(PTR_ERR(sg_table)); > + } > + > + etr_table->sg_table = sg_table; > + /* TMC should use table base address for DBA */ > + etr_table->hwaddr = sg_table->table_daddr; > + tmc_etr_sg_table_populate(etr_table); > + /* Sync the table pages for the HW */ > + tmc_sg_table_sync_table(sg_table); > +#ifdef ETR_SG_DEBUG > + tmc_etr_sg_table_dump(etr_table); > +#endif > + return etr_table; > +} > + > static void tmc_etr_enable_hw(struct tmc_drvdata *drvdata) > { > u32 axictl, sts; > -- > 2.13.6 >
Powered by blists - more mailing lists