fs/dlm/memory.c

   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
  18 static struct kmem_cache *writequeue_cache;
  19 static struct kmem_cache *mhandle_cache;
  20 static struct kmem_cache *msg_cache;
  21 static struct kmem_cache *lkb_cache;
  22 static struct kmem_cache *rsb_cache;
  23
  24
  25 int __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
  51 rsb:
  52         kmem_cache_destroy(msg_cache);
  53 msg:
  54         kmem_cache_destroy(lkb_cache);
  55 lkb:
  56         kmem_cache_destroy(mhandle_cache);
  57 mhandle:
  58         kmem_cache_destroy(writequeue_cache);
  59 out:
  60         return -ENOMEM;
  61 }
  62
  63 void 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
  72 char *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
  80 void dlm_free_lvb(char *p)
  81 {
  82         kfree(p);
  83 }
  84
  85 struct 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
  93 void 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
 100 struct 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
 108 void 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
 121 struct dlm_mhandle *dlm_allocate_mhandle(void)
 122 {
 123         return kmem_cache_alloc(mhandle_cache, GFP_NOFS);
 124 }
 125
 126 void dlm_free_mhandle(struct dlm_mhandle *mhandle)
 127 {
 128         kmem_cache_free(mhandle_cache, mhandle);
 129 }
 130
 131 struct writequeue_entry *dlm_allocate_writequeue(void)
 132 {
 133         return kmem_cache_alloc(writequeue_cache, GFP_ATOMIC);
 134 }
 135
 136 void dlm_free_writequeue(struct writequeue_entry *writequeue)
 137 {
 138         kmem_cache_free(writequeue_cache, writequeue);
 139 }
 140
 141 struct dlm_msg *dlm_allocate_msg(gfp_t allocation)
 142 {
 143         return kmem_cache_alloc(msg_cache, allocation);
 144 }
 145
 146 void dlm_free_msg(struct dlm_msg *msg)
 147 {
 148         kmem_cache_free(msg_cache, msg);
 149 }