Branch: HEAD

[fs/lustre-release.git] / lustre / llite / llite_lib.c

diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c
index de8f344..f006c38 100644 (file)
--- a/lustre/llite/llite_lib.c
+++ b/lustre/llite/llite_lib.c
@@ -263,15 +263,23 @@ static int lustre_connect_ost(struct super_block *sb, char *lov,
                 RETURN(err);
         }
 
-        if (pag) {
+        /* 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;
-                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);
-                }
+        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);
         }
 
         err = obd_connect(&dt_conn, obd, &sbi->ll_sb_uuid, data, 0);
@@ -401,12 +409,13 @@ int lustre_common_fill_super(struct super_block *sb, char *lmv, char *lov,
         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;
         }
-        /*connect GSS*/
+        
         err = lustre_init_root_inode(sb);
         if (err)
                 GOTO(out_gks, err);
@@ -458,10 +467,10 @@ void lustre_common_put_super(struct super_block *sb)
         ll_gns_del_timer(sbi);
         ll_close_thread_stop(sbi->ll_lcq);
 
-        lustre_destroy_crypto(sb);
-
         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) {
@@ -583,6 +592,8 @@ void ll_lli_init(struct ll_inode_info *lli)
         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)
@@ -866,6 +877,7 @@ static int lustre_process_profile(struct super_block *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);
@@ -932,6 +944,7 @@ static int lustre_clean_profile(struct ll_sb_info *sbi, int force_umount)
                 
         }
         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;
 
@@ -1144,6 +1157,7 @@ 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,
@@ -1178,7 +1192,10 @@ void ll_clear_inode(struct inode *inode)
                                (struct lov_stripe_md **) &lli->lli_mea);
                 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);
@@ -1197,12 +1214,12 @@ void ll_clear_inode(struct inode *inode)
                 lli->lli_remote_acl = NULL;
         }
 
-        if (lli->lli_trunc_capa) {
-                OBD_FREE(lli->lli_trunc_capa, sizeof(struct lustre_capa));
-                lli->lli_trunc_capa = 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;
 }
 
@@ -1226,7 +1243,6 @@ int ll_setattr_raw(struct inode *inode, struct iattr *attr)
         struct ll_sb_info *sbi = ll_i2sbi(inode);
         struct ptlrpc_request *request = NULL;
         struct mdc_op_data *op_data;
-        struct lustre_capa *trunc_capa = NULL;
         int ia_valid = attr->ia_valid;
         int err, rc = 0;
         ENTRY;
@@ -1282,9 +1298,15 @@ int ll_setattr_raw(struct inode *inode, struct iattr *attr)
                         RETURN(-ENOMEM);
                 ll_inode2mdc_data(op_data, inode, (OBD_MD_FLID | OBD_MD_MEA));
 
-                if (ia_valid & (ATTR_UID | ATTR_GID)) {
+                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, key, key_size, NULL, 0, NULL, 
@@ -1307,21 +1329,11 @@ int ll_setattr_raw(struct inode *inode, struct iattr *attr)
                 }
 
                 if (attr->ia_valid & ATTR_SIZE) {
-                        /* XXX: hack for truncate capa */
-                        rc = mdc_req2lustre_capa(request, 0, &trunc_capa);
+                        rc = ll_set_trunc_capa(request, 0, inode);
                         if (rc) {
                                 ptlrpc_req_finished(request);
                                 RETURN(rc);
                         }
-
-                        spin_lock(&lli->lli_lock);
-                        if (trunc_capa) {
-                                if (lli->lli_trunc_capa)
-                                        OBD_FREE(lli->lli_trunc_capa,
-                                                 sizeof(*trunc_capa));
-                                lli->lli_trunc_capa = trunc_capa;
-                        }
-                        spin_unlock(&lli->lli_lock);
                 }
 
                 /* We call inode_setattr to adjust timestamps, but we first
@@ -1443,7 +1455,7 @@ int ll_setattr_raw(struct inode *inode, struct iattr *attr)
 
                 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);
@@ -2297,7 +2309,7 @@ int ll_iocontrol(struct inode *inode, struct file *file,
                 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)