static int ramoops_remove(struct platform_device *pdev) { struct ramoops_context *cxt = &oops_cxt; pstore_unregister(&cxt->pstore); kfree(cxt->pstore.buf); cxt->pstore.bufsize = 0; persistent_ram_free(cxt->mprz); persistent_ram_free(cxt->cprz); ramoops_free_przs(cxt); return 0; }
static void ramoops_free_przs(struct ramoops_context *cxt) { int i; if (!cxt->przs) return; for (i = 0; !IS_ERR_OR_NULL(cxt->przs[i]); i++) persistent_ram_free(cxt->przs[i]); kfree(cxt->przs); }
static void ramoops_free_przs(struct ramoops_context *cxt) { int i; /* Free dump PRZs */ if (cxt->dprzs) { for (i = 0; i < cxt->max_dump_cnt; i++) persistent_ram_free(cxt->dprzs[i]); kfree(cxt->dprzs); cxt->max_dump_cnt = 0; } /* Free ftrace PRZs */ if (cxt->fprzs) { for (i = 0; i < cxt->max_ftrace_cnt; i++) persistent_ram_free(cxt->fprzs[i]); kfree(cxt->fprzs); cxt->max_ftrace_cnt = 0; } }
static void ramoops_free_przs(struct ramoops_context *cxt) { int i; if (!cxt->przs) return; for (i = 0; i < cxt->max_dump_cnt; i++) persistent_ram_free(cxt->przs[i]); kfree(cxt->przs); cxt->max_dump_cnt = 0; }
static int ramoops_init_przs(struct device *dev, struct ramoops_context *cxt, phys_addr_t *paddr, size_t dump_mem_sz) { int err = -ENOMEM; int i; if (!cxt->record_size) return 0; if (*paddr + dump_mem_sz - cxt->phys_addr > cxt->size) { dev_err(dev, "no room for dumps\n"); return -ENOMEM; } cxt->max_dump_cnt = dump_mem_sz / cxt->record_size; if (!cxt->max_dump_cnt) return -ENOMEM; cxt->przs = kzalloc(sizeof(*cxt->przs) * cxt->max_dump_cnt, GFP_KERNEL); if (!cxt->przs) { dev_err(dev, "failed to initialize a prz array for dumps\n"); goto fail_mem; } for (i = 0; i < cxt->max_dump_cnt; i++) { cxt->przs[i] = persistent_ram_new(*paddr, cxt->record_size, 0, &cxt->ecc_info, cxt->memtype); if (IS_ERR(cxt->przs[i])) { err = PTR_ERR(cxt->przs[i]); dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n", cxt->record_size, (unsigned long long)*paddr, err); while (i > 0) { i--; persistent_ram_free(cxt->przs[i]); } goto fail_prz; } *paddr += cxt->record_size; } return 0; fail_prz: kfree(cxt->przs); fail_mem: cxt->max_dump_cnt = 0; return err; }
static int ramoops_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct ramoops_platform_data *pdata = dev->platform_data; struct ramoops_context *cxt = &oops_cxt; size_t dump_mem_sz; phys_addr_t paddr; int err = -EINVAL; if (dev_of_node(dev) && !pdata) { pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) { err = -ENOMEM; goto fail_out; } err = ramoops_parse_dt(pdev, pdata); if (err < 0) goto fail_out; } /* Only a single ramoops area allowed at a time, so fail extra * probes. */ if (cxt->max_dump_cnt) goto fail_out; if (!pdata->mem_size || (!pdata->record_size && !pdata->console_size && !pdata->ftrace_size && !pdata->pmsg_size)) { pr_err("The memory size and the record/console size must be " "non-zero\n"); goto fail_out; } if (pdata->record_size && !is_power_of_2(pdata->record_size)) pdata->record_size = rounddown_pow_of_two(pdata->record_size); if (pdata->console_size && !is_power_of_2(pdata->console_size)) pdata->console_size = rounddown_pow_of_two(pdata->console_size); if (pdata->ftrace_size && !is_power_of_2(pdata->ftrace_size)) pdata->ftrace_size = rounddown_pow_of_two(pdata->ftrace_size); if (pdata->pmsg_size && !is_power_of_2(pdata->pmsg_size)) pdata->pmsg_size = rounddown_pow_of_two(pdata->pmsg_size); cxt->size = pdata->mem_size; cxt->phys_addr = pdata->mem_address; cxt->memtype = pdata->mem_type; cxt->record_size = pdata->record_size; cxt->console_size = pdata->console_size; cxt->ftrace_size = pdata->ftrace_size; cxt->pmsg_size = pdata->pmsg_size; cxt->dump_oops = pdata->dump_oops; cxt->ecc_info = pdata->ecc_info; paddr = cxt->phys_addr; dump_mem_sz = cxt->size - cxt->console_size - cxt->ftrace_size - cxt->pmsg_size; err = ramoops_init_przs(dev, cxt, &paddr, dump_mem_sz); if (err) goto fail_out; err = ramoops_init_prz(dev, cxt, &cxt->cprz, &paddr, cxt->console_size, 0); if (err) goto fail_init_cprz; err = ramoops_init_prz(dev, cxt, &cxt->fprz, &paddr, cxt->ftrace_size, LINUX_VERSION_CODE); if (err) goto fail_init_fprz; err = ramoops_init_prz(dev, cxt, &cxt->mprz, &paddr, cxt->pmsg_size, 0); if (err) goto fail_init_mprz; cxt->pstore.data = cxt; /* * Console can handle any buffer size, so prefer LOG_LINE_MAX. If we * have to handle dumps, we must have at least record_size buffer. And * for ftrace, bufsize is irrelevant (if bufsize is 0, buf will be * ZERO_SIZE_PTR). */ if (cxt->console_size) cxt->pstore.bufsize = 1024; /* LOG_LINE_MAX */ cxt->pstore.bufsize = max(cxt->record_size, cxt->pstore.bufsize); cxt->pstore.buf = kmalloc(cxt->pstore.bufsize, GFP_KERNEL); if (!cxt->pstore.buf) { pr_err("cannot allocate pstore buffer\n"); err = -ENOMEM; goto fail_clear; } spin_lock_init(&cxt->pstore.buf_lock); cxt->pstore.flags = PSTORE_FLAGS_DMESG; if (cxt->console_size) cxt->pstore.flags |= PSTORE_FLAGS_CONSOLE; if (cxt->ftrace_size) cxt->pstore.flags |= PSTORE_FLAGS_FTRACE; if (cxt->pmsg_size) cxt->pstore.flags |= PSTORE_FLAGS_PMSG; err = pstore_register(&cxt->pstore); if (err) { pr_err("registering with pstore failed\n"); goto fail_buf; } /* * Update the module parameter variables as well so they are visible * through /sys/module/ramoops/parameters/ */ mem_size = pdata->mem_size; mem_address = pdata->mem_address; record_size = pdata->record_size; dump_oops = pdata->dump_oops; ramoops_console_size = pdata->console_size; ramoops_pmsg_size = pdata->pmsg_size; ramoops_ftrace_size = pdata->ftrace_size; pr_info("attached 0x%lx@0x%llx, ecc: %d/%d\n", cxt->size, (unsigned long long)cxt->phys_addr, cxt->ecc_info.ecc_size, cxt->ecc_info.block_size); return 0; fail_buf: kfree(cxt->pstore.buf); fail_clear: cxt->pstore.bufsize = 0; persistent_ram_free(cxt->mprz); fail_init_mprz: persistent_ram_free(cxt->fprz); fail_init_fprz: persistent_ram_free(cxt->cprz); fail_init_cprz: ramoops_free_przs(cxt); fail_out: return err; }
static int ramoops_init_przs(const char *name, struct device *dev, struct ramoops_context *cxt, struct persistent_ram_zone ***przs, phys_addr_t *paddr, size_t mem_sz, ssize_t record_size, unsigned int *cnt, u32 sig, u32 flags) { int err = -ENOMEM; int i; size_t zone_sz; struct persistent_ram_zone **prz_ar; /* Allocate nothing for 0 mem_sz or 0 record_size. */ if (mem_sz == 0 || record_size == 0) { *cnt = 0; return 0; } /* * If we have a negative record size, calculate it based on * mem_sz / *cnt. If we have a positive record size, calculate * cnt from mem_sz / record_size. */ if (record_size < 0) { if (*cnt == 0) return 0; record_size = mem_sz / *cnt; if (record_size == 0) { dev_err(dev, "%s record size == 0 (%zu / %u)\n", name, mem_sz, *cnt); goto fail; } } else { *cnt = mem_sz / record_size; if (*cnt == 0) { dev_err(dev, "%s record count == 0 (%zu / %zu)\n", name, mem_sz, record_size); goto fail; } } if (*paddr + mem_sz - cxt->phys_addr > cxt->size) { dev_err(dev, "no room for %s mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n", name, mem_sz, (unsigned long long)*paddr, cxt->size, (unsigned long long)cxt->phys_addr); goto fail; } zone_sz = mem_sz / *cnt; if (!zone_sz) { dev_err(dev, "%s zone size == 0\n", name); goto fail; } prz_ar = kcalloc(*cnt, sizeof(**przs), GFP_KERNEL); if (!prz_ar) goto fail; for (i = 0; i < *cnt; i++) { prz_ar[i] = persistent_ram_new(*paddr, zone_sz, sig, &cxt->ecc_info, cxt->memtype, flags); if (IS_ERR(prz_ar[i])) { err = PTR_ERR(prz_ar[i]); dev_err(dev, "failed to request %s mem region (0x%zx@0x%llx): %d\n", name, record_size, (unsigned long long)*paddr, err); while (i > 0) { i--; persistent_ram_free(prz_ar[i]); } kfree(prz_ar); goto fail; } *paddr += zone_sz; } *przs = prz_ar; return 0; fail: *cnt = 0; return err; }