← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to fs/xfs/xfs_rtalloc.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/xfs/xfs_rtalloc.c
76
76
        xfs_mount_t     *mp,            /* file system mount point */
77
77
        xfs_extlen_t    oblocks,        /* old count of blocks */
78
78
        xfs_extlen_t    nblocks,        /* new count of blocks */
79
 
        xfs_ino_t       ino)            /* inode number (bitmap/summary) */
 
79
        xfs_inode_t     *ip)            /* inode (bitmap/summary) */
80
80
{
81
81
        xfs_fileoff_t   bno;            /* block number in file */
82
82
        xfs_buf_t       *bp;            /* temporary buffer for zeroing */
86
86
        xfs_fsblock_t   firstblock;     /* first block allocated in xaction */
87
87
        xfs_bmap_free_t flist;          /* list of freed blocks */
88
88
        xfs_fsblock_t   fsbno;          /* filesystem block for bno */
89
 
        xfs_inode_t     *ip;            /* pointer to incore inode */
90
89
        xfs_bmbt_irec_t map;            /* block map output */
91
90
        int             nmap;           /* number of block maps */
92
91
        int             resblks;        /* space reservation */
112
111
                /*
113
112
                 * Lock the inode.
114
113
                 */
115
 
                if ((error = xfs_trans_iget(mp, tp, ino, 0,
116
 
                                                XFS_ILOCK_EXCL, &ip)))
117
 
                        goto error_cancel;
 
114
                xfs_ilock(ip, XFS_ILOCK_EXCL);
 
115
                xfs_trans_ijoin_ref(tp, ip, XFS_ILOCK_EXCL);
 
116
 
118
117
                xfs_bmap_init(&flist, &firstblock);
119
118
                /*
120
119
                 * Allocate blocks to the bitmap file.
155
154
                        /*
156
155
                         * Lock the bitmap inode.
157
156
                         */
158
 
                        if ((error = xfs_trans_iget(mp, tp, ino, 0,
159
 
                                                        XFS_ILOCK_EXCL, &ip)))
160
 
                                goto error_cancel;
 
157
                        xfs_ilock(ip, XFS_ILOCK_EXCL);
 
158
                        xfs_trans_ijoin_ref(tp, ip, XFS_ILOCK_EXCL);
161
159
                        /*
162
160
                         * Get a buffer for the block.
163
161
                         */
1854
1852
        xfs_rtblock_t   bmbno;          /* bitmap block number */
1855
1853
        xfs_buf_t       *bp;            /* temporary buffer */
1856
1854
        int             error;          /* error return value */
1857
 
        xfs_inode_t     *ip;            /* bitmap inode, used as lock */
1858
1855
        xfs_mount_t     *nmp;           /* new (fake) mount structure */
1859
1856
        xfs_drfsbno_t   nrblocks;       /* new number of realtime blocks */
1860
1857
        xfs_extlen_t    nrbmblocks;     /* new number of rt bitmap blocks */
1918
1915
        /*
1919
1916
         * Allocate space to the bitmap and summary files, as necessary.
1920
1917
         */
1921
 
        if ((error = xfs_growfs_rt_alloc(mp, rbmblocks, nrbmblocks,
1922
 
                        mp->m_sb.sb_rbmino)))
 
1918
        error = xfs_growfs_rt_alloc(mp, rbmblocks, nrbmblocks, mp->m_rbmip);
 
1919
        if (error)
1923
1920
                return error;
1924
 
        if ((error = xfs_growfs_rt_alloc(mp, rsumblocks, nrsumblocks,
1925
 
                        mp->m_sb.sb_rsumino)))
 
1921
        error = xfs_growfs_rt_alloc(mp, rsumblocks, nrsumblocks, mp->m_rsumip);
 
1922
        if (error)
1926
1923
                return error;
1927
1924
        /*
1928
1925
         * Allocate a new (fake) mount/sb.
1972
1969
                /*
1973
1970
                 * Lock out other callers by grabbing the bitmap inode lock.
1974
1971
                 */
1975
 
                if ((error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rbmino, 0,
1976
 
                                                XFS_ILOCK_EXCL, &ip)))
1977
 
                        goto error_cancel;
1978
 
                ASSERT(ip == mp->m_rbmip);
 
1972
                xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL);
 
1973
                xfs_trans_ijoin_ref(tp, mp->m_rbmip, XFS_ILOCK_EXCL);
1979
1974
                /*
1980
1975
                 * Update the bitmap inode's size.
1981
1976
                 */
1986
1981
                /*
1987
1982
                 * Get the summary inode into the transaction.
1988
1983
                 */
1989
 
                if ((error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rsumino, 0,
1990
 
                                                XFS_ILOCK_EXCL, &ip)))
1991
 
                        goto error_cancel;
1992
 
                ASSERT(ip == mp->m_rsumip);
 
1984
                xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL);
 
1985
                xfs_trans_ijoin_ref(tp, mp->m_rsumip, XFS_ILOCK_EXCL);
1993
1986
                /*
1994
1987
                 * Update the summary inode's size.
1995
1988
                 */
2075
2068
        xfs_extlen_t    prod,           /* extent product factor */
2076
2069
        xfs_rtblock_t   *rtblock)       /* out: start block allocated */
2077
2070
{
 
2071
        xfs_mount_t     *mp = tp->t_mountp;
2078
2072
        int             error;          /* error value */
2079
 
        xfs_inode_t     *ip;            /* inode for bitmap file */
2080
 
        xfs_mount_t     *mp;            /* file system mount structure */
2081
2073
        xfs_rtblock_t   r;              /* result allocated block */
2082
2074
        xfs_fsblock_t   sb;             /* summary file block number */
2083
2075
        xfs_buf_t       *sumbp;         /* summary file block buffer */
2084
2076
 
 
2077
        ASSERT(xfs_isilocked(mp->m_rbmip, XFS_ILOCK_EXCL));
2085
2078
        ASSERT(minlen > 0 && minlen <= maxlen);
2086
 
        mp = tp->t_mountp;
 
2079
 
2087
2080
        /*
2088
2081
         * If prod is set then figure out what to do to minlen and maxlen.
2089
2082
         */
2099
2092
                        return 0;
2100
2093
                }
2101
2094
        }
2102
 
        /*
2103
 
         * Lock out other callers by grabbing the bitmap inode lock.
2104
 
         */
2105
 
        if ((error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rbmino, 0,
2106
 
                                        XFS_ILOCK_EXCL, &ip)))
2107
 
                return error;
 
2095
 
2108
2096
        sumbp = NULL;
2109
2097
        /*
2110
2098
         * Allocate by size, or near another block, or exactly at some block.
2123
2111
                                len, &sumbp, &sb, prod, &r);
2124
2112
                break;
2125
2113
        default:
 
2114
                error = EIO;
2126
2115
                ASSERT(0);
2127
2116
        }
2128
 
        if (error) {
 
2117
        if (error)
2129
2118
                return error;
2130
 
        }
 
2119
 
2131
2120
        /*
2132
2121
         * If it worked, update the superblock.
2133
2122
         */
2155
2144
        xfs_extlen_t    len)            /* length of extent freed */
2156
2145
{
2157
2146
        int             error;          /* error value */
2158
 
        xfs_inode_t     *ip;            /* bitmap file inode */
2159
2147
        xfs_mount_t     *mp;            /* file system mount structure */
2160
2148
        xfs_fsblock_t   sb;             /* summary file block number */
2161
2149
        xfs_buf_t       *sumbp;         /* summary file block buffer */
2164
2152
        /*
2165
2153
         * Synchronize by locking the bitmap inode.
2166
2154
         */
2167
 
        if ((error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rbmino, 0,
2168
 
                                        XFS_ILOCK_EXCL, &ip)))
2169
 
                return error;
 
2155
        xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL);
 
2156
        xfs_trans_ijoin_ref(tp, mp->m_rbmip, XFS_ILOCK_EXCL);
 
2157
 
2170
2158
#if defined(__KERNEL__) && defined(DEBUG)
2171
2159
        /*
2172
2160
         * Check to see that this whole range is currently allocated.
2199
2187
         */
2200
2188
        if (tp->t_frextents_delta + mp->m_sb.sb_frextents ==
2201
2189
            mp->m_sb.sb_rextents) {
2202
 
                if (!(ip->i_d.di_flags & XFS_DIFLAG_NEWRTBM))
2203
 
                        ip->i_d.di_flags |= XFS_DIFLAG_NEWRTBM;
2204
 
                *(__uint64_t *)&ip->i_d.di_atime = 0;
2205
 
                xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 
2190
                if (!(mp->m_rbmip->i_d.di_flags & XFS_DIFLAG_NEWRTBM))
 
2191
                        mp->m_rbmip->i_d.di_flags |= XFS_DIFLAG_NEWRTBM;
 
2192
                *(__uint64_t *)&mp->m_rbmip->i_d.di_atime = 0;
 
2193
                xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE);
2206
2194
        }
2207
2195
        return 0;
2208
2196
}
2222
2210
        if (sbp->sb_rblocks == 0)
2223
2211
                return 0;
2224
2212
        if (mp->m_rtdev_targp == NULL) {
2225
 
                cmn_err(CE_WARN,
2226
 
        "XFS: This filesystem has a realtime volume, use rtdev=device option");
 
2213
                xfs_warn(mp,
 
2214
        "Filesystem has a realtime volume, use rtdev=device option");
2227
2215
                return XFS_ERROR(ENODEV);
2228
2216
        }
2229
2217
        mp->m_rsumlevels = sbp->sb_rextslog + 1;
2237
2225
         */
2238
2226
        d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_rblocks);
2239
2227
        if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_rblocks) {
2240
 
                cmn_err(CE_WARN, "XFS: realtime mount -- %llu != %llu",
 
2228
                xfs_warn(mp, "realtime mount -- %llu != %llu",
2241
2229
                        (unsigned long long) XFS_BB_TO_FSB(mp, d),
2242
2230
                        (unsigned long long) mp->m_sb.sb_rblocks);
2243
2231
                return XFS_ERROR(EFBIG);
2246
2234
                                        d - XFS_FSB_TO_BB(mp, 1),
2247
2235
                                        XFS_FSB_TO_B(mp, 1), 0);
2248
2236
        if (!bp) {
2249
 
                cmn_err(CE_WARN, "XFS: realtime device size check failed");
 
2237
                xfs_warn(mp, "realtime device size check failed");
2250
2238
                return EIO;
2251
2239
        }
2252
2240
        xfs_buf_relse(bp);
2306
2294
        xfs_rtblock_t   *pick)          /* result rt extent */
2307
2295
{
2308
2296
        xfs_rtblock_t   b;              /* result block */
2309
 
        int             error;          /* error return value */
2310
 
        xfs_inode_t     *ip;            /* bitmap incore inode */
2311
2297
        int             log2;           /* log of sequence number */
2312
2298
        __uint64_t      resid;          /* residual after log removed */
2313
2299
        __uint64_t      seq;            /* sequence number of file creation */
2314
2300
        __uint64_t      *seqp;          /* pointer to seqno in inode */
2315
2301
 
2316
 
        if ((error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rbmino, 0,
2317
 
                                        XFS_ILOCK_EXCL, &ip)))
2318
 
                return error;
2319
 
        ASSERT(ip == mp->m_rbmip);
2320
 
        seqp = (__uint64_t *)&ip->i_d.di_atime;
2321
 
        if (!(ip->i_d.di_flags & XFS_DIFLAG_NEWRTBM)) {
2322
 
                ip->i_d.di_flags |= XFS_DIFLAG_NEWRTBM;
 
2302
        ASSERT(xfs_isilocked(mp->m_rbmip, XFS_ILOCK_EXCL));
 
2303
 
 
2304
        seqp = (__uint64_t *)&mp->m_rbmip->i_d.di_atime;
 
2305
        if (!(mp->m_rbmip->i_d.di_flags & XFS_DIFLAG_NEWRTBM)) {
 
2306
                mp->m_rbmip->i_d.di_flags |= XFS_DIFLAG_NEWRTBM;
2323
2307
                *seqp = 0;
2324
2308
        }
2325
2309
        seq = *seqp;
2335
2319
                        b = mp->m_sb.sb_rextents - len;
2336
2320
        }
2337
2321
        *seqp = seq + 1;
2338
 
        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 
2322
        xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE);
2339
2323
        *pick = b;
2340
2324
        return 0;
2341
2325
}