* along with Lustre; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-#ifdef HAVE_KERNEL_CONFIG_H
+
+#ifndef AUTOCONF_INCLUDED
#include <linux/config.h>
#endif
#include <linux/kernel.h>
#define DEBUG_SUBSYSTEM S_LLITE
+//#include <lustre_mdc.h>
#include <lustre_lite.h>
#include "llite_internal.h"
#include <linux/lustre_compat25.h>
pos = n, n = pos->prev )
#endif
-kmem_cache_t *ll_async_page_slab = NULL;
+cfs_mem_cache_t *ll_async_page_slab = NULL;
size_t ll_async_page_slab_size = 0;
/* SYNCHRONOUS I/O to object storage for an inode */
struct lov_stripe_md *lsm = lli->lli_smd;
struct obd_info oinfo = { { { 0 } } };
struct brw_page pg;
- int rc;
+ int opc, rc;
ENTRY;
pg.pg = page;
pg.off = ((obd_off)page->index) << CFS_PAGE_SHIFT;
- if ((cmd & OBD_BRW_WRITE) && (pg.off + CFS_PAGE_SIZE > inode->i_size))
- pg.count = inode->i_size % CFS_PAGE_SIZE;
+ if ((cmd & OBD_BRW_WRITE) && (pg.off+CFS_PAGE_SIZE>i_size_read(inode)))
+ pg.count = i_size_read(inode) % CFS_PAGE_SIZE;
else
pg.count = CFS_PAGE_SIZE;
inode->i_ino, pg.off, pg.off);
if (pg.count == 0) {
CERROR("ZERO COUNT: ino %lu: size %p:%Lu(%p:%Lu) idx %lu off "
- LPU64"\n",
- inode->i_ino, inode, inode->i_size, page->mapping->host,
- page->mapping->host->i_size, page->index, pg.off);
+ LPU64"\n", inode->i_ino, inode, i_size_read(inode),
+ page->mapping->host, i_size_read(page->mapping->host),
+ page->index, pg.off);
}
pg.flag = flags;
if (cmd & OBD_BRW_WRITE)
- lprocfs_counter_add(ll_i2sbi(inode)->ll_stats,
- LPROC_LL_BRW_WRITE, pg.count);
+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_BRW_WRITE,
+ pg.count);
else
- lprocfs_counter_add(ll_i2sbi(inode)->ll_stats,
- LPROC_LL_BRW_READ, pg.count);
+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_BRW_READ,
+ pg.count);
oinfo.oi_oa = oa;
oinfo.oi_md = lsm;
- rc = obd_brw(cmd, ll_i2obdexp(inode), &oinfo, 1, &pg, NULL);
+ /* NB partial write, so we might not have CAPA_OPC_OSS_READ capa */
+ opc = cmd & OBD_BRW_WRITE ? CAPA_OPC_OSS_WRITE : CAPA_OPC_OSS_RW;
+ oinfo.oi_capa = ll_osscapa_get(inode, opc);
+ rc = obd_brw(cmd, ll_i2dtexp(inode), &oinfo, 1, &pg, NULL);
+ capa_put(oinfo.oi_capa);
if (rc == 0)
obdo_to_inode(inode, oa, OBD_MD_FLBLOCKS);
else if (rc != -EIO)
int rc;
ENTRY;
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) to %Lu=%#Lx\n",inode->i_ino,
- inode->i_generation, inode, inode->i_size, inode->i_size);
+ inode->i_generation, inode, i_size_read(inode),
+ i_size_read(inode));
- ll_vfs_ops_tally(ll_i2sbi(inode), VFS_OPS_TRUNCATE);
+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_TRUNC, 1);
if (lli->lli_size_sem_owner != current) {
EXIT;
return;
* race condition. */
lov_stripe_lock(lli->lli_smd);
inode_init_lvb(inode, &lvb);
- obd_merge_lvb(ll_i2obdexp(inode), lli->lli_smd, &lvb, 0);
- if (lvb.lvb_size == inode->i_size) {
+ obd_merge_lvb(ll_i2dtexp(inode), lli->lli_smd, &lvb, 0);
+ if (lvb.lvb_size == i_size_read(inode)) {
CDEBUG(D_VFSTRACE, "skipping punch for obj "LPX64", %Lu=%#Lx\n",
- lli->lli_smd->lsm_object_id,inode->i_size,inode->i_size);
+ lli->lli_smd->lsm_object_id, i_size_read(inode),
+ i_size_read(inode));
lov_stripe_unlock(lli->lli_smd);
GOTO(out_unlock, 0);
}
- obd_adjust_kms(ll_i2obdexp(inode), lli->lli_smd, inode->i_size, 1);
+ obd_adjust_kms(ll_i2dtexp(inode), lli->lli_smd, i_size_read(inode), 1);
lov_stripe_unlock(lli->lli_smd);
if (unlikely((ll_i2sbi(inode)->ll_flags & LL_SBI_CHECKSUM) &&
- (inode->i_size & ~CFS_PAGE_MASK))) {
+ (i_size_read(inode) & ~CFS_PAGE_MASK))) {
/* If the truncate leaves behind a partial page, update its
* checksum. */
struct page *page = find_get_page(inode->i_mapping,
- inode->i_size >> CFS_PAGE_SHIFT);
+ i_size_read(inode) >>
+ CFS_PAGE_SHIFT);
if (page != NULL) {
struct ll_async_page *llap = llap_cast_private(page);
if (llap != NULL) {
}
CDEBUG(D_INFO, "calling punch for "LPX64" (new size %Lu=%#Lx)\n",
- lli->lli_smd->lsm_object_id, inode->i_size, inode->i_size);
+ lli->lli_smd->lsm_object_id, i_size_read(inode), i_size_read(inode));
oinfo.oi_md = lli->lli_smd;
- oinfo.oi_policy.l_extent.start = inode->i_size;
+ oinfo.oi_policy.l_extent.start = i_size_read(inode);
oinfo.oi_policy.l_extent.end = OBD_OBJECT_EOF;
oinfo.oi_oa = &oa;
oa.o_id = lli->lli_smd->lsm_object_id;
- oa.o_valid = OBD_MD_FLID;
+ oa.o_gr = lli->lli_smd->lsm_object_gr;
+ oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
- obdo_from_inode(&oa, inode, OBD_MD_FLTYPE | OBD_MD_FLMODE |OBD_MD_FLFID|
+ obdo_from_inode(&oa, inode, OBD_MD_FLTYPE | OBD_MD_FLMODE |
OBD_MD_FLATIME | OBD_MD_FLMTIME | OBD_MD_FLCTIME |
- OBD_MD_FLUID | OBD_MD_FLGID | OBD_MD_FLGENER |
- OBD_MD_FLBLOCKS);
+ OBD_MD_FLFID | OBD_MD_FLGENER);
ll_inode_size_unlock(inode, 0);
- rc = obd_punch_rqset(ll_i2obdexp(inode), &oinfo, NULL);
+ oinfo.oi_capa = ll_osscapa_get(inode, CAPA_OPC_OSS_TRUNC);
+ rc = obd_punch_rqset(ll_i2dtexp(inode), &oinfo, NULL);
+ ll_truncate_free_capa(oinfo.oi_capa);
if (rc)
CERROR("obd_truncate fails (%d) ino %lu\n", rc, inode->i_ino);
else
oa.o_mode = inode->i_mode;
oa.o_id = lsm->lsm_object_id;
- oa.o_valid = OBD_MD_FLID | OBD_MD_FLMODE | OBD_MD_FLTYPE;
+ oa.o_gr = lsm->lsm_object_gr;
+ oa.o_valid = OBD_MD_FLID | OBD_MD_FLMODE |
+ OBD_MD_FLTYPE | OBD_MD_FLGROUP;
obdo_from_inode(&oa, inode, OBD_MD_FLFID | OBD_MD_FLGENER);
oinfo.oi_oa = &oa;
oinfo.oi_md = lsm;
- rc = obd_brw(OBD_BRW_CHECK, ll_i2obdexp(inode), &oinfo, 1, &pga, NULL);
+ rc = obd_brw(OBD_BRW_CHECK, ll_i2dtexp(inode), &oinfo, 1, &pga, NULL);
if (rc)
RETURN(rc);
* treat it like i_size. */
lov_stripe_lock(lsm);
inode_init_lvb(inode, &lvb);
- obd_merge_lvb(ll_i2obdexp(inode), lsm, &lvb, 1);
+ obd_merge_lvb(ll_i2dtexp(inode), lsm, &lvb, 1);
lov_stripe_unlock(lsm);
if (lvb.lvb_size <= offset) {
LL_CDEBUG_PAGE(D_PAGE, page, "kms "LPU64" <= offset "LPU64"\n",
* we got the page cache list we'd create a lock inversion
* with the removepage path which gets the page lock then the
* cli lock */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- clear_page_dirty(page);
-#else
LASSERTF(!PageWriteback(page),"cmd %x page %p ino %lu index %lu\n", cmd, page,
page->mapping->host->i_ino, page->index);
clear_page_dirty_for_io(page);
/* This actually clears the dirty bit in the radix tree.*/
set_page_writeback(page);
-#endif
LL_CDEBUG_PAGE(D_PAGE, page, "made ready\n");
page_cache_get(page);
lov_stripe_lock(lsm);
inode_init_lvb(inode, &lvb);
- obd_merge_lvb(ll_i2obdexp(inode), lsm, &lvb, 1);
+ obd_merge_lvb(ll_i2dtexp(inode), lsm, &lvb, 1);
kms = lvb.lvb_size;
lov_stripe_unlock(lsm);
lsm = ll_i2info(inode)->lli_smd;
oa->o_id = lsm->lsm_object_id;
- oa->o_valid = OBD_MD_FLID;
+ oa->o_gr = lsm->lsm_object_gr;
+ oa->o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
valid_flags = OBD_MD_FLTYPE | OBD_MD_FLATIME;
if (cmd & OBD_BRW_WRITE) {
oa->o_valid |= OBD_MD_FLEPOCH;
- oa->o_easize = ll_i2info(inode)->lli_io_epoch;
+ oa->o_easize = ll_i2info(inode)->lli_ioepoch;
valid_flags |= OBD_MD_FLMTIME | OBD_MD_FLCTIME |
OBD_MD_FLUID | OBD_MD_FLGID |
EXIT;
}
+static struct obd_capa *ll_ap_lookup_capa(void *data, int cmd)
+{
+ struct ll_async_page *llap = LLAP_FROM_COOKIE(data);
+ int opc = cmd & OBD_BRW_WRITE ? CAPA_OPC_OSS_WRITE : CAPA_OPC_OSS_RW;
+
+ return ll_osscapa_get(llap->llap_page->mapping->host, opc);
+}
+
static struct obd_async_page_ops ll_async_page_ops = {
.ap_make_ready = ll_ap_make_ready,
.ap_refresh_count = ll_ap_refresh_count,
.ap_fill_obdo = ll_ap_fill_obdo,
.ap_update_obdo = ll_ap_update_obdo,
.ap_completion = ll_ap_completion,
+ .ap_lookup_capa = ll_ap_lookup_capa,
};
struct ll_async_page *llap_cast_private(struct page *page)
continue;
}
- if (llap->llap_write_queued || PageDirty(page) ||
- (!PageUptodate(page) &&
- llap->llap_origin != LLAP_ORIGIN_READAHEAD))
- keep = 1;
- else
- keep = 0;
+ keep = (llap->llap_write_queued || PageDirty(page) ||
+ PageWriteback(page) || (!PageUptodate(page) &&
+ llap->llap_origin != LLAP_ORIGIN_READAHEAD));
- LL_CDEBUG_PAGE(D_PAGE, page,"%s LRU page: %s%s%s%s origin %s\n",
+ LL_CDEBUG_PAGE(D_PAGE, page,"%s LRU page: %s%s%s%s%s origin %s\n",
keep ? "keep" : "drop",
llap->llap_write_queued ? "wq " : "",
PageDirty(page) ? "pd " : "",
PageUptodate(page) ? "" : "!pu ",
+ PageWriteback(page) ? "wb" : "",
llap->llap_defer_uptodate ? "" : "!du",
llap_origins[llap->llap_origin]);
return count;
}
-static struct ll_async_page *llap_from_page(struct page *page, unsigned origin)
+struct ll_async_page *llap_from_page(struct page *page, unsigned origin)
{
struct ll_async_page *llap;
struct obd_export *exp;
GOTO(out, llap);
}
- exp = ll_i2obdexp(page->mapping->host);
+ exp = ll_i2dtexp(page->mapping->host);
if (exp == NULL)
RETURN(ERR_PTR(-EINVAL));
if (sbi->ll_async_page_count >= sbi->ll_async_page_max)
llap_shrink_cache(sbi, 0);
- OBD_SLAB_ALLOC(llap, ll_async_page_slab, SLAB_KERNEL,
+ OBD_SLAB_ALLOC(llap, ll_async_page_slab, CFS_ALLOC_STD,
ll_async_page_slab_size);
if (llap == NULL)
RETURN(ERR_PTR(-ENOMEM));
/* also zeroing the PRIVBITS low order bitflags */
__set_page_ll_data(page, llap);
llap->llap_page = page;
-
spin_lock(&sbi->ll_lock);
sbi->ll_pglist_gen++;
sbi->ll_async_page_count++;
list_add_tail(&llap->llap_pglist_item, &sbi->ll_pglist);
+ INIT_LIST_HEAD(&llap->llap_pending_write);
spin_unlock(&sbi->ll_lock);
out:
struct ll_async_page *llap,
unsigned to, obd_flag async_flags)
{
- unsigned long size_index = inode->i_size >> CFS_PAGE_SHIFT;
+ unsigned long size_index = i_size_read(inode) >> CFS_PAGE_SHIFT;
struct obd_io_group *oig;
struct ll_sb_info *sbi = ll_i2sbi(inode);
int rc, noquot = llap->llap_ignore_quota ? OBD_BRW_NOQUOTA : 0;
0, 0, 0, async_flags);
if (rc == 0) {
LL_CDEBUG_PAGE(D_PAGE, llap->llap_page, "write queued\n");
- //llap_write_pending(inode, llap);
GOTO(out, 0);
}
llap->llap_write_queued = 0;
-
+ /* Do not pass llap here as it is sync write. */
+ llap_write_pending(inode, NULL);
+
rc = oig_init(&oig);
if (rc)
GOTO(out, rc);
size_index, to);
to = CFS_PAGE_SIZE;
} else if (to != CFS_PAGE_SIZE && llap->llap_page->index == size_index) {
- int size_to = inode->i_size & ~CFS_PAGE_MASK;
+ int size_to = i_size_read(inode) & ~CFS_PAGE_MASK;
LL_CDEBUG_PAGE(D_PAGE, llap->llap_page,
"sync write at EOF: size_index %lu, to %d/%d\n",
size_index, to, size_to);
}
}
+ if (rc == 0 && llap_write_complete(inode, llap))
+ ll_queue_done_writing(inode, 0);
+
LL_CDEBUG_PAGE(D_PAGE, llap->llap_page, "sync write returned %d\n", rc);
free_oig:
if (IS_ERR(llap))
RETURN(PTR_ERR(llap));
- exp = ll_i2obdexp(inode);
+ exp = ll_i2dtexp(inode);
if (exp == NULL)
RETURN(-EINVAL);
llap->llap_ignore_quota = capable(CAP_SYS_RESOURCE);
- /* queue a write for some time in the future the first time we
- * dirty the page */
+ /*
+ * queue a write for some time in the future the first time we
+ * dirty the page.
+ *
+ * This is different from what other file systems do: they usually
+ * just mark page (and some of its buffers) dirty and rely on
+ * balance_dirty_pages() to start a write-back. Lustre wants write-back
+ * to be started earlier for the following reasons:
+ *
+ * (1) with a large number of clients we need to limit the amount
+ * of cached data on the clients a lot;
+ *
+ * (2) large compute jobs generally want compute-only then io-only
+ * and the IO should complete as quickly as possible;
+ *
+ * (3) IO is batched up to the RPC size and is async until the
+ * client max cache is hit
+ * (/proc/fs/lustre/osc/OSC.../max_dirty_mb)
+ *
+ */
if (!PageDirty(page)) {
- lprocfs_counter_incr(ll_i2sbi(inode)->ll_stats,
- LPROC_LL_DIRTY_MISSES);
+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_DIRTY_MISSES, 1);
rc = queue_or_sync_write(exp, inode, llap, to, 0);
if (rc)
GOTO(out, rc);
} else {
- lprocfs_counter_incr(ll_i2sbi(inode)->ll_stats,
- LPROC_LL_DIRTY_HITS);
+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_DIRTY_HITS, 1);
}
/* put the page in the page cache, from now on ll_removepage is
lov_stripe_lock(lsm);
obd_adjust_kms(exp, lsm, size, 0);
lov_stripe_unlock(lsm);
- if (size > inode->i_size)
- inode->i_size = size;
+ if (size > i_size_read(inode))
+ i_size_write(inode, size);
SetPageUptodate(page);
- } else if (size > inode->i_size) {
+ } else if (size > i_size_read(inode)) {
/* this page beyond the pales of i_size, so it can't be
* truncated in ll_p_r_e during lock revoking. we must
* teardown our book-keeping here. */
page = llap->llap_page;
LASSERT(PageLocked(page));
LASSERT(CheckWriteback(page,cmd));
-
+
LL_CDEBUG_PAGE(D_PAGE, page, "completing cmd %d with %d\n", cmd, rc);
if (cmd & OBD_BRW_READ && llap->llap_defer_uptodate)
} else {
if (cmd & OBD_BRW_READ) {
llap->llap_defer_uptodate = 0;
- } else {
- ll_redirty_page(page);
- ret = 1;
}
SetPageError(page);
+ if (rc == -ENOSPC)
+ set_bit(AS_ENOSPC, &page->mapping->flags);
+ else
+ set_bit(AS_EIO, &page->mapping->flags);
}
unlock_page(page);
- if (0 && cmd & OBD_BRW_WRITE) {
- llap_write_complete(page->mapping->host, llap);
- ll_try_done_writing(page->mapping->host);
+ if (cmd & OBD_BRW_WRITE) {
+ /* Only rc == 0, write succeed, then this page could be deleted
+ * from the pending_writing list
+ */
+ if (rc == 0 && llap_write_complete(page->mapping->host, llap))
+ ll_queue_done_writing(page->mapping->host, 0);
}
if (PageWriteback(page)) {
LL_CDEBUG_PAGE(D_PAGE, page, "being evicted\n");
- exp = ll_i2obdexp(inode);
+ exp = ll_i2dtexp(inode);
if (exp == NULL) {
CERROR("page %p ind %lu gave null export\n", page, page->index);
EXIT;
return;
}
- llap = llap_from_page(page, 0);
+ llap = llap_from_page(page, LLAP_ORIGIN_REMOVEPAGE);
if (IS_ERR(llap)) {
CERROR("page %p ind %lu couldn't find llap: %ld\n", page,
page->index, PTR_ERR(llap));
return;
}
- //llap_write_complete(inode, llap);
+ if (llap_write_complete(inode, llap))
+ ll_queue_done_writing(inode, 0);
+
rc = obd_teardown_async_page(exp, ll_i2info(inode)->lli_smd, NULL,
llap->llap_cookie);
if (rc != 0)
flags = LDLM_FL_TEST_LOCK | LDLM_FL_BLOCK_GRANTED;
if (!(fd_flags & LL_FILE_READAHEAD))
flags |= LDLM_FL_CBPENDING;
- matches = obd_match(ll_i2sbi(inode)->ll_osc_exp,
+ matches = obd_match(ll_i2sbi(inode)->ll_dt_exp,
ll_i2info(inode)->lli_smd, LDLM_EXTENT,
&page_extent, LCK_PR | LCK_PW, &flags, inode,
&match_lockh);
llap->llap_ra_used = 0;
rc = obd_queue_group_io(exp, ll_i2info(page->mapping->host)->lli_smd,
NULL, oig, llap->llap_cookie, OBD_BRW_READ, 0,
- CFS_PAGE_SIZE, 0, ASYNC_COUNT_STABLE | ASYNC_READY |
- ASYNC_URGENT);
+ CFS_PAGE_SIZE, 0, ASYNC_COUNT_STABLE |
+ ASYNC_READY | ASYNC_URGENT);
if (rc) {
LL_CDEBUG_PAGE(D_ERROR, page, "read queue failed: rc %d\n", rc);
page_cache_release(page);
lov_stripe_lock(lsm);
inode_init_lvb(inode, &lvb);
- obd_merge_lvb(ll_i2obdexp(inode), lsm, &lvb, 1);
+ obd_merge_lvb(ll_i2dtexp(inode), lsm, &lvb, 1);
kms = lvb.lvb_size;
lov_stripe_unlock(lsm);
if (kms == 0) {
if (ras->ras_requests == 2 && !ras->ras_request_index) {
__u64 kms_pages;
- kms_pages = (inode->i_size + CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT;
+ kms_pages = (i_size_read(inode) + CFS_PAGE_SIZE - 1) >>
+ CFS_PAGE_SHIFT;
CDEBUG(D_READA, "kmsp "LPU64" mwp %lu mp %lu\n", kms_pages,
ra->ra_max_read_ahead_whole_pages, ra->ra_max_pages);
LASSERT(!PageDirty(page));
LASSERT(PageLocked(page));
- exp = ll_i2obdexp(inode);
+ exp = ll_i2dtexp(inode);
if (exp == NULL)
GOTO(out, rc = -EINVAL);
if (PageWriteback(page)) {
end_page_writeback(page);
}
- ll_redirty_page(page);
+ /* resend page only for not started IO*/
+ if (!PageError(page))
+ ll_redirty_page(page);
unlock_page(page);
}
RETURN(rc);
if (rc < 0)
GOTO(out, rc);
- exp = ll_i2obdexp(inode);
+ exp = ll_i2dtexp(inode);
if (exp == NULL)
GOTO(out, rc = -EINVAL);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff