linux-imx

#include "aops.h"

#include "bitmap.h"

#include "debug.h"

#include "dir.h"

#include "lcnalloc.h"

#include "malloc.h"

#include "mft.h"

#include "ntfs.h"

​

/**

 * map_mft_record_page - map the page in which a specific mft record resides

 * @ni:     ntfs inode whose mft record page to map

 *

 * This maps the page in which the mft record of the ntfs inode @ni is situated

 * and returns a pointer to the mft record within the mapped page.

 *

 * Return value needs to be checked with IS_ERR() and if that is true PTR_ERR()

 * contains the negative error code returned.

 */

 * TODO:  If @sync is false, want to do truly asynchronous i/o, i.e. just

 * schedule i/o via ->writepage or do it via kntfsd or whatever.

 */

int ntfs_sync_mft_mirror(ntfs_volume *vol, const unsigned long mft_no,

        MFT_RECORD *m, int sync)

{

    struct page *page;

    unsigned int blocksize = vol->sb->s_blocksize;

    int max_bhs = vol->mft_record_size / blocksize;

    struct buffer_head *bh, *head;

    u8 *kmirr;

    runlist_element *rl;

    unsigned int block_start, block_end, m_start, m_end, page_ofs;

    int i_bhs, nr_bhs, err = 0;

    unsigned char blocksize_bits = vol->sb->s_blocksize_bits;

​

    ntfs_debug("Entering for inode 0x%lx.", mft_no);

    BUG_ON(!max_bhs);

    if (unlikely(!vol->mftmirr_ino)) {

        /* This could happen during umount... */

        err = ntfs_sync_mft_mirror_umount(vol, mft_no, m);

        if (likely(!err))

            return err;

        goto err_out;

    }

    /* Get the page containing the mirror copy of the mft record @m. */

    page = ntfs_map_page(vol->mftmirr_ino->i_mapping, mft_no >>

            (PAGE_SHIFT - vol->mft_record_size_bits));

 * schedule i/o via ->writepage or do it via kntfsd or whatever.

 */

int write_mft_record_nolock(ntfs_inode *ni, MFT_RECORD *m, int sync)

{

    ntfs_volume *vol = ni->vol;

    struct page *page = ni->page;

    unsigned int blocksize = vol->sb->s_blocksize;

    unsigned char blocksize_bits = vol->sb->s_blocksize_bits;

    int max_bhs = vol->mft_record_size / blocksize;

    struct buffer_head *bh, *head;

    runlist_element *rl;

    unsigned int block_start, block_end, m_start, m_end;

    int i_bhs, nr_bhs, err = 0;

​

    ntfs_debug("Entering for inode 0x%lx.", ni->mft_no);

    BUG_ON(NInoAttr(ni));

    BUG_ON(!max_bhs);

    BUG_ON(!PageLocked(page));

    /*

     * If the ntfs_inode is clean no need to do anything.  If it is dirty,

     * mark it as clean now so that it can be redirtied later on if needed.

     * There is no danger of races since the caller is holding the locks

     * for the mft record @m and the page it is in.

     */

    if (!NInoTestClearDirty(ni))

        goto done;

    bh = head = page_buffers(page);

    BUG_ON(!bh);