*
* You should have received a copy of the GNU General Public License
* version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
*
* GPL HEADER END
*/
* Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2012, 2015, Intel Corporation.
+ * Copyright (c) 2012, 2016, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
buf->lb_buf, DMU_READ_PREFETCH);
record_end_io(osd, READ, cfs_time_current() - start, size,
- size >> PAGE_CACHE_SHIFT);
+ size >> PAGE_SHIFT);
if (rc == 0) {
rc = size;
*pos += size;
* LOHA_EXISTs is supposed to be the last step in the
* initialization */
- /* declare possible size change. notice we can't check
- * current size here as another thread can change it */
-
- if (dt_object_exists(dt)) {
- LASSERT(obj->oo_db);
+ /* size change (in dnode) will be declared by dmu_tx_hold_write() */
+ if (dt_object_exists(dt))
oid = obj->oo_db->db_object;
-
- dmu_tx_hold_sa(oh->ot_tx, obj->oo_sa_hdl, 0);
- } else {
+ else
oid = DMU_NEW_OBJECT;
- dmu_tx_hold_sa_create(oh->ot_tx, ZFS_SA_BASE_ATTR_SIZE);
- }
/* XXX: we still miss for append declaration support in ZFS
* -1 means append which is used by llog mostly, llog
LASSERT(th != NULL);
oh = container_of0(th, struct osd_thandle, ot_super);
- record_start_io(osd, WRITE, 0);
-
dmu_write(osd->od_os, obj->oo_db->db_object, offset,
(uint64_t)buf->lb_len, buf->lb_buf, oh->ot_tx);
write_lock(&obj->oo_attr_lock);
rc = buf->lb_len;
out:
- record_end_io(osd, WRITE, 0, buf->lb_len,
- buf->lb_len >> PAGE_CACHE_SHIFT);
-
RETURN(rc);
}
dbf = (void *) ((unsigned long)dbp[i] | 1);
while (tocpy > 0) {
- thispage = PAGE_CACHE_SIZE;
- thispage -= bufoff & (PAGE_CACHE_SIZE - 1);
+ thispage = PAGE_SIZE;
+ thispage -= bufoff & (PAGE_SIZE - 1);
thispage = min(tocpy, thispage);
lnb->lnb_rc = 0;
/* go over pages arcbuf contains, put them as
* local niobufs for ptlrpc's bulks */
while (sz_in_block > 0) {
- plen = min_t(int, sz_in_block, PAGE_CACHE_SIZE);
+ plen = min_t(int, sz_in_block, PAGE_SIZE);
lnb[i].lnb_file_offset = off;
lnb[i].lnb_page_offset = 0;
/* can't use zerocopy, allocate temp. buffers */
while (sz_in_block > 0) {
- plen = min_t(int, sz_in_block, PAGE_CACHE_SIZE);
+ plen = min_t(int, sz_in_block, PAGE_SIZE);
lnb[i].lnb_file_offset = off;
lnb[i].lnb_page_offset = 0;
* copies */
space *= osd->od_os->os_copies;
space = toqb(space);
- CDEBUG(D_QUOTA, "writing %d pages, reserving "LPD64"K of quota space\n",
+ CDEBUG(D_QUOTA, "writing %d pages, reserving %lldK of quota space\n",
npages, space);
record_start_io(osd, WRITE, discont_pages);
RETURN(rc);
}
+/**
+ * Policy to grow ZFS block size by write pattern.
+ * For sequential write, it grows block size gradually until it reaches the
+ * maximum blocksize the dataset can support. Otherwise, it will pick a
+ * a block size by the writing region of this I/O.
+ */
+static int osd_grow_blocksize(struct osd_object *obj, struct osd_thandle *oh,
+ uint64_t start, uint64_t end)
+{
+ struct osd_device *osd = osd_obj2dev(obj);
+ dmu_buf_impl_t *db = (dmu_buf_impl_t *)obj->oo_db;
+ dnode_t *dn;
+ uint32_t blksz;
+ int rc = 0;
+
+ ENTRY;
+
+ DB_DNODE_ENTER(db);
+ dn = DB_DNODE(db);
+
+ if (dn->dn_maxblkid > 0) /* can't change block size */
+ GOTO(out, rc);
+
+ if (dn->dn_datablksz >= osd->od_max_blksz)
+ GOTO(out, rc);
+
+ down_write(&obj->oo_guard);
+
+ blksz = dn->dn_datablksz;
+ if (blksz >= osd->od_max_blksz) /* check again after grabbing lock */
+ GOTO(out_unlock, rc);
+
+ /* now ZFS can support up to 16MB block size, and if the write
+ * is sequential, it just increases the block size gradually */
+ if (start <= blksz) { /* sequential */
+ blksz = (uint32_t)min_t(uint64_t, osd->od_max_blksz, end);
+ } else { /* sparse, pick a block size by write region */
+ blksz = (uint32_t)min_t(uint64_t, osd->od_max_blksz,
+ end - start);
+ }
+
+ if (!is_power_of_2(blksz))
+ blksz = size_roundup_power2(blksz);
+
+ if (blksz > dn->dn_datablksz) {
+ rc = -dmu_object_set_blocksize(osd->od_os, dn->dn_object,
+ blksz, 0, oh->ot_tx);
+ LASSERT(ergo(rc == 0, dn->dn_datablksz >= blksz));
+ if (rc < 0)
+ CDEBUG(D_INODE, "object "DFID": change block size"
+ "%u -> %u error rc = %d\n",
+ PFID(lu_object_fid(&obj->oo_dt.do_lu)),
+ dn->dn_datablksz, blksz, rc);
+ }
+ EXIT;
+out_unlock:
+ up_write(&obj->oo_guard);
+out:
+ DB_DNODE_EXIT(db);
+ return rc;
+}
+
static int osd_write_commit(const struct lu_env *env, struct dt_object *dt,
struct niobuf_local *lnb, int npages,
struct thandle *th)
LASSERT(th != NULL);
oh = container_of0(th, struct osd_thandle, ot_super);
+ /* adjust block size. Assume the buffers are sorted. */
+ (void)osd_grow_blocksize(obj, oh, lnb[0].lnb_file_offset,
+ lnb[npages - 1].lnb_file_offset +
+ lnb[npages - 1].lnb_len);
+
+ /* LU-8791: take oo_guard to avoid the deadlock that changing block
+ * size and assigning arcbuf take place at the same time.
+ *
+ * Thread 1:
+ * osd_write_commit()
+ * -> osd_grow_blocksize() with osd_object::oo_guard held
+ * -> dmu_object_set_blocksize()
+ * -> dnode_set_blksz(), with dnode_t::dn_struct_rwlock
+ * write lock held
+ * -> dbuf_new_size()
+ * -> dmu_buf_will_dirty()
+ * -> dbuf_read()
+ * -> wait for the dbuf state to change
+ * Thread 2:
+ * osd_write_commit()
+ * -> dmu_assign_arcbuf()
+ * -> dbuf_assign_arcbuf(), set dbuf state to DB_FILL
+ * -> dbuf_dirty()
+ * -> try to hold the read lock of dnode_t::dn_struct_rwlock
+ *
+ * By taking the read lock, it can avoid thread 2 to enter into the
+ * critical section of assigning the arcbuf, while thread 1 is
+ * changing the block size.
+ */
+ down_read(&obj->oo_guard);
for (i = 0; i < npages; i++) {
CDEBUG(D_INODE, "write %u bytes at %u\n",
(unsigned) lnb[i].lnb_len,
new_size = lnb[i].lnb_file_offset + lnb[i].lnb_len;
iosize += lnb[i].lnb_len;
}
+ up_read(&obj->oo_guard);
if (unlikely(new_size == 0)) {
/* no pages to write, no transno is needed */
false));
}
+static int osd_ladvise(const struct lu_env *env, struct dt_object *dt,
+ __u64 start, __u64 end, enum lu_ladvise_type advice)
+{
+ int rc;
+ ENTRY;
+
+ switch (advice) {
+ default:
+ rc = -ENOTSUPP;
+ break;
+ }
+
+ RETURN(rc);
+}
struct dt_body_operations osd_body_ops = {
.dbo_read = osd_read,
.dbo_read_prep = osd_read_prep,
.dbo_declare_punch = osd_declare_punch,
.dbo_punch = osd_punch,
+ .dbo_ladvise = osd_ladvise,
};