Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
awilliam
GitHub Repository: awilliam/linux-vfio
 Path: blob/master/fs/dlm/util.c
15109 views
1
/******************************************************************************

2
*******************************************************************************

3
**

4
**  Copyright (C) 2005-2008 Red Hat, Inc.  All rights reserved.

5
**

6
**  This copyrighted material is made available to anyone wishing to use,

7
**  modify, copy, or redistribute it subject to the terms and conditions

8
**  of the GNU General Public License v.2.

9
**

10
*******************************************************************************

11
******************************************************************************/

12


13
#include "dlm_internal.h"

14
#include "rcom.h"

15
#include "util.h"

16


17
#define DLM_ERRNO_EDEADLK		35

18
#define DLM_ERRNO_EBADR			53

19
#define DLM_ERRNO_EBADSLT		57

20
#define DLM_ERRNO_EPROTO		71

21
#define DLM_ERRNO_EOPNOTSUPP		95

22
#define DLM_ERRNO_ETIMEDOUT	       110

23
#define DLM_ERRNO_EINPROGRESS	       115

24


25
static void header_out(struct dlm_header *hd)

26
{

27
	hd->h_version		= cpu_to_le32(hd->h_version);

28
	hd->h_lockspace		= cpu_to_le32(hd->h_lockspace);

29
	hd->h_nodeid		= cpu_to_le32(hd->h_nodeid);

30
	hd->h_length		= cpu_to_le16(hd->h_length);

31
}

32


33
static void header_in(struct dlm_header *hd)

34
{

35
	hd->h_version		= le32_to_cpu(hd->h_version);

36
	hd->h_lockspace		= le32_to_cpu(hd->h_lockspace);

37
	hd->h_nodeid		= le32_to_cpu(hd->h_nodeid);

38
	hd->h_length		= le16_to_cpu(hd->h_length);

39
}

40


41
/* higher errno values are inconsistent across architectures, so select

42
   one set of values for on the wire */

43


44
static int to_dlm_errno(int err)

45
{

46
	switch (err) {

47
	case -EDEADLK:

48
		return -DLM_ERRNO_EDEADLK;

49
	case -EBADR:

50
		return -DLM_ERRNO_EBADR;

51
	case -EBADSLT:

52
		return -DLM_ERRNO_EBADSLT;

53
	case -EPROTO:

54
		return -DLM_ERRNO_EPROTO;

55
	case -EOPNOTSUPP:

56
		return -DLM_ERRNO_EOPNOTSUPP;

57
	case -ETIMEDOUT:

58
		return -DLM_ERRNO_ETIMEDOUT;

59
	case -EINPROGRESS:

60
		return -DLM_ERRNO_EINPROGRESS;

61
	}

62
	return err;

63
}

64


65
static int from_dlm_errno(int err)

66
{

67
	switch (err) {

68
	case -DLM_ERRNO_EDEADLK:

69
		return -EDEADLK;

70
	case -DLM_ERRNO_EBADR:

71
		return -EBADR;

72
	case -DLM_ERRNO_EBADSLT:

73
		return -EBADSLT;

74
	case -DLM_ERRNO_EPROTO:

75
		return -EPROTO;

76
	case -DLM_ERRNO_EOPNOTSUPP:

77
		return -EOPNOTSUPP;

78
	case -DLM_ERRNO_ETIMEDOUT:

79
		return -ETIMEDOUT;

80
	case -DLM_ERRNO_EINPROGRESS:

81
		return -EINPROGRESS;

82
	}

83
	return err;

84
}

85


86
void dlm_message_out(struct dlm_message *ms)

87
{

88
	header_out(&ms->m_header);

89


90
	ms->m_type		= cpu_to_le32(ms->m_type);

91
	ms->m_nodeid		= cpu_to_le32(ms->m_nodeid);

92
	ms->m_pid		= cpu_to_le32(ms->m_pid);

93
	ms->m_lkid		= cpu_to_le32(ms->m_lkid);

94
	ms->m_remid		= cpu_to_le32(ms->m_remid);

95
	ms->m_parent_lkid	= cpu_to_le32(ms->m_parent_lkid);

96
	ms->m_parent_remid	= cpu_to_le32(ms->m_parent_remid);

97
	ms->m_exflags		= cpu_to_le32(ms->m_exflags);

98
	ms->m_sbflags		= cpu_to_le32(ms->m_sbflags);

99
	ms->m_flags		= cpu_to_le32(ms->m_flags);

100
	ms->m_lvbseq		= cpu_to_le32(ms->m_lvbseq);

101
	ms->m_hash		= cpu_to_le32(ms->m_hash);

102
	ms->m_status		= cpu_to_le32(ms->m_status);

103
	ms->m_grmode		= cpu_to_le32(ms->m_grmode);

104
	ms->m_rqmode		= cpu_to_le32(ms->m_rqmode);

105
	ms->m_bastmode		= cpu_to_le32(ms->m_bastmode);

106
	ms->m_asts		= cpu_to_le32(ms->m_asts);

107
	ms->m_result		= cpu_to_le32(to_dlm_errno(ms->m_result));

108
}

109


110
void dlm_message_in(struct dlm_message *ms)

111
{

112
	header_in(&ms->m_header);

113


114
	ms->m_type		= le32_to_cpu(ms->m_type);

115
	ms->m_nodeid		= le32_to_cpu(ms->m_nodeid);

116
	ms->m_pid		= le32_to_cpu(ms->m_pid);

117
	ms->m_lkid		= le32_to_cpu(ms->m_lkid);

118
	ms->m_remid		= le32_to_cpu(ms->m_remid);

119
	ms->m_parent_lkid	= le32_to_cpu(ms->m_parent_lkid);

120
	ms->m_parent_remid	= le32_to_cpu(ms->m_parent_remid);

121
	ms->m_exflags		= le32_to_cpu(ms->m_exflags);

122
	ms->m_sbflags		= le32_to_cpu(ms->m_sbflags);

123
	ms->m_flags		= le32_to_cpu(ms->m_flags);

124
	ms->m_lvbseq		= le32_to_cpu(ms->m_lvbseq);

125
	ms->m_hash		= le32_to_cpu(ms->m_hash);

126
	ms->m_status		= le32_to_cpu(ms->m_status);

127
	ms->m_grmode		= le32_to_cpu(ms->m_grmode);

128
	ms->m_rqmode		= le32_to_cpu(ms->m_rqmode);

129
	ms->m_bastmode		= le32_to_cpu(ms->m_bastmode);

130
	ms->m_asts		= le32_to_cpu(ms->m_asts);

131
	ms->m_result		= from_dlm_errno(le32_to_cpu(ms->m_result));

132
}

133


134
void dlm_rcom_out(struct dlm_rcom *rc)

135
{

136
	header_out(&rc->rc_header);

137


138
	rc->rc_type		= cpu_to_le32(rc->rc_type);

139
	rc->rc_result		= cpu_to_le32(rc->rc_result);

140
	rc->rc_id		= cpu_to_le64(rc->rc_id);

141
	rc->rc_seq		= cpu_to_le64(rc->rc_seq);

142
	rc->rc_seq_reply	= cpu_to_le64(rc->rc_seq_reply);

143
}

144


145
void dlm_rcom_in(struct dlm_rcom *rc)

146
{

147
	header_in(&rc->rc_header);

148


149
	rc->rc_type		= le32_to_cpu(rc->rc_type);

150
	rc->rc_result		= le32_to_cpu(rc->rc_result);

151
	rc->rc_id		= le64_to_cpu(rc->rc_id);

152
	rc->rc_seq		= le64_to_cpu(rc->rc_seq);

153
	rc->rc_seq_reply	= le64_to_cpu(rc->rc_seq_reply);

154
}

155


156