cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

memory.c (3182B)

      1// SPDX-License-Identifier: GPL-2.0-only
      2/******************************************************************************
      3*******************************************************************************
      4**
      5**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
      6**  Copyright (C) 2004-2007 Red Hat, Inc.  All rights reserved.
      7**
      8**
      9*******************************************************************************
     10******************************************************************************/
     11
     12#include "dlm_internal.h"
     13#include "midcomms.h"
     14#include "lowcomms.h"
     15#include "config.h"
     16#include "memory.h"
     17
     18static struct kmem_cache *writequeue_cache;
     19static struct kmem_cache *mhandle_cache;
     20static struct kmem_cache *msg_cache;
     21static struct kmem_cache *lkb_cache;
     22static struct kmem_cache *rsb_cache;
     23
     24
     25int __init dlm_memory_init(void)
     26{
     27	writequeue_cache = dlm_lowcomms_writequeue_cache_create();
     28	if (!writequeue_cache)
     29		goto out;
     30
     31	mhandle_cache = dlm_midcomms_cache_create();
     32	if (!mhandle_cache)
     33		goto mhandle;
     34
     35	lkb_cache = kmem_cache_create("dlm_lkb", sizeof(struct dlm_lkb),
     36				__alignof__(struct dlm_lkb), 0, NULL);
     37	if (!lkb_cache)
     38		goto lkb;
     39
     40	msg_cache = dlm_lowcomms_msg_cache_create();
     41	if (!msg_cache)
     42		goto msg;
     43
     44	rsb_cache = kmem_cache_create("dlm_rsb", sizeof(struct dlm_rsb),
     45				__alignof__(struct dlm_rsb), 0, NULL);
     46	if (!rsb_cache)
     47		goto rsb;
     48
     49	return 0;
     50
     51rsb:
     52	kmem_cache_destroy(msg_cache);
     53msg:
     54	kmem_cache_destroy(lkb_cache);
     55lkb:
     56	kmem_cache_destroy(mhandle_cache);
     57mhandle:
     58	kmem_cache_destroy(writequeue_cache);
     59out:
     60	return -ENOMEM;
     61}
     62
     63void dlm_memory_exit(void)
     64{
     65	kmem_cache_destroy(writequeue_cache);
     66	kmem_cache_destroy(mhandle_cache);
     67	kmem_cache_destroy(msg_cache);
     68	kmem_cache_destroy(lkb_cache);
     69	kmem_cache_destroy(rsb_cache);
     70}
     71
     72char *dlm_allocate_lvb(struct dlm_ls *ls)
     73{
     74	char *p;
     75
     76	p = kzalloc(ls->ls_lvblen, GFP_NOFS);
     77	return p;
     78}
     79
     80void dlm_free_lvb(char *p)
     81{
     82	kfree(p);
     83}
     84
     85struct dlm_rsb *dlm_allocate_rsb(struct dlm_ls *ls)
     86{
     87	struct dlm_rsb *r;
     88
     89	r = kmem_cache_zalloc(rsb_cache, GFP_NOFS);
     90	return r;
     91}
     92
     93void dlm_free_rsb(struct dlm_rsb *r)
     94{
     95	if (r->res_lvbptr)
     96		dlm_free_lvb(r->res_lvbptr);
     97	kmem_cache_free(rsb_cache, r);
     98}
     99
    100struct dlm_lkb *dlm_allocate_lkb(struct dlm_ls *ls)
    101{
    102	struct dlm_lkb *lkb;
    103
    104	lkb = kmem_cache_zalloc(lkb_cache, GFP_NOFS);
    105	return lkb;
    106}
    107
    108void dlm_free_lkb(struct dlm_lkb *lkb)
    109{
    110	if (lkb->lkb_flags & DLM_IFL_USER) {
    111		struct dlm_user_args *ua;
    112		ua = lkb->lkb_ua;
    113		if (ua) {
    114			kfree(ua->lksb.sb_lvbptr);
    115			kfree(ua);
    116		}
    117	}
    118	kmem_cache_free(lkb_cache, lkb);
    119}
    120
    121struct dlm_mhandle *dlm_allocate_mhandle(void)
    122{
    123	return kmem_cache_alloc(mhandle_cache, GFP_NOFS);
    124}
    125
    126void dlm_free_mhandle(struct dlm_mhandle *mhandle)
    127{
    128	kmem_cache_free(mhandle_cache, mhandle);
    129}
    130
    131struct writequeue_entry *dlm_allocate_writequeue(void)
    132{
    133	return kmem_cache_alloc(writequeue_cache, GFP_ATOMIC);
    134}
    135
    136void dlm_free_writequeue(struct writequeue_entry *writequeue)
    137{
    138	kmem_cache_free(writequeue_cache, writequeue);
    139}
    140
    141struct dlm_msg *dlm_allocate_msg(gfp_t allocation)
    142{
    143	return kmem_cache_alloc(msg_cache, allocation);
    144}
    145
    146void dlm_free_msg(struct dlm_msg *msg)
    147{
    148	kmem_cache_free(msg_cache, msg);
    149}