#include <linux/types.h>
#include <linux/random.h>
#include <linux/version.h>
+#include <linux/seq_file.h>
#include <linux/lustre_lite.h>
#include <linux/lustre_ha.h>
#include <linux/lustre_dlm.h>
#include <linux/lprocfs_status.h>
#include <linux/lustre_acl.h>
+#include <linux/lustre_audit.h>
+#include <linux/lustre_gs.h>
+#include <linux/lustre_sec.h>
#include "llite_internal.h"
kmem_cache_t *ll_file_data_slab;
sbi->ll_gns_timer.data = (unsigned long)sbi;
sbi->ll_gns_timer.function = ll_gns_timer_callback;
init_timer(&sbi->ll_gns_timer);
-
+ //audit mask
+ sbi->ll_audit_mask = AUDIT_OFF;
ll_set_sbi(sb, sbi);
generate_random_uuid(uuid);
RETURN(rc);
}
-extern struct dentry_operations ll_d_ops;
-
-int lustre_common_fill_super(struct super_block *sb, char *lmv, char *lov,
- int async, char *mds_security, char *oss_security,
- __u32 *nllu, __u64 *remote)
+static int lustre_connect_mds(struct super_block *sb, char *lmv,
+ struct obd_connect_data *data,
+ char *mds_security, int async, int pag)
{
struct ll_sb_info *sbi = ll_s2sbi(sb);
- struct ptlrpc_request *request = NULL;
- struct lustre_handle dt_conn = {0, };
struct lustre_handle md_conn = {0, };
- struct obd_connect_data *data;
- struct inode *root = NULL;
- struct obd_device *obd;
+ struct obd_device *md_obd;
struct obd_statfs osfs;
- struct lustre_md md;
- kdev_t devno;
- int err;
+ unsigned long sec_flags;
__u32 valsize;
- ENTRY;
-
- obd = class_name2obd(lmv);
- if (!obd) {
+ int err = 0;
+ ENTRY;
+
+ md_obd = class_name2obd(lmv);
+ if (!md_obd) {
CERROR("MDC %s: not setup or attached\n", lmv);
RETURN(-EINVAL);
}
- obd_set_info(obd->obd_self_export, strlen("async"), "async",
- sizeof(async), &async);
-
- if ((*remote & (OBD_CONNECT_LOCAL | OBD_CONNECT_REMOTE)) ==
- (OBD_CONNECT_LOCAL | OBD_CONNECT_REMOTE)) {
- CERROR("wrong remote flag "LPX64"\n", *remote);
- RETURN(-EINVAL);
- }
- OBD_ALLOC(data, sizeof(*data));
- if (!data)
- RETURN(-ENOMEM);
-
- data->ocd_connect_flags |= *remote & (OBD_CONNECT_LOCAL |
- OBD_CONNECT_REMOTE);
- memcpy(data->ocd_nllu, nllu, sizeof(data->ocd_nllu));
+ obd_set_info(md_obd->obd_self_export, strlen("async"), "async",
+ sizeof(async), &async);
if (mds_security == NULL)
mds_security = "null";
-
- err = obd_set_info(obd->obd_self_export, strlen("sec"), "sec",
+
+ err = obd_set_info(md_obd->obd_self_export, strlen("sec"), "sec",
strlen(mds_security), mds_security);
+
if (err) {
CERROR("LMV %s: failed to set security %s, err %d\n",
lmv, mds_security, err);
- OBD_FREE(data, sizeof(*data));
RETURN(err);
}
- if (proc_lustre_fs_root) {
- err = lprocfs_register_mountpoint(proc_lustre_fs_root,
- sb, lov, lmv);
- if (err < 0)
- CERROR("could not register mount in /proc/lustre");
+ if (pag) {
+ sec_flags = PTLRPC_SEC_FL_PAG;
+ err = obd_set_info(md_obd->obd_self_export,
+ strlen("sec_flags"), "sec_flags",
+ sizeof(sec_flags), &sec_flags);
+ if (err) {
+ OBD_FREE(data, sizeof(*data));
+ RETURN(err);
+ }
}
- err = obd_connect(&md_conn, obd, &sbi->ll_sb_uuid, data,
+ err = obd_connect(&md_conn, md_obd, &sbi->ll_sb_uuid, data,
OBD_OPT_REAL_CLIENT);
if (err == -EBUSY) {
CERROR("An MDS (lmv %s) is performing recovery, of which this"
CERROR("cannot connect to %s: rc = %d\n", lmv, err);
GOTO(out, err);
}
+
sbi->ll_md_exp = class_conn2export(&md_conn);
- err = obd_statfs(obd, &osfs, jiffies - HZ);
+
+ err = obd_statfs(md_obd, &osfs, jiffies - HZ);
if (err)
- GOTO(out_lmv, err);
+ GOTO(out_disconnect, err);
if (!osfs.os_bsize) {
CERROR("Invalid block size is detected.");
- GOTO(out_lmv, err);
+ GOTO(out_disconnect, err);
}
sb->s_magic = LL_SUPER_MAGIC;
sb->s_blocksize = osfs.os_bsize;
sb->s_blocksize_bits = log2(osfs.os_bsize);
sb->s_maxbytes = PAGE_CACHE_MAXBYTES;
-
- devno = get_uuid2int((char *)sbi->ll_md_exp->exp_obd->obd_uuid.uuid,
- strlen((char *)sbi->ll_md_exp->exp_obd->obd_uuid.uuid));
- sb->s_dev = devno;
+ /* in 2.6.x FS is not allowed to form s_dev */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+ {
+ kdev_t devno;
+
+ devno = get_uuid2int((char *)sbi->ll_md_exp->exp_obd->obd_uuid.uuid,
+ strlen((char *)sbi->ll_md_exp->exp_obd->obd_uuid.uuid));
+
+ sb->s_dev = devno;
+ }
+#endif
/* after statfs, we are supposed to have connected to MDSs,
* so it's ok to check remote flag returned.
&valsize, &sbi->ll_remote);
if (err) {
CERROR("fail to obtain remote flag\n");
- GOTO(out, err);
+ GOTO(out_disconnect, err);
}
+out_disconnect:
+ if (err)
+ obd_disconnect(sbi->ll_md_exp, 0);
+out:
+ RETURN(err);
+}
+
+static int lustre_connect_ost(struct super_block *sb, char *lov,
+ struct obd_connect_data *data,
+ char *oss_security, int async, int pag)
+{
+ struct ll_sb_info *sbi = ll_s2sbi(sb);
+ struct lustre_handle dt_conn = {0, };
+ struct obd_device *obd = NULL;
+ unsigned long sec_flags;
+ int err, mdsize;
+
obd = class_name2obd(lov);
if (!obd) {
CERROR("OSC %s: not setup or attached\n", lov);
- GOTO(out_lmv, err);
+ GOTO(out, err = -EINVAL);
}
obd_set_info(obd->obd_self_export, strlen("async"), "async",
sizeof(async), &async);
if (err) {
CERROR("LOV %s: failed to set security %s, err %d\n",
lov, oss_security, err);
+ RETURN(err);
+ }
+
+ /* FIXME Because of the async nature of file i/o, we never know
+ * who is actually dirty the pages; and any process have chance
+ * to trigger dirty-flushing within its own process context. So
+ * for simplicity we simply use root's credential, we suppose root
+ * always have credential.
+ */
+ if (pag)
+ sec_flags = PTLRPC_SEC_FL_PAG;
+ else
+ sec_flags = PTLRPC_SEC_FL_OSS;
+
+ err = obd_set_info(obd->obd_self_export,
+ strlen("sec_flags"), "sec_flags",
+ sizeof(sec_flags), &sec_flags);
+ if (err) {
OBD_FREE(data, sizeof(*data));
RETURN(err);
}
GOTO(out, err);
} else if (err) {
CERROR("cannot connect to %s: rc = %d\n", lov, err);
- GOTO(out_lmv, err);
+ GOTO(out, err);
}
sbi->ll_dt_exp = class_conn2export(&dt_conn);
err = lustre_init_dt_desc(sbi);
- if (err == 0) {
- int mdsize = obd_size_diskmd(sbi->ll_dt_exp, NULL);
- obd_init_ea_size(sbi->ll_md_exp, mdsize,
- sbi->ll_dt_desc.ld_tgt_count *
- sizeof(struct llog_cookie));
+
+ if (err) {
+ CWARN("init dt_desc error %d \n", err);
+ GOTO(out, err = 0);
}
-
+ mdsize = obd_size_diskmd(sbi->ll_dt_exp, NULL);
+ obd_init_ea_size(sbi->ll_md_exp, mdsize, sbi->ll_dt_desc.ld_tgt_count *
+ sizeof(struct llog_cookie));
+out:
+ RETURN(err);
+}
+
+extern struct dentry_operations ll_d_ops;
+
+static int lustre_init_root_inode(struct super_block *sb)
+{
+ struct ll_sb_info *sbi = ll_s2sbi(sb);
+ struct ptlrpc_request *request = NULL;
+ struct inode *root = NULL;
+ struct lustre_md md;
+ int err = 0;
+ ENTRY;
+
err = md_getstatus(sbi->ll_md_exp, &sbi->ll_rootid);
if (err) {
CERROR("cannot mds_connect: rc = %d\n", err);
- GOTO(out_lov, err);
+ GOTO(out, err);
}
CDEBUG(D_SUPER, "rootid "DLID4"\n", OLID4(&sbi->ll_rootid));
/* make root inode */
err = md_getattr(sbi->ll_md_exp, &sbi->ll_rootid,
(OBD_MD_FLNOTOBD | OBD_MD_FLBLOCKS | OBD_MD_FID),
- NULL, 0, 0, &request);
+ NULL, NULL, 0, 0, NULL, &request);
if (err) {
CERROR("md_getattr failed for root: rc = %d\n", err);
- GOTO(out_lov, err);
+ GOTO(out, err);
}
err = mdc_req2lustre_md(sbi->ll_md_exp, request, 0,
if (err) {
CERROR("failed to understand root inode md: rc = %d\n", err);
ptlrpc_req_finished(request);
- GOTO(out_lov, err);
+ GOTO(out, err);
}
LASSERT(id_ino(&sbi->ll_rootid) != 0);
CERROR("lustre_lite: bad iget4 for root\n");
GOTO(out_root, err = -EBADF);
}
+ sb->s_root = d_alloc_root(root);
+ sb->s_root->d_op = &ll_d_ops;
+out_root:
+ if (err)
+ iput(root);
+out:
+ RETURN(err);
+}
+
+int lustre_common_fill_super(struct super_block *sb, char *lmv, char *lov,
+ char *gkc, int async, char *mds_security,
+ char *oss_security, __u32 *nllu, int pag,
+ __u64 *remote)
+{
+ struct ll_sb_info *sbi = ll_s2sbi(sb);
+ struct obd_connect_data *data;
+ int err;
+ ENTRY;
+
+ /*process the connect flags*/
+ if ((*remote & (OBD_CONNECT_LOCAL | OBD_CONNECT_REMOTE)) ==
+ (OBD_CONNECT_LOCAL | OBD_CONNECT_REMOTE)) {
+ CERROR("wrong remote flag "LPX64"\n", *remote);
+ RETURN(-EINVAL);
+ }
+
+ OBD_ALLOC(data, sizeof(*data));
+ if (!data)
+ RETURN(-ENOMEM);
+
+ data->ocd_connect_flags |= *remote & (OBD_CONNECT_LOCAL |
+ OBD_CONNECT_REMOTE);
+ memcpy(data->ocd_nllu, nllu, sizeof(data->ocd_nllu));
+
+ if (proc_lustre_fs_root) {
+ err = lprocfs_register_mountpoint(proc_lustre_fs_root,
+ sb, lov, lmv);
+ if (err < 0)
+ CERROR("could not register mount in /proc/lustre");
+ }
+
+ /*connect mds */
+ err = lustre_connect_mds(sb, lmv, data, mds_security, async, pag);
+ if (err)
+ GOTO(out, err);
+
+ /*connect OST*/
+ err = lustre_connect_ost(sb, lov, data, oss_security, async, pag);
+ if (err)
+ GOTO(out_lmv, err);
+
+ /*connect GSS*/
+ err = lustre_init_crypto(sb, gkc, data, async);
+ if (err) {
+ CERROR("Could not connect to GSS err %d\n", err);
+ err = 0;
+ }
+
+ err = lustre_init_root_inode(sb);
+ if (err)
+ GOTO(out_gks, err);
err = ll_close_thread_start(&sbi->ll_lcq);
if (err) {
/* bug 2805 - set VM readahead to zero */
vm_max_readahead = vm_min_readahead = 0;
#endif
-
- sb->s_root = d_alloc_root(root);
- sb->s_root->d_op = &ll_d_ops;
-
sb->s_flags |= MS_POSIXACL;
#ifdef S_PDIROPS
CWARN("Enabling PDIROPS\n");
sb->s_flags |= S_PDIROPS;
#endif
-
if (data != NULL)
OBD_FREE(data, sizeof(*data));
RETURN(err);
out_root:
- if (root)
- iput(root);
-out_lov:
- obd_disconnect(sbi->ll_dt_exp, 0);
+ if (sb->s_root)
+ dput(sb->s_root);
+out_gks:
+ lustre_destroy_crypto(sb);
out_lmv:
obd_disconnect(sbi->ll_md_exp, 0);
out:
if (data != NULL)
OBD_FREE(data, sizeof(*data));
lprocfs_unregister_mountpoint(sbi);
- return err;
+ RETURN(err);
}
void lustre_common_put_super(struct super_block *sb)
ENTRY;
ll_gns_del_timer(sbi);
- ll_close_thread_shutdown(sbi->ll_lcq);
+ ll_close_thread_stop(sbi->ll_lcq);
list_del(&sbi->ll_conn_chain);
obd_disconnect(sbi->ll_dt_exp, 0);
+
+ lustre_destroy_crypto(sb);
lprocfs_unregister_mountpoint(sbi);
if (sbi->ll_proc_root) {
RETURN(fl);
}
-void ll_options(char *options, char **lov, char **lmv, char **mds_sec,
- char **oss_sec, int *async, int *flags)
+void ll_options(char *options, char **lov, char **lmv, char **gkc,
+ char **mds_sec, char **oss_sec, int *async, int *flags)
{
char *this_char;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
continue;
if (!*lmv && (*lmv = ll_read_opt("mdc", this_char)))
continue;
+ if (!*gkc && (*gkc = ll_read_opt("gkc", this_char)))
+ continue;
if (!strncmp(this_char, "lasync", strlen("lasync"))) {
*async = 1;
continue;
lli->lli_maxbytes = PAGE_CACHE_MAXBYTES;
spin_lock_init(&lli->lli_lock);
INIT_LIST_HEAD(&lli->lli_pending_write_llaps);
+ INIT_LIST_HEAD(&lli->lli_close_item);
lli->lli_inode_magic = LLI_INODE_MAGIC;
memset(&lli->lli_id, 0, sizeof(lli->lli_id));
sema_init(&lli->lli_och_sem, 1);
lli->lli_mds_exec_och = NULL;
lli->lli_open_fd_read_count = lli->lli_open_fd_write_count = 0;
lli->lli_open_fd_exec_count = 0;
+ lli->lli_audit_mask = AUDIT_OFF;
+ lli->lli_key_info = NULL;
+ init_waitqueue_head(&lli->lli_dirty_wait);
+ lli->lli_io_epoch = 0;
+ INIT_LIST_HEAD(&lli->lli_capas);
}
int ll_fill_super(struct super_block *sb, void *data, int silent)
{
struct ll_sb_info *sbi;
- char *lov = NULL;
- char *lmv = NULL;
+ char *lov = NULL, *lmv = NULL, *gkc = NULL;
char *mds_sec = NULL;
char *oss_sec = NULL;
int async, err;
RETURN(-ENOMEM);
sbi->ll_flags |= LL_SBI_READAHEAD;
- ll_options(data, &lov, &lmv, &mds_sec, &oss_sec,
+ ll_options(data, &lov, &lmv, &gkc, &mds_sec, &oss_sec,
&async, &sbi->ll_flags);
- if (!lov) {
- CERROR("no osc\n");
- GOTO(out, err = -EINVAL);
- }
-
- if (!lmv) {
- CERROR("no mdc\n");
+ if (!lov || !lmv) {
+ CERROR("no osc %p or no mdc %p\n", lov, lmv);
GOTO(out, err = -EINVAL);
}
- err = lustre_common_fill_super(sb, lmv, lov, async, mds_sec, oss_sec,
- nllu, &remote_flag);
+ err = lustre_common_fill_super(sb, lmv, lov, gkc, async, mds_sec,
+ oss_sec, nllu, 0, &remote_flag);
EXIT;
out:
if (err)
OBD_FREE(mds_sec, strlen(mds_sec) + 1);
if (oss_sec)
OBD_FREE(oss_sec, strlen(oss_sec) + 1);
+ if (gkc)
+ OBD_FREE(gkc, strlen(gkc) + 1);
return err;
} /* ll_read_super */
GOTO(out_del_conn, err);
lustre_cfg_bufs_reset(&bufs, name);
- lustre_cfg_bufs_set_string(&bufs, 1, LUSTRE_MDC_NAME);
+ lustre_cfg_bufs_set_string(&bufs, 1, OBD_MDC_DEVICENAME);
lustre_cfg_bufs_set_string(&bufs, 2, (char *)lmv_uuid.uuid);
lcfg = lustre_cfg_new(LCFG_ATTACH, &bufs);
if (rc)
GOTO(out_cleanup, rc);
+ if (lmd->lmd_pag) {
+ unsigned long sec_flags = PTLRPC_SEC_FL_PAG;
+ rc = obd_set_info(obd->obd_self_export,
+ strlen("sec_flags"), "sec_flags",
+ sizeof(sec_flags), &sec_flags);
+ if (rc)
+ GOTO(out_cleanup, rc);
+ }
+
/* Disable initial recovery on this import */
rc = obd_set_info(obd->obd_self_export,
strlen("initial_recov"), "initial_recov",
if (rc)
GOTO(out_cleanup, rc);
- rc = obd_connect(&md_conn, obd, &lmv_uuid, NULL, 0);
+ rc = obd_connect(&md_conn, obd, &lmv_uuid, NULL, OBD_OPT_REAL_CLIENT);
if (rc) {
CERROR("cannot connect to %s: rc = %d\n", lmd->lmd_mds, rc);
GOTO(out_cleanup, rc);
struct obd_device *obd;
int next = 0;
- while ((obd = class_devices_in_group(&sbi->ll_sb_uuid, &next)) != NULL)
- {
+ while ((obd = class_devices_in_group(&sbi->ll_sb_uuid, &next)) != NULL) {
int err;
lustre_cfg_bufs_reset(&bufs, obd->obd_name);
class_del_profile(sbi->ll_lmd->lmd_profile);
}
+static int lustre_process_profile(struct super_block *sb,
+ struct lustre_mount_data *lmd,
+ char **lov, char **lmv, char **gkc)
+{
+ struct ll_sb_info *sbi = ll_s2sbi(sb);
+ struct config_llog_instance cfg;
+ struct lustre_profile *lprof;
+ int len, err = 0;
+ ENTRY;
+
+ if (!lmd->lmd_profile)
+ RETURN(0);
+
+ if (lmd->lmd_mds[0] == '\0') {
+ CERROR("no mds name\n");
+ GOTO(out, err = -EINVAL);
+ }
+ lmd->lmd_mds_security[sizeof(lmd->lmd_mds_security) - 1] = 0;
+ lmd->lmd_oss_security[sizeof(lmd->lmd_oss_security) - 1] = 0;
+
+ OBD_ALLOC(sbi->ll_lmd, sizeof(*sbi->ll_lmd));
+ if (sbi->ll_lmd == NULL)
+ GOTO(out, err = -ENOMEM);
+ memcpy(sbi->ll_lmd, lmd, sizeof(*lmd));
+
+ /* generate a string unique to this super, let's try the address of the
+ * super itself. */
+ len = (sizeof(sb) * 2) + 1;
+ OBD_ALLOC(sbi->ll_instance, len);
+ if (sbi->ll_instance == NULL)
+ GOTO(out, err = -ENOMEM);
+ sprintf(sbi->ll_instance, "%p", sb);
+
+ cfg.cfg_instance = sbi->ll_instance;
+ cfg.cfg_uuid = sbi->ll_sb_uuid;
+ cfg.cfg_local_nid = lmd->lmd_local_nid;
+ cfg.cfg_flags |= CFG_MODIFY_UUID_FL;
+ err = lustre_process_log(lmd, lmd->lmd_profile, &cfg, 0);
+ if (err < 0) {
+ CERROR("Unable to process log: %s\n", lmd->lmd_profile);
+ GOTO(out, err);
+ }
+
+ lprof = class_get_profile(lmd->lmd_profile);
+ if (lprof == NULL) {
+ CERROR("No profile found: %s\n", lmd->lmd_profile);
+ GOTO(out, err = -EINVAL);
+ }
+
+ OBD_ALLOC(*lov, strlen(lprof->lp_lov) +
+ strlen(sbi->ll_instance) + 2);
+ if (*lov == NULL)
+ GOTO(out, err = -ENOMEM);
+
+ sprintf(*lov, "%s-%s", lprof->lp_lov, sbi->ll_instance);
+
+ OBD_ALLOC(*lmv, strlen(lprof->lp_lmv) +
+ strlen(sbi->ll_instance) + 2);
+ if (*lmv == NULL)
+ GOTO(out_free_lov, err = -ENOMEM);
+
+ sprintf(*lmv, "%s-%s", lprof->lp_lmv, sbi->ll_instance);
+
+ if (lprof->lp_gkc) {
+ OBD_ALLOC(*gkc, strlen(lprof->lp_gkc) +
+ strlen(sbi->ll_instance) + 2);
+ if (*gkc == NULL)
+ GOTO(out_free_lmv, err = -ENOMEM);
+
+ sprintf(*gkc, "%s-%s", lprof->lp_gkc, sbi->ll_instance);
+ }
+
+ RETURN(err);
+out_free_lmv:
+ OBD_FREE(*lmv, strlen(lprof->lp_lmv) +
+ strlen(sbi->ll_instance) + 2);
+out_free_lov:
+ OBD_FREE(*lov, strlen(lprof->lp_lov) +
+ strlen(sbi->ll_instance) + 2);
+out:
+ return err;
+}
+
+static int lustre_clean_profile(struct ll_sb_info *sbi, int force_umount)
+{
+ struct lustre_mount_data *lmd = sbi->ll_lmd;
+ struct config_llog_instance cfg;
+ char *cl_prof;
+ int len, err = 0;
+ ENTRY;
+
+ if (!lmd)
+ RETURN(err);
+
+ len = strlen(sbi->ll_lmd->lmd_profile) + sizeof("-clean") + 1;
+
+ if (force_umount) {
+ CERROR("force umount, doing manual cleanup\n");
+ lustre_manual_cleanup(sbi);
+ GOTO(free_lmd, 0);
+
+ }
+ if (sbi->ll_instance != NULL) {
+ cfg.cfg_flags |= CFG_MODIFY_UUID_FL;
+ cfg.cfg_instance = sbi->ll_instance;
+ cfg.cfg_uuid = sbi->ll_sb_uuid;
+
+ OBD_ALLOC(cl_prof, len);
+ if (!cl_prof) {
+ CERROR("can't allocate memory, "
+ "skipping processing cleanup profile.\n");
+ GOTO(free_lmd, err = -ENOMEM);
+ }
+
+ sprintf(cl_prof, "%s-clean", lmd->lmd_profile);
+ err = lustre_process_log(lmd, cl_prof, &cfg, 0);
+ if (err < 0) {
+ CERROR("Unable to process log: %s\n", cl_prof);
+ lustre_manual_cleanup(sbi);
+ }
+ OBD_FREE(cl_prof, len);
+ }
+ EXIT;
+free_lmd:
+ if (sbi->ll_instance)
+ OBD_FREE(sbi->ll_instance, strlen(sbi->ll_instance) + 1);
+ OBD_FREE(sbi->ll_lmd, sizeof(*sbi->ll_lmd));
+ return err;
+}
+
int lustre_fill_super(struct super_block *sb, void *data, int silent)
{
struct lustre_mount_data * lmd = data;
- char *lov = NULL, *lmv = NULL;
+ char *lov = NULL, *lmv = NULL, *gkc = NULL;
struct ll_sb_info *sbi;
int err;
ENTRY;
sbi->ll_flags |= LL_SBI_READAHEAD;
- if (lmd->lmd_profile) {
- struct lustre_profile *lprof;
- struct config_llog_instance cfg;
- int len;
-
- if (lmd->lmd_mds[0] == '\0') {
- CERROR("no mds name\n");
- GOTO(out_free, err = -EINVAL);
- }
- lmd->lmd_mds_security[sizeof(lmd->lmd_mds_security) - 1] = 0;
- lmd->lmd_oss_security[sizeof(lmd->lmd_oss_security) - 1] = 0;
-
- OBD_ALLOC(sbi->ll_lmd, sizeof(*sbi->ll_lmd));
- if (sbi->ll_lmd == NULL)
- GOTO(out_free, err = -ENOMEM);
- memcpy(sbi->ll_lmd, lmd, sizeof(*lmd));
-
- /* generate a string unique to this super, let's try
- the address of the super itself.*/
- len = (sizeof(sb) * 2) + 1;
- OBD_ALLOC(sbi->ll_instance, len);
- if (sbi->ll_instance == NULL)
- GOTO(out_free, err = -ENOMEM);
- sprintf(sbi->ll_instance, "%p", sb);
-
- cfg.cfg_instance = sbi->ll_instance;
- cfg.cfg_uuid = sbi->ll_sb_uuid;
- cfg.cfg_local_nid = lmd->lmd_local_nid;
- err = lustre_process_log(lmd, lmd->lmd_profile, &cfg, 0);
- if (err < 0) {
- CERROR("Unable to process log: %s\n", lmd->lmd_profile);
- GOTO(out_free, err);
- }
-
- lprof = class_get_profile(lmd->lmd_profile);
- if (lprof == NULL) {
- CERROR("No profile found: %s\n", lmd->lmd_profile);
- GOTO(out_free, err = -EINVAL);
- }
- if (lov)
- OBD_FREE(lov, strlen(lov) + 1);
- OBD_ALLOC(lov, strlen(lprof->lp_lov) +
- strlen(sbi->ll_instance) + 2);
- sprintf(lov, "%s-%s", lprof->lp_lov, sbi->ll_instance);
-
- if (lmv)
- OBD_FREE(lmv, strlen(lmv) + 1);
- OBD_ALLOC(lmv, strlen(lprof->lp_lmv) +
- strlen(sbi->ll_instance) + 2);
- sprintf(lmv, "%s-%s", lprof->lp_lmv, sbi->ll_instance);
- }
-
- if (!lov) {
- CERROR("no osc\n");
- GOTO(out_free, err = -EINVAL);
+ err = lustre_process_profile(sb, lmd, &lov, &lmv, &gkc);
+ if (err) {
+ CERROR("Can not process the profile err %d \n", err);
+ GOTO(out_free, err);
}
-
- if (!lmv) {
- CERROR("no mdc\n");
+ if (!lov || !lmv) {
+ CERROR("no osc %p or no mdc %p \n", lov, lmv);
GOTO(out_free, err = -EINVAL);
}
- err = lustre_common_fill_super(sb, lmv, lov, lmd->lmd_async,
+ err = lustre_common_fill_super(sb, lmv, lov, gkc, lmd->lmd_async,
lmd->lmd_mds_security,
lmd->lmd_oss_security,
- &lmd->lmd_nllu, &lmd->lmd_remote_flag);
+ &lmd->lmd_nllu, lmd->lmd_pag,
+ &lmd->lmd_remote_flag);
if (err)
GOTO(out_free, err);
-
+
+ EXIT;
out_dev:
if (lmv)
OBD_FREE(lmv, strlen(lmv) + 1);
if (lov)
OBD_FREE(lov, strlen(lov) + 1);
-
- RETURN(err);
-
+ if (gkc)
+ OBD_FREE(gkc, strlen(gkc) + 1);
+
+ return err;
out_free:
- if (sbi->ll_lmd) {
- int len = strlen(sbi->ll_lmd->lmd_profile) + sizeof("-clean")+1;
- int err;
-
- if (sbi->ll_instance != NULL) {
- struct lustre_mount_data *lmd = sbi->ll_lmd;
- struct config_llog_instance cfg;
- char *cl_prof;
-
- cfg.cfg_instance = sbi->ll_instance;
- cfg.cfg_uuid = sbi->ll_sb_uuid;
-
- OBD_ALLOC(cl_prof, len);
- sprintf(cl_prof, "%s-clean", lmd->lmd_profile);
- err = lustre_process_log(lmd, cl_prof, &cfg, 0);
- if (err < 0) {
- CERROR("Unable to process log: %s\n", cl_prof);
- lustre_manual_cleanup(sbi);
- }
- OBD_FREE(cl_prof, len);
- OBD_FREE(sbi->ll_instance, strlen(sbi->ll_instance) + 1);
- }
- OBD_FREE(sbi->ll_lmd, sizeof(*sbi->ll_lmd));
- }
+ lustre_clean_profile(sbi, 0);
lustre_free_sbi(sb);
goto out_dev;
+
} /* lustre_fill_super */
void lustre_put_super(struct super_block *sb)
obd = NULL;
lustre_common_put_super(sb);
- if (sbi->ll_lmd != NULL) {
- char *cl_prof;
- int len = strlen(sbi->ll_lmd->lmd_profile) + sizeof("-clean")+1;
- int err;
- struct config_llog_instance cfg;
-
- if (force_umount) {
- CERROR("force umount, doing manual cleanup\n");
- lustre_manual_cleanup(sbi);
- GOTO(free_lmd, 0);
- }
-
- cfg.cfg_instance = sbi->ll_instance;
- cfg.cfg_uuid = sbi->ll_sb_uuid;
-
- OBD_ALLOC(cl_prof, len);
- sprintf(cl_prof, "%s-clean", sbi->ll_lmd->lmd_profile);
- err = lustre_process_log(sbi->ll_lmd, cl_prof, &cfg, 0);
- if (err < 0) {
- CERROR("Unable to process log: %s, doing manual cleanup"
- "\n", cl_prof);
- lustre_manual_cleanup(sbi);
- }
-
- OBD_FREE(cl_prof, len);
- free_lmd:
- OBD_FREE(sbi->ll_lmd, sizeof(*sbi->ll_lmd));
- OBD_FREE(sbi->ll_instance, strlen(sbi->ll_instance) + 1);
- }
-
+ lustre_clean_profile(sbi, force_umount);
lustre_free_sbi(sb);
EXIT;
RETURN(0);
}
- rc = obd_cancel_unused(sbi->ll_md_exp, NULL,
- LDLM_FL_CONFIG_CHANGE, NULL);
- if (rc != 0)
- CWARN("obd_cancel_unused(mdc): %d\n", rc);
-
- rc = obd_cancel_unused(sbi->ll_dt_exp, NULL,
- LDLM_FL_CONFIG_CHANGE, NULL);
- if (rc != 0)
- CWARN("obd_cancel_unused(lov): %d\n", rc);
-
cfg.cfg_instance = sbi->ll_instance;
cfg.cfg_uuid = sbi->ll_sb_uuid;
cfg.cfg_local_nid = lmd->lmd_local_nid;
struct inode *ll_inode_from_lock(struct ldlm_lock *lock)
{
struct inode *inode = NULL;
- l_lock(&lock->l_resource->lr_namespace->ns_lock);
+
+ /* NOTE: we depend on atomic igrab() -bzzz */
+ lock_res_and_lock(lock);
if (lock->l_ast_data) {
struct ll_inode_info *lli = ll_i2info(lock->l_ast_data);
if (lli->lli_inode_magic == LLI_INODE_MAGIC) {
inode = igrab(lock->l_ast_data);
} else {
+ struct timeval now;
+ do_gettimeofday(&now);
inode = lock->l_ast_data;
+ LDLM_ERROR(lock, "granted at %lu.%lu, now %lu.%lu",
+ lock->l_enqueued_time.tv_sec,
+ lock->l_enqueued_time.tv_usec,
+ now.tv_sec, now.tv_usec);
CDEBUG(inode->i_state & I_FREEING ? D_INFO : D_WARNING,
"l_ast_data %p is bogus: magic %0x8\n",
lock->l_ast_data, lli->lli_inode_magic);
+ CDEBUG(D_ERROR, "i_state = 0x%lx, l_ast_data %p is bogus: magic %0x8\n",
+ inode->i_state, lock->l_ast_data, lli->lli_inode_magic);
inode = NULL;
+ unlock_res_and_lock(lock);
+ LBUG();
}
}
- l_unlock(&lock->l_resource->lr_namespace->ns_lock);
+ unlock_res_and_lock(lock);
return inode;
}
return LDLM_ITER_CONTINUE;
}
+static void remote_acl_free(struct remote_acl *racl);
+
void ll_clear_inode(struct inode *inode)
{
struct lustre_id id;
struct ll_inode_info *lli = ll_i2info(inode);
struct ll_sb_info *sbi = ll_i2sbi(inode);
+ struct obd_capa *ocapa, *tmp;
ENTRY;
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
inode->i_generation, inode);
- lli->lli_inode_magic = LLI_INODE_DEAD;
+ LASSERT(ll_is_inode_dirty(inode) == 0);
ll_inode2id(&id, inode);
clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK, &(ll_i2info(inode)->lli_flags));
lli->lli_mea = NULL;
}
+ LASSERT(sbi->ll_crypto_info != NULL);
+ ll_crypto_destroy_inode_key(inode);
+
if (lli->lli_symlink_name) {
OBD_FREE(lli->lli_symlink_name,
strlen(lli->lli_symlink_name) + 1);
lli->lli_symlink_name = NULL;
}
- lli->lli_inode_magic = LLI_INODE_DEAD;
+ if (lli->lli_posix_acl) {
+ LASSERT(lli->lli_remote_acl == NULL);
+ posix_acl_release(lli->lli_posix_acl);
+ lli->lli_posix_acl = NULL;
+ }
+
+ if (lli->lli_remote_acl) {
+ LASSERT(lli->lli_posix_acl == NULL);
+ remote_acl_free(lli->lli_remote_acl);
+ lli->lli_remote_acl = NULL;
+ }
+
+ list_for_each_entry_safe(ocapa, tmp, &lli->lli_capas, u.client.lli_list)
+ capa_put(ocapa);
+
+ LASSERT(!mapping_has_pages(inode->i_mapping));
+ lli->lli_inode_magic = LLI_INODE_DEAD;
+
EXIT;
}
int ll_setattr_raw(struct inode *inode, struct iattr *attr)
{
struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
+ struct ll_inode_info *lli = ll_i2info(inode);
struct ll_sb_info *sbi = ll_i2sbi(inode);
struct ptlrpc_request *request = NULL;
struct mdc_op_data *op_data;
LTIME_S(attr->ia_mtime), LTIME_S(attr->ia_ctime),
LTIME_S(CURRENT_TIME));
- if (lsm)
- attr->ia_valid &= ~ATTR_SIZE;
-
/* If only OST attributes being set on objects, don't do MDS RPC.
* In that case, we need to check permissions and update the local
* inode ourselves so we can call obdo_from_inode() always. */
if (ia_valid & (lsm ? ~(ATTR_SIZE | ATTR_FROM_OPEN /*| ATTR_RAW*/) : ~0)) {
struct lustre_md md;
+ void *key = NULL;
+ int key_size = 0;
OBD_ALLOC(op_data, sizeof(*op_data));
if (op_data == NULL)
RETURN(-ENOMEM);
- ll_prepare_mdc_data(op_data, inode, NULL, NULL, 0, 0);
-
+ ll_inode2mdc_data(op_data, inode, (OBD_MD_FLID | OBD_MD_MEA));
+
+ if (ia_valid & (ATTR_UID | ATTR_GID | ATTR_MODE)) {
+ rc = ll_crypto_get_mac(inode, attr, NULL, 0, &key,
+ &key_size);
+ if (rc) {
+ CERROR("can not get right mac, rc=%d\n", rc);
+ if (key && key_size)
+ OBD_FREE(key, key_size);
+ RETURN(rc);
+ }
+ }
rc = md_setattr(sbi->ll_md_exp, op_data,
- attr, NULL, 0, NULL, 0, &request);
+ attr, key, key_size, NULL, 0, NULL,
+ 0, &request);
OBD_FREE(op_data, sizeof(*op_data));
+
+ if (key && key_size)
+ OBD_FREE(key, key_size);
if (rc) {
ptlrpc_req_finished(request);
if (rc != -EPERM && rc != -EACCES)
CERROR("md_setattr fails: rc = %d\n", rc);
RETURN(rc);
}
-
rc = mdc_req2lustre_md(sbi->ll_md_exp, request, 0,
sbi->ll_dt_exp, &md);
if (rc) {
RETURN(rc);
}
+ if (attr->ia_valid & ATTR_SIZE) {
+ rc = ll_set_trunc_capa(request, 0, inode);
+ if (rc) {
+ ptlrpc_req_finished(request);
+ RETURN(rc);
+ }
+ }
+
/* We call inode_setattr to adjust timestamps, but we first
* clear ATTR_SIZE to avoid invoking vmtruncate.
*
/* from sys_utime() */
if (!(ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET))) {
if (current->fsuid != inode->i_uid &&
- (rc=ll_permission(inode,MAY_WRITE,NULL))!=0)
+ (rc = ll_permission(inode, MAY_WRITE, NULL)) != 0)
RETURN(rc);
} else {
/* from inode_change_ok() */
}
}
+ if (lsm)
+ attr->ia_valid &= ~ATTR_SIZE;
+
/* won't invoke vmtruncate, as we already cleared ATTR_SIZE */
err = inode_setattr(inode, attr);
/*
ldlm_policy_data_t policy = { .l_extent = {attr->ia_size,
OBD_OBJECT_EOF } };
struct lustre_handle lockh = { 0 };
- struct ll_inode_info *lli = ll_i2info(inode);
int err, ast_flags = 0;
/* XXX when we fix the AST intents to pass the discard-range
* XXX extent, make ast_flags always LDLM_AST_DISCARD_DATA
if (!rc)
rc = err;
}
- } else if (ia_valid & (ATTR_MTIME | ATTR_MTIME_SET)) {
+ } else if (ia_valid & (ATTR_MTIME | ATTR_MTIME_SET | ATTR_UID | ATTR_GID)) {
struct obdo *oa = NULL;
CDEBUG(D_INODE, "set mtime on OST inode %lu to %lu\n",
oa->o_id = lsm->lsm_object_id;
oa->o_gr = lsm->lsm_object_gr;
oa->o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
+
+ /* adding uid and gid, needed for quota */
+ if (ia_valid & ATTR_UID) {
+ oa->o_uid = inode->i_uid;
+ oa->o_valid |= OBD_MD_FLUID;
+ }
+
+ if (ia_valid & ATTR_GID) {
+ oa->o_gid = inode->i_gid;
+ oa->o_valid |= OBD_MD_FLGID;
+ }
+
+ *(obdo_id(oa)) = lli->lli_id;
+ oa->o_valid |= OBD_MD_FLIFID;
+
obdo_from_inode(oa, inode, OBD_MD_FLTYPE | OBD_MD_FLATIME |
OBD_MD_FLMTIME | OBD_MD_FLCTIME);
- rc = obd_setattr(sbi->ll_dt_exp, oa, lsm, NULL);
+ rc = obd_setattr(sbi->ll_dt_exp, oa, lsm, NULL, NULL);
obdo_free(oa);
if (rc)
CERROR("obd_setattr fails: rc = %d\n", rc);
}
+
RETURN(rc);
}
return 0;
}
+
+/********************************
+ * remote acl *
+ ********************************/
+
+static struct remote_acl *remote_acl_alloc(void)
+{
+ struct remote_acl *racl;
+ int i;
+
+ OBD_ALLOC(racl, sizeof(*racl));
+ if (!racl)
+ return NULL;
+
+ spin_lock_init(&racl->ra_lock);
+ init_MUTEX(&racl->ra_update_sem);
+
+ for (i = 0; i < REMOTE_ACL_HASHSIZE; i++)
+ INIT_LIST_HEAD(&racl->ra_perm_cache[i]);
+
+ return racl;
+}
+
+/*
+ * caller should guarantee no race here.
+ */
+static void remote_perm_flush_xperms(struct lustre_remote_perm *perm)
+{
+ struct remote_perm_setxid *xperm;
+
+ while (!list_empty(&perm->lrp_setxid_perms)) {
+ xperm = list_entry(perm->lrp_setxid_perms.next,
+ struct remote_perm_setxid,
+ list);
+ list_del(&xperm->list);
+ OBD_FREE(xperm, sizeof(*xperm));
+ }
+}
+
+/*
+ * caller should guarantee no race here.
+ */
+static void remote_acl_flush(struct remote_acl *racl)
+{
+ struct list_head *head;
+ struct lustre_remote_perm *perm, *tmp;
+ int i;
+
+ for (i = 0; i < REMOTE_ACL_HASHSIZE; i++) {
+ head = &racl->ra_perm_cache[i];
+
+ list_for_each_entry_safe(perm, tmp, head, lrp_list) {
+ remote_perm_flush_xperms(perm);
+ list_del(&perm->lrp_list);
+ OBD_FREE(perm, sizeof(*perm));
+ }
+ }
+}
+
+static void remote_acl_free(struct remote_acl *racl)
+{
+ if (!racl)
+ return;
+
+ down(&racl->ra_update_sem);
+ spin_lock(&racl->ra_lock);
+ remote_acl_flush(racl);
+ spin_unlock(&racl->ra_lock);
+ up(&racl->ra_update_sem);
+
+ OBD_FREE(racl, sizeof(*racl));
+}
+
+static inline int remote_acl_hashfunc(__u32 id)
+{
+ return (id & (REMOTE_ACL_HASHSIZE - 1));
+}
+
+static
+int __remote_acl_check(struct remote_acl *racl, unsigned int *perm)
+{
+ struct list_head *head;
+ struct lustre_remote_perm *lperm;
+ struct remote_perm_setxid *xperm;
+ int found = 0, rc = -ENOENT;
+
+ LASSERT(racl);
+ head = &racl->ra_perm_cache[remote_acl_hashfunc(current->uid)];
+ spin_lock(&racl->ra_lock);
+
+ list_for_each_entry(lperm, head, lrp_list) {
+ if (lperm->lrp_auth_uid == current->uid) {
+ found = 1;
+ break;
+ }
+ }
+
+ if (!found)
+ goto out;
+
+ if (lperm->lrp_auth_uid == current->fsuid &&
+ lperm->lrp_auth_gid == current->fsgid) {
+ if (lperm->lrp_valid) {
+ *perm = lperm->lrp_perm;
+ rc = 0;
+ }
+ goto out;
+ } else if ((!lperm->lrp_setuid &&
+ lperm->lrp_auth_uid != current->fsuid) ||
+ (!lperm->lrp_setgid &&
+ lperm->lrp_auth_gid != current->fsgid)) {
+ *perm = 0;
+ rc = 0;
+ goto out;
+ }
+
+ list_for_each_entry(xperm, &lperm->lrp_setxid_perms, list) {
+ if (xperm->uid == current->fsuid &&
+ xperm->gid == current->fsgid) {
+ *perm = xperm->perm;
+ rc = 0;
+ goto out;
+ }
+ }
+
+out:
+ spin_unlock(&racl->ra_lock);
+ return rc;
+}
+
+static
+int __remote_acl_update(struct remote_acl *racl,
+ struct mds_remote_perm *mperm,
+ struct lustre_remote_perm *lperm,
+ struct remote_perm_setxid *xperm)
+{
+ struct list_head *head;
+ struct lustre_remote_perm *lp;
+ struct remote_perm_setxid *xp;
+ int found = 0, setuid = 0, setgid = 0;
+
+ LASSERT(racl);
+ LASSERT(mperm);
+ LASSERT(lperm);
+ LASSERT(current->uid == mperm->mrp_auth_uid);
+
+ if (current->fsuid != mperm->mrp_auth_uid)
+ setuid = 1;
+ if (current->fsgid != mperm->mrp_auth_gid)
+ setgid = 1;
+
+ head = &racl->ra_perm_cache[remote_acl_hashfunc(current->uid)];
+ spin_lock(&racl->ra_lock);
+
+ list_for_each_entry(lp, head, lrp_list) {
+ if (lp->lrp_auth_uid == current->uid) {
+ found = 1;
+ break;
+ }
+ }
+
+ if (found) {
+ OBD_FREE(lperm, sizeof(*lperm));
+
+ if (!lp->lrp_valid && !setuid && !setgid) {
+ lp->lrp_perm = mperm->mrp_perm;
+ lp->lrp_valid = 1;
+ }
+
+ /* sanity check for changes of setxid rules */
+ if ((lp->lrp_setuid != 0) != (mperm->mrp_allow_setuid != 0)) {
+ CWARN("setuid changes: %d => %d\n",
+ (lp->lrp_setuid != 0),
+ (mperm->mrp_allow_setuid != 0));
+ lp->lrp_setuid = (mperm->mrp_allow_setuid != 0);
+ }
+
+ if ((lp->lrp_setgid != 0) != (mperm->mrp_allow_setgid != 0)) {
+ CWARN("setgid changes: %d => %d\n",
+ (lp->lrp_setgid != 0),
+ (mperm->mrp_allow_setgid != 0));
+ lp->lrp_setgid = (mperm->mrp_allow_setgid != 0);
+ }
+
+ if (!lp->lrp_setuid && !lp->lrp_setgid &&
+ !list_empty(&lp->lrp_setxid_perms)) {
+ remote_perm_flush_xperms(lp);
+ }
+ } else {
+ /* initialize lperm and linked into hashtable
+ */
+ INIT_LIST_HEAD(&lperm->lrp_setxid_perms);
+ lperm->lrp_auth_uid = mperm->mrp_auth_uid;
+ lperm->lrp_auth_gid = mperm->mrp_auth_gid;
+ lperm->lrp_setuid = (mperm->mrp_allow_setuid != 0);
+ lperm->lrp_setgid = (mperm->mrp_allow_setgid != 0);
+ list_add(&lperm->lrp_list, head);
+
+ if (!setuid && !setgid) {
+ /* in this case, i'm the authenticated user,
+ * and mrp_perm is for me.
+ */
+ lperm->lrp_perm = mperm->mrp_perm;
+ lperm->lrp_valid = 1;
+ spin_unlock(&racl->ra_lock);
+
+ if (xperm)
+ OBD_FREE(xperm, sizeof(*xperm));
+ return 0;
+ }
+
+ lp = lperm;
+ /* fall through */
+ }
+
+ LASSERT(lp->lrp_setuid || lp->lrp_setgid ||
+ list_empty(&lp->lrp_setxid_perms));
+
+ /* if no xperm supplied, we are all done here */
+ if (!xperm) {
+ spin_unlock(&racl->ra_lock);
+ return 0;
+ }
+
+ /* whether we allow setuid/setgid */
+ if ((!lp->lrp_setuid && setuid) || (!lp->lrp_setgid && setgid)) {
+ OBD_FREE(xperm, sizeof(*xperm));
+ spin_unlock(&racl->ra_lock);
+ return 0;
+ }
+
+ /* traverse xperm list */
+ list_for_each_entry(xp, &lp->lrp_setxid_perms, list) {
+ if (xp->uid == current->fsuid &&
+ xp->gid == current->fsgid) {
+ if (xp->perm != mperm->mrp_perm) {
+ /* actually this should not happen */
+ CWARN("perm changed: %o => %o\n",
+ xp->perm, mperm->mrp_perm);
+ xp->perm = mperm->mrp_perm;
+ }
+ OBD_FREE(xperm, sizeof(*xperm));
+ spin_unlock(&racl->ra_lock);
+ return 0;
+ }
+ }
+
+ /* finally insert this xperm */
+ xperm->uid = current->fsuid;
+ xperm->gid = current->fsgid;
+ xperm->perm = mperm->mrp_perm;
+ list_add(&xperm->list, &lp->lrp_setxid_perms);
+
+ spin_unlock(&racl->ra_lock);
+ return 0;
+}
+
+/*
+ * remote_acl semaphore must be held by caller
+ */
+static
+int remote_acl_update_locked(struct remote_acl *racl,
+ struct mds_remote_perm *mperm)
+{
+ struct lustre_remote_perm *lperm;
+ struct remote_perm_setxid *xperm;
+ int setuid = 0, setgid = 0;
+
+ might_sleep();
+
+ if (current->uid != mperm->mrp_auth_uid) {
+ CERROR("current uid %u while authenticated as %u\n",
+ current->uid, mperm->mrp_auth_uid);
+ return -EINVAL;
+ }
+
+ if (current->fsuid != mperm->mrp_auth_uid)
+ setuid = 1;
+ if (current->fsgid == mperm->mrp_auth_gid)
+ setgid = 1;
+
+ OBD_ALLOC(lperm, sizeof(*lperm));
+ if (!lperm)
+ return -ENOMEM;
+
+ if ((setuid || setgid) &&
+ !(setuid && !mperm->mrp_allow_setuid) &&
+ !(setgid && !mperm->mrp_allow_setgid)) {
+ OBD_ALLOC(xperm, sizeof(*xperm));
+ if (!xperm) {
+ OBD_FREE(lperm, sizeof(*lperm));
+ return -ENOMEM;
+ }
+ } else
+ xperm = NULL;
+
+ return __remote_acl_update(racl, mperm, lperm, xperm);
+}
+
+/*
+ * return -EACCES at any error cases
+ */
+int ll_remote_acl_permission(struct inode *inode, int mode)
+{
+ struct ll_sb_info *sbi = ll_i2sbi(inode);
+ struct remote_acl *racl = ll_i2info(inode)->lli_remote_acl;
+ struct ptlrpc_request *req = NULL;
+ struct lustre_id id;
+ struct mds_remote_perm *mperm;
+ int rc = -EACCES, perm;
+
+ if (!racl)
+ return -EACCES;
+
+ if (__remote_acl_check(racl, &perm) == 0) {
+ return ((perm & mode) == mode ? 0 : -EACCES);
+ }
+
+ might_sleep();
+
+ /* doing update
+ */
+ down(&racl->ra_update_sem);
+
+ /* we might lose the race when obtain semaphore,
+ * so check again.
+ */
+ if (__remote_acl_check(racl, &perm) == 0) {
+ if ((perm & mode) == mode)
+ rc = 0;
+ goto out;
+ }
+
+ /* really fetch from mds
+ */
+ ll_inode2id(&id, inode);
+ if (md_access_check(sbi->ll_md_exp, &id, &req))
+ goto out;
+
+ /* status non-zero indicate there's more apparent error
+ * detected by mds, e.g. didn't allow this user at all.
+ * we simply ignore and didn't cache it.
+ */
+ if (req->rq_repmsg->status)
+ goto out;
+
+ mperm = lustre_swab_repbuf(req, 1, sizeof(*mperm),
+ lustre_swab_remote_perm);
+ LASSERT(mperm);
+ LASSERT_REPSWABBED(req, 1);
+
+ if ((mperm->mrp_perm & mode) == mode)
+ rc = 0;
+
+ remote_acl_update_locked(racl, mperm);
+out:
+ if (req)
+ ptlrpc_req_finished(req);
+
+ up(&racl->ra_update_sem);
+ return rc;
+}
+
+int ll_remote_acl_update(struct inode *inode, struct mds_remote_perm *perm)
+{
+ struct remote_acl *racl = ll_i2info(inode)->lli_remote_acl;
+ int rc;
+
+ LASSERT(perm);
+
+ if (!racl)
+ return -EACCES;
+
+ down(&racl->ra_update_sem);
+ rc = remote_acl_update_locked(racl, perm);
+ up(&racl->ra_update_sem);
+
+ return rc;
+}
+
+void ll_inode_invalidate_acl(struct inode *inode)
+{
+ struct ll_sb_info *sbi = ll_i2sbi(inode);
+ struct ll_inode_info *lli = ll_i2info(inode);
+
+ if (sbi->ll_remote) {
+ struct remote_acl *racl = lli->lli_remote_acl;
+
+ LASSERT(!lli->lli_posix_acl);
+ if (racl) {
+ down(&racl->ra_update_sem);
+ spin_lock(&racl->ra_lock);
+ remote_acl_flush(lli->lli_remote_acl);
+ spin_unlock(&racl->ra_lock);
+ up(&racl->ra_update_sem);
+ }
+ } else {
+ /* we can't invalide acl here: suppose we touch a new file
+ * under a dir, blocking ast on dir will lead to open failure
+ * on client, although succeed on mds. it's kind of weird,
+ * the real fix i think is improve client-vfs interaction.
+ *
+ * currently we just do nothing here.
+ */
+ return;
+
+ LASSERT(!lli->lli_remote_acl);
+ spin_lock(&lli->lli_lock);
+ posix_acl_release(lli->lli_posix_acl);
+ lli->lli_posix_acl = NULL;
+ spin_unlock(&lli->lli_lock);
+ }
+}
+
void ll_update_inode(struct inode *inode, struct lustre_md *md)
{
struct ll_inode_info *lli = ll_i2info(inode);
struct lov_stripe_md *lsm = md->lsm;
struct mds_body *body = md->body;
struct mea *mea = md->mea;
- struct posix_acl *ll_acl_access = md->acl_access;
+ struct posix_acl *posix_acl = md->posix_acl;
+ struct ll_sb_info *sbi = ll_i2sbi(inode);
+ struct lustre_key *mkey = md->key;
ENTRY;
LASSERT((lsm != NULL) == ((body->valid & OBD_MD_FLEASIZE) != 0));
if (body->valid & OBD_MD_FLGENER)
id_gen(&lli->lli_id) = id_gen(&body->id1);
- spin_lock(&lli->lli_lock);
- if (ll_acl_access != NULL) {
- if (lli->lli_acl_access != NULL)
- posix_acl_release(lli->lli_acl_access);
- lli->lli_acl_access = ll_acl_access;
+ /* local/remote ACL */
+ if (sbi->ll_remote) {
+ LASSERT(md->posix_acl == NULL);
+ if (md->remote_perm) {
+ ll_remote_acl_update(inode, md->remote_perm);
+ OBD_FREE(md->remote_perm, sizeof(*md->remote_perm));
+ md->remote_perm = NULL;
+ }
+ } else {
+ LASSERT(md->remote_perm == NULL);
+ spin_lock(&lli->lli_lock);
+ if (posix_acl != NULL) {
+ if (lli->lli_posix_acl != NULL)
+ posix_acl_release(lli->lli_posix_acl);
+ lli->lli_posix_acl = posix_acl;
+ }
+ spin_unlock(&lli->lli_lock);
}
- spin_unlock(&lli->lli_lock);
-
+
if (body->valid & OBD_MD_FLID)
inode->i_ino = id_ino(&body->id1);
if (body->valid & OBD_MD_FLGENER)
if (body->valid & OBD_MD_FLSIZE)
set_bit(LLI_F_HAVE_MDS_SIZE_LOCK, &lli->lli_flags);
+ if (body->valid & OBD_MD_FLAUDIT) {
+ struct ll_sb_info * sbi = ll_s2sbi(inode->i_sb);
+ if (IS_AUDIT_OP(body->audit, AUDIT_FS))
+ sbi->ll_audit_mask = body->audit;
+ else
+ lli->lli_audit_mask = body->audit;
+ }
+
+ if (mkey != NULL) {
+ LASSERT(body->valid & OBD_MD_FLKEY);
+ ll_crypto_init_inode_key(inode, mkey);
+ }
+
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
inode->i_dev = (kdev_t)id_group(&lli->lli_id);
#endif
LASSERT(!lli->lli_smd);
+ if (ll_i2sbi(inode)->ll_remote) {
+ lli->lli_remote_acl = remote_acl_alloc();
+ /* if failed alloc, nobody will be able to access this inode */
+ }
+
/* Core attributes from the MDS first. This is a new inode, and
* the VFS doesn't zero times in the core inode so we have to do
* it ourselves. They will be overwritten by either MDS or OST
struct mds_body *body;
ll_inode2id(&id, inode);
- rc = md_getattr(sbi->ll_md_exp, &id, valid, NULL, 0, 0, &req);
+ rc = md_getattr(sbi->ll_md_exp, &id, valid, NULL, NULL,
+ 0, 0, NULL, &req);
if (rc) {
CERROR("failure %d inode %lu\n", rc, inode->i_ino);
RETURN(-abs(rc));
obdo_free(oa);
RETURN(-ENOMEM);
}
- ll_prepare_mdc_data(op_data, inode, NULL, NULL, 0, 0);
+ ll_inode2mdc_data(op_data, inode, (OBD_MD_FLID | OBD_MD_MEA));
memset(&attr, 0x0, sizeof(attr));
attr.ia_attr_flags = flags;
attr.ia_valid |= ATTR_ATTR_FLAG;
rc = md_setattr(sbi->ll_md_exp, op_data,
- &attr, NULL, 0, NULL, 0, &req);
+ &attr, NULL, 0, NULL, 0, NULL, 0, &req);
OBD_FREE(op_data, sizeof(*op_data));
if (rc) {
ptlrpc_req_finished(req);
oa->o_id = lsm->lsm_object_id;
oa->o_gr = lsm->lsm_object_gr;
oa->o_flags = flags;
- oa->o_valid = OBD_MD_FLID | OBD_MD_FLFLAGS | OBD_MD_FLGROUP;
+ *(obdo_id(oa)) = ll_i2info(inode)->lli_id;
+ oa->o_valid = OBD_MD_FLID | OBD_MD_FLFLAGS | OBD_MD_FLGROUP
+ | OBD_MD_FLIFID;
- rc = obd_setattr(sbi->ll_dt_exp, oa, lsm, NULL);
+ rc = obd_setattr(sbi->ll_dt_exp, oa, lsm, NULL, NULL);
obdo_free(oa);
if (rc) {
if (rc != -EPERM && rc != -EACCES)
RETURN(rc);
}
+int ll_show_options(struct seq_file *m, struct vfsmount *mnt)
+{
+ struct ll_sb_info *sbi = ll_s2sbi(mnt->mnt_sb);
+ struct lustre_mount_data *lmd = sbi->ll_lmd;
+
+ if (lmd) {
+ seq_printf(m, ",mds_sec=%s,oss_sec=%s",
+ lmd->lmd_mds_security, lmd->lmd_oss_security);
+ }
+ seq_printf(m, ",%s", sbi->ll_remote ? "remote" : "local");
+ if (sbi->ll_remote && lmd)
+ seq_printf(m, ",nllu=%u:%u", lmd->lmd_nllu, lmd->lmd_nllg);
+
+ if (lmd && lmd->lmd_pag)
+ seq_printf(m, ",pag");
+
+ return 0;
+}
+
int ll_get_fid(struct obd_export *exp, struct lustre_id *idp,
char *filename, struct lustre_id *ret)
{
return rc;
}
+int ll_flush_cred(struct inode *inode)
+{
+ struct ll_sb_info *sbi = ll_i2sbi(inode);
+ int rc = 0;
+
+ /* XXX to avoid adding api, we simply use set_info() interface
+ * to notify underlying obds. set_info() is more like a ioctl() now...
+ */
+ if (sbi->ll_md_exp) {
+ rc = obd_set_info(sbi->ll_md_exp,
+ strlen("flush_cred"), "flush_cred",
+ 0, NULL);
+ if (rc)
+ return rc;
+ }
+
+ if (sbi->ll_dt_exp) {
+ rc = obd_set_info(sbi->ll_dt_exp,
+ strlen("flush_cred"), "flush_cred",
+ 0, NULL);
+ if (rc)
+ return rc;
+ }
+
+ return rc;
+}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff