static int zcache_comp_cpu_up(int cpu) { struct crypto_comp *tfm; tfm = crypto_alloc_comp(zcache_comp_name, 0, 0); if (IS_ERR(tfm)) return NOTIFY_BAD; *per_cpu_ptr(zcache_comp_pcpu_tfms, cpu) = tfm; return NOTIFY_OK; }
static int __init compr_init(struct ubifs_compressor *compr) { if (compr->capi_name) { compr->cc = crypto_alloc_comp(compr->capi_name, 0, 0); if (IS_ERR(compr->cc)) { ubifs_err("cannot initialize compressor %s, error %ld", compr->name, PTR_ERR(compr->cc)); return PTR_ERR(compr->cc); } } ubifs_compressors[compr->compr_type] = compr; return 0; }
static void allocate_buf_for_compression(void) { struct crypto_comp *ctx; int size; char *buf; /* Skip if not built-in or compression backend not selected yet. */ if (!IS_ENABLED(CONFIG_PSTORE_COMPRESS) || !zbackend) return; /* Skip if no pstore backend yet or compression init already done. */ if (!psinfo || tfm) return; if (!crypto_has_comp(zbackend->name, 0, 0)) { pr_err("Unknown compression: %s\n", zbackend->name); return; } size = zbackend->zbufsize(psinfo->bufsize); if (size <= 0) { pr_err("Invalid compression size for %s: %d\n", zbackend->name, size); return; } buf = kmalloc(size, GFP_KERNEL); if (!buf) { pr_err("Failed %d byte compression buffer allocation for: %s\n", size, zbackend->name); return; } ctx = crypto_alloc_comp(zbackend->name, 0, 0); if (IS_ERR_OR_NULL(ctx)) { kfree(buf); pr_err("crypto_alloc_comp('%s') failed: %ld\n", zbackend->name, PTR_ERR(ctx)); return; } /* A non-NULL big_oops_buf indicates compression is available. */ tfm = ctx; big_oops_buf_sz = size; big_oops_buf = buf; pr_info("Using crash dump compression: %s\n", zbackend->name); }
/** * compr_init - initialize a compressor. * @compr: compressor description object * * This function initializes the requested compressor and returns zero in case * of success or a negative error code in case of failure. */ static int compr_init(struct scfs_compressor *compr) { if (compr->capi_name) { compr->cc = crypto_alloc_comp(compr->capi_name, 0, 0); if (IS_ERR(compr->cc)) { SCFS_PRINT_ERROR("cannot initialize compressor %s, error %ld", compr->name, PTR_ERR(compr->cc)); return PTR_ERR(compr->cc); } } scfs_compressors[compr->compr_type] = compr; SCFS_PRINT("compr name %s(%d) got cc(%x)\n", compr->capi_name, compr->compr_type, compr->cc); return 0; }
/* * allocate new zcomp_strm structure with ->tfm initialized by * backend, return NULL on error */ static struct zcomp_strm *zcomp_strm_alloc(struct zcomp *comp) { struct zcomp_strm *zstrm = kmalloc(sizeof(*zstrm), GFP_KERNEL); if (!zstrm) return NULL; zstrm->tfm = crypto_alloc_comp(comp->name, 0, 0); /* * allocate 2 pages. 1 for compressed data, plus 1 extra for the * case when compressed size is larger than the original one */ zstrm->buffer = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, 1); if (IS_ERR_OR_NULL(zstrm->tfm) || !zstrm->buffer) { zcomp_strm_free(zstrm); zstrm = NULL; } return zstrm; }
/** * compr_init - initialize a compressor. * @compr: compressor description object * * This function initializes the requested compressor and returns zero in case * of success or a negative error code in case of failure. */ static int __init compr_init(struct ubifs_compressor *compr) { ubifs_compressors[compr->compr_type] = compr; #ifdef CONFIG_NEEDS_MANUAL_RELOC ubifs_compressors[compr->compr_type]->name += gd->reloc_off; ubifs_compressors[compr->compr_type]->capi_name += gd->reloc_off; ubifs_compressors[compr->compr_type]->decompress += gd->reloc_off; #endif if (compr->capi_name) { compr->cc = crypto_alloc_comp(compr->capi_name, 0, 0); if (IS_ERR(compr->cc)) { ubifs_err("cannot initialize compressor %s, error %ld", compr->name, PTR_ERR(compr->cc)); return PTR_ERR(compr->cc); } } return 0; }
static int __zswap_cpu_notifier(unsigned long action, unsigned long cpu) { struct crypto_comp *tfm; u8 *dst; switch (action) { case CPU_UP_PREPARE: tfm = crypto_alloc_comp(zswap_compressor, 0, 0); if (IS_ERR(tfm)) { pr_err("can't allocate compressor transform\n"); return NOTIFY_BAD; } *per_cpu_ptr(zswap_comp_pcpu_tfms, cpu) = tfm; dst = kmalloc_node(PAGE_SIZE * 2, GFP_KERNEL, cpu_to_node(cpu)); if (!dst) { pr_err("can't allocate compressor buffer\n"); crypto_free_comp(tfm); *per_cpu_ptr(zswap_comp_pcpu_tfms, cpu) = NULL; return NOTIFY_BAD; } per_cpu(zswap_dstmem, cpu) = dst; break; case CPU_DEAD: case CPU_UP_CANCELED: tfm = *per_cpu_ptr(zswap_comp_pcpu_tfms, cpu); if (tfm) { crypto_free_comp(tfm); *per_cpu_ptr(zswap_comp_pcpu_tfms, cpu) = NULL; } dst = per_cpu(zswap_dstmem, cpu); kfree(dst); per_cpu(zswap_dstmem, cpu) = NULL; break; default: break; } return NOTIFY_OK; }