Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client

-7

Documentation/ABI/testing/sysfs-bus-rbd

··· 57 57 58 58 $ echo <snap-name> > /sys/bus/rbd/devices/<dev-id>/snap_create 59 59 60 - rollback_snap 61 - 62 - Rolls back data to the specified snapshot. This goes over the entire 63 - list of rados blocks and sends a rollback command to each. 64 - 65 - $ echo <snap-name> > /sys/bus/rbd/devices/<dev-id>/snap_rollback 66 - 67 60 snap_* 68 61 69 62 A directory per each snapshot

+10 -91

drivers/block/rbd.c

··· 183 183 184 184 static int __rbd_init_snaps_header(struct rbd_device *rbd_dev); 185 185 static void rbd_dev_release(struct device *dev); 186 - static ssize_t rbd_snap_rollback(struct device *dev, 187 - struct device_attribute *attr, 188 - const char *buf, 189 - size_t size); 190 186 static ssize_t rbd_snap_add(struct device *dev, 191 187 struct device_attribute *attr, 192 188 const char *buf, ··· 456 460 int i; 457 461 u32 snap_count = le32_to_cpu(ondisk->snap_count); 458 462 int ret = -ENOMEM; 463 + 464 + if (memcmp(ondisk, RBD_HEADER_TEXT, sizeof(RBD_HEADER_TEXT))) { 465 + return -ENXIO; 466 + } 459 467 460 468 init_rwsem(&header->snap_rwsem); 461 469 header->snap_names_len = le64_to_cpu(ondisk->snap_names_len); ··· 1356 1356 } 1357 1357 1358 1358 /* 1359 - * Request sync osd rollback 1360 - */ 1361 - static int rbd_req_sync_rollback_obj(struct rbd_device *dev, 1362 - u64 snapid, 1363 - const char *obj) 1364 - { 1365 - struct ceph_osd_req_op *ops; 1366 - int ret = rbd_create_rw_ops(&ops, 1, CEPH_OSD_OP_ROLLBACK, 0); 1367 - if (ret < 0) 1368 - return ret; 1369 - 1370 - ops[0].snap.snapid = snapid; 1371 - 1372 - ret = rbd_req_sync_op(dev, NULL, 1373 - CEPH_NOSNAP, 1374 - 0, 1375 - CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK, 1376 - ops, 1377 - 1, obj, 0, 0, NULL, NULL, NULL); 1378 - 1379 - rbd_destroy_ops(ops); 1380 - 1381 - return ret; 1382 - } 1383 - 1384 - /* 1385 1359 * Request sync osd read 1386 1360 */ 1387 1361 static int rbd_req_sync_exec(struct rbd_device *dev, ··· 1584 1610 goto out_dh; 1585 1611 1586 1612 rc = rbd_header_from_disk(header, dh, snap_count, GFP_KERNEL); 1587 - if (rc < 0) 1613 + if (rc < 0) { 1614 + if (rc == -ENXIO) { 1615 + pr_warning("unrecognized header format" 1616 + " for image %s", rbd_dev->obj); 1617 + } 1588 1618 goto out_dh; 1619 + } 1589 1620 1590 1621 if (snap_count != header->total_snaps) { 1591 1622 snap_count = header->total_snaps; ··· 1861 1882 static DEVICE_ATTR(refresh, S_IWUSR, NULL, rbd_image_refresh); 1862 1883 static DEVICE_ATTR(current_snap, S_IRUGO, rbd_snap_show, NULL); 1863 1884 static DEVICE_ATTR(create_snap, S_IWUSR, NULL, rbd_snap_add); 1864 - static DEVICE_ATTR(rollback_snap, S_IWUSR, NULL, rbd_snap_rollback); 1865 1885 1866 1886 static struct attribute *rbd_attrs[] = { 1867 1887 &dev_attr_size.attr, ··· 1871 1893 &dev_attr_current_snap.attr, 1872 1894 &dev_attr_refresh.attr, 1873 1895 &dev_attr_create_snap.attr, 1874 - &dev_attr_rollback_snap.attr, 1875 1896 NULL 1876 1897 }; 1877 1898 ··· 2398 2421 err_unlock: 2399 2422 mutex_unlock(&ctl_mutex); 2400 2423 kfree(name); 2401 - return ret; 2402 - } 2403 - 2404 - static ssize_t rbd_snap_rollback(struct device *dev, 2405 - struct device_attribute *attr, 2406 - const char *buf, 2407 - size_t count) 2408 - { 2409 - struct rbd_device *rbd_dev = dev_to_rbd(dev); 2410 - int ret; 2411 - u64 snapid; 2412 - u64 cur_ofs; 2413 - char *seg_name = NULL; 2414 - char *snap_name = kmalloc(count + 1, GFP_KERNEL); 2415 - ret = -ENOMEM; 2416 - if (!snap_name) 2417 - return ret; 2418 - 2419 - /* parse snaps add command */ 2420 - snprintf(snap_name, count, "%s", buf); 2421 - seg_name = kmalloc(RBD_MAX_SEG_NAME_LEN + 1, GFP_NOIO); 2422 - if (!seg_name) 2423 - goto done; 2424 - 2425 - mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING); 2426 - 2427 - ret = snap_by_name(&rbd_dev->header, snap_name, &snapid, NULL); 2428 - if (ret < 0) 2429 - goto done_unlock; 2430 - 2431 - dout("snapid=%lld\n", snapid); 2432 - 2433 - cur_ofs = 0; 2434 - while (cur_ofs < rbd_dev->header.image_size) { 2435 - cur_ofs += rbd_get_segment(&rbd_dev->header, 2436 - rbd_dev->obj, 2437 - cur_ofs, (u64)-1, 2438 - seg_name, NULL); 2439 - dout("seg_name=%s\n", seg_name); 2440 - 2441 - ret = rbd_req_sync_rollback_obj(rbd_dev, snapid, seg_name); 2442 - if (ret < 0) 2443 - pr_warning("could not roll back obj %s err=%d\n", 2444 - seg_name, ret); 2445 - } 2446 - 2447 - ret = __rbd_update_snaps(rbd_dev); 2448 - if (ret < 0) 2449 - goto done_unlock; 2450 - 2451 - ret = count; 2452 - 2453 - done_unlock: 2454 - mutex_unlock(&ctl_mutex); 2455 - done: 2456 - kfree(seg_name); 2457 - kfree(snap_name); 2458 - 2459 2424 return ret; 2460 2425 } 2461 2426

+4 -4

fs/ceph/addr.c

··· 87 87 snapc = ceph_get_snap_context(ci->i_snap_realm->cached_context); 88 88 89 89 /* dirty the head */ 90 - spin_lock(&inode->i_lock); 90 + spin_lock(&ci->i_ceph_lock); 91 91 if (ci->i_head_snapc == NULL) 92 92 ci->i_head_snapc = ceph_get_snap_context(snapc); 93 93 ++ci->i_wrbuffer_ref_head; ··· 100 100 ci->i_wrbuffer_ref-1, ci->i_wrbuffer_ref_head-1, 101 101 ci->i_wrbuffer_ref, ci->i_wrbuffer_ref_head, 102 102 snapc, snapc->seq, snapc->num_snaps); 103 - spin_unlock(&inode->i_lock); 103 + spin_unlock(&ci->i_ceph_lock); 104 104 105 105 /* now adjust page */ 106 106 spin_lock_irq(&mapping->tree_lock); ··· 391 391 struct ceph_snap_context *snapc = NULL; 392 392 struct ceph_cap_snap *capsnap = NULL; 393 393 394 - spin_lock(&inode->i_lock); 394 + spin_lock(&ci->i_ceph_lock); 395 395 list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) { 396 396 dout(" cap_snap %p snapc %p has %d dirty pages\n", capsnap, 397 397 capsnap->context, capsnap->dirty_pages); ··· 407 407 dout(" head snapc %p has %d dirty pages\n", 408 408 snapc, ci->i_wrbuffer_ref_head); 409 409 } 410 - spin_unlock(&inode->i_lock); 410 + spin_unlock(&ci->i_ceph_lock); 411 411 return snapc; 412 412 } 413 413

+94 -93

fs/ceph/caps.c

··· 309 309 /* 310 310 * Find ceph_cap for given mds, if any. 311 311 * 312 - * Called with i_lock held. 312 + * Called with i_ceph_lock held. 313 313 */ 314 314 static struct ceph_cap *__get_cap_for_mds(struct ceph_inode_info *ci, int mds) 315 315 { ··· 332 332 { 333 333 struct ceph_cap *cap; 334 334 335 - spin_lock(&ci->vfs_inode.i_lock); 335 + spin_lock(&ci->i_ceph_lock); 336 336 cap = __get_cap_for_mds(ci, mds); 337 - spin_unlock(&ci->vfs_inode.i_lock); 337 + spin_unlock(&ci->i_ceph_lock); 338 338 return cap; 339 339 } 340 340 ··· 361 361 362 362 int ceph_get_cap_mds(struct inode *inode) 363 363 { 364 + struct ceph_inode_info *ci = ceph_inode(inode); 364 365 int mds; 365 - spin_lock(&inode->i_lock); 366 + spin_lock(&ci->i_ceph_lock); 366 367 mds = __ceph_get_cap_mds(ceph_inode(inode)); 367 - spin_unlock(&inode->i_lock); 368 + spin_unlock(&ci->i_ceph_lock); 368 369 return mds; 369 370 } 370 371 371 372 /* 372 - * Called under i_lock. 373 + * Called under i_ceph_lock. 373 374 */ 374 375 static void __insert_cap_node(struct ceph_inode_info *ci, 375 376 struct ceph_cap *new) ··· 416 415 * 417 416 * If I_FLUSH is set, leave the inode at the front of the list. 418 417 * 419 - * Caller holds i_lock 418 + * Caller holds i_ceph_lock 420 419 * -> we take mdsc->cap_delay_lock 421 420 */ 422 421 static void __cap_delay_requeue(struct ceph_mds_client *mdsc, ··· 458 457 /* 459 458 * Cancel delayed work on cap. 460 459 * 461 - * Caller must hold i_lock. 460 + * Caller must hold i_ceph_lock. 462 461 */ 463 462 static void __cap_delay_cancel(struct ceph_mds_client *mdsc, 464 463 struct ceph_inode_info *ci) ··· 533 532 wanted |= ceph_caps_for_mode(fmode); 534 533 535 534 retry: 536 - spin_lock(&inode->i_lock); 535 + spin_lock(&ci->i_ceph_lock); 537 536 cap = __get_cap_for_mds(ci, mds); 538 537 if (!cap) { 539 538 if (new_cap) { 540 539 cap = new_cap; 541 540 new_cap = NULL; 542 541 } else { 543 - spin_unlock(&inode->i_lock); 542 + spin_unlock(&ci->i_ceph_lock); 544 543 new_cap = get_cap(mdsc, caps_reservation); 545 544 if (new_cap == NULL) 546 545 return -ENOMEM; ··· 626 625 627 626 if (fmode >= 0) 628 627 __ceph_get_fmode(ci, fmode); 629 - spin_unlock(&inode->i_lock); 628 + spin_unlock(&ci->i_ceph_lock); 630 629 wake_up_all(&ci->i_cap_wq); 631 630 return 0; 632 631 } ··· 793 792 struct rb_node *p; 794 793 int ret = 0; 795 794 796 - spin_lock(&inode->i_lock); 795 + spin_lock(&ci->i_ceph_lock); 797 796 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) { 798 797 cap = rb_entry(p, struct ceph_cap, ci_node); 799 798 if (__cap_is_valid(cap) && ··· 802 801 break; 803 802 } 804 803 } 805 - spin_unlock(&inode->i_lock); 804 + spin_unlock(&ci->i_ceph_lock); 806 805 dout("ceph_caps_revoking %p %s = %d\n", inode, 807 806 ceph_cap_string(mask), ret); 808 807 return ret; ··· 856 855 } 857 856 858 857 /* 859 - * called under i_lock 858 + * called under i_ceph_lock 860 859 */ 861 860 static int __ceph_is_any_caps(struct ceph_inode_info *ci) 862 861 { ··· 866 865 /* 867 866 * Remove a cap. Take steps to deal with a racing iterate_session_caps. 868 867 * 869 - * caller should hold i_lock. 868 + * caller should hold i_ceph_lock. 870 869 * caller will not hold session s_mutex if called from destroy_inode. 871 870 */ 872 871 void __ceph_remove_cap(struct ceph_cap *cap) ··· 1029 1028 1030 1029 /* 1031 1030 * Queue cap releases when an inode is dropped from our cache. Since 1032 - * inode is about to be destroyed, there is no need for i_lock. 1031 + * inode is about to be destroyed, there is no need for i_ceph_lock. 1033 1032 */ 1034 1033 void ceph_queue_caps_release(struct inode *inode) 1035 1034 { ··· 1050 1049 1051 1050 /* 1052 1051 * Send a cap msg on the given inode. Update our caps state, then 1053 - * drop i_lock and send the message. 1052 + * drop i_ceph_lock and send the message. 1054 1053 * 1055 1054 * Make note of max_size reported/requested from mds, revoked caps 1056 1055 * that have now been implemented. ··· 1062 1061 * Return non-zero if delayed release, or we experienced an error 1063 1062 * such that the caller should requeue + retry later. 1064 1063 * 1065 - * called with i_lock, then drops it. 1064 + * called with i_ceph_lock, then drops it. 1066 1065 * caller should hold snap_rwsem (read), s_mutex. 1067 1066 */ 1068 1067 static int __send_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap, 1069 1068 int op, int used, int want, int retain, int flushing, 1070 1069 unsigned *pflush_tid) 1071 - __releases(cap->ci->vfs_inode->i_lock) 1070 + __releases(cap->ci->i_ceph_lock) 1072 1071 { 1073 1072 struct ceph_inode_info *ci = cap->ci; 1074 1073 struct inode *inode = &ci->vfs_inode; ··· 1171 1170 xattr_version = ci->i_xattrs.version; 1172 1171 } 1173 1172 1174 - spin_unlock(&inode->i_lock); 1173 + spin_unlock(&ci->i_ceph_lock); 1175 1174 1176 1175 ret = send_cap_msg(session, ceph_vino(inode).ino, cap_id, 1177 1176 op, keep, want, flushing, seq, flush_tid, issue_seq, mseq, ··· 1199 1198 * Unless @again is true, skip cap_snaps that were already sent to 1200 1199 * the MDS (i.e., during this session). 1201 1200 * 1202 - * Called under i_lock. Takes s_mutex as needed. 1201 + * Called under i_ceph_lock. Takes s_mutex as needed. 1203 1202 */ 1204 1203 void __ceph_flush_snaps(struct ceph_inode_info *ci, 1205 1204 struct ceph_mds_session **psession, 1206 1205 int again) 1207 - __releases(ci->vfs_inode->i_lock) 1208 - __acquires(ci->vfs_inode->i_lock) 1206 + __releases(ci->i_ceph_lock) 1207 + __acquires(ci->i_ceph_lock) 1209 1208 { 1210 1209 struct inode *inode = &ci->vfs_inode; 1211 1210 int mds; ··· 1262 1261 session = NULL; 1263 1262 } 1264 1263 if (!session) { 1265 - spin_unlock(&inode->i_lock); 1264 + spin_unlock(&ci->i_ceph_lock); 1266 1265 mutex_lock(&mdsc->mutex); 1267 1266 session = __ceph_lookup_mds_session(mdsc, mds); 1268 1267 mutex_unlock(&mdsc->mutex); ··· 1276 1275 * deletion or migration. retry, and we'll 1277 1276 * get a better @mds value next time. 1278 1277 */ 1279 - spin_lock(&inode->i_lock); 1278 + spin_lock(&ci->i_ceph_lock); 1280 1279 goto retry; 1281 1280 } 1282 1281 ··· 1286 1285 list_del_init(&capsnap->flushing_item); 1287 1286 list_add_tail(&capsnap->flushing_item, 1288 1287 &session->s_cap_snaps_flushing); 1289 - spin_unlock(&inode->i_lock); 1288 + spin_unlock(&ci->i_ceph_lock); 1290 1289 1291 1290 dout("flush_snaps %p cap_snap %p follows %lld tid %llu\n", 1292 1291 inode, capsnap, capsnap->follows, capsnap->flush_tid); ··· 1303 1302 next_follows = capsnap->follows + 1; 1304 1303 ceph_put_cap_snap(capsnap); 1305 1304 1306 - spin_lock(&inode->i_lock); 1305 + spin_lock(&ci->i_ceph_lock); 1307 1306 goto retry; 1308 1307 } 1309 1308 ··· 1323 1322 1324 1323 static void ceph_flush_snaps(struct ceph_inode_info *ci) 1325 1324 { 1326 - struct inode *inode = &ci->vfs_inode; 1327 - 1328 - spin_lock(&inode->i_lock); 1325 + spin_lock(&ci->i_ceph_lock); 1329 1326 __ceph_flush_snaps(ci, NULL, 0); 1330 - spin_unlock(&inode->i_lock); 1327 + spin_unlock(&ci->i_ceph_lock); 1331 1328 } 1332 1329 1333 1330 /* ··· 1372 1373 * Add dirty inode to the flushing list. Assigned a seq number so we 1373 1374 * can wait for caps to flush without starving. 1374 1375 * 1375 - * Called under i_lock. 1376 + * Called under i_ceph_lock. 1376 1377 */ 1377 1378 static int __mark_caps_flushing(struct inode *inode, 1378 1379 struct ceph_mds_session *session) ··· 1420 1421 struct ceph_inode_info *ci = ceph_inode(inode); 1421 1422 u32 invalidating_gen = ci->i_rdcache_gen; 1422 1423 1423 - spin_unlock(&inode->i_lock); 1424 + spin_unlock(&ci->i_ceph_lock); 1424 1425 invalidate_mapping_pages(&inode->i_data, 0, -1); 1425 - spin_lock(&inode->i_lock); 1426 + spin_lock(&ci->i_ceph_lock); 1426 1427 1427 1428 if (inode->i_data.nrpages == 0 && 1428 1429 invalidating_gen == ci->i_rdcache_gen) { ··· 1469 1470 if (mdsc->stopping) 1470 1471 is_delayed = 1; 1471 1472 1472 - spin_lock(&inode->i_lock); 1473 + spin_lock(&ci->i_ceph_lock); 1473 1474 1474 1475 if (ci->i_ceph_flags & CEPH_I_FLUSH) 1475 1476 flags |= CHECK_CAPS_FLUSH; ··· 1479 1480 __ceph_flush_snaps(ci, &session, 0); 1480 1481 goto retry_locked; 1481 1482 retry: 1482 - spin_lock(&inode->i_lock); 1483 + spin_lock(&ci->i_ceph_lock); 1483 1484 retry_locked: 1484 1485 file_wanted = __ceph_caps_file_wanted(ci); 1485 1486 used = __ceph_caps_used(ci); ··· 1633 1634 if (mutex_trylock(&session->s_mutex) == 0) { 1634 1635 dout("inverting session/ino locks on %p\n", 1635 1636 session); 1636 - spin_unlock(&inode->i_lock); 1637 + spin_unlock(&ci->i_ceph_lock); 1637 1638 if (took_snap_rwsem) { 1638 1639 up_read(&mdsc->snap_rwsem); 1639 1640 took_snap_rwsem = 0; ··· 1647 1648 if (down_read_trylock(&mdsc->snap_rwsem) == 0) { 1648 1649 dout("inverting snap/in locks on %p\n", 1649 1650 inode); 1650 - spin_unlock(&inode->i_lock); 1651 + spin_unlock(&ci->i_ceph_lock); 1651 1652 down_read(&mdsc->snap_rwsem); 1652 1653 took_snap_rwsem = 1; 1653 1654 goto retry; ··· 1663 1664 mds = cap->mds; /* remember mds, so we don't repeat */ 1664 1665 sent++; 1665 1666 1666 - /* __send_cap drops i_lock */ 1667 + /* __send_cap drops i_ceph_lock */ 1667 1668 delayed += __send_cap(mdsc, cap, CEPH_CAP_OP_UPDATE, used, want, 1668 1669 retain, flushing, NULL); 1669 - goto retry; /* retake i_lock and restart our cap scan. */ 1670 + goto retry; /* retake i_ceph_lock and restart our cap scan. */ 1670 1671 } 1671 1672 1672 1673 /* ··· 1680 1681 else if (!is_delayed || force_requeue) 1681 1682 __cap_delay_requeue(mdsc, ci); 1682 1683 1683 - spin_unlock(&inode->i_lock); 1684 + spin_unlock(&ci->i_ceph_lock); 1684 1685 1685 1686 if (queue_invalidate) 1686 1687 ceph_queue_invalidate(inode); ··· 1703 1704 int flushing = 0; 1704 1705 1705 1706 retry: 1706 - spin_lock(&inode->i_lock); 1707 + spin_lock(&ci->i_ceph_lock); 1707 1708 if (ci->i_ceph_flags & CEPH_I_NOFLUSH) { 1708 1709 dout("try_flush_caps skipping %p I_NOFLUSH set\n", inode); 1709 1710 goto out; ··· 1715 1716 int delayed; 1716 1717 1717 1718 if (!session) { 1718 - spin_unlock(&inode->i_lock); 1719 + spin_unlock(&ci->i_ceph_lock); 1719 1720 session = cap->session; 1720 1721 mutex_lock(&session->s_mutex); 1721 1722 goto retry; ··· 1726 1727 1727 1728 flushing = __mark_caps_flushing(inode, session); 1728 1729 1729 - /* __send_cap drops i_lock */ 1730 + /* __send_cap drops i_ceph_lock */ 1730 1731 delayed = __send_cap(mdsc, cap, CEPH_CAP_OP_FLUSH, used, want, 1731 1732 cap->issued | cap->implemented, flushing, 1732 1733 flush_tid); 1733 1734 if (!delayed) 1734 1735 goto out_unlocked; 1735 1736 1736 - spin_lock(&inode->i_lock); 1737 + spin_lock(&ci->i_ceph_lock); 1737 1738 __cap_delay_requeue(mdsc, ci); 1738 1739 } 1739 1740 out: 1740 - spin_unlock(&inode->i_lock); 1741 + spin_unlock(&ci->i_ceph_lock); 1741 1742 out_unlocked: 1742 1743 if (session && unlock_session) 1743 1744 mutex_unlock(&session->s_mutex); ··· 1752 1753 struct ceph_inode_info *ci = ceph_inode(inode); 1753 1754 int i, ret = 1; 1754 1755 1755 - spin_lock(&inode->i_lock); 1756 + spin_lock(&ci->i_ceph_lock); 1756 1757 for (i = 0; i < CEPH_CAP_BITS; i++) 1757 1758 if ((ci->i_flushing_caps & (1 << i)) && 1758 1759 ci->i_cap_flush_tid[i] <= tid) { ··· 1760 1761 ret = 0; 1761 1762 break; 1762 1763 } 1763 - spin_unlock(&inode->i_lock); 1764 + spin_unlock(&ci->i_ceph_lock); 1764 1765 return ret; 1765 1766 } 1766 1767 ··· 1867 1868 struct ceph_mds_client *mdsc = 1868 1869 ceph_sb_to_client(inode->i_sb)->mdsc; 1869 1870 1870 - spin_lock(&inode->i_lock); 1871 + spin_lock(&ci->i_ceph_lock); 1871 1872 if (__ceph_caps_dirty(ci)) 1872 1873 __cap_delay_requeue_front(mdsc, ci); 1873 - spin_unlock(&inode->i_lock); 1874 + spin_unlock(&ci->i_ceph_lock); 1874 1875 } 1875 1876 return err; 1876 1877 } ··· 1893 1894 struct inode *inode = &ci->vfs_inode; 1894 1895 struct ceph_cap *cap; 1895 1896 1896 - spin_lock(&inode->i_lock); 1897 + spin_lock(&ci->i_ceph_lock); 1897 1898 cap = ci->i_auth_cap; 1898 1899 if (cap && cap->session == session) { 1899 1900 dout("kick_flushing_caps %p cap %p capsnap %p\n", inode, ··· 1903 1904 pr_err("%p auth cap %p not mds%d ???\n", inode, 1904 1905 cap, session->s_mds); 1905 1906 } 1906 - spin_unlock(&inode->i_lock); 1907 + spin_unlock(&ci->i_ceph_lock); 1907 1908 } 1908 1909 } 1909 1910 ··· 1920 1921 struct ceph_cap *cap; 1921 1922 int delayed = 0; 1922 1923 1923 - spin_lock(&inode->i_lock); 1924 + spin_lock(&ci->i_ceph_lock); 1924 1925 cap = ci->i_auth_cap; 1925 1926 if (cap && cap->session == session) { 1926 1927 dout("kick_flushing_caps %p cap %p %s\n", inode, ··· 1931 1932 cap->issued | cap->implemented, 1932 1933 ci->i_flushing_caps, NULL); 1933 1934 if (delayed) { 1934 - spin_lock(&inode->i_lock); 1935 + spin_lock(&ci->i_ceph_lock); 1935 1936 __cap_delay_requeue(mdsc, ci); 1936 - spin_unlock(&inode->i_lock); 1937 + spin_unlock(&ci->i_ceph_lock); 1937 1938 } 1938 1939 } else { 1939 1940 pr_err("%p auth cap %p not mds%d ???\n", inode, 1940 1941 cap, session->s_mds); 1941 - spin_unlock(&inode->i_lock); 1942 + spin_unlock(&ci->i_ceph_lock); 1942 1943 } 1943 1944 } 1944 1945 } ··· 1951 1952 struct ceph_cap *cap; 1952 1953 int delayed = 0; 1953 1954 1954 - spin_lock(&inode->i_lock); 1955 + spin_lock(&ci->i_ceph_lock); 1955 1956 cap = ci->i_auth_cap; 1956 1957 dout("kick_flushing_inode_caps %p flushing %s flush_seq %lld\n", inode, 1957 1958 ceph_cap_string(ci->i_flushing_caps), ci->i_cap_flush_seq); ··· 1963 1964 cap->issued | cap->implemented, 1964 1965 ci->i_flushing_caps, NULL); 1965 1966 if (delayed) { 1966 - spin_lock(&inode->i_lock); 1967 + spin_lock(&ci->i_ceph_lock); 1967 1968 __cap_delay_requeue(mdsc, ci); 1968 - spin_unlock(&inode->i_lock); 1969 + spin_unlock(&ci->i_ceph_lock); 1969 1970 } 1970 1971 } else { 1971 - spin_unlock(&inode->i_lock); 1972 + spin_unlock(&ci->i_ceph_lock); 1972 1973 } 1973 1974 } 1974 1975 ··· 1977 1978 * Take references to capabilities we hold, so that we don't release 1978 1979 * them to the MDS prematurely. 1979 1980 * 1980 - * Protected by i_lock. 1981 + * Protected by i_ceph_lock. 1981 1982 */ 1982 1983 static void __take_cap_refs(struct ceph_inode_info *ci, int got) 1983 1984 { ··· 2015 2016 2016 2017 dout("get_cap_refs %p need %s want %s\n", inode, 2017 2018 ceph_cap_string(need), ceph_cap_string(want)); 2018 - spin_lock(&inode->i_lock); 2019 + spin_lock(&ci->i_ceph_lock); 2019 2020 2020 2021 /* make sure file is actually open */ 2021 2022 file_wanted = __ceph_caps_file_wanted(ci); ··· 2076 2077 ceph_cap_string(have), ceph_cap_string(need)); 2077 2078 } 2078 2079 out: 2079 - spin_unlock(&inode->i_lock); 2080 + spin_unlock(&ci->i_ceph_lock); 2080 2081 dout("get_cap_refs %p ret %d got %s\n", inode, 2081 2082 ret, ceph_cap_string(*got)); 2082 2083 return ret; ··· 2093 2094 int check = 0; 2094 2095 2095 2096 /* do we need to explicitly request a larger max_size? */ 2096 - spin_lock(&inode->i_lock); 2097 + spin_lock(&ci->i_ceph_lock); 2097 2098 if ((endoff >= ci->i_max_size || 2098 2099 endoff > (inode->i_size << 1)) && 2099 2100 endoff > ci->i_wanted_max_size) { ··· 2102 2103 ci->i_wanted_max_size = endoff; 2103 2104 check = 1; 2104 2105 } 2105 - spin_unlock(&inode->i_lock); 2106 + spin_unlock(&ci->i_ceph_lock); 2106 2107 if (check) 2107 2108 ceph_check_caps(ci, CHECK_CAPS_AUTHONLY, NULL); 2108 2109 } ··· 2139 2140 */ 2140 2141 void ceph_get_cap_refs(struct ceph_inode_info *ci, int caps) 2141 2142 { 2142 - spin_lock(&ci->vfs_inode.i_lock); 2143 + spin_lock(&ci->i_ceph_lock); 2143 2144 __take_cap_refs(ci, caps); 2144 - spin_unlock(&ci->vfs_inode.i_lock); 2145 + spin_unlock(&ci->i_ceph_lock); 2145 2146 } 2146 2147 2147 2148 /* ··· 2159 2160 int last = 0, put = 0, flushsnaps = 0, wake = 0; 2160 2161 struct ceph_cap_snap *capsnap; 2161 2162 2162 - spin_lock(&inode->i_lock); 2163 + spin_lock(&ci->i_ceph_lock); 2163 2164 if (had & CEPH_CAP_PIN) 2164 2165 --ci->i_pin_ref; 2165 2166 if (had & CEPH_CAP_FILE_RD) ··· 2192 2193 } 2193 2194 } 2194 2195 } 2195 - spin_unlock(&inode->i_lock); 2196 + spin_unlock(&ci->i_ceph_lock); 2196 2197 2197 2198 dout("put_cap_refs %p had %s%s%s\n", inode, ceph_cap_string(had), 2198 2199 last ? " last" : "", put ? " put" : ""); ··· 2224 2225 int found = 0; 2225 2226 struct ceph_cap_snap *capsnap = NULL; 2226 2227 2227 - spin_lock(&inode->i_lock); 2228 + spin_lock(&ci->i_ceph_lock); 2228 2229 ci->i_wrbuffer_ref -= nr; 2229 2230 last = !ci->i_wrbuffer_ref; 2230 2231 ··· 2273 2274 } 2274 2275 } 2275 2276 2276 - spin_unlock(&inode->i_lock); 2277 + spin_unlock(&ci->i_ceph_lock); 2277 2278 2278 2279 if (last) { 2279 2280 ceph_check_caps(ci, CHECK_CAPS_AUTHONLY, NULL); ··· 2290 2291 * Handle a cap GRANT message from the MDS. (Note that a GRANT may 2291 2292 * actually be a revocation if it specifies a smaller cap set.) 2292 2293 * 2293 - * caller holds s_mutex and i_lock, we drop both. 2294 + * caller holds s_mutex and i_ceph_lock, we drop both. 2294 2295 * 2295 2296 * return value: 2296 2297 * 0 - ok ··· 2301 2302 struct ceph_mds_session *session, 2302 2303 struct ceph_cap *cap, 2303 2304 struct ceph_buffer *xattr_buf) 2304 - __releases(inode->i_lock) 2305 + __releases(ci->i_ceph_lock) 2305 2306 { 2306 2307 struct ceph_inode_info *ci = ceph_inode(inode); 2307 2308 int mds = session->s_mds; ··· 2452 2453 } 2453 2454 BUG_ON(cap->issued & ~cap->implemented); 2454 2455 2455 - spin_unlock(&inode->i_lock); 2456 + spin_unlock(&ci->i_ceph_lock); 2456 2457 if (writeback) 2457 2458 /* 2458 2459 * queue inode for writeback: we can't actually call ··· 2482 2483 struct ceph_mds_caps *m, 2483 2484 struct ceph_mds_session *session, 2484 2485 struct ceph_cap *cap) 2485 - __releases(inode->i_lock) 2486 + __releases(ci->i_ceph_lock) 2486 2487 { 2487 2488 struct ceph_inode_info *ci = ceph_inode(inode); 2488 2489 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc; ··· 2538 2539 wake_up_all(&ci->i_cap_wq); 2539 2540 2540 2541 out: 2541 - spin_unlock(&inode->i_lock); 2542 + spin_unlock(&ci->i_ceph_lock); 2542 2543 if (drop) 2543 2544 iput(inode); 2544 2545 } ··· 2561 2562 dout("handle_cap_flushsnap_ack inode %p ci %p mds%d follows %lld\n", 2562 2563 inode, ci, session->s_mds, follows); 2563 2564 2564 - spin_lock(&inode->i_lock); 2565 + spin_lock(&ci->i_ceph_lock); 2565 2566 list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) { 2566 2567 if (capsnap->follows == follows) { 2567 2568 if (capsnap->flush_tid != flush_tid) { ··· 2584 2585 capsnap, capsnap->follows); 2585 2586 } 2586 2587 } 2587 - spin_unlock(&inode->i_lock); 2588 + spin_unlock(&ci->i_ceph_lock); 2588 2589 if (drop) 2589 2590 iput(inode); 2590 2591 } ··· 2597 2598 static void handle_cap_trunc(struct inode *inode, 2598 2599 struct ceph_mds_caps *trunc, 2599 2600 struct ceph_mds_session *session) 2600 - __releases(inode->i_lock) 2601 + __releases(ci->i_ceph_lock) 2601 2602 { 2602 2603 struct ceph_inode_info *ci = ceph_inode(inode); 2603 2604 int mds = session->s_mds; ··· 2616 2617 inode, mds, seq, truncate_size, truncate_seq); 2617 2618 queue_trunc = ceph_fill_file_size(inode, issued, 2618 2619 truncate_seq, truncate_size, size); 2619 - spin_unlock(&inode->i_lock); 2620 + spin_unlock(&ci->i_ceph_lock); 2620 2621 2621 2622 if (queue_trunc) 2622 2623 ceph_queue_vmtruncate(inode); ··· 2645 2646 dout("handle_cap_export inode %p ci %p mds%d mseq %d\n", 2646 2647 inode, ci, mds, mseq); 2647 2648 2648 - spin_lock(&inode->i_lock); 2649 + spin_lock(&ci->i_ceph_lock); 2649 2650 2650 2651 /* make sure we haven't seen a higher mseq */ 2651 2652 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) { ··· 2689 2690 } 2690 2691 /* else, we already released it */ 2691 2692 2692 - spin_unlock(&inode->i_lock); 2693 + spin_unlock(&ci->i_ceph_lock); 2693 2694 } 2694 2695 2695 2696 /* ··· 2744 2745 up_read(&mdsc->snap_rwsem); 2745 2746 2746 2747 /* make sure we re-request max_size, if necessary */ 2747 - spin_lock(&inode->i_lock); 2748 + spin_lock(&ci->i_ceph_lock); 2748 2749 ci->i_requested_max_size = 0; 2749 - spin_unlock(&inode->i_lock); 2750 + spin_unlock(&ci->i_ceph_lock); 2750 2751 } 2751 2752 2752 2753 /* ··· 2761 2762 struct ceph_mds_client *mdsc = session->s_mdsc; 2762 2763 struct super_block *sb = mdsc->fsc->sb; 2763 2764 struct inode *inode; 2765 + struct ceph_inode_info *ci; 2764 2766 struct ceph_cap *cap; 2765 2767 struct ceph_mds_caps *h; 2766 2768 int mds = session->s_mds; ··· 2815 2815 2816 2816 /* lookup ino */ 2817 2817 inode = ceph_find_inode(sb, vino); 2818 + ci = ceph_inode(inode); 2818 2819 dout(" op %s ino %llx.%llx inode %p\n", ceph_cap_op_name(op), vino.ino, 2819 2820 vino.snap, inode); 2820 2821 if (!inode) { ··· 2845 2844 } 2846 2845 2847 2846 /* the rest require a cap */ 2848 - spin_lock(&inode->i_lock); 2847 + spin_lock(&ci->i_ceph_lock); 2849 2848 cap = __get_cap_for_mds(ceph_inode(inode), mds); 2850 2849 if (!cap) { 2851 2850 dout(" no cap on %p ino %llx.%llx from mds%d\n", 2852 2851 inode, ceph_ino(inode), ceph_snap(inode), mds); 2853 - spin_unlock(&inode->i_lock); 2852 + spin_unlock(&ci->i_ceph_lock); 2854 2853 goto flush_cap_releases; 2855 2854 } 2856 2855 2857 - /* note that each of these drops i_lock for us */ 2856 + /* note that each of these drops i_ceph_lock for us */ 2858 2857 switch (op) { 2859 2858 case CEPH_CAP_OP_REVOKE: 2860 2859 case CEPH_CAP_OP_GRANT: ··· 2870 2869 break; 2871 2870 2872 2871 default: 2873 - spin_unlock(&inode->i_lock); 2872 + spin_unlock(&ci->i_ceph_lock); 2874 2873 pr_err("ceph_handle_caps: unknown cap op %d %s\n", op, 2875 2874 ceph_cap_op_name(op)); 2876 2875 } ··· 2963 2962 struct inode *inode = &ci->vfs_inode; 2964 2963 int last = 0; 2965 2964 2966 - spin_lock(&inode->i_lock); 2965 + spin_lock(&ci->i_ceph_lock); 2967 2966 dout("put_fmode %p fmode %d %d -> %d\n", inode, fmode, 2968 2967 ci->i_nr_by_mode[fmode], ci->i_nr_by_mode[fmode]-1); 2969 2968 BUG_ON(ci->i_nr_by_mode[fmode] == 0); 2970 2969 if (--ci->i_nr_by_mode[fmode] == 0) 2971 2970 last++; 2972 - spin_unlock(&inode->i_lock); 2971 + spin_unlock(&ci->i_ceph_lock); 2973 2972 2974 2973 if (last && ci->i_vino.snap == CEPH_NOSNAP) 2975 2974 ceph_check_caps(ci, 0, NULL); ··· 2992 2991 int used, dirty; 2993 2992 int ret = 0; 2994 2993 2995 - spin_lock(&inode->i_lock); 2994 + spin_lock(&ci->i_ceph_lock); 2996 2995 used = __ceph_caps_used(ci); 2997 2996 dirty = __ceph_caps_dirty(ci); 2998 2997 ··· 3047 3046 inode, cap, ceph_cap_string(cap->issued)); 3048 3047 } 3049 3048 } 3050 - spin_unlock(&inode->i_lock); 3049 + spin_unlock(&ci->i_ceph_lock); 3051 3050 return ret; 3052 3051 } 3053 3052 ··· 3062 3061 3063 3062 /* 3064 3063 * force an record for the directory caps if we have a dentry lease. 3065 - * this is racy (can't take i_lock and d_lock together), but it 3064 + * this is racy (can't take i_ceph_lock and d_lock together), but it 3066 3065 * doesn't have to be perfect; the mds will revoke anything we don't 3067 3066 * release. 3068 3067 */

+12 -12

fs/ceph/dir.c

··· 281 281 } 282 282 283 283 /* can we use the dcache? */ 284 - spin_lock(&inode->i_lock); 284 + spin_lock(&ci->i_ceph_lock); 285 285 if ((filp->f_pos == 2 || fi->dentry) && 286 286 !ceph_test_mount_opt(fsc, NOASYNCREADDIR) && 287 287 ceph_snap(inode) != CEPH_SNAPDIR && 288 288 ceph_dir_test_complete(inode) && 289 289 __ceph_caps_issued_mask(ci, CEPH_CAP_FILE_SHARED, 1)) { 290 - spin_unlock(&inode->i_lock); 290 + spin_unlock(&ci->i_ceph_lock); 291 291 err = __dcache_readdir(filp, dirent, filldir); 292 292 if (err != -EAGAIN) 293 293 return err; 294 294 } else { 295 - spin_unlock(&inode->i_lock); 295 + spin_unlock(&ci->i_ceph_lock); 296 296 } 297 297 if (fi->dentry) { 298 298 err = note_last_dentry(fi, fi->dentry->d_name.name, ··· 428 428 * were released during the whole readdir, and we should have 429 429 * the complete dir contents in our cache. 430 430 */ 431 - spin_lock(&inode->i_lock); 431 + spin_lock(&ci->i_ceph_lock); 432 432 if (ci->i_release_count == fi->dir_release_count) { 433 433 ceph_dir_set_complete(inode); 434 434 ci->i_max_offset = filp->f_pos; 435 435 } 436 - spin_unlock(&inode->i_lock); 436 + spin_unlock(&ci->i_ceph_lock); 437 437 438 438 dout("readdir %p filp %p done.\n", inode, filp); 439 439 return 0; ··· 607 607 struct ceph_inode_info *ci = ceph_inode(dir); 608 608 struct ceph_dentry_info *di = ceph_dentry(dentry); 609 609 610 - spin_lock(&dir->i_lock); 610 + spin_lock(&ci->i_ceph_lock); 611 611 dout(" dir %p flags are %d\n", dir, ci->i_ceph_flags); 612 612 if (strncmp(dentry->d_name.name, 613 613 fsc->mount_options->snapdir_name, ··· 615 615 !is_root_ceph_dentry(dir, dentry) && 616 616 ceph_dir_test_complete(dir) && 617 617 (__ceph_caps_issued_mask(ci, CEPH_CAP_FILE_SHARED, 1))) { 618 - spin_unlock(&dir->i_lock); 618 + spin_unlock(&ci->i_ceph_lock); 619 619 dout(" dir %p complete, -ENOENT\n", dir); 620 620 d_add(dentry, NULL); 621 621 di->lease_shared_gen = ci->i_shared_gen; 622 622 return NULL; 623 623 } 624 - spin_unlock(&dir->i_lock); 624 + spin_unlock(&ci->i_ceph_lock); 625 625 } 626 626 627 627 op = ceph_snap(dir) == CEPH_SNAPDIR ? ··· 841 841 struct ceph_inode_info *ci = ceph_inode(inode); 842 842 int drop = CEPH_CAP_LINK_SHARED | CEPH_CAP_LINK_EXCL; 843 843 844 - spin_lock(&inode->i_lock); 844 + spin_lock(&ci->i_ceph_lock); 845 845 if (inode->i_nlink == 1) { 846 846 drop |= ~(__ceph_caps_wanted(ci) | CEPH_CAP_PIN); 847 847 ci->i_ceph_flags |= CEPH_I_NODELAY; 848 848 } 849 - spin_unlock(&inode->i_lock); 849 + spin_unlock(&ci->i_ceph_lock); 850 850 return drop; 851 851 } 852 852 ··· 1015 1015 struct ceph_dentry_info *di = ceph_dentry(dentry); 1016 1016 int valid = 0; 1017 1017 1018 - spin_lock(&dir->i_lock); 1018 + spin_lock(&ci->i_ceph_lock); 1019 1019 if (ci->i_shared_gen == di->lease_shared_gen) 1020 1020 valid = __ceph_caps_issued_mask(ci, CEPH_CAP_FILE_SHARED, 1); 1021 - spin_unlock(&dir->i_lock); 1021 + spin_unlock(&ci->i_ceph_lock); 1022 1022 dout("dir_lease_is_valid dir %p v%u dentry %p v%u = %d\n", 1023 1023 dir, (unsigned)ci->i_shared_gen, dentry, 1024 1024 (unsigned)di->lease_shared_gen, valid);

+12 -11

fs/ceph/file.c

··· 147 147 148 148 /* trivially open snapdir */ 149 149 if (ceph_snap(inode) == CEPH_SNAPDIR) { 150 - spin_lock(&inode->i_lock); 150 + spin_lock(&ci->i_ceph_lock); 151 151 __ceph_get_fmode(ci, fmode); 152 - spin_unlock(&inode->i_lock); 152 + spin_unlock(&ci->i_ceph_lock); 153 153 return ceph_init_file(inode, file, fmode); 154 154 } 155 155 ··· 158 158 * write) or any MDS (for read). Update wanted set 159 159 * asynchronously. 160 160 */ 161 - spin_lock(&inode->i_lock); 161 + spin_lock(&ci->i_ceph_lock); 162 162 if (__ceph_is_any_real_caps(ci) && 163 163 (((fmode & CEPH_FILE_MODE_WR) == 0) || ci->i_auth_cap)) { 164 164 int mds_wanted = __ceph_caps_mds_wanted(ci); ··· 168 168 inode, fmode, ceph_cap_string(wanted), 169 169 ceph_cap_string(issued)); 170 170 __ceph_get_fmode(ci, fmode); 171 - spin_unlock(&inode->i_lock); 171 + spin_unlock(&ci->i_ceph_lock); 172 172 173 173 /* adjust wanted? */ 174 174 if ((issued & wanted) != wanted && ··· 180 180 } else if (ceph_snap(inode) != CEPH_NOSNAP && 181 181 (ci->i_snap_caps & wanted) == wanted) { 182 182 __ceph_get_fmode(ci, fmode); 183 - spin_unlock(&inode->i_lock); 183 + spin_unlock(&ci->i_ceph_lock); 184 184 return ceph_init_file(inode, file, fmode); 185 185 } 186 - spin_unlock(&inode->i_lock); 186 + spin_unlock(&ci->i_ceph_lock); 187 187 188 188 dout("open fmode %d wants %s\n", fmode, ceph_cap_string(wanted)); 189 189 req = prepare_open_request(inode->i_sb, flags, 0); ··· 743 743 */ 744 744 int dirty; 745 745 746 - spin_lock(&inode->i_lock); 746 + spin_lock(&ci->i_ceph_lock); 747 747 dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_FILE_WR); 748 - spin_unlock(&inode->i_lock); 748 + spin_unlock(&ci->i_ceph_lock); 749 749 ceph_put_cap_refs(ci, got); 750 750 751 751 ret = generic_file_aio_write(iocb, iov, nr_segs, pos); ··· 764 764 765 765 if (ret >= 0) { 766 766 int dirty; 767 - spin_lock(&inode->i_lock); 767 + spin_lock(&ci->i_ceph_lock); 768 768 dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_FILE_WR); 769 - spin_unlock(&inode->i_lock); 769 + spin_unlock(&ci->i_ceph_lock); 770 770 if (dirty) 771 771 __mark_inode_dirty(inode, dirty); 772 772 } ··· 797 797 798 798 mutex_lock(&inode->i_mutex); 799 799 __ceph_do_pending_vmtruncate(inode); 800 - if (origin != SEEK_CUR || origin != SEEK_SET) { 800 + 801 + if (origin == SEEK_END || origin == SEEK_DATA || origin == SEEK_HOLE) { 801 802 ret = ceph_do_getattr(inode, CEPH_STAT_CAP_SIZE); 802 803 if (ret < 0) { 803 804 offset = ret;

+28 -25

fs/ceph/inode.c

··· 297 297 298 298 dout("alloc_inode %p\n", &ci->vfs_inode); 299 299 300 + spin_lock_init(&ci->i_ceph_lock); 301 + 300 302 ci->i_version = 0; 301 303 ci->i_time_warp_seq = 0; 302 304 ci->i_ceph_flags = 0; ··· 585 583 iinfo->xattr_len); 586 584 } 587 585 588 - spin_lock(&inode->i_lock); 586 + spin_lock(&ci->i_ceph_lock); 589 587 590 588 /* 591 589 * provided version will be odd if inode value is projected, ··· 682 680 char *sym; 683 681 684 682 BUG_ON(symlen != inode->i_size); 685 - spin_unlock(&inode->i_lock); 683 + spin_unlock(&ci->i_ceph_lock); 686 684 687 685 err = -ENOMEM; 688 686 sym = kmalloc(symlen+1, GFP_NOFS); ··· 691 689 memcpy(sym, iinfo->symlink, symlen); 692 690 sym[symlen] = 0; 693 691 694 - spin_lock(&inode->i_lock); 692 + spin_lock(&ci->i_ceph_lock); 695 693 if (!ci->i_symlink) 696 694 ci->i_symlink = sym; 697 695 else ··· 717 715 } 718 716 719 717 no_change: 720 - spin_unlock(&inode->i_lock); 718 + spin_unlock(&ci->i_ceph_lock); 721 719 722 720 /* queue truncate if we saw i_size decrease */ 723 721 if (queue_trunc) ··· 752 750 info->cap.flags, 753 751 caps_reservation); 754 752 } else { 755 - spin_lock(&inode->i_lock); 753 + spin_lock(&ci->i_ceph_lock); 756 754 dout(" %p got snap_caps %s\n", inode, 757 755 ceph_cap_string(le32_to_cpu(info->cap.caps))); 758 756 ci->i_snap_caps |= le32_to_cpu(info->cap.caps); 759 757 if (cap_fmode >= 0) 760 758 __ceph_get_fmode(ci, cap_fmode); 761 - spin_unlock(&inode->i_lock); 759 + spin_unlock(&ci->i_ceph_lock); 762 760 } 763 761 } else if (cap_fmode >= 0) { 764 762 pr_warning("mds issued no caps on %llx.%llx\n", ··· 851 849 { 852 850 struct dentry *dir = dn->d_parent; 853 851 struct inode *inode = dir->d_inode; 852 + struct ceph_inode_info *ci = ceph_inode(inode); 854 853 struct ceph_dentry_info *di; 855 854 856 855 BUG_ON(!inode); 857 856 858 857 di = ceph_dentry(dn); 859 858 860 - spin_lock(&inode->i_lock); 859 + spin_lock(&ci->i_ceph_lock); 861 860 if (!ceph_dir_test_complete(inode)) { 862 - spin_unlock(&inode->i_lock); 861 + spin_unlock(&ci->i_ceph_lock); 863 862 return; 864 863 } 865 864 di->offset = ceph_inode(inode)->i_max_offset++; 866 - spin_unlock(&inode->i_lock); 865 + spin_unlock(&ci->i_ceph_lock); 867 866 868 867 spin_lock(&dir->d_lock); 869 868 spin_lock_nested(&dn->d_lock, DENTRY_D_LOCK_NESTED); ··· 1311 1308 struct ceph_inode_info *ci = ceph_inode(inode); 1312 1309 int ret = 0; 1313 1310 1314 - spin_lock(&inode->i_lock); 1311 + spin_lock(&ci->i_ceph_lock); 1315 1312 dout("set_size %p %llu -> %llu\n", inode, inode->i_size, size); 1316 1313 inode->i_size = size; 1317 1314 inode->i_blocks = (size + (1 << 9) - 1) >> 9; ··· 1321 1318 (ci->i_reported_size << 1) < ci->i_max_size) 1322 1319 ret = 1; 1323 1320 1324 - spin_unlock(&inode->i_lock); 1321 + spin_unlock(&ci->i_ceph_lock); 1325 1322 return ret; 1326 1323 } 1327 1324 ··· 1379 1376 u32 orig_gen; 1380 1377 int check = 0; 1381 1378 1382 - spin_lock(&inode->i_lock); 1379 + spin_lock(&ci->i_ceph_lock); 1383 1380 dout("invalidate_pages %p gen %d revoking %d\n", inode, 1384 1381 ci->i_rdcache_gen, ci->i_rdcache_revoking); 1385 1382 if (ci->i_rdcache_revoking != ci->i_rdcache_gen) { 1386 1383 /* nevermind! */ 1387 - spin_unlock(&inode->i_lock); 1384 + spin_unlock(&ci->i_ceph_lock); 1388 1385 goto out; 1389 1386 } 1390 1387 orig_gen = ci->i_rdcache_gen; 1391 - spin_unlock(&inode->i_lock); 1388 + spin_unlock(&ci->i_ceph_lock); 1392 1389 1393 1390 truncate_inode_pages(&inode->i_data, 0); 1394 1391 1395 - spin_lock(&inode->i_lock); 1392 + spin_lock(&ci->i_ceph_lock); 1396 1393 if (orig_gen == ci->i_rdcache_gen && 1397 1394 orig_gen == ci->i_rdcache_revoking) { 1398 1395 dout("invalidate_pages %p gen %d successful\n", inode, ··· 1404 1401 inode, orig_gen, ci->i_rdcache_gen, 1405 1402 ci->i_rdcache_revoking); 1406 1403 } 1407 - spin_unlock(&inode->i_lock); 1404 + spin_unlock(&ci->i_ceph_lock); 1408 1405 1409 1406 if (check) 1410 1407 ceph_check_caps(ci, 0, NULL); ··· 1463 1460 int wrbuffer_refs, wake = 0; 1464 1461 1465 1462 retry: 1466 - spin_lock(&inode->i_lock); 1463 + spin_lock(&ci->i_ceph_lock); 1467 1464 if (ci->i_truncate_pending == 0) { 1468 1465 dout("__do_pending_vmtruncate %p none pending\n", inode); 1469 - spin_unlock(&inode->i_lock); 1466 + spin_unlock(&ci->i_ceph_lock); 1470 1467 return; 1471 1468 } 1472 1469 ··· 1477 1474 if (ci->i_wrbuffer_ref_head < ci->i_wrbuffer_ref) { 1478 1475 dout("__do_pending_vmtruncate %p flushing snaps first\n", 1479 1476 inode); 1480 - spin_unlock(&inode->i_lock); 1477 + spin_unlock(&ci->i_ceph_lock); 1481 1478 filemap_write_and_wait_range(&inode->i_data, 0, 1482 1479 inode->i_sb->s_maxbytes); 1483 1480 goto retry; ··· 1487 1484 wrbuffer_refs = ci->i_wrbuffer_ref; 1488 1485 dout("__do_pending_vmtruncate %p (%d) to %lld\n", inode, 1489 1486 ci->i_truncate_pending, to); 1490 - spin_unlock(&inode->i_lock); 1487 + spin_unlock(&ci->i_ceph_lock); 1491 1488 1492 1489 truncate_inode_pages(inode->i_mapping, to); 1493 1490 1494 - spin_lock(&inode->i_lock); 1491 + spin_lock(&ci->i_ceph_lock); 1495 1492 ci->i_truncate_pending--; 1496 1493 if (ci->i_truncate_pending == 0) 1497 1494 wake = 1; 1498 - spin_unlock(&inode->i_lock); 1495 + spin_unlock(&ci->i_ceph_lock); 1499 1496 1500 1497 if (wrbuffer_refs == 0) 1501 1498 ceph_check_caps(ci, CHECK_CAPS_AUTHONLY, NULL); ··· 1550 1547 if (IS_ERR(req)) 1551 1548 return PTR_ERR(req); 1552 1549 1553 - spin_lock(&inode->i_lock); 1550 + spin_lock(&ci->i_ceph_lock); 1554 1551 issued = __ceph_caps_issued(ci, NULL); 1555 1552 dout("setattr %p issued %s\n", inode, ceph_cap_string(issued)); 1556 1553 ··· 1698 1695 } 1699 1696 1700 1697 release &= issued; 1701 - spin_unlock(&inode->i_lock); 1698 + spin_unlock(&ci->i_ceph_lock); 1702 1699 1703 1700 if (inode_dirty_flags) 1704 1701 __mark_inode_dirty(inode, inode_dirty_flags); ··· 1720 1717 __ceph_do_pending_vmtruncate(inode); 1721 1718 return err; 1722 1719 out: 1723 - spin_unlock(&inode->i_lock); 1720 + spin_unlock(&ci->i_ceph_lock); 1724 1721 ceph_mdsc_put_request(req); 1725 1722 return err; 1726 1723 }

+2 -2

fs/ceph/ioctl.c

··· 241 241 struct ceph_inode_info *ci = ceph_inode(inode); 242 242 243 243 if ((fi->fmode & CEPH_FILE_MODE_LAZY) == 0) { 244 - spin_lock(&inode->i_lock); 244 + spin_lock(&ci->i_ceph_lock); 245 245 ci->i_nr_by_mode[fi->fmode]--; 246 246 fi->fmode |= CEPH_FILE_MODE_LAZY; 247 247 ci->i_nr_by_mode[fi->fmode]++; 248 - spin_unlock(&inode->i_lock); 248 + spin_unlock(&ci->i_ceph_lock); 249 249 dout("ioctl_layzio: file %p marked lazy\n", file); 250 250 251 251 ceph_check_caps(ci, 0, NULL);

+17 -16

fs/ceph/mds_client.c

··· 732 732 } 733 733 } 734 734 735 - spin_lock(&inode->i_lock); 735 + spin_lock(&ci->i_ceph_lock); 736 736 cap = NULL; 737 737 if (mode == USE_AUTH_MDS) 738 738 cap = ci->i_auth_cap; 739 739 if (!cap && !RB_EMPTY_ROOT(&ci->i_caps)) 740 740 cap = rb_entry(rb_first(&ci->i_caps), struct ceph_cap, ci_node); 741 741 if (!cap) { 742 - spin_unlock(&inode->i_lock); 742 + spin_unlock(&ci->i_ceph_lock); 743 743 goto random; 744 744 } 745 745 mds = cap->session->s_mds; 746 746 dout("choose_mds %p %llx.%llx mds%d (%scap %p)\n", 747 747 inode, ceph_vinop(inode), mds, 748 748 cap == ci->i_auth_cap ? "auth " : "", cap); 749 - spin_unlock(&inode->i_lock); 749 + spin_unlock(&ci->i_ceph_lock); 750 750 return mds; 751 751 752 752 random: ··· 951 951 952 952 dout("removing cap %p, ci is %p, inode is %p\n", 953 953 cap, ci, &ci->vfs_inode); 954 - spin_lock(&inode->i_lock); 954 + spin_lock(&ci->i_ceph_lock); 955 955 __ceph_remove_cap(cap); 956 956 if (!__ceph_is_any_real_caps(ci)) { 957 957 struct ceph_mds_client *mdsc = ··· 984 984 } 985 985 spin_unlock(&mdsc->cap_dirty_lock); 986 986 } 987 - spin_unlock(&inode->i_lock); 987 + spin_unlock(&ci->i_ceph_lock); 988 988 while (drop--) 989 989 iput(inode); 990 990 return 0; ··· 1015 1015 1016 1016 wake_up_all(&ci->i_cap_wq); 1017 1017 if (arg) { 1018 - spin_lock(&inode->i_lock); 1018 + spin_lock(&ci->i_ceph_lock); 1019 1019 ci->i_wanted_max_size = 0; 1020 1020 ci->i_requested_max_size = 0; 1021 - spin_unlock(&inode->i_lock); 1021 + spin_unlock(&ci->i_ceph_lock); 1022 1022 } 1023 1023 return 0; 1024 1024 } ··· 1151 1151 if (session->s_trim_caps <= 0) 1152 1152 return -1; 1153 1153 1154 - spin_lock(&inode->i_lock); 1154 + spin_lock(&ci->i_ceph_lock); 1155 1155 mine = cap->issued | cap->implemented; 1156 1156 used = __ceph_caps_used(ci); 1157 1157 oissued = __ceph_caps_issued_other(ci, cap); ··· 1170 1170 __ceph_remove_cap(cap); 1171 1171 } else { 1172 1172 /* try to drop referring dentries */ 1173 - spin_unlock(&inode->i_lock); 1173 + spin_unlock(&ci->i_ceph_lock); 1174 1174 d_prune_aliases(inode); 1175 1175 dout("trim_caps_cb %p cap %p pruned, count now %d\n", 1176 1176 inode, cap, atomic_read(&inode->i_count)); ··· 1178 1178 } 1179 1179 1180 1180 out: 1181 - spin_unlock(&inode->i_lock); 1181 + spin_unlock(&ci->i_ceph_lock); 1182 1182 return 0; 1183 1183 } 1184 1184 ··· 1296 1296 i_flushing_item); 1297 1297 struct inode *inode = &ci->vfs_inode; 1298 1298 1299 - spin_lock(&inode->i_lock); 1299 + spin_lock(&ci->i_ceph_lock); 1300 1300 if (ci->i_cap_flush_seq <= want_flush_seq) { 1301 1301 dout("check_cap_flush still flushing %p " 1302 1302 "seq %lld <= %lld to mds%d\n", inode, ··· 1304 1304 session->s_mds); 1305 1305 ret = 0; 1306 1306 } 1307 - spin_unlock(&inode->i_lock); 1307 + spin_unlock(&ci->i_ceph_lock); 1308 1308 } 1309 1309 mutex_unlock(&session->s_mutex); 1310 1310 ceph_put_mds_session(session); ··· 1495 1495 pos, temp); 1496 1496 } else if (stop_on_nosnap && inode && 1497 1497 ceph_snap(inode) == CEPH_NOSNAP) { 1498 + spin_unlock(&temp->d_lock); 1498 1499 break; 1499 1500 } else { 1500 1501 pos -= temp->d_name.len; ··· 2012 2011 struct ceph_inode_info *ci = ceph_inode(inode); 2013 2012 2014 2013 dout("invalidate_dir_request %p (D_COMPLETE, lease(s))\n", inode); 2015 - spin_lock(&inode->i_lock); 2014 + spin_lock(&ci->i_ceph_lock); 2016 2015 ceph_dir_clear_complete(inode); 2017 2016 ci->i_release_count++; 2018 - spin_unlock(&inode->i_lock); 2017 + spin_unlock(&ci->i_ceph_lock); 2019 2018 2020 2019 if (req->r_dentry) 2021 2020 ceph_invalidate_dentry_lease(req->r_dentry); ··· 2423 2422 if (err) 2424 2423 goto out_free; 2425 2424 2426 - spin_lock(&inode->i_lock); 2425 + spin_lock(&ci->i_ceph_lock); 2427 2426 cap->seq = 0; /* reset cap seq */ 2428 2427 cap->issue_seq = 0; /* and issue_seq */ 2429 2428 ··· 2446 2445 rec.v1.pathbase = cpu_to_le64(pathbase); 2447 2446 reclen = sizeof(rec.v1); 2448 2447 } 2449 - spin_unlock(&inode->i_lock); 2448 + spin_unlock(&ci->i_ceph_lock); 2450 2449 2451 2450 if (recon_state->flock) { 2452 2451 int num_fcntl_locks, num_flock_locks;

+1 -1

fs/ceph/mds_client.h

··· 20 20 * 21 21 * mdsc->snap_rwsem 22 22 * 23 - * inode->i_lock 23 + * ci->i_ceph_lock 24 24 * mdsc->snap_flush_lock 25 25 * mdsc->cap_delay_lock 26 26 *

+8 -8

fs/ceph/snap.c

··· 446 446 return; 447 447 } 448 448 449 - spin_lock(&inode->i_lock); 449 + spin_lock(&ci->i_ceph_lock); 450 450 used = __ceph_caps_used(ci); 451 451 dirty = __ceph_caps_dirty(ci); 452 452 ··· 528 528 kfree(capsnap); 529 529 } 530 530 531 - spin_unlock(&inode->i_lock); 531 + spin_unlock(&ci->i_ceph_lock); 532 532 } 533 533 534 534 /* ··· 537 537 * 538 538 * If capsnap can now be flushed, add to snap_flush list, and return 1. 539 539 * 540 - * Caller must hold i_lock. 540 + * Caller must hold i_ceph_lock. 541 541 */ 542 542 int __ceph_finish_cap_snap(struct ceph_inode_info *ci, 543 543 struct ceph_cap_snap *capsnap) ··· 739 739 inode = &ci->vfs_inode; 740 740 ihold(inode); 741 741 spin_unlock(&mdsc->snap_flush_lock); 742 - spin_lock(&inode->i_lock); 742 + spin_lock(&ci->i_ceph_lock); 743 743 __ceph_flush_snaps(ci, &session, 0); 744 - spin_unlock(&inode->i_lock); 744 + spin_unlock(&ci->i_ceph_lock); 745 745 iput(inode); 746 746 spin_lock(&mdsc->snap_flush_lock); 747 747 } ··· 847 847 continue; 848 848 ci = ceph_inode(inode); 849 849 850 - spin_lock(&inode->i_lock); 850 + spin_lock(&ci->i_ceph_lock); 851 851 if (!ci->i_snap_realm) 852 852 goto skip_inode; 853 853 /* ··· 876 876 oldrealm = ci->i_snap_realm; 877 877 ci->i_snap_realm = realm; 878 878 spin_unlock(&realm->inodes_with_caps_lock); 879 - spin_unlock(&inode->i_lock); 879 + spin_unlock(&ci->i_ceph_lock); 880 880 881 881 ceph_get_snap_realm(mdsc, realm); 882 882 ceph_put_snap_realm(mdsc, oldrealm); ··· 885 885 continue; 886 886 887 887 skip_inode: 888 - spin_unlock(&inode->i_lock); 888 + spin_unlock(&ci->i_ceph_lock); 889 889 iput(inode); 890 890 } 891 891

+1 -1

fs/ceph/super.c

··· 383 383 if (fsopt->rsize != CEPH_RSIZE_DEFAULT) 384 384 seq_printf(m, ",rsize=%d", fsopt->rsize); 385 385 if (fsopt->rasize != CEPH_RASIZE_DEFAULT) 386 - seq_printf(m, ",rasize=%d", fsopt->rsize); 386 + seq_printf(m, ",rasize=%d", fsopt->rasize); 387 387 if (fsopt->congestion_kb != default_congestion_kb()) 388 388 seq_printf(m, ",write_congestion_kb=%d", fsopt->congestion_kb); 389 389 if (fsopt->caps_wanted_delay_min != CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT)

+16 -15

fs/ceph/super.h

··· 220 220 * The locking for D_COMPLETE is a bit odd: 221 221 * - we can clear it at almost any time (see ceph_d_prune) 222 222 * - it is only meaningful if: 223 - * - we hold dir inode i_lock 223 + * - we hold dir inode i_ceph_lock 224 224 * - we hold dir FILE_SHARED caps 225 225 * - the dentry D_COMPLETE is set 226 226 */ ··· 250 250 struct ceph_inode_info { 251 251 struct ceph_vino i_vino; /* ceph ino + snap */ 252 252 253 + spinlock_t i_ceph_lock; 254 + 253 255 u64 i_version; 254 256 u32 i_time_warp_seq; 255 257 ··· 273 271 274 272 struct ceph_inode_xattrs_info i_xattrs; 275 273 276 - /* capabilities. protected _both_ by i_lock and cap->session's 274 + /* capabilities. protected _both_ by i_ceph_lock and cap->session's 277 275 * s_mutex. */ 278 276 struct rb_root i_caps; /* cap list */ 279 277 struct ceph_cap *i_auth_cap; /* authoritative cap, if any */ ··· 439 437 { 440 438 struct ceph_inode_info *ci = ceph_inode(inode); 441 439 442 - spin_lock(&inode->i_lock); 440 + spin_lock(&ci->i_ceph_lock); 443 441 ci->i_ceph_flags &= ~mask; 444 - spin_unlock(&inode->i_lock); 442 + spin_unlock(&ci->i_ceph_lock); 445 443 } 446 444 447 445 static inline void ceph_i_set(struct inode *inode, unsigned mask) 448 446 { 449 447 struct ceph_inode_info *ci = ceph_inode(inode); 450 448 451 - spin_lock(&inode->i_lock); 449 + spin_lock(&ci->i_ceph_lock); 452 450 ci->i_ceph_flags |= mask; 453 - spin_unlock(&inode->i_lock); 451 + spin_unlock(&ci->i_ceph_lock); 454 452 } 455 453 456 454 static inline bool ceph_i_test(struct inode *inode, unsigned mask) ··· 458 456 struct ceph_inode_info *ci = ceph_inode(inode); 459 457 bool r; 460 458 461 - spin_lock(&inode->i_lock); 459 + spin_lock(&ci->i_ceph_lock); 462 460 r = (ci->i_ceph_flags & mask) == mask; 463 - spin_unlock(&inode->i_lock); 461 + spin_unlock(&ci->i_ceph_lock); 464 462 return r; 465 463 } 466 464 ··· 510 508 static inline int ceph_caps_issued(struct ceph_inode_info *ci) 511 509 { 512 510 int issued; 513 - spin_lock(&ci->vfs_inode.i_lock); 511 + spin_lock(&ci->i_ceph_lock); 514 512 issued = __ceph_caps_issued(ci, NULL); 515 - spin_unlock(&ci->vfs_inode.i_lock); 513 + spin_unlock(&ci->i_ceph_lock); 516 514 return issued; 517 515 } 518 516 ··· 520 518 int touch) 521 519 { 522 520 int r; 523 - spin_lock(&ci->vfs_inode.i_lock); 521 + spin_lock(&ci->i_ceph_lock); 524 522 r = __ceph_caps_issued_mask(ci, mask, touch); 525 - spin_unlock(&ci->vfs_inode.i_lock); 523 + spin_unlock(&ci->i_ceph_lock); 526 524 return r; 527 525 } 528 526 ··· 745 743 extern void __ceph_remove_cap(struct ceph_cap *cap); 746 744 static inline void ceph_remove_cap(struct ceph_cap *cap) 747 745 { 748 - struct inode *inode = &cap->ci->vfs_inode; 749 - spin_lock(&inode->i_lock); 746 + spin_lock(&cap->ci->i_ceph_lock); 750 747 __ceph_remove_cap(cap); 751 - spin_unlock(&inode->i_lock); 748 + spin_unlock(&cap->ci->i_ceph_lock); 752 749 } 753 750 extern void ceph_put_cap(struct ceph_mds_client *mdsc, 754 751 struct ceph_cap *cap);

+21 -21

fs/ceph/xattr.c

··· 343 343 } 344 344 345 345 static int __build_xattrs(struct inode *inode) 346 - __releases(inode->i_lock) 347 - __acquires(inode->i_lock) 346 + __releases(ci->i_ceph_lock) 347 + __acquires(ci->i_ceph_lock) 348 348 { 349 349 u32 namelen; 350 350 u32 numattr = 0; ··· 372 372 end = p + ci->i_xattrs.blob->vec.iov_len; 373 373 ceph_decode_32_safe(&p, end, numattr, bad); 374 374 xattr_version = ci->i_xattrs.version; 375 - spin_unlock(&inode->i_lock); 375 + spin_unlock(&ci->i_ceph_lock); 376 376 377 377 xattrs = kcalloc(numattr, sizeof(struct ceph_xattr *), 378 378 GFP_NOFS); ··· 387 387 goto bad_lock; 388 388 } 389 389 390 - spin_lock(&inode->i_lock); 390 + spin_lock(&ci->i_ceph_lock); 391 391 if (ci->i_xattrs.version != xattr_version) { 392 392 /* lost a race, retry */ 393 393 for (i = 0; i < numattr; i++) ··· 418 418 419 419 return err; 420 420 bad_lock: 421 - spin_lock(&inode->i_lock); 421 + spin_lock(&ci->i_ceph_lock); 422 422 bad: 423 423 if (xattrs) { 424 424 for (i = 0; i < numattr; i++) ··· 512 512 if (vxattrs) 513 513 vxattr = ceph_match_vxattr(vxattrs, name); 514 514 515 - spin_lock(&inode->i_lock); 515 + spin_lock(&ci->i_ceph_lock); 516 516 dout("getxattr %p ver=%lld index_ver=%lld\n", inode, 517 517 ci->i_xattrs.version, ci->i_xattrs.index_version); 518 518 ··· 520 520 (ci->i_xattrs.index_version >= ci->i_xattrs.version)) { 521 521 goto get_xattr; 522 522 } else { 523 - spin_unlock(&inode->i_lock); 523 + spin_unlock(&ci->i_ceph_lock); 524 524 /* get xattrs from mds (if we don't already have them) */ 525 525 err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR); 526 526 if (err) 527 527 return err; 528 528 } 529 529 530 - spin_lock(&inode->i_lock); 530 + spin_lock(&ci->i_ceph_lock); 531 531 532 532 if (vxattr && vxattr->readonly) { 533 533 err = vxattr->getxattr_cb(ci, value, size); ··· 558 558 memcpy(value, xattr->val, xattr->val_len); 559 559 560 560 out: 561 - spin_unlock(&inode->i_lock); 561 + spin_unlock(&ci->i_ceph_lock); 562 562 return err; 563 563 } 564 564 ··· 573 573 u32 len; 574 574 int i; 575 575 576 - spin_lock(&inode->i_lock); 576 + spin_lock(&ci->i_ceph_lock); 577 577 dout("listxattr %p ver=%lld index_ver=%lld\n", inode, 578 578 ci->i_xattrs.version, ci->i_xattrs.index_version); 579 579 ··· 581 581 (ci->i_xattrs.index_version >= ci->i_xattrs.version)) { 582 582 goto list_xattr; 583 583 } else { 584 - spin_unlock(&inode->i_lock); 584 + spin_unlock(&ci->i_ceph_lock); 585 585 err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR); 586 586 if (err) 587 587 return err; 588 588 } 589 589 590 - spin_lock(&inode->i_lock); 590 + spin_lock(&ci->i_ceph_lock); 591 591 592 592 err = __build_xattrs(inode); 593 593 if (err < 0) ··· 619 619 } 620 620 621 621 out: 622 - spin_unlock(&inode->i_lock); 622 + spin_unlock(&ci->i_ceph_lock); 623 623 return err; 624 624 } 625 625 ··· 739 739 if (!xattr) 740 740 goto out; 741 741 742 - spin_lock(&inode->i_lock); 742 + spin_lock(&ci->i_ceph_lock); 743 743 retry: 744 744 issued = __ceph_caps_issued(ci, NULL); 745 745 if (!(issued & CEPH_CAP_XATTR_EXCL)) ··· 752 752 required_blob_size > ci->i_xattrs.prealloc_blob->alloc_len) { 753 753 struct ceph_buffer *blob = NULL; 754 754 755 - spin_unlock(&inode->i_lock); 755 + spin_unlock(&ci->i_ceph_lock); 756 756 dout(" preaallocating new blob size=%d\n", required_blob_size); 757 757 blob = ceph_buffer_new(required_blob_size, GFP_NOFS); 758 758 if (!blob) 759 759 goto out; 760 - spin_lock(&inode->i_lock); 760 + spin_lock(&ci->i_ceph_lock); 761 761 if (ci->i_xattrs.prealloc_blob) 762 762 ceph_buffer_put(ci->i_xattrs.prealloc_blob); 763 763 ci->i_xattrs.prealloc_blob = blob; ··· 770 770 dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL); 771 771 ci->i_xattrs.dirty = true; 772 772 inode->i_ctime = CURRENT_TIME; 773 - spin_unlock(&inode->i_lock); 773 + spin_unlock(&ci->i_ceph_lock); 774 774 if (dirty) 775 775 __mark_inode_dirty(inode, dirty); 776 776 return err; 777 777 778 778 do_sync: 779 - spin_unlock(&inode->i_lock); 779 + spin_unlock(&ci->i_ceph_lock); 780 780 err = ceph_sync_setxattr(dentry, name, value, size, flags); 781 781 out: 782 782 kfree(newname); ··· 833 833 return -EOPNOTSUPP; 834 834 } 835 835 836 - spin_lock(&inode->i_lock); 836 + spin_lock(&ci->i_ceph_lock); 837 837 __build_xattrs(inode); 838 838 issued = __ceph_caps_issued(ci, NULL); 839 839 dout("removexattr %p issued %s\n", inode, ceph_cap_string(issued)); ··· 846 846 ci->i_xattrs.dirty = true; 847 847 inode->i_ctime = CURRENT_TIME; 848 848 849 - spin_unlock(&inode->i_lock); 849 + spin_unlock(&ci->i_ceph_lock); 850 850 if (dirty) 851 851 __mark_inode_dirty(inode, dirty); 852 852 return err; 853 853 do_sync: 854 - spin_unlock(&inode->i_lock); 854 + spin_unlock(&ci->i_ceph_lock); 855 855 err = ceph_send_removexattr(dentry, name); 856 856 return err; 857 857 }

+13 -22

net/ceph/crush/mapper.c

··· 477 477 int i, j; 478 478 int numrep; 479 479 int firstn; 480 - int rc = -1; 481 480 482 481 BUG_ON(ruleno >= map->max_rules); 483 482 ··· 490 491 * that this may or may not correspond to the specific types 491 492 * referenced by the crush rule. 492 493 */ 493 - if (force >= 0) { 494 - if (force >= map->max_devices || 495 - map->device_parents[force] == 0) { 496 - /*dprintk("CRUSH: forcefed device dne\n");*/ 497 - rc = -1; /* force fed device dne */ 498 - goto out; 499 - } 500 - if (!is_out(map, weight, force, x)) { 501 - while (1) { 502 - force_context[++force_pos] = force; 503 - if (force >= 0) 504 - force = map->device_parents[force]; 505 - else 506 - force = map->bucket_parents[-1-force]; 507 - if (force == 0) 508 - break; 509 - } 494 + if (force >= 0 && 495 + force < map->max_devices && 496 + map->device_parents[force] != 0 && 497 + !is_out(map, weight, force, x)) { 498 + while (1) { 499 + force_context[++force_pos] = force; 500 + if (force >= 0) 501 + force = map->device_parents[force]; 502 + else 503 + force = map->bucket_parents[-1-force]; 504 + if (force == 0) 505 + break; 510 506 } 511 507 } 512 508 ··· 594 600 BUG_ON(1); 595 601 } 596 602 } 597 - rc = result_len; 598 - 599 - out: 600 - return rc; 603 + return result_len; 601 604 } 602 605 603 606

Configure Feed

Configure Feed