Loading...
1// SPDX-License-Identifier: GPL-2.0
2#include <linux/ceph/ceph_debug.h>
3
4#include <linux/types.h>
5#include <linux/slab.h>
6
7#include <linux/ceph/cls_lock_client.h>
8#include <linux/ceph/decode.h>
9#include <linux/ceph/libceph.h>
10
11/**
12 * ceph_cls_lock - grab rados lock for object
13 * @osdc: OSD client instance
14 * @oid: object to lock
15 * @oloc: object to lock
16 * @lock_name: the name of the lock
17 * @type: lock type (CEPH_CLS_LOCK_EXCLUSIVE or CEPH_CLS_LOCK_SHARED)
18 * @cookie: user-defined identifier for this instance of the lock
19 * @tag: user-defined tag
20 * @desc: user-defined lock description
21 * @flags: lock flags
22 *
23 * All operations on the same lock should use the same tag.
24 */
25int ceph_cls_lock(struct ceph_osd_client *osdc,
26 struct ceph_object_id *oid,
27 struct ceph_object_locator *oloc,
28 char *lock_name, u8 type, char *cookie,
29 char *tag, char *desc, u8 flags)
30{
31 int lock_op_buf_size;
32 int name_len = strlen(lock_name);
33 int cookie_len = strlen(cookie);
34 int tag_len = strlen(tag);
35 int desc_len = strlen(desc);
36 void *p, *end;
37 struct page *lock_op_page;
38 struct timespec64 mtime;
39 int ret;
40
41 lock_op_buf_size = name_len + sizeof(__le32) +
42 cookie_len + sizeof(__le32) +
43 tag_len + sizeof(__le32) +
44 desc_len + sizeof(__le32) +
45 sizeof(struct ceph_timespec) +
46 /* flag and type */
47 sizeof(u8) + sizeof(u8) +
48 CEPH_ENCODING_START_BLK_LEN;
49 if (lock_op_buf_size > PAGE_SIZE)
50 return -E2BIG;
51
52 lock_op_page = alloc_page(GFP_NOIO);
53 if (!lock_op_page)
54 return -ENOMEM;
55
56 p = page_address(lock_op_page);
57 end = p + lock_op_buf_size;
58
59 /* encode cls_lock_lock_op struct */
60 ceph_start_encoding(&p, 1, 1,
61 lock_op_buf_size - CEPH_ENCODING_START_BLK_LEN);
62 ceph_encode_string(&p, end, lock_name, name_len);
63 ceph_encode_8(&p, type);
64 ceph_encode_string(&p, end, cookie, cookie_len);
65 ceph_encode_string(&p, end, tag, tag_len);
66 ceph_encode_string(&p, end, desc, desc_len);
67 /* only support infinite duration */
68 memset(&mtime, 0, sizeof(mtime));
69 ceph_encode_timespec64(p, &mtime);
70 p += sizeof(struct ceph_timespec);
71 ceph_encode_8(&p, flags);
72
73 dout("%s lock_name %s type %d cookie %s tag %s desc %s flags 0x%x\n",
74 __func__, lock_name, type, cookie, tag, desc, flags);
75 ret = ceph_osdc_call(osdc, oid, oloc, "lock", "lock",
76 CEPH_OSD_FLAG_WRITE, lock_op_page,
77 lock_op_buf_size, NULL, NULL);
78
79 dout("%s: status %d\n", __func__, ret);
80 __free_page(lock_op_page);
81 return ret;
82}
83EXPORT_SYMBOL(ceph_cls_lock);
84
85/**
86 * ceph_cls_unlock - release rados lock for object
87 * @osdc: OSD client instance
88 * @oid: object to lock
89 * @oloc: object to lock
90 * @lock_name: the name of the lock
91 * @cookie: user-defined identifier for this instance of the lock
92 */
93int ceph_cls_unlock(struct ceph_osd_client *osdc,
94 struct ceph_object_id *oid,
95 struct ceph_object_locator *oloc,
96 char *lock_name, char *cookie)
97{
98 int unlock_op_buf_size;
99 int name_len = strlen(lock_name);
100 int cookie_len = strlen(cookie);
101 void *p, *end;
102 struct page *unlock_op_page;
103 int ret;
104
105 unlock_op_buf_size = name_len + sizeof(__le32) +
106 cookie_len + sizeof(__le32) +
107 CEPH_ENCODING_START_BLK_LEN;
108 if (unlock_op_buf_size > PAGE_SIZE)
109 return -E2BIG;
110
111 unlock_op_page = alloc_page(GFP_NOIO);
112 if (!unlock_op_page)
113 return -ENOMEM;
114
115 p = page_address(unlock_op_page);
116 end = p + unlock_op_buf_size;
117
118 /* encode cls_lock_unlock_op struct */
119 ceph_start_encoding(&p, 1, 1,
120 unlock_op_buf_size - CEPH_ENCODING_START_BLK_LEN);
121 ceph_encode_string(&p, end, lock_name, name_len);
122 ceph_encode_string(&p, end, cookie, cookie_len);
123
124 dout("%s lock_name %s cookie %s\n", __func__, lock_name, cookie);
125 ret = ceph_osdc_call(osdc, oid, oloc, "lock", "unlock",
126 CEPH_OSD_FLAG_WRITE, unlock_op_page,
127 unlock_op_buf_size, NULL, NULL);
128
129 dout("%s: status %d\n", __func__, ret);
130 __free_page(unlock_op_page);
131 return ret;
132}
133EXPORT_SYMBOL(ceph_cls_unlock);
134
135/**
136 * ceph_cls_break_lock - release rados lock for object for specified client
137 * @osdc: OSD client instance
138 * @oid: object to lock
139 * @oloc: object to lock
140 * @lock_name: the name of the lock
141 * @cookie: user-defined identifier for this instance of the lock
142 * @locker: current lock owner
143 */
144int ceph_cls_break_lock(struct ceph_osd_client *osdc,
145 struct ceph_object_id *oid,
146 struct ceph_object_locator *oloc,
147 char *lock_name, char *cookie,
148 struct ceph_entity_name *locker)
149{
150 int break_op_buf_size;
151 int name_len = strlen(lock_name);
152 int cookie_len = strlen(cookie);
153 struct page *break_op_page;
154 void *p, *end;
155 int ret;
156
157 break_op_buf_size = name_len + sizeof(__le32) +
158 cookie_len + sizeof(__le32) +
159 sizeof(u8) + sizeof(__le64) +
160 CEPH_ENCODING_START_BLK_LEN;
161 if (break_op_buf_size > PAGE_SIZE)
162 return -E2BIG;
163
164 break_op_page = alloc_page(GFP_NOIO);
165 if (!break_op_page)
166 return -ENOMEM;
167
168 p = page_address(break_op_page);
169 end = p + break_op_buf_size;
170
171 /* encode cls_lock_break_op struct */
172 ceph_start_encoding(&p, 1, 1,
173 break_op_buf_size - CEPH_ENCODING_START_BLK_LEN);
174 ceph_encode_string(&p, end, lock_name, name_len);
175 ceph_encode_copy(&p, locker, sizeof(*locker));
176 ceph_encode_string(&p, end, cookie, cookie_len);
177
178 dout("%s lock_name %s cookie %s locker %s%llu\n", __func__, lock_name,
179 cookie, ENTITY_NAME(*locker));
180 ret = ceph_osdc_call(osdc, oid, oloc, "lock", "break_lock",
181 CEPH_OSD_FLAG_WRITE, break_op_page,
182 break_op_buf_size, NULL, NULL);
183
184 dout("%s: status %d\n", __func__, ret);
185 __free_page(break_op_page);
186 return ret;
187}
188EXPORT_SYMBOL(ceph_cls_break_lock);
189
190int ceph_cls_set_cookie(struct ceph_osd_client *osdc,
191 struct ceph_object_id *oid,
192 struct ceph_object_locator *oloc,
193 char *lock_name, u8 type, char *old_cookie,
194 char *tag, char *new_cookie)
195{
196 int cookie_op_buf_size;
197 int name_len = strlen(lock_name);
198 int old_cookie_len = strlen(old_cookie);
199 int tag_len = strlen(tag);
200 int new_cookie_len = strlen(new_cookie);
201 void *p, *end;
202 struct page *cookie_op_page;
203 int ret;
204
205 cookie_op_buf_size = name_len + sizeof(__le32) +
206 old_cookie_len + sizeof(__le32) +
207 tag_len + sizeof(__le32) +
208 new_cookie_len + sizeof(__le32) +
209 sizeof(u8) + CEPH_ENCODING_START_BLK_LEN;
210 if (cookie_op_buf_size > PAGE_SIZE)
211 return -E2BIG;
212
213 cookie_op_page = alloc_page(GFP_NOIO);
214 if (!cookie_op_page)
215 return -ENOMEM;
216
217 p = page_address(cookie_op_page);
218 end = p + cookie_op_buf_size;
219
220 /* encode cls_lock_set_cookie_op struct */
221 ceph_start_encoding(&p, 1, 1,
222 cookie_op_buf_size - CEPH_ENCODING_START_BLK_LEN);
223 ceph_encode_string(&p, end, lock_name, name_len);
224 ceph_encode_8(&p, type);
225 ceph_encode_string(&p, end, old_cookie, old_cookie_len);
226 ceph_encode_string(&p, end, tag, tag_len);
227 ceph_encode_string(&p, end, new_cookie, new_cookie_len);
228
229 dout("%s lock_name %s type %d old_cookie %s tag %s new_cookie %s\n",
230 __func__, lock_name, type, old_cookie, tag, new_cookie);
231 ret = ceph_osdc_call(osdc, oid, oloc, "lock", "set_cookie",
232 CEPH_OSD_FLAG_WRITE, cookie_op_page,
233 cookie_op_buf_size, NULL, NULL);
234
235 dout("%s: status %d\n", __func__, ret);
236 __free_page(cookie_op_page);
237 return ret;
238}
239EXPORT_SYMBOL(ceph_cls_set_cookie);
240
241void ceph_free_lockers(struct ceph_locker *lockers, u32 num_lockers)
242{
243 int i;
244
245 for (i = 0; i < num_lockers; i++)
246 kfree(lockers[i].id.cookie);
247 kfree(lockers);
248}
249EXPORT_SYMBOL(ceph_free_lockers);
250
251static int decode_locker(void **p, void *end, struct ceph_locker *locker)
252{
253 u8 struct_v;
254 u32 len;
255 char *s;
256 int ret;
257
258 ret = ceph_start_decoding(p, end, 1, "locker_id_t", &struct_v, &len);
259 if (ret)
260 return ret;
261
262 ceph_decode_copy(p, &locker->id.name, sizeof(locker->id.name));
263 s = ceph_extract_encoded_string(p, end, NULL, GFP_NOIO);
264 if (IS_ERR(s))
265 return PTR_ERR(s);
266
267 locker->id.cookie = s;
268
269 ret = ceph_start_decoding(p, end, 1, "locker_info_t", &struct_v, &len);
270 if (ret)
271 return ret;
272
273 *p += sizeof(struct ceph_timespec); /* skip expiration */
274
275 ret = ceph_decode_entity_addr(p, end, &locker->info.addr);
276 if (ret)
277 return ret;
278
279 len = ceph_decode_32(p);
280 *p += len; /* skip description */
281
282 dout("%s %s%llu cookie %s addr %s\n", __func__,
283 ENTITY_NAME(locker->id.name), locker->id.cookie,
284 ceph_pr_addr(&locker->info.addr));
285 return 0;
286}
287
288static int decode_lockers(void **p, void *end, u8 *type, char **tag,
289 struct ceph_locker **lockers, u32 *num_lockers)
290{
291 u8 struct_v;
292 u32 struct_len;
293 char *s;
294 int i;
295 int ret;
296
297 ret = ceph_start_decoding(p, end, 1, "cls_lock_get_info_reply",
298 &struct_v, &struct_len);
299 if (ret)
300 return ret;
301
302 *num_lockers = ceph_decode_32(p);
303 *lockers = kcalloc(*num_lockers, sizeof(**lockers), GFP_NOIO);
304 if (!*lockers)
305 return -ENOMEM;
306
307 for (i = 0; i < *num_lockers; i++) {
308 ret = decode_locker(p, end, *lockers + i);
309 if (ret)
310 goto err_free_lockers;
311 }
312
313 *type = ceph_decode_8(p);
314 s = ceph_extract_encoded_string(p, end, NULL, GFP_NOIO);
315 if (IS_ERR(s)) {
316 ret = PTR_ERR(s);
317 goto err_free_lockers;
318 }
319
320 *tag = s;
321 return 0;
322
323err_free_lockers:
324 ceph_free_lockers(*lockers, *num_lockers);
325 return ret;
326}
327
328/*
329 * On success, the caller is responsible for:
330 *
331 * kfree(tag);
332 * ceph_free_lockers(lockers, num_lockers);
333 */
334int ceph_cls_lock_info(struct ceph_osd_client *osdc,
335 struct ceph_object_id *oid,
336 struct ceph_object_locator *oloc,
337 char *lock_name, u8 *type, char **tag,
338 struct ceph_locker **lockers, u32 *num_lockers)
339{
340 int get_info_op_buf_size;
341 int name_len = strlen(lock_name);
342 struct page *get_info_op_page, *reply_page;
343 size_t reply_len = PAGE_SIZE;
344 void *p, *end;
345 int ret;
346
347 get_info_op_buf_size = name_len + sizeof(__le32) +
348 CEPH_ENCODING_START_BLK_LEN;
349 if (get_info_op_buf_size > PAGE_SIZE)
350 return -E2BIG;
351
352 get_info_op_page = alloc_page(GFP_NOIO);
353 if (!get_info_op_page)
354 return -ENOMEM;
355
356 reply_page = alloc_page(GFP_NOIO);
357 if (!reply_page) {
358 __free_page(get_info_op_page);
359 return -ENOMEM;
360 }
361
362 p = page_address(get_info_op_page);
363 end = p + get_info_op_buf_size;
364
365 /* encode cls_lock_get_info_op struct */
366 ceph_start_encoding(&p, 1, 1,
367 get_info_op_buf_size - CEPH_ENCODING_START_BLK_LEN);
368 ceph_encode_string(&p, end, lock_name, name_len);
369
370 dout("%s lock_name %s\n", __func__, lock_name);
371 ret = ceph_osdc_call(osdc, oid, oloc, "lock", "get_info",
372 CEPH_OSD_FLAG_READ, get_info_op_page,
373 get_info_op_buf_size, &reply_page, &reply_len);
374
375 dout("%s: status %d\n", __func__, ret);
376 if (ret >= 0) {
377 p = page_address(reply_page);
378 end = p + reply_len;
379
380 ret = decode_lockers(&p, end, type, tag, lockers, num_lockers);
381 }
382
383 __free_page(get_info_op_page);
384 __free_page(reply_page);
385 return ret;
386}
387EXPORT_SYMBOL(ceph_cls_lock_info);
388
389int ceph_cls_assert_locked(struct ceph_osd_request *req, int which,
390 char *lock_name, u8 type, char *cookie, char *tag)
391{
392 int assert_op_buf_size;
393 int name_len = strlen(lock_name);
394 int cookie_len = strlen(cookie);
395 int tag_len = strlen(tag);
396 struct page **pages;
397 void *p, *end;
398 int ret;
399
400 assert_op_buf_size = name_len + sizeof(__le32) +
401 cookie_len + sizeof(__le32) +
402 tag_len + sizeof(__le32) +
403 sizeof(u8) + CEPH_ENCODING_START_BLK_LEN;
404 if (assert_op_buf_size > PAGE_SIZE)
405 return -E2BIG;
406
407 ret = osd_req_op_cls_init(req, which, "lock", "assert_locked");
408 if (ret)
409 return ret;
410
411 pages = ceph_alloc_page_vector(1, GFP_NOIO);
412 if (IS_ERR(pages))
413 return PTR_ERR(pages);
414
415 p = page_address(pages[0]);
416 end = p + assert_op_buf_size;
417
418 /* encode cls_lock_assert_op struct */
419 ceph_start_encoding(&p, 1, 1,
420 assert_op_buf_size - CEPH_ENCODING_START_BLK_LEN);
421 ceph_encode_string(&p, end, lock_name, name_len);
422 ceph_encode_8(&p, type);
423 ceph_encode_string(&p, end, cookie, cookie_len);
424 ceph_encode_string(&p, end, tag, tag_len);
425 WARN_ON(p != end);
426
427 osd_req_op_cls_request_data_pages(req, which, pages, assert_op_buf_size,
428 0, false, true);
429 return 0;
430}
431EXPORT_SYMBOL(ceph_cls_assert_locked);
1// SPDX-License-Identifier: GPL-2.0
2#include <linux/ceph/ceph_debug.h>
3
4#include <linux/types.h>
5#include <linux/slab.h>
6
7#include <linux/ceph/cls_lock_client.h>
8#include <linux/ceph/decode.h>
9
10/**
11 * ceph_cls_lock - grab rados lock for object
12 * @oid, @oloc: object to lock
13 * @lock_name: the name of the lock
14 * @type: lock type (CEPH_CLS_LOCK_EXCLUSIVE or CEPH_CLS_LOCK_SHARED)
15 * @cookie: user-defined identifier for this instance of the lock
16 * @tag: user-defined tag
17 * @desc: user-defined lock description
18 * @flags: lock flags
19 *
20 * All operations on the same lock should use the same tag.
21 */
22int ceph_cls_lock(struct ceph_osd_client *osdc,
23 struct ceph_object_id *oid,
24 struct ceph_object_locator *oloc,
25 char *lock_name, u8 type, char *cookie,
26 char *tag, char *desc, u8 flags)
27{
28 int lock_op_buf_size;
29 int name_len = strlen(lock_name);
30 int cookie_len = strlen(cookie);
31 int tag_len = strlen(tag);
32 int desc_len = strlen(desc);
33 void *p, *end;
34 struct page *lock_op_page;
35 struct timespec mtime;
36 int ret;
37
38 lock_op_buf_size = name_len + sizeof(__le32) +
39 cookie_len + sizeof(__le32) +
40 tag_len + sizeof(__le32) +
41 desc_len + sizeof(__le32) +
42 sizeof(struct ceph_timespec) +
43 /* flag and type */
44 sizeof(u8) + sizeof(u8) +
45 CEPH_ENCODING_START_BLK_LEN;
46 if (lock_op_buf_size > PAGE_SIZE)
47 return -E2BIG;
48
49 lock_op_page = alloc_page(GFP_NOIO);
50 if (!lock_op_page)
51 return -ENOMEM;
52
53 p = page_address(lock_op_page);
54 end = p + lock_op_buf_size;
55
56 /* encode cls_lock_lock_op struct */
57 ceph_start_encoding(&p, 1, 1,
58 lock_op_buf_size - CEPH_ENCODING_START_BLK_LEN);
59 ceph_encode_string(&p, end, lock_name, name_len);
60 ceph_encode_8(&p, type);
61 ceph_encode_string(&p, end, cookie, cookie_len);
62 ceph_encode_string(&p, end, tag, tag_len);
63 ceph_encode_string(&p, end, desc, desc_len);
64 /* only support infinite duration */
65 memset(&mtime, 0, sizeof(mtime));
66 ceph_encode_timespec(p, &mtime);
67 p += sizeof(struct ceph_timespec);
68 ceph_encode_8(&p, flags);
69
70 dout("%s lock_name %s type %d cookie %s tag %s desc %s flags 0x%x\n",
71 __func__, lock_name, type, cookie, tag, desc, flags);
72 ret = ceph_osdc_call(osdc, oid, oloc, "lock", "lock",
73 CEPH_OSD_FLAG_WRITE, lock_op_page,
74 lock_op_buf_size, NULL, NULL);
75
76 dout("%s: status %d\n", __func__, ret);
77 __free_page(lock_op_page);
78 return ret;
79}
80EXPORT_SYMBOL(ceph_cls_lock);
81
82/**
83 * ceph_cls_unlock - release rados lock for object
84 * @oid, @oloc: object to lock
85 * @lock_name: the name of the lock
86 * @cookie: user-defined identifier for this instance of the lock
87 */
88int ceph_cls_unlock(struct ceph_osd_client *osdc,
89 struct ceph_object_id *oid,
90 struct ceph_object_locator *oloc,
91 char *lock_name, char *cookie)
92{
93 int unlock_op_buf_size;
94 int name_len = strlen(lock_name);
95 int cookie_len = strlen(cookie);
96 void *p, *end;
97 struct page *unlock_op_page;
98 int ret;
99
100 unlock_op_buf_size = name_len + sizeof(__le32) +
101 cookie_len + sizeof(__le32) +
102 CEPH_ENCODING_START_BLK_LEN;
103 if (unlock_op_buf_size > PAGE_SIZE)
104 return -E2BIG;
105
106 unlock_op_page = alloc_page(GFP_NOIO);
107 if (!unlock_op_page)
108 return -ENOMEM;
109
110 p = page_address(unlock_op_page);
111 end = p + unlock_op_buf_size;
112
113 /* encode cls_lock_unlock_op struct */
114 ceph_start_encoding(&p, 1, 1,
115 unlock_op_buf_size - CEPH_ENCODING_START_BLK_LEN);
116 ceph_encode_string(&p, end, lock_name, name_len);
117 ceph_encode_string(&p, end, cookie, cookie_len);
118
119 dout("%s lock_name %s cookie %s\n", __func__, lock_name, cookie);
120 ret = ceph_osdc_call(osdc, oid, oloc, "lock", "unlock",
121 CEPH_OSD_FLAG_WRITE, unlock_op_page,
122 unlock_op_buf_size, NULL, NULL);
123
124 dout("%s: status %d\n", __func__, ret);
125 __free_page(unlock_op_page);
126 return ret;
127}
128EXPORT_SYMBOL(ceph_cls_unlock);
129
130/**
131 * ceph_cls_break_lock - release rados lock for object for specified client
132 * @oid, @oloc: object to lock
133 * @lock_name: the name of the lock
134 * @cookie: user-defined identifier for this instance of the lock
135 * @locker: current lock owner
136 */
137int ceph_cls_break_lock(struct ceph_osd_client *osdc,
138 struct ceph_object_id *oid,
139 struct ceph_object_locator *oloc,
140 char *lock_name, char *cookie,
141 struct ceph_entity_name *locker)
142{
143 int break_op_buf_size;
144 int name_len = strlen(lock_name);
145 int cookie_len = strlen(cookie);
146 struct page *break_op_page;
147 void *p, *end;
148 int ret;
149
150 break_op_buf_size = name_len + sizeof(__le32) +
151 cookie_len + sizeof(__le32) +
152 sizeof(u8) + sizeof(__le64) +
153 CEPH_ENCODING_START_BLK_LEN;
154 if (break_op_buf_size > PAGE_SIZE)
155 return -E2BIG;
156
157 break_op_page = alloc_page(GFP_NOIO);
158 if (!break_op_page)
159 return -ENOMEM;
160
161 p = page_address(break_op_page);
162 end = p + break_op_buf_size;
163
164 /* encode cls_lock_break_op struct */
165 ceph_start_encoding(&p, 1, 1,
166 break_op_buf_size - CEPH_ENCODING_START_BLK_LEN);
167 ceph_encode_string(&p, end, lock_name, name_len);
168 ceph_encode_copy(&p, locker, sizeof(*locker));
169 ceph_encode_string(&p, end, cookie, cookie_len);
170
171 dout("%s lock_name %s cookie %s locker %s%llu\n", __func__, lock_name,
172 cookie, ENTITY_NAME(*locker));
173 ret = ceph_osdc_call(osdc, oid, oloc, "lock", "break_lock",
174 CEPH_OSD_FLAG_WRITE, break_op_page,
175 break_op_buf_size, NULL, NULL);
176
177 dout("%s: status %d\n", __func__, ret);
178 __free_page(break_op_page);
179 return ret;
180}
181EXPORT_SYMBOL(ceph_cls_break_lock);
182
183int ceph_cls_set_cookie(struct ceph_osd_client *osdc,
184 struct ceph_object_id *oid,
185 struct ceph_object_locator *oloc,
186 char *lock_name, u8 type, char *old_cookie,
187 char *tag, char *new_cookie)
188{
189 int cookie_op_buf_size;
190 int name_len = strlen(lock_name);
191 int old_cookie_len = strlen(old_cookie);
192 int tag_len = strlen(tag);
193 int new_cookie_len = strlen(new_cookie);
194 void *p, *end;
195 struct page *cookie_op_page;
196 int ret;
197
198 cookie_op_buf_size = name_len + sizeof(__le32) +
199 old_cookie_len + sizeof(__le32) +
200 tag_len + sizeof(__le32) +
201 new_cookie_len + sizeof(__le32) +
202 sizeof(u8) + CEPH_ENCODING_START_BLK_LEN;
203 if (cookie_op_buf_size > PAGE_SIZE)
204 return -E2BIG;
205
206 cookie_op_page = alloc_page(GFP_NOIO);
207 if (!cookie_op_page)
208 return -ENOMEM;
209
210 p = page_address(cookie_op_page);
211 end = p + cookie_op_buf_size;
212
213 /* encode cls_lock_set_cookie_op struct */
214 ceph_start_encoding(&p, 1, 1,
215 cookie_op_buf_size - CEPH_ENCODING_START_BLK_LEN);
216 ceph_encode_string(&p, end, lock_name, name_len);
217 ceph_encode_8(&p, type);
218 ceph_encode_string(&p, end, old_cookie, old_cookie_len);
219 ceph_encode_string(&p, end, tag, tag_len);
220 ceph_encode_string(&p, end, new_cookie, new_cookie_len);
221
222 dout("%s lock_name %s type %d old_cookie %s tag %s new_cookie %s\n",
223 __func__, lock_name, type, old_cookie, tag, new_cookie);
224 ret = ceph_osdc_call(osdc, oid, oloc, "lock", "set_cookie",
225 CEPH_OSD_FLAG_WRITE, cookie_op_page,
226 cookie_op_buf_size, NULL, NULL);
227
228 dout("%s: status %d\n", __func__, ret);
229 __free_page(cookie_op_page);
230 return ret;
231}
232EXPORT_SYMBOL(ceph_cls_set_cookie);
233
234void ceph_free_lockers(struct ceph_locker *lockers, u32 num_lockers)
235{
236 int i;
237
238 for (i = 0; i < num_lockers; i++)
239 kfree(lockers[i].id.cookie);
240 kfree(lockers);
241}
242EXPORT_SYMBOL(ceph_free_lockers);
243
244static int decode_locker(void **p, void *end, struct ceph_locker *locker)
245{
246 u8 struct_v;
247 u32 len;
248 char *s;
249 int ret;
250
251 ret = ceph_start_decoding(p, end, 1, "locker_id_t", &struct_v, &len);
252 if (ret)
253 return ret;
254
255 ceph_decode_copy(p, &locker->id.name, sizeof(locker->id.name));
256 s = ceph_extract_encoded_string(p, end, NULL, GFP_NOIO);
257 if (IS_ERR(s))
258 return PTR_ERR(s);
259
260 locker->id.cookie = s;
261
262 ret = ceph_start_decoding(p, end, 1, "locker_info_t", &struct_v, &len);
263 if (ret)
264 return ret;
265
266 *p += sizeof(struct ceph_timespec); /* skip expiration */
267 ceph_decode_copy(p, &locker->info.addr, sizeof(locker->info.addr));
268 ceph_decode_addr(&locker->info.addr);
269 len = ceph_decode_32(p);
270 *p += len; /* skip description */
271
272 dout("%s %s%llu cookie %s addr %s\n", __func__,
273 ENTITY_NAME(locker->id.name), locker->id.cookie,
274 ceph_pr_addr(&locker->info.addr.in_addr));
275 return 0;
276}
277
278static int decode_lockers(void **p, void *end, u8 *type, char **tag,
279 struct ceph_locker **lockers, u32 *num_lockers)
280{
281 u8 struct_v;
282 u32 struct_len;
283 char *s;
284 int i;
285 int ret;
286
287 ret = ceph_start_decoding(p, end, 1, "cls_lock_get_info_reply",
288 &struct_v, &struct_len);
289 if (ret)
290 return ret;
291
292 *num_lockers = ceph_decode_32(p);
293 *lockers = kcalloc(*num_lockers, sizeof(**lockers), GFP_NOIO);
294 if (!*lockers)
295 return -ENOMEM;
296
297 for (i = 0; i < *num_lockers; i++) {
298 ret = decode_locker(p, end, *lockers + i);
299 if (ret)
300 goto err_free_lockers;
301 }
302
303 *type = ceph_decode_8(p);
304 s = ceph_extract_encoded_string(p, end, NULL, GFP_NOIO);
305 if (IS_ERR(s)) {
306 ret = PTR_ERR(s);
307 goto err_free_lockers;
308 }
309
310 *tag = s;
311 return 0;
312
313err_free_lockers:
314 ceph_free_lockers(*lockers, *num_lockers);
315 return ret;
316}
317
318/*
319 * On success, the caller is responsible for:
320 *
321 * kfree(tag);
322 * ceph_free_lockers(lockers, num_lockers);
323 */
324int ceph_cls_lock_info(struct ceph_osd_client *osdc,
325 struct ceph_object_id *oid,
326 struct ceph_object_locator *oloc,
327 char *lock_name, u8 *type, char **tag,
328 struct ceph_locker **lockers, u32 *num_lockers)
329{
330 int get_info_op_buf_size;
331 int name_len = strlen(lock_name);
332 struct page *get_info_op_page, *reply_page;
333 size_t reply_len = PAGE_SIZE;
334 void *p, *end;
335 int ret;
336
337 get_info_op_buf_size = name_len + sizeof(__le32) +
338 CEPH_ENCODING_START_BLK_LEN;
339 if (get_info_op_buf_size > PAGE_SIZE)
340 return -E2BIG;
341
342 get_info_op_page = alloc_page(GFP_NOIO);
343 if (!get_info_op_page)
344 return -ENOMEM;
345
346 reply_page = alloc_page(GFP_NOIO);
347 if (!reply_page) {
348 __free_page(get_info_op_page);
349 return -ENOMEM;
350 }
351
352 p = page_address(get_info_op_page);
353 end = p + get_info_op_buf_size;
354
355 /* encode cls_lock_get_info_op struct */
356 ceph_start_encoding(&p, 1, 1,
357 get_info_op_buf_size - CEPH_ENCODING_START_BLK_LEN);
358 ceph_encode_string(&p, end, lock_name, name_len);
359
360 dout("%s lock_name %s\n", __func__, lock_name);
361 ret = ceph_osdc_call(osdc, oid, oloc, "lock", "get_info",
362 CEPH_OSD_FLAG_READ, get_info_op_page,
363 get_info_op_buf_size, reply_page, &reply_len);
364
365 dout("%s: status %d\n", __func__, ret);
366 if (ret >= 0) {
367 p = page_address(reply_page);
368 end = p + reply_len;
369
370 ret = decode_lockers(&p, end, type, tag, lockers, num_lockers);
371 }
372
373 __free_page(get_info_op_page);
374 __free_page(reply_page);
375 return ret;
376}
377EXPORT_SYMBOL(ceph_cls_lock_info);