fs/dlm/util.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /******************************************************************************
   3 *******************************************************************************
   4 **
   5 **  Copyright (C) 2005-2008 Red Hat, Inc.  All rights reserved.
   6 **
   7 **
   8 *******************************************************************************
   9 ******************************************************************************/
  10
  11 #include "dlm_internal.h"
  12 #include "rcom.h"
  13 #include "util.h"
  14
  15 #define DLM_ERRNO_EDEADLK               35
  16 #define DLM_ERRNO_EBADR                 53
  17 #define DLM_ERRNO_EBADSLT               57
  18 #define DLM_ERRNO_EPROTO                71
  19 #define DLM_ERRNO_EOPNOTSUPP            95
  20 #define DLM_ERRNO_ETIMEDOUT            110
  21 #define DLM_ERRNO_EINPROGRESS          115
  22
  23 static void header_out(struct dlm_header *hd)
  24 {
  25         hd->h_version           = cpu_to_le32(hd->h_version);
  26         hd->h_lockspace         = cpu_to_le32(hd->h_lockspace);
  27         hd->h_nodeid            = cpu_to_le32(hd->h_nodeid);
  28         hd->h_length            = cpu_to_le16(hd->h_length);
  29 }
  30
  31 static void header_in(struct dlm_header *hd)
  32 {
  33         hd->h_version           = le32_to_cpu(hd->h_version);
  34         hd->h_lockspace         = le32_to_cpu(hd->h_lockspace);
  35         hd->h_nodeid            = le32_to_cpu(hd->h_nodeid);
  36         hd->h_length            = le16_to_cpu(hd->h_length);
  37 }
  38
  39 /* higher errno values are inconsistent across architectures, so select
  40    one set of values for on the wire */
  41
  42 static int to_dlm_errno(int err)
  43 {
  44         switch (err) {
  45         case -EDEADLK:
  46                 return -DLM_ERRNO_EDEADLK;
  47         case -EBADR:
  48                 return -DLM_ERRNO_EBADR;
  49         case -EBADSLT:
  50                 return -DLM_ERRNO_EBADSLT;
  51         case -EPROTO:
  52                 return -DLM_ERRNO_EPROTO;
  53         case -EOPNOTSUPP:
  54                 return -DLM_ERRNO_EOPNOTSUPP;
  55         case -ETIMEDOUT:
  56                 return -DLM_ERRNO_ETIMEDOUT;
  57         case -EINPROGRESS:
  58                 return -DLM_ERRNO_EINPROGRESS;
  59         }
  60         return err;
  61 }
  62
  63 static int from_dlm_errno(int err)
  64 {
  65         switch (err) {
  66         case -DLM_ERRNO_EDEADLK:
  67                 return -EDEADLK;
  68         case -DLM_ERRNO_EBADR:
  69                 return -EBADR;
  70         case -DLM_ERRNO_EBADSLT:
  71                 return -EBADSLT;
  72         case -DLM_ERRNO_EPROTO:
  73                 return -EPROTO;
  74         case -DLM_ERRNO_EOPNOTSUPP:
  75                 return -EOPNOTSUPP;
  76         case -DLM_ERRNO_ETIMEDOUT:
  77                 return -ETIMEDOUT;
  78         case -DLM_ERRNO_EINPROGRESS:
  79                 return -EINPROGRESS;
  80         }
  81         return err;
  82 }
  83
  84 void dlm_message_out(struct dlm_message *ms)
  85 {
  86         header_out(&ms->m_header);
  87
  88         ms->m_type              = cpu_to_le32(ms->m_type);
  89         ms->m_nodeid            = cpu_to_le32(ms->m_nodeid);
  90         ms->m_pid               = cpu_to_le32(ms->m_pid);
  91         ms->m_lkid              = cpu_to_le32(ms->m_lkid);
  92         ms->m_remid             = cpu_to_le32(ms->m_remid);
  93         ms->m_parent_lkid       = cpu_to_le32(ms->m_parent_lkid);
  94         ms->m_parent_remid      = cpu_to_le32(ms->m_parent_remid);
  95         ms->m_exflags           = cpu_to_le32(ms->m_exflags);
  96         ms->m_sbflags           = cpu_to_le32(ms->m_sbflags);
  97         ms->m_flags             = cpu_to_le32(ms->m_flags);
  98         ms->m_lvbseq            = cpu_to_le32(ms->m_lvbseq);
  99         ms->m_hash              = cpu_to_le32(ms->m_hash);
 100         ms->m_status            = cpu_to_le32(ms->m_status);
 101         ms->m_grmode            = cpu_to_le32(ms->m_grmode);
 102         ms->m_rqmode            = cpu_to_le32(ms->m_rqmode);
 103         ms->m_bastmode          = cpu_to_le32(ms->m_bastmode);
 104         ms->m_asts              = cpu_to_le32(ms->m_asts);
 105         ms->m_result            = cpu_to_le32(to_dlm_errno(ms->m_result));
 106 }
 107
 108 void dlm_message_in(struct dlm_message *ms)
 109 {
 110         header_in(&ms->m_header);
 111
 112         ms->m_type              = le32_to_cpu(ms->m_type);
 113         ms->m_nodeid            = le32_to_cpu(ms->m_nodeid);
 114         ms->m_pid               = le32_to_cpu(ms->m_pid);
 115         ms->m_lkid              = le32_to_cpu(ms->m_lkid);
 116         ms->m_remid             = le32_to_cpu(ms->m_remid);
 117         ms->m_parent_lkid       = le32_to_cpu(ms->m_parent_lkid);
 118         ms->m_parent_remid      = le32_to_cpu(ms->m_parent_remid);
 119         ms->m_exflags           = le32_to_cpu(ms->m_exflags);
 120         ms->m_sbflags           = le32_to_cpu(ms->m_sbflags);
 121         ms->m_flags             = le32_to_cpu(ms->m_flags);
 122         ms->m_lvbseq            = le32_to_cpu(ms->m_lvbseq);
 123         ms->m_hash              = le32_to_cpu(ms->m_hash);
 124         ms->m_status            = le32_to_cpu(ms->m_status);
 125         ms->m_grmode            = le32_to_cpu(ms->m_grmode);
 126         ms->m_rqmode            = le32_to_cpu(ms->m_rqmode);
 127         ms->m_bastmode          = le32_to_cpu(ms->m_bastmode);
 128         ms->m_asts              = le32_to_cpu(ms->m_asts);
 129         ms->m_result            = from_dlm_errno(le32_to_cpu(ms->m_result));
 130 }
 131
 132 void dlm_rcom_out(struct dlm_rcom *rc)
 133 {
 134         header_out(&rc->rc_header);
 135
 136         rc->rc_type             = cpu_to_le32(rc->rc_type);
 137         rc->rc_result           = cpu_to_le32(rc->rc_result);
 138         rc->rc_id               = cpu_to_le64(rc->rc_id);
 139         rc->rc_seq              = cpu_to_le64(rc->rc_seq);
 140         rc->rc_seq_reply        = cpu_to_le64(rc->rc_seq_reply);
 141 }
 142
 143 void dlm_rcom_in(struct dlm_rcom *rc)
 144 {
 145         header_in(&rc->rc_header);
 146
 147         rc->rc_type             = le32_to_cpu(rc->rc_type);
 148         rc->rc_result           = le32_to_cpu(rc->rc_result);
 149         rc->rc_id               = le64_to_cpu(rc->rc_id);
 150         rc->rc_seq              = le64_to_cpu(rc->rc_seq);
 151         rc->rc_seq_reply        = le64_to_cpu(rc->rc_seq_reply);
 152 }