#ifdef CONFIG_IMA
 extern int ima_bprm_check(struct linux_binprm *bprm);
-extern int ima_file_check(struct file *file, int mask);
+extern int ima_file_check(struct file *file, int mask, int opened);
 extern void ima_file_free(struct file *file);
 extern int ima_file_mmap(struct file *file, unsigned long prot);
 extern int ima_module_check(struct file *file);
        return 0;
 }
 
-static inline int ima_file_check(struct file *file, int mask)
+static inline int ima_file_check(struct file *file, int mask, int opened)
 {
        return 0;
 }
 
 int ima_appraise_measurement(int func, struct integrity_iint_cache *iint,
                             struct file *file, const unsigned char *filename,
                             struct evm_ima_xattr_data *xattr_value,
-                            int xattr_len);
+                            int xattr_len, int opened);
 int ima_must_appraise(struct inode *inode, int mask, enum ima_hooks func);
 void ima_update_xattr(struct integrity_iint_cache *iint, struct file *file);
 enum integrity_status ima_get_cache_status(struct integrity_iint_cache *iint,
                                           struct file *file,
                                           const unsigned char *filename,
                                           struct evm_ima_xattr_data *xattr_value,
-                                          int xattr_len)
+                                          int xattr_len, int opened)
 {
        return INTEGRITY_UNKNOWN;
 }
 
 int ima_appraise_measurement(int func, struct integrity_iint_cache *iint,
                             struct file *file, const unsigned char *filename,
                             struct evm_ima_xattr_data *xattr_value,
-                            int xattr_len)
+                            int xattr_len, int opened)
 {
        static const char op[] = "appraise_data";
        char *cause = "unknown";
 
                cause = "missing-hash";
                status = INTEGRITY_NOLABEL;
-               if (inode->i_size == 0) {
+               if (opened & FILE_CREATED) {
                        iint->flags |= IMA_NEW_FILE;
                        status = INTEGRITY_PASS;
                }
 
 }
 
 static int process_measurement(struct file *file, const char *filename,
-                              int mask, int function)
+                              int mask, int function, int opened)
 {
        struct inode *inode = file_inode(file);
        struct integrity_iint_cache *iint;
                                      xattr_value, xattr_len);
        if (action & IMA_APPRAISE_SUBMASK)
                rc = ima_appraise_measurement(_func, iint, file, pathname,
-                                             xattr_value, xattr_len);
+                                             xattr_value, xattr_len, opened);
        if (action & IMA_AUDIT)
                ima_audit_measurement(iint, pathname);
        kfree(pathbuf);
 int ima_file_mmap(struct file *file, unsigned long prot)
 {
        if (file && (prot & PROT_EXEC))
-               return process_measurement(file, NULL, MAY_EXEC, MMAP_CHECK);
+               return process_measurement(file, NULL, MAY_EXEC, MMAP_CHECK, 0);
        return 0;
 }
 
        return process_measurement(bprm->file,
                                   (strcmp(bprm->filename, bprm->interp) == 0) ?
                                   bprm->filename : bprm->interp,
-                                  MAY_EXEC, BPRM_CHECK);
+                                  MAY_EXEC, BPRM_CHECK, 0);
 }
 
 /**
  * On success return 0.  On integrity appraisal error, assuming the file
  * is in policy and IMA-appraisal is in enforcing mode, return -EACCES.
  */
-int ima_file_check(struct file *file, int mask)
+int ima_file_check(struct file *file, int mask, int opened)
 {
        ima_rdwr_violation_check(file);
        return process_measurement(file, NULL,
                                   mask & (MAY_READ | MAY_WRITE | MAY_EXEC),
-                                  FILE_CHECK);
+                                  FILE_CHECK, opened);
 }
 EXPORT_SYMBOL_GPL(ima_file_check);
 
 #endif
                return 0;       /* We rely on module signature checking */
        }
-       return process_measurement(file, NULL, MAY_EXEC, MODULE_CHECK);
+       return process_measurement(file, NULL, MAY_EXEC, MODULE_CHECK, 0);
 }
 
 int ima_fw_from_file(struct file *file, char *buf, size_t size)
                        return -EACCES; /* INTEGRITY_UNKNOWN */
                return 0;
        }
-       return process_measurement(file, NULL, MAY_EXEC, FIRMWARE_CHECK);
+       return process_measurement(file, NULL, MAY_EXEC, FIRMWARE_CHECK, 0);
 }
 
 static int __init init_ima(void)