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 */ 25 int 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 } 83 EXPORT_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 */ 93 int 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 } 133 EXPORT_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 */ 144 int 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 } 188 EXPORT_SYMBOL(ceph_cls_break_lock); 189 190 int 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 } 239 EXPORT_SYMBOL(ceph_cls_set_cookie); 240 241 void 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 } 249 EXPORT_SYMBOL(ceph_free_lockers); 250 251 static 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_safe(p, end, &locker->id.name, 263 sizeof(locker->id.name), bad); 264 s = ceph_extract_encoded_string(p, end, NULL, GFP_NOIO); 265 if (IS_ERR(s)) 266 return PTR_ERR(s); 267 268 locker->id.cookie = s; 269 270 ret = ceph_start_decoding(p, end, 1, "locker_info_t", &struct_v, &len); 271 if (ret) 272 return ret; 273 274 /* skip expiration */ 275 ceph_decode_skip_n(p, end, sizeof(struct ceph_timespec), bad); 276 277 ret = ceph_decode_entity_addr(p, end, &locker->info.addr); 278 if (ret) 279 return ret; 280 281 /* skip description */ 282 ceph_decode_skip_string(p, end, bad); 283 284 dout("%s %s%llu cookie %s addr %s\n", __func__, 285 ENTITY_NAME(locker->id.name), locker->id.cookie, 286 ceph_pr_addr(&locker->info.addr)); 287 return 0; 288 289 bad: 290 return -EINVAL; 291 } 292 293 static int decode_lockers(void **p, void *end, u8 *type, char **tag, 294 struct ceph_locker **lockers, u32 *num_lockers) 295 { 296 u8 struct_v; 297 u32 struct_len; 298 char *s; 299 int i; 300 int ret; 301 302 ret = ceph_start_decoding(p, end, 1, "cls_lock_get_info_reply", 303 &struct_v, &struct_len); 304 if (ret) 305 return ret; 306 307 ceph_decode_32_safe(p, end, *num_lockers, err_inval); 308 *lockers = kzalloc_objs(**lockers, *num_lockers, GFP_NOIO); 309 if (!*lockers) 310 return -ENOMEM; 311 312 for (i = 0; i < *num_lockers; i++) { 313 ret = decode_locker(p, end, *lockers + i); 314 if (ret) 315 goto err_free_lockers; 316 } 317 318 ret = -EINVAL; 319 ceph_decode_8_safe(p, end, *type, err_free_lockers); 320 s = ceph_extract_encoded_string(p, end, NULL, GFP_NOIO); 321 if (IS_ERR(s)) { 322 ret = PTR_ERR(s); 323 goto err_free_lockers; 324 } 325 326 *tag = s; 327 return 0; 328 329 err_inval: 330 return -EINVAL; 331 332 err_free_lockers: 333 ceph_free_lockers(*lockers, *num_lockers); 334 return ret; 335 } 336 337 /* 338 * On success, the caller is responsible for: 339 * 340 * kfree(tag); 341 * ceph_free_lockers(lockers, num_lockers); 342 */ 343 int ceph_cls_lock_info(struct ceph_osd_client *osdc, 344 struct ceph_object_id *oid, 345 struct ceph_object_locator *oloc, 346 char *lock_name, u8 *type, char **tag, 347 struct ceph_locker **lockers, u32 *num_lockers) 348 { 349 int get_info_op_buf_size; 350 int name_len = strlen(lock_name); 351 struct page *get_info_op_page, *reply_page; 352 size_t reply_len = PAGE_SIZE; 353 void *p, *end; 354 int ret; 355 356 get_info_op_buf_size = name_len + sizeof(__le32) + 357 CEPH_ENCODING_START_BLK_LEN; 358 if (get_info_op_buf_size > PAGE_SIZE) 359 return -E2BIG; 360 361 get_info_op_page = alloc_page(GFP_NOIO); 362 if (!get_info_op_page) 363 return -ENOMEM; 364 365 reply_page = alloc_page(GFP_NOIO); 366 if (!reply_page) { 367 __free_page(get_info_op_page); 368 return -ENOMEM; 369 } 370 371 p = page_address(get_info_op_page); 372 end = p + get_info_op_buf_size; 373 374 /* encode cls_lock_get_info_op struct */ 375 ceph_start_encoding(&p, 1, 1, 376 get_info_op_buf_size - CEPH_ENCODING_START_BLK_LEN); 377 ceph_encode_string(&p, end, lock_name, name_len); 378 379 dout("%s lock_name %s\n", __func__, lock_name); 380 ret = ceph_osdc_call(osdc, oid, oloc, "lock", "get_info", 381 CEPH_OSD_FLAG_READ, get_info_op_page, 382 get_info_op_buf_size, &reply_page, &reply_len); 383 384 dout("%s: status %d\n", __func__, ret); 385 if (ret >= 0) { 386 p = page_address(reply_page); 387 end = p + reply_len; 388 389 ret = decode_lockers(&p, end, type, tag, lockers, num_lockers); 390 } 391 392 __free_page(get_info_op_page); 393 __free_page(reply_page); 394 return ret; 395 } 396 EXPORT_SYMBOL(ceph_cls_lock_info); 397 398 int ceph_cls_assert_locked(struct ceph_osd_request *req, int which, 399 char *lock_name, u8 type, char *cookie, char *tag) 400 { 401 int assert_op_buf_size; 402 int name_len = strlen(lock_name); 403 int cookie_len = strlen(cookie); 404 int tag_len = strlen(tag); 405 struct page **pages; 406 void *p, *end; 407 int ret; 408 409 assert_op_buf_size = name_len + sizeof(__le32) + 410 cookie_len + sizeof(__le32) + 411 tag_len + sizeof(__le32) + 412 sizeof(u8) + CEPH_ENCODING_START_BLK_LEN; 413 if (assert_op_buf_size > PAGE_SIZE) 414 return -E2BIG; 415 416 ret = osd_req_op_cls_init(req, which, "lock", "assert_locked"); 417 if (ret) 418 return ret; 419 420 pages = ceph_alloc_page_vector(1, GFP_NOIO); 421 if (IS_ERR(pages)) 422 return PTR_ERR(pages); 423 424 p = page_address(pages[0]); 425 end = p + assert_op_buf_size; 426 427 /* encode cls_lock_assert_op struct */ 428 ceph_start_encoding(&p, 1, 1, 429 assert_op_buf_size - CEPH_ENCODING_START_BLK_LEN); 430 ceph_encode_string(&p, end, lock_name, name_len); 431 ceph_encode_8(&p, type); 432 ceph_encode_string(&p, end, cookie, cookie_len); 433 ceph_encode_string(&p, end, tag, tag_len); 434 WARN_ON(p != end); 435 436 osd_req_op_cls_request_data_pages(req, which, pages, assert_op_buf_size, 437 0, false, true); 438 return 0; 439 } 440 EXPORT_SYMBOL(ceph_cls_assert_locked); 441