#include <linux/security.h>
#include <uapi/linux/lustre/lustre_ioctl.h>
+#ifdef HAVE_UAPI_LINUX_MOUNT_H
+#include <uapi/linux/mount.h>
+#endif
+
#include <lustre_ha.h>
#include <lustre_dlm.h>
#include <lprocfs_status.h>
unsigned long pages;
unsigned long lru_page_max;
struct sysinfo si;
+ int rc;
int i;
+
ENTRY;
OBD_ALLOC_PTR(sbi);
if (sbi == NULL)
- RETURN(NULL);
+ RETURN(ERR_PTR(-ENOMEM));
+
+ rc = pcc_super_init(&sbi->ll_pcc_super);
+ if (rc < 0)
+ GOTO(out_sbi, rc);
spin_lock_init(&sbi->ll_lock);
mutex_init(&sbi->ll_lco.lco_lock);
spin_lock_init(&sbi->ll_pp_extent_lock);
spin_lock_init(&sbi->ll_process_lock);
sbi->ll_rw_stats_on = 0;
+ sbi->ll_statfs_max_age = OBD_STATFS_CACHE_SECONDS;
si_meminfo(&si);
pages = si.totalram - si.totalhigh;
lru_page_max = pages / 2;
+ sbi->ll_ra_info.ra_async_max_active = 0;
+ sbi->ll_ra_info.ll_readahead_wq =
+ alloc_workqueue("ll-readahead-wq", WQ_UNBOUND,
+ sbi->ll_ra_info.ra_async_max_active);
+ if (!sbi->ll_ra_info.ll_readahead_wq)
+ GOTO(out_pcc, rc = -ENOMEM);
+
/* initialize ll_cache data */
sbi->ll_cache = cl_cache_init(lru_page_max);
- if (sbi->ll_cache == NULL) {
- OBD_FREE(sbi, sizeof(*sbi));
- RETURN(NULL);
- }
+ if (sbi->ll_cache == NULL)
+ GOTO(out_destroy_ra, rc = -ENOMEM);
sbi->ll_ra_info.ra_max_pages_per_file = min(pages / 32,
SBI_DEFAULT_READAHEAD_MAX);
+ sbi->ll_ra_info.ra_async_pages_per_file_threshold =
+ sbi->ll_ra_info.ra_max_pages_per_file;
sbi->ll_ra_info.ra_max_pages = sbi->ll_ra_info.ra_max_pages_per_file;
sbi->ll_ra_info.ra_max_read_ahead_whole_pages = -1;
sbi->ll_squash.rsi_uid = 0;
sbi->ll_squash.rsi_gid = 0;
INIT_LIST_HEAD(&sbi->ll_squash.rsi_nosquash_nids);
- init_rwsem(&sbi->ll_squash.rsi_sem);
- pcc_super_init(&sbi->ll_pcc_super);
+ spin_lock_init(&sbi->ll_squash.rsi_lock);
/* Per-filesystem file heat */
sbi->ll_heat_decay_weight = SBI_DEFAULT_HEAT_DECAY_WEIGHT;
sbi->ll_heat_period_second = SBI_DEFAULT_HEAT_PERIOD_SECOND;
RETURN(sbi);
+out_destroy_ra:
+ destroy_workqueue(sbi->ll_ra_info.ll_readahead_wq);
+out_pcc:
+ pcc_super_fini(&sbi->ll_pcc_super);
+out_sbi:
+ OBD_FREE_PTR(sbi);
+ RETURN(ERR_PTR(rc));
}
static void ll_free_sbi(struct super_block *sb)
if (sbi != NULL) {
if (!list_empty(&sbi->ll_squash.rsi_nosquash_nids))
cfs_free_nidlist(&sbi->ll_squash.rsi_nosquash_nids);
+ if (sbi->ll_ra_info.ll_readahead_wq)
+ destroy_workqueue(sbi->ll_ra_info.ll_readahead_wq);
if (sbi->ll_cache != NULL) {
cl_cache_decref(sbi->ll_cache);
sbi->ll_cache = NULL;
if (sbi->ll_flags & LL_SBI_LRU_RESIZE)
data->ocd_connect_flags |= OBD_CONNECT_LRU_RESIZE;
#endif
-#ifdef CONFIG_FS_POSIX_ACL
+#ifdef CONFIG_LUSTRE_FS_POSIX_ACL
data->ocd_connect_flags |= OBD_CONNECT_ACL | OBD_CONNECT_UMASK |
OBD_CONNECT_LARGE_ACL;
#endif
if (OBD_FAIL_CHECK(OBD_FAIL_MDC_LIGHTWEIGHT))
/* flag mdc connection as lightweight, only used for test
* purpose, use with care */
- data->ocd_connect_flags |= OBD_CONNECT_LIGHTWEIGHT;
+ data->ocd_connect_flags |= OBD_CONNECT_LIGHTWEIGHT;
- data->ocd_ibits_known = MDS_INODELOCK_FULL;
- data->ocd_version = LUSTRE_VERSION_CODE;
+ data->ocd_ibits_known = MDS_INODELOCK_FULL;
+ data->ocd_version = LUSTRE_VERSION_CODE;
- if (sb->s_flags & MS_RDONLY)
- data->ocd_connect_flags |= OBD_CONNECT_RDONLY;
- if (sbi->ll_flags & LL_SBI_USER_XATTR)
- data->ocd_connect_flags |= OBD_CONNECT_XATTR;
+ if (sb->s_flags & SB_RDONLY)
+ data->ocd_connect_flags |= OBD_CONNECT_RDONLY;
+ if (sbi->ll_flags & LL_SBI_USER_XATTR)
+ data->ocd_connect_flags |= OBD_CONNECT_XATTR;
-#ifdef MS_NOSEC
+#ifdef SB_NOSEC
/* Setting this indicates we correctly support S_NOSEC (See kernel
* commit 9e1f1de02c2275d7172e18dc4e7c2065777611bf)
*/
- sb->s_flags |= MS_NOSEC;
+ sb->s_flags |= SB_NOSEC;
#endif
- if (sbi->ll_flags & LL_SBI_FLOCK)
- sbi->ll_fop = &ll_file_operations_flock;
- else if (sbi->ll_flags & LL_SBI_LOCALFLOCK)
- sbi->ll_fop = &ll_file_operations;
- else
- sbi->ll_fop = &ll_file_operations_noflock;
+ if (sbi->ll_flags & LL_SBI_FLOCK)
+ sbi->ll_fop = &ll_file_operations_flock;
+ else if (sbi->ll_flags & LL_SBI_LOCALFLOCK)
+ sbi->ll_fop = &ll_file_operations;
+ else
+ sbi->ll_fop = &ll_file_operations_noflock;
/* always ping even if server suppress_pings */
if (sbi->ll_flags & LL_SBI_ALWAYS_PING)
err = obd_connect(NULL, &sbi->ll_md_exp, sbi->ll_md_obd,
&sbi->ll_sb_uuid, data, sbi->ll_cache);
- if (err == -EBUSY) {
- LCONSOLE_ERROR_MSG(0x14f, "An MDT (md %s) is performing "
- "recovery, of which this client is not a "
- "part. Please wait for recovery to complete,"
- " abort, or time out.\n", md);
- GOTO(out, err);
- } else if (err) {
- CERROR("cannot connect to %s: rc = %d\n", md, err);
- GOTO(out, err);
- }
+ if (err == -EBUSY) {
+ LCONSOLE_ERROR_MSG(0x14f, "An MDT (md %s) is performing "
+ "recovery, of which this client is not a "
+ "part. Please wait for recovery to complete,"
+ " abort, or time out.\n", md);
+ GOTO(out, err);
+ } else if (err) {
+ CERROR("cannot connect to %s: rc = %d\n", md, err);
+ GOTO(out, err);
+ }
sbi->ll_md_exp->exp_connect_data = *data;
* can make sure the client can be mounted as long as MDT0 is
* avaible */
err = obd_statfs(NULL, sbi->ll_md_exp, osfs,
- ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS,
+ ktime_get_seconds() - sbi->ll_statfs_max_age,
OBD_STATFS_FOR_MDT0);
if (err)
GOTO(out_md_fid, err);
sbi->ll_namelen = osfs->os_namelen;
sbi->ll_mnt.mnt = current->fs->root.mnt;
- if ((sbi->ll_flags & LL_SBI_USER_XATTR) &&
- !(data->ocd_connect_flags & OBD_CONNECT_XATTR)) {
- LCONSOLE_INFO("Disabling user_xattr feature because "
- "it is not supported on the server\n");
- sbi->ll_flags &= ~LL_SBI_USER_XATTR;
- }
+ if ((sbi->ll_flags & LL_SBI_USER_XATTR) &&
+ !(data->ocd_connect_flags & OBD_CONNECT_XATTR)) {
+ LCONSOLE_INFO("Disabling user_xattr feature because "
+ "it is not supported on the server\n");
+ sbi->ll_flags &= ~LL_SBI_USER_XATTR;
+ }
- if (data->ocd_connect_flags & OBD_CONNECT_ACL) {
-#ifdef MS_POSIXACL
- sb->s_flags |= MS_POSIXACL;
+ if (data->ocd_connect_flags & OBD_CONNECT_ACL) {
+#ifdef SB_POSIXACL
+ sb->s_flags |= SB_POSIXACL;
#endif
- sbi->ll_flags |= LL_SBI_ACL;
- } else {
- LCONSOLE_INFO("client wants to enable acl, but mdt not!\n");
-#ifdef MS_POSIXACL
- sb->s_flags &= ~MS_POSIXACL;
+ sbi->ll_flags |= LL_SBI_ACL;
+ } else {
+ LCONSOLE_INFO("client wants to enable acl, but mdt not!\n");
+#ifdef SB_POSIXACL
+ sb->s_flags &= ~SB_POSIXACL;
#endif
- sbi->ll_flags &= ~LL_SBI_ACL;
- }
+ sbi->ll_flags &= ~LL_SBI_ACL;
+ }
- if (data->ocd_connect_flags & OBD_CONNECT_64BITHASH)
- sbi->ll_flags |= LL_SBI_64BIT_HASH;
+ if (data->ocd_connect_flags & OBD_CONNECT_64BITHASH)
+ sbi->ll_flags |= LL_SBI_64BIT_HASH;
if (data->ocd_connect_flags & OBD_CONNECT_LAYOUTLOCK)
sbi->ll_flags |= LL_SBI_LAYOUT_LOCK;
CDEBUG(D_SUPER, "rootfid "DFID"\n", PFID(&sbi->ll_root_fid));
sb->s_op = &lustre_super_operations;
-#ifdef HAVE_XATTR_HANDLER_FLAGS
sb->s_xattr = ll_xattr_handlers;
-#endif
#if THREAD_SIZE >= 8192 /*b=17630*/
sb->s_export_op = &lustre_export_operations;
#endif
ptlrpc_req_finished(request);
if (IS_ERR(root)) {
-#ifdef CONFIG_FS_POSIX_ACL
+#ifdef CONFIG_LUSTRE_FS_POSIX_ACL
if (lmd.posix_acl) {
posix_acl_release(lmd.posix_acl);
lmd.posix_acl = NULL;
#endif
err = IS_ERR(root) ? PTR_ERR(root) : -EBADF;
root = NULL;
- CERROR("lustre_lite: bad iget4 for root\n");
+ CERROR("%s: bad ll_iget() for root: rc = %d\n",
+ sbi->ll_fsname, err);
GOTO(out_root, err);
}
sbi->ll_fsname, err);
GOTO(out_root, err);
}
-#ifdef HAVE_DCACHE_LOCK
- sb->s_root->d_op = &ll_d_ops;
-#endif
sbi->ll_sdev_orig = sb->s_dev;
struct ll_sb_info *sbi;
ENTRY;
- /* not init sb ?*/
- if (!(sb->s_flags & MS_ACTIVE))
+ /* not init sb ?*/
+ if (!(sb->s_flags & SB_ACTIVE))
return;
sbi = ll_s2sbi(sb);
* put_super not affected real removing devices */
if (sbi) {
sb->s_dev = sbi->ll_sdev_orig;
- sbi->ll_umounting = 1;
/* wait running statahead threads to quit */
while (atomic_read(&sbi->ll_sa_running) > 0) {
set_current_state(TASK_UNINTERRUPTIBLE);
- schedule_timeout(msecs_to_jiffies(MSEC_PER_SEC >> 3));
+ schedule_timeout(cfs_time_seconds(1) >> 3);
}
}
LASSERT(lli->lli_vfs_inode.i_mode != 0);
if (S_ISDIR(lli->lli_vfs_inode.i_mode)) {
- mutex_init(&lli->lli_readdir_mutex);
lli->lli_opendir_key = NULL;
lli->lli_sai = NULL;
spin_lock_init(&lli->lli_sa_lock);
lli->lli_opendir_pid = 0;
lli->lli_sa_enabled = 0;
- lli->lli_def_stripe_offset = -1;
init_rwsem(&lli->lli_lsm_sem);
} else {
mutex_init(&lli->lli_size_mutex);
obd_heat_clear(lli->lli_heat_instances, OBD_HEAT_COUNT);
lli->lli_heat_flags = 0;
mutex_init(&lli->lli_pcc_lock);
+ lli->lli_pcc_state = PCC_STATE_FL_NONE;
lli->lli_pcc_inode = NULL;
+ mutex_init(&lli->lli_group_mutex);
+ lli->lli_group_users = 0;
+ lli->lli_group_gid = 0;
}
mutex_init(&lli->lli_layout_mutex);
memset(lli->lli_jobid, 0, sizeof(lli->lli_jobid));
/* client additional sb info */
lsi->lsi_llsbi = sbi = ll_init_sbi();
- if (!sbi)
- GOTO(out_free_cfg, err = -ENOMEM);
+ if (IS_ERR(sbi))
+ GOTO(out_free_cfg, err = PTR_ERR(sbi));
err = ll_options(lsi->lsi_lmd->lmd_opts, sbi);
if (err)
GOTO(out_free_cfg, err);
-#ifndef HAVE_DCACHE_LOCK
/* kernel >= 2.6.38 store dentry operations in sb->s_d_op. */
sb->s_d_op = &ll_d_ops;
-#endif
+
/* UUID handling */
generate_random_uuid(uuid.b);
snprintf(sbi->ll_sb_uuid.uuid, UUID_SIZE, "%pU", uuid.b);
int next, force = 1, rc = 0;
ENTRY;
- if (!sbi)
+ if (IS_ERR(sbi))
GOTO(out_no_sbi, 0);
/* Should replace instance_id with something better for ASLR */
LASSERT(S_ISDIR(inode->i_mode));
- if (lli->lli_lsm_md != NULL) {
+ if (lli->lli_lsm_md) {
lmv_free_memmd(lli->lli_lsm_md);
lli->lli_lsm_md = NULL;
}
+
+ if (lli->lli_default_lsm_md) {
+ lmv_free_memmd(lli->lli_default_lsm_md);
+ lli->lli_default_lsm_md = NULL;
+ }
}
static struct inode *ll_iget_anon_dir(struct super_block *sb,
ll_i2sbi(inode)->ll_fsname, PFID(&lli->lli_fid));
lsm_md_dump(D_INODE, lsm);
+ if (!lmv_dir_striped(lsm))
+ goto out;
+
/* XXX sigh, this lsm_root initialization should be in
* LMV layer, but it needs ll_iget right now, so we
* put this here right now. */
return rc;
}
}
-
+out:
lli->lli_lsm_md = lsm;
return 0;
}
+static void ll_update_default_lsm_md(struct inode *inode, struct lustre_md *md)
+{
+ struct ll_inode_info *lli = ll_i2info(inode);
+
+ if (!md->default_lmv) {
+ /* clear default lsm */
+ if (lli->lli_default_lsm_md) {
+ down_write(&lli->lli_lsm_sem);
+ if (lli->lli_default_lsm_md) {
+ lmv_free_memmd(lli->lli_default_lsm_md);
+ lli->lli_default_lsm_md = NULL;
+ }
+ up_write(&lli->lli_lsm_sem);
+ }
+ } else if (lli->lli_default_lsm_md) {
+ /* update default lsm if it changes */
+ down_read(&lli->lli_lsm_sem);
+ if (lli->lli_default_lsm_md &&
+ !lsm_md_eq(lli->lli_default_lsm_md, md->default_lmv)) {
+ up_read(&lli->lli_lsm_sem);
+ down_write(&lli->lli_lsm_sem);
+ if (lli->lli_default_lsm_md)
+ lmv_free_memmd(lli->lli_default_lsm_md);
+ lli->lli_default_lsm_md = md->default_lmv;
+ lsm_md_dump(D_INODE, md->default_lmv);
+ md->default_lmv = NULL;
+ up_write(&lli->lli_lsm_sem);
+ } else {
+ up_read(&lli->lli_lsm_sem);
+ }
+ } else {
+ /* init default lsm */
+ down_write(&lli->lli_lsm_sem);
+ lli->lli_default_lsm_md = md->default_lmv;
+ lsm_md_dump(D_INODE, md->default_lmv);
+ md->default_lmv = NULL;
+ up_write(&lli->lli_lsm_sem);
+ }
+}
+
static int ll_update_lsm_md(struct inode *inode, struct lustre_md *md)
{
struct ll_inode_info *lli = ll_i2info(inode);
CDEBUG(D_INODE, "update lsm %p of "DFID"\n", lli->lli_lsm_md,
PFID(ll_inode2fid(inode)));
+ /* update default LMV */
+ if (md->default_lmv)
+ ll_update_default_lsm_md(inode, md);
+
/*
* no striped information from request, lustre_md from req does not
* include stripeEA, see ll_md_setattr()
*
* foreign LMV should not change.
*/
- if (lli->lli_lsm_md &&
- lli->lli_lsm_md->lsm_md_magic != LMV_MAGIC_FOREIGN &&
- !lsm_md_eq(lli->lli_lsm_md, lsm)) {
- if (lsm->lsm_md_layout_version <=
+ if (lli->lli_lsm_md && !lsm_md_eq(lli->lli_lsm_md, lsm)) {
+ if (lmv_dir_striped(lli->lli_lsm_md) &&
+ lsm->lsm_md_layout_version <=
lli->lli_lsm_md->lsm_md_layout_version) {
CERROR("%s: "DFID" dir layout mismatch:\n",
ll_i2sbi(inode)->ll_fsname,
if (!lli->lli_lsm_md) {
struct cl_attr *attr;
- if (lsm->lsm_md_magic == LMV_MAGIC_FOREIGN) {
- /* set md->lmv to NULL, so the following free lustre_md
- * will not free this lsm */
- md->lmv = NULL;
- lli->lli_lsm_md = lsm;
- up_write(&lli->lli_lsm_sem);
- RETURN(0);
- }
-
rc = ll_init_lsm_md(inode, md);
up_write(&lli->lli_lsm_sem);
if (rc != 0)
*/
down_read(&lli->lli_lsm_sem);
+ if (!lmv_dir_striped(lli->lli_lsm_md))
+ GOTO(unlock, rc);
+
OBD_ALLOC_PTR(attr);
if (attr == NULL)
GOTO(unlock, rc = -ENOMEM);
ll_xattr_cache_destroy(inode);
-#ifdef CONFIG_FS_POSIX_ACL
+#ifdef CONFIG_LUSTRE_FS_POSIX_ACL
forget_all_cached_acls(inode);
if (lli->lli_posix_acl) {
posix_acl_release(lli->lli_posix_acl);
struct ll_inode_info *lli = ll_i2info(inode);
struct md_op_data *op_data = NULL;
int rc = 0;
+
ENTRY;
CDEBUG(D_VFSTRACE, "%s: setattr inode "DFID"(%p) from %llu to %llu, "
int rc;
ENTRY;
- max_age = ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS;
+ max_age = ktime_get_seconds() - sbi->ll_statfs_max_age;
rc = obd_statfs(NULL, sbi->ll_md_exp, osfs, max_age, flags);
if (rc)
int rc;
CDEBUG(D_VFSTRACE, "VFS Op: at %llu jiffies\n", get_jiffies_64());
- ll_stats_ops_tally(ll_s2sbi(sb), LPROC_LL_STAFS, 1);
+ ll_stats_ops_tally(ll_s2sbi(sb), LPROC_LL_STATFS, 1);
/* Some amount of caching on the client is allowed */
rc = ll_statfs_internal(ll_s2sbi(sb), &osfs, OBD_STATFS_SUM);
return rc;
}
-#ifdef CONFIG_FS_POSIX_ACL
+#ifdef CONFIG_LUSTRE_FS_POSIX_ACL
if (body->mbo_valid & OBD_MD_FLACL) {
spin_lock(&lli->lli_lock);
if (lli->lli_posix_acl)
ll_i2sbi(inode)->ll_fsname,
PFID(ll_inode2fid(inode)), inode, nrpages);
-#ifdef HAVE_SBOPS_EVICT_INODE
ll_clear_inode(inode);
-#endif
clear_inode(inode);
EXIT;
}
obd->obd_force = 1;
- obd = class_exp2obd(sbi->ll_dt_exp);
- if (obd == NULL) {
+ obd = class_exp2obd(sbi->ll_dt_exp);
+ if (obd == NULL) {
CERROR("Invalid LOV connection handle %#llx\n",
- sbi->ll_dt_exp->exp_handle.h_cookie);
- EXIT;
- return;
- }
- obd->obd_force = 1;
+ sbi->ll_dt_exp->exp_handle.h_cookie);
+ EXIT;
+ return;
+ }
+ obd->obd_force = 1;
- OBD_ALLOC_PTR(ioc_data);
+ OBD_ALLOC_PTR(ioc_data);
if (ioc_data) {
obd_iocontrol(IOC_OSC_SET_ACTIVE, sbi->ll_md_exp,
sizeof *ioc_data, ioc_data, NULL);
int ll_remount_fs(struct super_block *sb, int *flags, char *data)
{
- struct ll_sb_info *sbi = ll_s2sbi(sb);
- char *profilenm = get_profile_name(sb);
- int err;
- __u32 read_only;
-
- if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY)) {
- read_only = *flags & MS_RDONLY;
- err = obd_set_info_async(NULL, sbi->ll_md_exp,
- sizeof(KEY_READ_ONLY),
- KEY_READ_ONLY, sizeof(read_only),
- &read_only, NULL);
- if (err) {
- LCONSOLE_WARN("Failed to remount %s %s (%d)\n",
- profilenm, read_only ?
- "read-only" : "read-write", err);
- return err;
- }
+ struct ll_sb_info *sbi = ll_s2sbi(sb);
+ char *profilenm = get_profile_name(sb);
+ int err;
+ __u32 read_only;
+
+ if ((*flags & MS_RDONLY) != (sb->s_flags & SB_RDONLY)) {
+ read_only = *flags & MS_RDONLY;
+ err = obd_set_info_async(NULL, sbi->ll_md_exp,
+ sizeof(KEY_READ_ONLY),
+ KEY_READ_ONLY, sizeof(read_only),
+ &read_only, NULL);
+ if (err) {
+ LCONSOLE_WARN("Failed to remount %s %s (%d)\n",
+ profilenm, read_only ?
+ "read-only" : "read-write", err);
+ return err;
+ }
- if (read_only)
- sb->s_flags |= MS_RDONLY;
- else
- sb->s_flags &= ~MS_RDONLY;
+ if (read_only)
+ sb->s_flags |= SB_RDONLY;
+ else
+ sb->s_flags &= ~SB_RDONLY;
- if (sbi->ll_flags & LL_SBI_VERBOSE)
- LCONSOLE_WARN("Remounted %s %s\n", profilenm,
- read_only ? "read-only" : "read-write");
- }
- return 0;
+ if (sbi->ll_flags & LL_SBI_VERBOSE)
+ LCONSOLE_WARN("Remounted %s %s\n", profilenm,
+ read_only ? "read-only" : "read-write");
+ }
+ return 0;
}
/**
{
struct ll_sb_info *sbi = NULL;
struct lustre_md md = { NULL };
+ bool default_lmv_deleted = false;
int rc;
+
ENTRY;
LASSERT(*inode || sb);
if (rc != 0)
GOTO(out, rc);
+ /*
+ * clear default_lmv only if intent_getattr reply doesn't contain it.
+ * but it needs to be done after iget, check this early because
+ * ll_update_lsm_md() may change md.
+ */
+ if (it && (it->it_op & (IT_LOOKUP | IT_GETATTR)) &&
+ S_ISDIR(md.body->mbo_mode) && !md.default_lmv)
+ default_lmv_deleted = true;
+
if (*inode) {
rc = ll_update_inode(*inode, &md);
if (rc != 0)
sbi->ll_flags & LL_SBI_32BIT_API),
&md);
if (IS_ERR(*inode)) {
-#ifdef CONFIG_FS_POSIX_ACL
+#ifdef CONFIG_LUSTRE_FS_POSIX_ACL
if (md.posix_acl) {
posix_acl_release(md.posix_acl);
md.posix_acl = NULL;
LDLM_LOCK_PUT(lock);
}
+ if (default_lmv_deleted)
+ ll_update_default_lsm_md(*inode, &md);
+
GOTO(out, rc = 0);
out:
struct md_op_data *ll_prep_md_op_data(struct md_op_data *op_data,
struct inode *i1, struct inode *i2,
const char *name, size_t namelen,
- __u32 mode, __u32 opc, void *data)
+ __u32 mode, enum md_op_code opc,
+ void *data)
{
LASSERT(i1 != NULL);
ll_i2gids(op_data->op_suppgids, i1, i2);
op_data->op_fid1 = *ll_inode2fid(i1);
- op_data->op_default_stripe_offset = -1;
+ op_data->op_code = opc;
if (S_ISDIR(i1->i_mode)) {
down_read(&ll_i2info(i1)->lli_lsm_sem);
op_data->op_mea1_sem = &ll_i2info(i1)->lli_lsm_sem;
op_data->op_mea1 = ll_i2info(i1)->lli_lsm_md;
- if (opc == LUSTRE_OPC_MKDIR)
- op_data->op_default_stripe_offset =
- ll_i2info(i1)->lli_def_stripe_offset;
+ op_data->op_default_mea1 = ll_i2info(i1)->lli_default_lsm_md;
}
if (i2) {
path = ll_d_path(dentry, buf, PAGE_SIZE);
}
+ /* The below message is checked in recovery-small.sh test_24b */
CDEBUG(D_WARNING,
"%s: dirty page discard: %s/fid: "DFID"/%s may get corrupted "
"(rc %d)\n", ll_i2sbi(inode)->ll_fsname,
if (lum_size < 0)
RETURN(lum_size);
- OBD_ALLOC(*kbuf, lum_size);
+ OBD_ALLOC_LARGE(*kbuf, lum_size);
if (*kbuf == NULL)
RETURN(-ENOMEM);
if (copy_from_user(*kbuf, md, lum_size) != 0) {
- OBD_FREE(*kbuf, lum_size);
+ OBD_FREE_LARGE(*kbuf, lum_size);
RETURN(-EFAULT);
}
struct lnet_process_id id;
/* Update norootsquash flag */
- down_write(&squash->rsi_sem);
+ spin_lock(&squash->rsi_lock);
if (list_empty(&squash->rsi_nosquash_nids))
sbi->ll_flags &= ~LL_SBI_NOROOTSQUASH;
else {
else
sbi->ll_flags &= ~LL_SBI_NOROOTSQUASH;
}
- up_write(&squash->rsi_sem);
+ spin_unlock(&squash->rsi_lock);
}
/**
if (rc < 0)
GOTO(ldata_free, rc);
-#ifdef HAVE_XATTR_HANDLER_FLAGS
rc = ll_xattr_list(inode, XATTR_NAME_LINK, XATTR_TRUSTED_T, buf.lb_buf,
buf.lb_len, OBD_MD_FLXATTR);
-#else
- rc = ll_getxattr(file_dentry(file), XATTR_NAME_LINK, buf.lb_buf,
- buf.lb_len);
-#endif /* HAVE_XATTR_HANDLER_FLAGS */
if (rc < 0)
GOTO(lb_free, rc);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff