← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-linaro-omap/trusty

« back to all changes in this revision

Viewing changes to fs/ceph/caps.c

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-57i0gl3v99b3lkfg
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/ceph/caps.c
569
569
                list_add_tail(&cap->session_caps, &session->s_caps);
570
570
                session->s_nr_caps++;
571
571
                spin_unlock(&session->s_cap_lock);
572
 
        }
 
572
        } else if (new_cap)
 
573
                ceph_put_cap(mdsc, new_cap);
573
574
 
574
575
        if (!ci->i_snap_realm) {
575
576
                /*
2634
2635
                              struct ceph_mds_session *session,
2635
2636
                              int *open_target_sessions)
2636
2637
{
 
2638
        struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
2637
2639
        struct ceph_inode_info *ci = ceph_inode(inode);
2638
2640
        int mds = session->s_mds;
2639
2641
        unsigned mseq = le32_to_cpu(ex->migrate_seq);
2670
2672
                         * export targets, so that we get the matching IMPORT
2671
2673
                         */
2672
2674
                        *open_target_sessions = 1;
 
2675
 
 
2676
                        /*
 
2677
                         * we can't flush dirty caps that we've seen the
 
2678
                         * EXPORT but no IMPORT for
 
2679
                         */
 
2680
                        spin_lock(&mdsc->cap_dirty_lock);
 
2681
                        if (!list_empty(&ci->i_dirty_item)) {
 
2682
                                dout(" moving %p to cap_dirty_migrating\n",
 
2683
                                     inode);
 
2684
                                list_move(&ci->i_dirty_item,
 
2685
                                          &mdsc->cap_dirty_migrating);
 
2686
                        }
 
2687
                        spin_unlock(&mdsc->cap_dirty_lock);
2673
2688
                }
2674
2689
                __ceph_remove_cap(cap);
2675
2690
        }
2707
2722
                ci->i_cap_exporting_issued = 0;
2708
2723
                ci->i_cap_exporting_mseq = 0;
2709
2724
                ci->i_cap_exporting_mds = -1;
 
2725
 
 
2726
                spin_lock(&mdsc->cap_dirty_lock);
 
2727
                if (!list_empty(&ci->i_dirty_item)) {
 
2728
                        dout(" moving %p back to cap_dirty\n", inode);
 
2729
                        list_move(&ci->i_dirty_item, &mdsc->cap_dirty);
 
2730
                }
 
2731
                spin_unlock(&mdsc->cap_dirty_lock);
2710
2732
        } else {
2711
2733
                dout("handle_cap_import inode %p ci %p mds%d mseq %d\n",
2712
2734
                     inode, ci, mds, mseq);
2910
2932
 */
2911
2933
void ceph_flush_dirty_caps(struct ceph_mds_client *mdsc)
2912
2934
{
2913
 
        struct ceph_inode_info *ci, *nci = NULL;
2914
 
        struct inode *inode, *ninode = NULL;
2915
 
        struct list_head *p, *n;
 
2935
        struct ceph_inode_info *ci;
 
2936
        struct inode *inode;
2916
2937
 
2917
2938
        dout("flush_dirty_caps\n");
2918
2939
        spin_lock(&mdsc->cap_dirty_lock);
2919
 
        list_for_each_safe(p, n, &mdsc->cap_dirty) {
2920
 
                if (nci) {
2921
 
                        ci = nci;
2922
 
                        inode = ninode;
2923
 
                        ci->i_ceph_flags &= ~CEPH_I_NOFLUSH;
2924
 
                        dout("flush_dirty_caps inode %p (was next inode)\n",
2925
 
                             inode);
2926
 
                } else {
2927
 
                        ci = list_entry(p, struct ceph_inode_info,
2928
 
                                        i_dirty_item);
2929
 
                        inode = igrab(&ci->vfs_inode);
2930
 
                        BUG_ON(!inode);
2931
 
                        dout("flush_dirty_caps inode %p\n", inode);
2932
 
                }
2933
 
                if (n != &mdsc->cap_dirty) {
2934
 
                        nci = list_entry(n, struct ceph_inode_info,
2935
 
                                         i_dirty_item);
2936
 
                        ninode = igrab(&nci->vfs_inode);
2937
 
                        BUG_ON(!ninode);
2938
 
                        nci->i_ceph_flags |= CEPH_I_NOFLUSH;
2939
 
                        dout("flush_dirty_caps next inode %p, noflush\n",
2940
 
                             ninode);
2941
 
                } else {
2942
 
                        nci = NULL;
2943
 
                        ninode = NULL;
2944
 
                }
 
2940
        while (!list_empty(&mdsc->cap_dirty)) {
 
2941
                ci = list_first_entry(&mdsc->cap_dirty, struct ceph_inode_info,
 
2942
                                      i_dirty_item);
 
2943
                inode = &ci->vfs_inode;
 
2944
                ihold(inode);
 
2945
                dout("flush_dirty_caps %p\n", inode);
2945
2946
                spin_unlock(&mdsc->cap_dirty_lock);
2946
 
                if (inode) {
2947
 
                        ceph_check_caps(ci, CHECK_CAPS_NODELAY|CHECK_CAPS_FLUSH,
2948
 
                                        NULL);
2949
 
                        iput(inode);
2950
 
                }
 
2947
                ceph_check_caps(ci, CHECK_CAPS_NODELAY|CHECK_CAPS_FLUSH, NULL);
 
2948
                iput(inode);
2951
2949
                spin_lock(&mdsc->cap_dirty_lock);
2952
2950
        }
2953
2951
        spin_unlock(&mdsc->cap_dirty_lock);
 
2952
        dout("flush_dirty_caps done\n");
2954
2953
}
2955
2954
 
2956
2955
/*