Whamcloud - gitweb
LU-4217 build: bump build warnings to 2.7 development
[fs/lustre-release.git] / lustre / include / lustre_update.h
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.gnu.org/licenses/gpl-2.0.htm
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2013, Intel Corporation.
24  */
25 /*
26  * lustre/include/lustre_update.h
27  *
28  * Author: Di Wang <di.wang@intel.com>
29  */
30
31 #ifndef _LUSTRE_UPDATE_H
32 #define _LUSTRE_UPDATE_H
33
34 #define UPDATE_BUFFER_SIZE      8192
35 struct update_request {
36         struct dt_device        *ur_dt;
37         cfs_list_t              ur_list;    /* attached itself to thandle */
38         int                     ur_flags;
39         int                     ur_rc;      /* request result */
40         int                     ur_batchid; /* Current batch(trans) id */
41         struct update_buf       *ur_buf;   /* Holding the update req */
42 };
43
44 static inline unsigned long update_size(struct update *update)
45 {
46         unsigned long size;
47         int        i;
48
49         size = cfs_size_round(offsetof(struct update, u_bufs[0]));
50         for (i = 0; i < UPDATE_BUF_COUNT; i++)
51                 size += cfs_size_round(update->u_lens[i]);
52
53         return size;
54 }
55
56 static inline void *update_param_buf(struct update *update, int index,
57                                      int *size)
58 {
59         int     i;
60         void    *ptr;
61
62         if (index >= UPDATE_BUF_COUNT)
63                 return NULL;
64
65         ptr = (char *)update + cfs_size_round(offsetof(struct update,
66                                                        u_bufs[0]));
67         for (i = 0; i < index; i++) {
68                 LASSERT(update->u_lens[i] > 0);
69                 ptr += cfs_size_round(update->u_lens[i]);
70         }
71
72         if (size != NULL)
73                 *size = update->u_lens[index];
74
75         return ptr;
76 }
77
78 static inline unsigned long update_buf_size(struct update_buf *buf)
79 {
80         unsigned long size;
81         int        i = 0;
82
83         size = cfs_size_round(offsetof(struct update_buf, ub_bufs[0]));
84         for (i = 0; i < buf->ub_count; i++) {
85                 struct update *update;
86
87                 update = (struct update *)((char *)buf + size);
88                 size += update_size(update);
89         }
90         LASSERT(size <= UPDATE_BUFFER_SIZE);
91         return size;
92 }
93
94 static inline void *update_buf_get(struct update_buf *buf, int index, int *size)
95 {
96         int     count = buf->ub_count;
97         void    *ptr;
98         int     i = 0;
99
100         if (index >= count)
101                 return NULL;
102
103         ptr = (char *)buf + cfs_size_round(offsetof(struct update_buf,
104                                                     ub_bufs[0]));
105         for (i = 0; i < index; i++)
106                 ptr += update_size((struct update *)ptr);
107
108         if (size != NULL)
109                 *size = update_size((struct update *)ptr);
110
111         return ptr;
112 }
113
114 static inline void update_init_reply_buf(struct update_reply *reply, int count)
115 {
116         reply->ur_version = UPDATE_REPLY_V1;
117         reply->ur_count = count;
118 }
119
120 static inline void *update_get_buf_internal(struct update_reply *reply,
121                                             int index, int *size)
122 {
123         char *ptr;
124         int count = reply->ur_count;
125         int i;
126
127         if (index >= count)
128                 return NULL;
129
130         ptr = (char *)reply + cfs_size_round(offsetof(struct update_reply,
131                                              ur_lens[count]));
132         for (i = 0; i < index; i++) {
133                 LASSERT(reply->ur_lens[i] > 0);
134                 ptr += cfs_size_round(reply->ur_lens[i]);
135         }
136
137         if (size != NULL)
138                 *size = reply->ur_lens[index];
139
140         return ptr;
141 }
142
143 static inline void update_insert_reply(struct update_reply *reply, void *data,
144                                        int data_len, int index, int rc)
145 {
146         char *ptr;
147
148         ptr = update_get_buf_internal(reply, index, NULL);
149         LASSERT(ptr != NULL);
150
151         *(int *)ptr = cpu_to_le32(rc);
152         ptr += sizeof(int);
153         if (data_len > 0) {
154                 LASSERT(data != NULL);
155                 memcpy(ptr, data, data_len);
156         }
157         reply->ur_lens[index] = data_len + sizeof(int);
158 }
159
160 static inline int update_get_reply_buf(struct update_reply *reply, void **buf,
161                                        int index)
162 {
163         char *ptr;
164         int  size = 0;
165         int  result;
166
167         ptr = update_get_buf_internal(reply, index, &size);
168         LASSERT(ptr != NULL);
169         result = *(int *)ptr;
170
171         if (result < 0)
172                 return result;
173
174         LASSERT(size >= sizeof(int));
175         *buf = ptr + sizeof(int);
176         return size - sizeof(int);
177 }
178
179 static inline int update_get_reply_result(struct update_reply *reply,
180                                           void **buf, int index)
181 {
182         void *ptr;
183         int  size;
184
185         ptr = update_get_buf_internal(reply, index, &size);
186         LASSERT(ptr != NULL && size > sizeof(int));
187         return *(int *)ptr;
188 }
189
190 #endif
191
192