* Use is subject to license terms.
*/
/*
+ * Copyright (c) 2011 Whamcloud, Inc.
+ */
+/*
* This file is part of Lustre, http://www.lustre.org/
* Lustre is a trademark of Sun Microsystems, Inc.
*
if (oti->oti_transno == 0) {
last_rcvd = le64_to_cpu(lsd->lsd_last_transno) + 1;
lsd->lsd_last_transno = cpu_to_le64(last_rcvd);
+ LASSERT(last_rcvd >= le64_to_cpu(lcd->lcd_last_transno));
} else {
last_rcvd = oti->oti_transno;
if (last_rcvd > le64_to_cpu(lsd->lsd_last_transno))
lsd->lsd_last_transno = cpu_to_le64(last_rcvd);
+ if (unlikely(last_rcvd < le64_to_cpu(lcd->lcd_last_transno))) {
+ CERROR("Trying to overwrite bigger transno, on-disk: "
+ LPU64", new: "LPU64"\n",
+ le64_to_cpu(lcd->lcd_last_transno), last_rcvd);
+ cfs_spin_lock(&exp->exp_lock);
+ exp->exp_vbr_failed = 1;
+ cfs_spin_unlock(&exp->exp_lock);
+ cfs_spin_unlock(&obt->obt_lut->lut_translock);
+ cfs_mutex_up(&ted->ted_lcd_lock);
+ RETURN(-EOVERFLOW);
+ }
}
oti->oti_transno = last_rcvd;
- LASSERT(last_rcvd >= le64_to_cpu(lcd->lcd_last_transno));
lcd->lcd_last_transno = cpu_to_le64(last_rcvd);
lcd->lcd_pre_versions[0] = cpu_to_le64(oti->oti_pre_version);
lcd->lcd_last_xid = cpu_to_le64(oti->oti_xid);
plus the procfs overhead :( */
static int filter_export_stats_init(struct obd_device *obd,
struct obd_export *exp,
- int reconnect,
void *client_nid)
{
int rc, newnid = 0;
/* Self-export gets no proc entry */
RETURN(0);
- rc = lprocfs_exp_setup(exp, client_nid, reconnect, &newnid);
+ rc = lprocfs_exp_setup(exp, client_nid, &newnid);
if (rc) {
/* Mask error for already created
* /proc entries */
RETURN(0);
clean:
- lprocfs_exp_cleanup(exp);
return rc;
}
fed = &exp->exp_filter_data;
*fed->fed_ted.ted_lcd = *lcd;
fed->fed_group = 0; /* will be assigned at connect */
- filter_export_stats_init(obd, exp, 0, NULL);
+ filter_export_stats_init(obd, exp, NULL);
rc = filter_client_add(obd, exp, cl_idx);
/* can't fail for existing client */
LASSERTF(rc == 0, "rc = %d\n", rc);
exp->exp_connecting = 0;
exp->exp_in_recovery = 0;
cfs_spin_unlock(&exp->exp_lock);
- cfs_spin_lock_bh(&obd->obd_processing_task_lock);
obd->obd_max_recoverable_clients++;
- cfs_spin_unlock_bh(&obd->obd_processing_task_lock);
class_export_put(exp);
if (last_rcvd > le64_to_cpu(lsd->lsd_last_transno))
loff_t off = 0;
ENTRY;
- O_dentry = simple_mkdir(current->fs->pwd, obd->u.obt.obt_vfsmnt,
+ O_dentry = simple_mkdir(cfs_fs_pwd(current->fs), obd->u.obt.obt_vfsmnt,
"O", 0700, 1);
CDEBUG(D_INODE, "got/created O: %p\n", O_dentry);
if (IS_ERR(O_dentry)) {
if (off == 0)
last_group = FID_SEQ_OST_MDT0;
- CWARN("%s: initialize groups [%d,%d]\n", obd->obd_name,
+ CWARN("%s: initialize groups [%u,%u]\n", obd->obd_name,
FID_SEQ_OST_MDT0, last_group);
filter->fo_committed_group = last_group;
rc = filter_read_groups(obd, last_group, 1);
{
struct filter_obd *filter = &obd->u.filter;
struct filter_subdirs *subdirs;
- LASSERT(group < filter->fo_group_count); /* FIXME: object groups */
+
+ if (group >= filter->fo_group_count) /* FIXME: object groups */
+ return ERR_PTR(-EBADF);
if (!fid_seq_is_mdt(group) || filter->fo_subdir_count == 0)
return filter->fo_dentry_O_groups[group];
obd->u.filter.fo_destroys_in_progress == 0) {
/* don't fail lookups for orphan recovery, it causes
* later LBUGs when objects still exist during precreate */
- CDEBUG(D_INFO, "*** obd_fail_loc=%x ***\n",OBD_FAIL_OST_ENOENT);
+ CDEBUG(D_INFO, "*** cfs_fail_loc=%x ***\n",OBD_FAIL_OST_ENOENT);
RETURN(ERR_PTR(-ENOENT));
}
if (id == 0) {
}
CDEBUG(D_INODE, "looking up object O/%.*s/%s\n",
dparent->d_name.len, dparent->d_name.name, name);
- dchild = /*ll_*/lookup_one_len(name, dparent, len);
+ /* dparent is already locked here, so we cannot use ll_lookup_one_len() */
+ dchild = lookup_one_len(name, dparent, len);
if (dir_dentry == NULL)
filter_parent_unlock(dparent);
if (IS_ERR(dchild)) {
GOTO(out, rc = -EPERM);
/* check_sticky() */
- if ((dentry->d_inode->i_uid != current->fsuid &&
+ if ((dentry->d_inode->i_uid != cfs_curproc_fsuid() &&
!cfs_capable(CFS_CAP_FOWNER)) || IS_APPEND(dentry->d_inode) ||
IS_IMMUTABLE(dentry->d_inode))
GOTO(out, rc = -EPERM);
/* NOTE: This might need to go outside i_mutex, though it isn't clear if
* that was done because of journal_start (which is already done
* here) or some other ordering issue. */
- DQUOT_INIT(dir);
+ ll_vfs_dq_init(dir);
rc = ll_security_inode_unlink(dir, dentry, mnt);
if (rc)
struct inode *inode = dchild->d_inode;
int rc;
- if (inode->i_nlink != 1 || atomic_read(&inode->i_count) != 1) {
+ /* There should be 2 references to the inode:
+ * 1) taken by filter_prepare_destroy
+ * 2) taken by filter_destroy */
+ if (inode->i_nlink != 1 || atomic_read(&inode->i_count) != 2) {
CERROR("destroying objid %.*s ino %lu nlink %lu count %d\n",
dchild->d_name.len, dchild->d_name.name, inode->i_ino,
(unsigned long)inode->i_nlink,
* lock, and should not be granted if the lock will be blocked.
*/
- LASSERT(ns == res->lr_namespace);
+ LASSERT(ns == ldlm_res_to_ns(res));
lock_res(res);
rc = policy(lock, &tmpflags, 0, &err, &rpc_list);
check_res_locked(res);
if (rc == LDLM_ITER_CONTINUE) {
/* do not grant locks to the liblustre clients: they cannot
* handle ASTs robustly. We need to do this while still
- * holding ns_lock to avoid the lock remaining on the res_link
+ * holding lr_lock to avoid the lock remaining on the res_link
* list (and potentially being added to l_pending_list by an
* AST) when we are going to drop this lock ASAP. */
if (lock->l_export->exp_libclient ||
*reply_lvb = *res_lvb;
/*
- * ->ns_lock guarantees that no new locks are granted, and,
+ * lr_lock guarantees that no new locks are granted, and,
* therefore, that res->lr_lvb_data cannot increase beyond the
* end of already granted lock. As a result, it is safe to
* check against "stale" reply_lvb->lvb_size value without
LASSERTF(l->l_glimpse_ast != NULL, "l == %p", l);
rc = l->l_glimpse_ast(l, NULL); /* this will update the LVB */
- /* Update the LVB from disk if the AST failed (this is a legal race) */
- /*
- * XXX nikita: situation when ldlm_server_glimpse_ast() failed before
- * sending ast is not handled. This can result in lost client writes.
- */
- if (rc != 0)
- ldlm_res_lvbo_update(res, NULL, 1);
lock_res(res);
*reply_lvb = *res_lvb;
__u8 *uuid_ptr;
char *str, *label;
char ns_name[48];
- request_queue_t *q;
+ struct request_queue *q;
int rc, i;
ENTRY;
CFS_INIT_LIST_HEAD(&filter->fo_export_list);
cfs_sema_init(&filter->fo_alloc_lock, 1);
init_brw_stats(&filter->fo_filter_stats);
+ cfs_spin_lock_init(&filter->fo_flags_lock);
filter->fo_read_cache = 1; /* enable read-only cache by default */
filter->fo_writethrough_cache = 1; /* enable writethrough cache */
filter->fo_readcache_max_filesize = FILTER_MAX_CACHE_SIZE;
GOTO(err_post, rc = -ENOMEM);
sprintf(ns_name, "filter-%s", obd->obd_uuid.uuid);
- obd->obd_namespace = ldlm_namespace_new(obd, ns_name, LDLM_NAMESPACE_SERVER,
- LDLM_NAMESPACE_GREEDY);
+ obd->obd_namespace = ldlm_namespace_new(obd, ns_name,
+ LDLM_NAMESPACE_SERVER,
+ LDLM_NAMESPACE_GREEDY,
+ LDLM_NS_TYPE_OST);
if (obd->obd_namespace == NULL)
GOTO(err_post, rc = -ENOMEM);
obd->obd_namespace->ns_lvbp = obd;
GOTO(err_post, rc);
q = bdev_get_queue(mnt->mnt_sb->s_bdev);
- if (q->max_sectors < q->max_hw_sectors &&
- q->max_sectors < PTLRPC_MAX_BRW_SIZE >> 9)
+ if (queue_max_sectors(q) < queue_max_hw_sectors(q) &&
+ queue_max_sectors(q) < PTLRPC_MAX_BRW_SIZE >> 9)
LCONSOLE_INFO("%s: underlying device %s should be tuned "
"for larger I/O requests: max_sectors = %u "
"could be up to max_hw_sectors=%u\n",
obd->obd_name, mnt->mnt_sb->s_id,
- q->max_sectors, q->max_hw_sectors);
+ queue_max_sectors(q), queue_max_hw_sectors(q));
uuid_ptr = fsfilt_uuid(obd, obd->u.obt.obt_sb);
if (uuid_ptr != NULL) {
static int filter_setup(struct obd_device *obd, struct lustre_cfg* lcfg)
{
struct lprocfs_static_vars lvars;
+ cfs_proc_dir_entry_t *entry;
unsigned long addr;
struct page *page;
int rc;
+ ENTRY;
CLASSERT(offsetof(struct obd_device, u.obt) ==
offsetof(struct obd_device, u.filter.fo_obt));
if (!LUSTRE_CFG_BUFLEN(lcfg, 1) || !LUSTRE_CFG_BUFLEN(lcfg, 2))
RETURN(-EINVAL);
- /* 2.6.9 selinux wants a full option page for do_kern_mount (bug6471) */
- OBD_PAGE_ALLOC(page, CFS_ALLOC_STD);
- if (!page)
- RETURN(-ENOMEM);
- addr = (unsigned long)cfs_page_address(page);
- clear_page((void *)addr);
-
/* lprocfs must be setup before the filter so state can be safely added
* to /proc incrementally as the filter is setup */
lprocfs_filter_init_vars(&lvars);
- if (lprocfs_obd_setup(obd, lvars.obd_vars) == 0 &&
- lprocfs_alloc_obd_stats(obd, LPROC_FILTER_LAST) == 0) {
- /* Init obdfilter private stats here */
- lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_READ_BYTES,
- LPROCFS_CNTR_AVGMINMAX,
- "read_bytes", "bytes");
- lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_WRITE_BYTES,
- LPROCFS_CNTR_AVGMINMAX,
- "write_bytes", "bytes");
- lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_GET_PAGE,
- LPROCFS_CNTR_AVGMINMAX|LPROCFS_CNTR_STDDEV,
- "get_page", "usec");
- lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_NO_PAGE,
- LPROCFS_CNTR_AVGMINMAX,
- "get_page_failures", "num");
- lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_CACHE_ACCESS,
- LPROCFS_CNTR_AVGMINMAX,
- "cache_access", "pages");
- lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_CACHE_HIT,
- LPROCFS_CNTR_AVGMINMAX,
- "cache_hit", "pages");
- lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_CACHE_MISS,
- LPROCFS_CNTR_AVGMINMAX,
- "cache_miss", "pages");
-
- lproc_filter_attach_seqstat(obd);
- obd->obd_proc_exports_entry = lprocfs_register("exports",
- obd->obd_proc_entry,
- NULL, NULL);
- if (IS_ERR(obd->obd_proc_exports_entry)) {
- rc = PTR_ERR(obd->obd_proc_exports_entry);
- CERROR("error %d setting up lprocfs for %s\n",
- rc, "exports");
- obd->obd_proc_exports_entry = NULL;
- }
+ rc = lprocfs_obd_setup(obd, lvars.obd_vars);
+ if (rc) {
+ CERROR("%s: lprocfs_obd_setup failed: %d.\n",
+ obd->obd_name, rc);
+ RETURN(rc);
+ }
+
+ rc = lprocfs_alloc_obd_stats(obd, LPROC_FILTER_LAST);
+ if (rc) {
+ CERROR("%s: lprocfs_alloc_obd_stats failed: %d.\n",
+ obd->obd_name, rc);
+ GOTO(obd_cleanup, rc);
}
- if (obd->obd_proc_exports_entry)
- lprocfs_add_simple(obd->obd_proc_exports_entry, "clear",
+
+ /* Init obdfilter private stats here */
+ lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_READ_BYTES,
+ LPROCFS_CNTR_AVGMINMAX, "read_bytes", "bytes");
+ lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_WRITE_BYTES,
+ LPROCFS_CNTR_AVGMINMAX, "write_bytes", "bytes");
+ lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_GET_PAGE,
+ LPROCFS_CNTR_AVGMINMAX|LPROCFS_CNTR_STDDEV,
+ "get_page", "usec");
+ lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_NO_PAGE,
+ LPROCFS_CNTR_AVGMINMAX, "get_page_failures", "num");
+ lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_CACHE_ACCESS,
+ LPROCFS_CNTR_AVGMINMAX, "cache_access", "pages");
+ lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_CACHE_HIT,
+ LPROCFS_CNTR_AVGMINMAX, "cache_hit", "pages");
+ lprocfs_counter_init(obd->obd_stats, LPROC_FILTER_CACHE_MISS,
+ LPROCFS_CNTR_AVGMINMAX, "cache_miss", "pages");
+
+ rc = lproc_filter_attach_seqstat(obd);
+ if (rc) {
+ CERROR("%s: create seqstat failed: %d.\n", obd->obd_name, rc);
+ GOTO(free_obd_stats, rc);
+ }
+
+ entry = lprocfs_register("exports", obd->obd_proc_entry, NULL, NULL);
+ if (IS_ERR(entry)) {
+ rc = PTR_ERR(entry);
+ CERROR("%s: error %d setting up lprocfs for %s\n",
+ obd->obd_name, rc, "exports");
+ GOTO(free_obd_stats, rc);
+ }
+ obd->obd_proc_exports_entry = entry;
+
+ entry = lprocfs_add_simple(obd->obd_proc_exports_entry, "clear",
lprocfs_nid_stats_clear_read,
lprocfs_nid_stats_clear_write, obd, NULL);
+ if (IS_ERR(entry)) {
+ rc = PTR_ERR(entry);
+ CERROR("%s: add proc entry 'clear' failed: %d.\n",
+ obd->obd_name, rc);
+ GOTO(free_obd_stats, rc);
+ }
+ /* 2.6.9 selinux wants a full option page for do_kern_mount (bug6471) */
+ OBD_PAGE_ALLOC(page, CFS_ALLOC_STD);
+ if (!page)
+ GOTO(remove_entry_clear, rc = -ENOMEM);
+ addr = (unsigned long)cfs_page_address(page);
+ clear_page((void *)addr);
memcpy((void *)addr, lustre_cfg_buf(lcfg, 4),
LUSTRE_CFG_BUFLEN(lcfg, 4));
rc = filter_common_setup(obd, lcfg, (void *)addr);
OBD_PAGE_FREE(page);
-
if (rc) {
- lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry);
- lprocfs_free_per_client_stats(obd);
- lprocfs_free_obd_stats(obd);
- lprocfs_obd_cleanup(obd);
+ CERROR("%s: filter_common_setup failed: %d.\n",
+ obd->obd_name, rc);
+ GOTO(remove_entry_clear, rc);
}
+ RETURN(0);
+
+remove_entry_clear:
+ lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry);
+free_obd_stats:
+ lprocfs_free_obd_stats(obd);
+obd_cleanup:
+ lprocfs_obd_cleanup(obd);
return rc;
}
*/
struct obd_llog_group *filter_find_create_olg(struct obd_device *obd, int group)
{
- struct obd_llog_group *olg = NULL;
+ struct obd_llog_group *olg = NULL, *olg_new = NULL;
struct filter_obd *filter;
int rc;
if (group == FID_SEQ_LLOG)
RETURN(&obd->obd_olg);
+ OBD_ALLOC_PTR(olg_new);
+ if (olg_new == NULL)
+ RETURN(ERR_PTR(-ENOMEM));
+
cfs_spin_lock(&filter->fo_llog_list_lock);
olg = filter_find_olg_internal(filter, group);
if (olg) {
} else {
GOTO(out_unlock, olg);
}
+ } else {
+ /* set as the newly allocated one */
+ olg = olg_new;
+ olg_new = NULL;
}
- OBD_ALLOC_PTR(olg);
- if (olg == NULL)
- GOTO(out_unlock, olg = ERR_PTR(-ENOMEM));
llog_group_init(olg, group);
cfs_list_add(&olg->olg_list, &filter->fo_llog_list);
out_unlock:
cfs_spin_unlock(&filter->fo_llog_list_lock);
- GOTO(out, olg);
+ if (olg_new)
+ OBD_FREE_PTR(olg_new);
+ goto out;
}
static int filter_llog_connect(struct obd_export *exp,
obd->obd_name, body->lgdc_logid.lgl_oid,
body->lgdc_logid.lgl_oseq, body->lgdc_logid.lgl_ogen);
- cfs_spin_lock_bh(&obd->obd_processing_task_lock);
+ cfs_spin_lock(&obd->u.filter.fo_flags_lock);
obd->u.filter.fo_mds_ost_sync = 1;
- cfs_spin_unlock_bh(&obd->obd_processing_task_lock);
+ cfs_spin_unlock(&obd->u.filter.fo_flags_lock);
rc = llog_connect(ctxt, &body->lgdc_logid,
&body->lgdc_gen, NULL);
llog_ctxt_put(ctxt);
filter_post(obd);
- LL_DQUOT_OFF(obd->u.obt.obt_sb);
+ ll_vfs_dq_off(obd->u.obt.obt_sb, 0);
shrink_dcache_sb(obd->u.obt.obt_sb);
server_put_mount(obd->obd_name, obd->u.obt.obt_vfsmnt);
CWARN("!!! This export (nid %s) used object group %d "
"earlier; now it's trying to use group %d! This could "
"be a bug in the MDS. Please report to "
- "http://bugzilla.lustre.org/\n",
+ "http://bugs.whamcloud.com/\n",
obd_export_nid2str(exp), fed->fed_group,data->ocd_group);
RETURN(-EPROTO);
}
} else if (data->ocd_connect_flags & OBD_CONNECT_BRW_SIZE) {
data->ocd_brw_size = min(data->ocd_brw_size,
(__u32)(PTLRPC_MAX_BRW_PAGES << CFS_PAGE_SHIFT));
- LASSERT(data->ocd_brw_size);
+ if (data->ocd_brw_size == 0) {
+ CERROR("%s: cli %s/%p ocd_connect_flags: "LPX64
+ " ocd_version: %x ocd_grant: %d ocd_index: %u "
+ "ocd_brw_size is unexpectedly zero, "
+ "network data corruption?"
+ "Refusing connection of this client\n",
+ exp->exp_obd->obd_name,
+ exp->exp_client_uuid.uuid,
+ exp, data->ocd_connect_flags, data->ocd_version,
+ data->ocd_grant, data->ocd_index);
+ RETURN(-EPROTO);
+ }
}
if (data->ocd_connect_flags & OBD_CONNECT_CKSUM) {
obd_export_nid2str(exp));
}
+ if (data->ocd_connect_flags & OBD_CONNECT_MAXBYTES)
+ data->ocd_maxbytes = exp->exp_obd->u.obt.obt_sb->s_maxbytes;
+
RETURN(0);
}
rc = filter_connect_internal(exp, data, 1);
if (rc == 0)
- filter_export_stats_init(obd, exp, 1, localdata);
+ filter_export_stats_init(obd, exp, localdata);
RETURN(rc);
}
if (rc)
GOTO(cleanup, rc);
- filter_export_stats_init(obd, lexp, 0, localdata);
+ filter_export_stats_init(obd, lexp, localdata);
if (obd->obd_replayable) {
struct lsd_client_data *lcd = lexp->exp_target_data.ted_lcd;
LASSERT(lcd);
cleanup:
if (rc) {
class_disconnect(lexp);
- lprocfs_exp_cleanup(lexp);
*exp = NULL;
} else {
*exp = lexp;
*fcc = oa->o_lcookie;
}
if (ia_valid & (ATTR_SIZE | ATTR_UID | ATTR_GID)) {
- DQUOT_INIT(inode);
+ unsigned long now = jiffies;
+ ll_vfs_dq_init(inode);
/* Filter truncates and writes are serialized by
* i_alloc_sem, see the comment in
* filter_preprw_write.*/
if (ia_valid & ATTR_SIZE)
down_write(&inode->i_alloc_sem);
LOCK_INODE_MUTEX(inode);
+ fsfilt_check_slow(exp->exp_obd, now, "i_alloc_sem and i_mutex");
old_size = i_size_read(inode);
}
* we have two left for the last_rcvd and VBR inode version updates. */
err = fsfilt_extend(exp->exp_obd, inode, 2, handle);
- rc = filter_finish_transno(exp, inode, oti, rc, sync);
+ /* Update inode version only if data has changed => size has changed */
+ rc = filter_finish_transno(exp, ia_valid & ATTR_SIZE ? inode : NULL,
+ oti, rc, sync);
+
if (sync) {
filter_cancel_cookies_cb(exp->exp_obd, 0, fcc, rc);
fcc = NULL;
*/
if (oa->o_valid &
(OBD_MD_FLMTIME | OBD_MD_FLATIME | OBD_MD_FLCTIME)) {
+ unsigned long now = jiffies;
down_write(&dentry->d_inode->i_alloc_sem);
+ fsfilt_check_slow(exp->exp_obd, now, "i_alloc_sem");
fmd = filter_fmd_get(exp, oa->o_id, oa->o_seq);
if (fmd && fmd->fmd_mactime_xid < oti->oti_xid)
fmd->fmd_mactime_xid = oti->oti_xid;
LASSERT((*lsmp)->lsm_object_id);
}
- (*lsmp)->lsm_maxbytes = LUSTRE_STRIPE_MAXBYTES;
+ (*lsmp)->lsm_maxbytes = exp->exp_obd->u.obt.obt_sb->s_maxbytes;
RETURN(lsm_size);
}
filter_set_last_id(filter, id, doa.o_seq);
rc = filter_update_last_objid(exp->exp_obd, doa.o_seq, 1);
} else {
- /* don't reuse orphan object, return last used objid */
+ /*
+ * We have destroyed orphan objects, but don't want to reuse
+ * them. Therefore we don't reset last_id to the last created
+ * objects. Instead, we report back to the MDS the object id
+ * of the last orphan, so that the MDS can restart allocating
+ * objects from this id + 1 and thus skip the whole orphan
+ * object id range
+ */
oa->o_id = last;
rc = 0;
}
struct lr_server_data *lsd = class_server_data(obd);
int index = le32_to_cpu(lsd->lsd_ost_index);
- if (obd_fail_val == -1 ||
- index == obd_fail_val)
+ if (cfs_fail_val == -1 || index == cfs_fail_val)
osfs->os_bfree = osfs->os_bavail = 2;
- else if (obd_fail_loc & OBD_FAIL_ONCE)
- obd_fail_loc &= ~OBD_FAILED; /* reset flag */
+ else if (cfs_fail_loc & OBD_FAIL_ONCE)
+ cfs_fail_loc &= ~OBD_FAILED; /* reset flag */
}
/* set EROFS to state field if FS is mounted as RDONLY. The goal is to
struct dentry *dchild = NULL, *dparent = NULL;
struct filter_obd *filter;
struct obd_statfs *osfs;
+ struct iattr iattr;
int err = 0, rc = 0, recreate_obj = 0, i;
cfs_time_t enough_time = cfs_time_shift(DISK_TIMEOUT/2);
__u64 os_ffree;
} else
next_id = filter_last_id(filter, group) + 1;
- /* Temporary solution for oid in CMD before fid-on-OST */
- if ((fid_seq_is_mdt0(oa->o_seq) && next_id >= IDIF_MAX_OID) &&
- (fid_seq_is_cmd(oa->o_seq) && next_id >= OBIF_MAX_OID)) {
- CERROR("%s:"POSTID" hit the max IDIF_MAX_OID(1<<48)!\n",
+ /* Don't create objects beyond the valid range for this SEQ */
+ if (unlikely(fid_seq_is_mdt0(group) &&
+ next_id >= IDIF_MAX_OID)) {
+ CERROR("%s:"POSTID" hit the IDIF_MAX_OID (1<<48)!\n",
+ obd->obd_name, next_id, group);
+ GOTO(cleanup, rc = -ENOSPC);
+ } else if (unlikely(!fid_seq_is_mdt0(group) &&
+ next_id >= OBIF_MAX_OID)) {
+ CERROR("%s:"POSTID" hit the OBIF_MAX_OID (1<<32)!\n",
obd->obd_name, next_id, group);
GOTO(cleanup, rc = -ENOSPC);
}
dchild->d_inode->i_ino);
set_last_id:
+ /* Set a/c/m time to a insane large negative value at creation
+ * time so that any timestamp arriving from the client will
+ * always be newer and update the inode.
+ * See LU-221 for details */
+ iattr.ia_valid = ATTR_ATIME | ATTR_MTIME | ATTR_CTIME;
+ LTIME_S(iattr.ia_atime) = INT_MIN + 24 * 3600;
+ LTIME_S(iattr.ia_mtime) = INT_MIN + 24 * 3600;
+ LTIME_S(iattr.ia_ctime) = INT_MIN + 24 * 3600;
+ err = fsfilt_setattr(obd, dchild, handle, &iattr, 0);
+ if (err)
+ CERROR("unable to initialize a/c/m time of newly"
+ "created inode\n");
+
if (!recreate_obj) {
filter_set_last_id(filter, next_id, group);
err = filter_update_last_objid(obd, group, 0);
struct llog_cookie *fcc = NULL;
int rc, rc2, cleanup_phase = 0, sync = 0;
struct iattr iattr;
+ unsigned long now;
ENTRY;
rc = filter_auth_capa(exp, NULL, oa->o_seq,
if (fcc != NULL)
*fcc = oa->o_lcookie;
}
- DQUOT_INIT(dchild->d_inode);
+ ll_vfs_dq_init(dchild->d_inode);
/* we're gonna truncate it first in order to avoid possible deadlock:
* P1 P2
* between page lock, i_mutex & starting new journal handle.
* (see bug 20321) -johann
*/
+ now = jiffies;
down_write(&dchild->d_inode->i_alloc_sem);
LOCK_INODE_MUTEX(dchild->d_inode);
+ fsfilt_check_slow(exp->exp_obd, now, "i_alloc_sem and i_mutex");
/* VBR: version recovery check */
rc = filter_version_get_check(exp, oti, dchild->d_inode);
RETURN(rc);
}
-static int filter_sync(struct obd_export *exp, struct obdo *oa,
- struct lov_stripe_md *lsm, obd_off start, obd_off end,
- void *capa)
+static int filter_sync(struct obd_export *exp, struct obd_info *oinfo,
+ obd_off start, obd_off end,
+ struct ptlrpc_request_set *set)
{
struct lvfs_run_ctxt saved;
struct obd_device_target *obt;
int rc, rc2;
ENTRY;
- rc = filter_auth_capa(exp, NULL, oa->o_seq,
- (struct lustre_capa *)capa, CAPA_OPC_OSS_WRITE);
+ rc = filter_auth_capa(exp, NULL, oinfo->oi_oa->o_seq,
+ (struct lustre_capa *)oinfo->oi_capa,
+ CAPA_OPC_OSS_WRITE);
if (rc)
RETURN(rc);
obt = &exp->exp_obd->u.obt;
/* An objid of zero is taken to mean "sync whole filesystem" */
- if (!oa || !(oa->o_valid & OBD_MD_FLID)) {
+ if (!oinfo->oi_oa || !(oinfo->oi_oa->o_valid & OBD_MD_FLID)) {
rc = fsfilt_sync(exp->exp_obd, obt->obt_sb);
/* Flush any remaining cancel messages out to the target */
filter_sync_llogs(exp->exp_obd, exp);
RETURN(rc);
}
- dentry = filter_oa2dentry(exp->exp_obd, &oa->o_oi);
+ dentry = filter_oa2dentry(exp->exp_obd, &oinfo->oi_oa->o_oi);
if (IS_ERR(dentry))
RETURN(PTR_ERR(dentry));
}
UNLOCK_INODE_MUTEX(dentry->d_inode);
- oa->o_valid = OBD_MD_FLID;
- obdo_from_inode(oa, dentry->d_inode, NULL, FILTER_VALID_FLAGS);
+ oinfo->oi_oa->o_valid = OBD_MD_FLID;
+ obdo_from_inode(oinfo->oi_oa, dentry->d_inode, NULL,
+ FILTER_VALID_FLAGS);
pop_ctxt(&saved, &exp->exp_obd->obd_lvfs_ctxt, NULL);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff