~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ceph/cls_lock_client.c

Version: ~ [ linux-5.1-rc2 ] ~ [ linux-5.0.4 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.31 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.108 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.165 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.177 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.137 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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  */
 22 int 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 }
 80 EXPORT_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  */
 88 int 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 }
128 EXPORT_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  */
137 int 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 }
181 EXPORT_SYMBOL(ceph_cls_break_lock);
182 
183 int 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 }
232 EXPORT_SYMBOL(ceph_cls_set_cookie);
233 
234 void 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 }
242 EXPORT_SYMBOL(ceph_free_lockers);
243 
244 static 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 
278 static 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 
313 err_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  */
324 int 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 }
377 EXPORT_SYMBOL(ceph_cls_lock_info);
378 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp