src/com/android/loganalysis/parser/DmesgParser.java - platform/tools/loganalysis - Git at Google

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.loganalysis.parser;

 import com.android.loganalysis.item.DmesgActionInfoItem;
 import com.android.loganalysis.item.DmesgItem;
 import com.android.loganalysis.item.DmesgServiceInfoItem;
 import com.android.loganalysis.item.DmesgStageInfoItem;
 import com.android.loganalysis.item.DmesgModuleInfoItem;

 import com.google.common.annotations.VisibleForTesting;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.util.List;
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;


 /**
  * Parse the dmesg logs. </p>
  */
 public class DmesgParser implements IParser {

     private static final String SERVICENAME = "SERVICENAME";
     private static final String TIMESTAMP = "TIMESTAMP";
     private static final String STAGE = "STAGE";
     private static final String ACTION = "ACTION";
     private static final String SOURCE = "SOURCE";
     private static final String DURATION = "DURATION";
     private static final String UEVENTD = "ueventd";
     private static final String INIT = "init";
     private static final String WAIT_PROPERTY = "Wait for property ";
     private static final String TOTAL_MODULE = "TOTAL_MODULE";

     // Matches: [ 14.822691] init:
     private static final String SERVICE_PREFIX = String.format("^\\[\\s+(?<%s>.*)\\] init:\\s+",
             TIMESTAMP);
     // Matches: [    3.791635] ueventd:
     private static final String UEVENTD_PREFIX = String.format("^\\[\\s+(?<%s>.*)\\] ueventd:\\s+",
             TIMESTAMP);

     // Matches: starting service 'ueventd'...
     private static final String START_SERVICE_SUFFIX = String.format("starting service "
             + "\\'(?<%s>.*)\\'...", SERVICENAME);
     // Matches: Service 'ueventd' (pid 439) exited with status 0
     private static final String EXIT_SERVICE_SUFFIX = String.format("Service \\'(?<%s>.*)\\'\\s+"
             + "\\((?<PID>.*)\\) exited with status 0.*", SERVICENAME);

     private static final Pattern START_SERVICE = Pattern.compile(
             String.format("%s%s", SERVICE_PREFIX, START_SERVICE_SUFFIX));
     private static final Pattern EXIT_SERVICE = Pattern.compile(
             String.format("%s%s", SERVICE_PREFIX, EXIT_SERVICE_SUFFIX));

     // Matches: init first stage started!
     // Matches: init second stage started!
     private static final String START_STAGE_PREFIX = String.format("init (?<%s>.*) stage started!",
             STAGE);

     // Matches: [   13.647997] init: init first stage started!
     private static final Pattern START_STAGE = Pattern.compile(
             String.format("%s%s", SERVICE_PREFIX, START_STAGE_PREFIX));

     // Matches: init: processing action (early-init) from (/init.rc:14)
     private static final String START_PROCESSING_ACTION_PREFIX =
             String.format("processing action \\((?<%s>[^)]*)\\)( from \\((?<%s>.*)\\)|.*)$",
                     ACTION, SOURCE);

     // Matches: init: processing action (early-init) from (/init.rc:14)
     private static final Pattern START_PROCESSING_ACTION =
             Pattern.compile(String.format("%s%s", SERVICE_PREFIX, START_PROCESSING_ACTION_PREFIX));

     // Matches: [    1.175984] [    T1] init: Loaded 198 kernel modules took 808 ms
     private static final Pattern MODULES_INFO =
             Pattern.compile(
                     String.format(
                             "%sLoaded (?<count>\\d+) kernel modules took (?<%s>\\d+) ms.*$",
                             SERVICE_PREFIX, DURATION));

     // Matches: [    0.503853] [    T1] init: Loading module /lib/modules/exynos_dit.ko with args ''
     private static final Pattern MODULE_LOADING =
             Pattern.compile(
                     String.format(
                             "%sLoading module \\S+\\/(?<koname>\\S+)\\.ko with args.*",
                             SERVICE_PREFIX));

     // Matches: [    0.503803] [    T1] init: Loaded kernel module /lib/modules/boot_device_spi.ko
     private static final Pattern MODULE_LOADED =
             Pattern.compile(
                     String.format(
                             "%sLoaded kernel module \\S+\\/(?<koname>\\S+)\\.ko", SERVICE_PREFIX));

     // Matches: [    3.791635] ueventd: Coldboot took 0.695055 seconds
     private static final String STAGE_SUFFIX= String.format(
             "(?<%s>.*)\\s+took\\s+(?<%s>.*)\\s+seconds$", STAGE, DURATION);
     private static final Pattern UEVENTD_STAGE_INFO = Pattern.compile(
             String.format("%s%s", UEVENTD_PREFIX, STAGE_SUFFIX));

     private static final String PROPERTY_SUFFIX =
             String.format("Wait for property\\s(?<%s>.*)\\s+took\\s+(?<%s>.*)ms$", STAGE, DURATION);
     // Matches [    7.270487] init: Wait for property 'apexd.status=ready' took 230ms
     private static final Pattern WAIT_FOR_PROPERTY_INFO = Pattern.compile(
             String.format("%s%s", SERVICE_PREFIX, PROPERTY_SUFFIX));

     private DmesgItem mDmesgItem = new DmesgItem();

     /**
      * {@inheritDoc}
      */
     @Override
     public DmesgItem parse(List<String> lines) {
         for (String line : lines) {
             parse(line);
         }

         return mDmesgItem;
     }

     /**
      * Parse the kernel log till EOF to retrieve the duration of the service calls, start times of
      * different boot stages and actions taken. Besides, while parsing these informations are stored
      * in the intermediate {@link DmesgServiceInfoItem}, {@link DmesgStageInfoItem} and
      * {@link DmesgActionInfoItem} objects
      *
      * @param input dmesg log
      * @throws IOException
      */
     public DmesgItem parseInfo(BufferedReader bufferedLog) throws IOException {
         String line;
         while ((line = bufferedLog.readLine()) != null) {
             parse(line);
         }

         return mDmesgItem;
     }

     /**
      * <p>
      * Parse single line of the dmesg log to retrieve the duration of the service calls or start
      * times of different boot stages or start times of actions taken based on the info contained in
      * the line.
      * </p>
      * <p>
      * Besides, while parsing these informations are stored in the intermediate
      * {@link DmesgServiceInfoItem}, {@link DmesgStageInfoItem} and {@link DmesgActionInfoItem}
      * objects
      * </p>
      *
      * @param line individual line of the dmesg log
      */
     private void parse(String line) {

         if (parseServiceInfo(line)) {
             return;
         }
         if (parseStageInfo(line)) {
             return;
         }
         if (parseActionInfo(line)) {
             return;
         }
         if (parseModuleInfo(line)) {
             return;
         }
     }

     /**
      * Parse init services {@code start time} and {@code end time} from each {@code line} of dmesg
      * log and store the {@code duration} it took to complete the service if the end time stamp is
      * available in {@link DmesgServiceInfoItem}.
      *
      * @param individual line of the dmesg log
      * @return {@code true}, if the {@code line} indicates start or end of a service,
      *         {@code false}, otherwise
      */
     @VisibleForTesting
     boolean parseServiceInfo(String line) {
         Matcher match = null;
         if ((match = matches(START_SERVICE, line)) != null) {
             DmesgServiceInfoItem serviceItem = new DmesgServiceInfoItem();
             serviceItem.setServiceName(match.group(SERVICENAME));
             serviceItem.setStartTime((long) (Double.parseDouble(
                     match.group(TIMESTAMP)) * 1000));
             getServiceInfoItems().put(match.group(SERVICENAME), serviceItem);
             return true;
         } else if ((match = matches(EXIT_SERVICE, line)) != null) {
             if (getServiceInfoItems().containsKey(match.group(SERVICENAME))) {
                 DmesgServiceInfoItem serviceItem = getServiceInfoItems().get(
                         match.group(SERVICENAME));
                 serviceItem.setEndTime((long) (Double.parseDouble(
                         match.group(TIMESTAMP)) * 1000));
             }
             return true;
         }
         return false;
     }

     /**
      * Parse init stages log from each {@code line} of dmesg log and
      * store the stage name, start time and duration if available in a
      * {@link DmesgStageInfoItem} object
      *
      * @param individual line of the dmesg log
      * @return {@code true}, if the {@code line} indicates start of a boot stage,
      *         {@code false}, otherwise
      */
     @VisibleForTesting
     boolean parseStageInfo(String line) {
         Matcher match = null;
         if ((match = matches(START_STAGE, line)) != null) {
             DmesgStageInfoItem stageInfoItem = new DmesgStageInfoItem();
             stageInfoItem.setStageName(match.group(STAGE));
             stageInfoItem.setStartTime((long) (Double.parseDouble(
                     match.group(TIMESTAMP)) * 1000));
             mDmesgItem.addStageInfoItem(stageInfoItem);
             return true;
         }
         if((match = matches(UEVENTD_STAGE_INFO, line)) != null) {
             DmesgStageInfoItem stageInfoItem = new DmesgStageInfoItem();
             stageInfoItem.setStageName(String.format("%s_%s", UEVENTD, match.group(STAGE)));
             stageInfoItem.setDuration((long) (Double.parseDouble(
                     match.group(DURATION)) * 1000));
             mDmesgItem.addStageInfoItem(stageInfoItem);
             return true;
         }
         if((match = matches(WAIT_FOR_PROPERTY_INFO, line)) != null) {
             DmesgStageInfoItem stageInfoItem = new DmesgStageInfoItem();
             stageInfoItem.setStageName(
                     String.format("%s_%s%s", INIT, WAIT_PROPERTY, match.group(STAGE)));
             stageInfoItem.setDuration((long) Double.parseDouble(match.group(DURATION)));
             mDmesgItem.addStageInfoItem(stageInfoItem);
             return true;
         }

         return false;
     }

     /**
      * Parse action from each {@code line} of dmesg log and store the action name and start time
      * in {@link DmesgActionInfoItem} object
      *
      * @param individual {@code line} of the dmesg log
      * @return {@code true}, if {@code line} indicates starting of processing of action
      *         {@code false}, otherwise
      */
     @VisibleForTesting
     boolean parseActionInfo(String line) {
         Matcher match = null;
         if ((match = matches(START_PROCESSING_ACTION, line)) != null) {
             DmesgActionInfoItem actionInfoItem = new DmesgActionInfoItem();
             if (match.group(SOURCE) != null) {
                 actionInfoItem.setSourceName(match.group(SOURCE));
             }
             actionInfoItem.setActionName(match.group(ACTION));
             actionInfoItem.setStartTime((long) (Double.parseDouble(
                     match.group(TIMESTAMP)) * 1000));
             mDmesgItem.addActionInfoItem(actionInfoItem);
             return true;
         }
         return false;
     }

     /**
      * Parse modules from each {@code line} of dmesg log and store the module name and loading time
      * in {@link DmesgModuleInfoItem} object
      *
      * @param individual {@code line} of the dmesg log
      * @return {@code true}, if {@code line} indicates start, end of a module loading or the summary
      *     {@code false}, otherwise
      */
     @VisibleForTesting
     boolean parseModuleInfo(String line) {
         Matcher match = null;
         if ((match = matches(MODULES_INFO, line)) != null) {
             DmesgModuleInfoItem moduleInfoItem = new DmesgModuleInfoItem();
             moduleInfoItem.setModuleName(TOTAL_MODULE);
             moduleInfoItem.setModuleDuration((long) Double.parseDouble(match.group(DURATION)));
             moduleInfoItem.setModuleCount(match.group("count"));
             mDmesgItem.addModuleInfoItem(TOTAL_MODULE, moduleInfoItem);
             return true;
         }

         if ((match = matches(MODULE_LOADING, line)) != null) {
             DmesgModuleInfoItem moduleInfoItem = new DmesgModuleInfoItem();
             moduleInfoItem.setModuleName(match.group("koname"));
             moduleInfoItem.setStartTime((long) (Double.parseDouble(match.group(TIMESTAMP)) * 1000));
             mDmesgItem.addModuleInfoItem(match.group("koname"), moduleInfoItem);
             return true;
         } else if ((match = matches(MODULE_LOADED, line)) != null) {
             if (getModuleInfoItems().containsKey(match.group("koname"))) {
                 DmesgModuleInfoItem moduleInfoItem =
                         getModuleInfoItems().get(match.group("koname"));
                 moduleInfoItem.setEndTime(
                         (long) (Double.parseDouble(match.group(TIMESTAMP)) * 1000));
             }
             return true;
         }
         return false;
     }

     /**
      * Checks whether {@code line} matches the given {@link Pattern}.
      *
      * @return The resulting {@link Matcher} obtained by matching the {@code line} against
      *         {@code pattern}, or null if the {@code line} does not match.
      */
     private static Matcher matches(Pattern pattern, String line) {
         Matcher ret = pattern.matcher(line);
         return ret.matches() ? ret : null;
     }

     public Map<String, DmesgServiceInfoItem> getServiceInfoItems() {
         return mDmesgItem.getServiceInfoItems();
     }

     public void setServiceInfoItems(Map<String, DmesgServiceInfoItem> serviceInfoItems) {
         for(String key : serviceInfoItems.keySet()) {
             mDmesgItem.addServiceInfoItem(key, serviceInfoItems.get(key));
         }
     }

     public List<DmesgStageInfoItem> getStageInfoItems() {
         return mDmesgItem.getStageInfoItems();
     }

     public List<DmesgActionInfoItem> getActionInfoItems() {
         return mDmesgItem.getActionInfoItems();
     }

     public Map<String, DmesgModuleInfoItem> getModuleInfoItems() {
         return mDmesgItem.getModuleInfoItems();
     }
 }
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.loganalysis.parser;

	import com.android.loganalysis.item.DmesgActionInfoItem;
	import com.android.loganalysis.item.DmesgItem;
	import com.android.loganalysis.item.DmesgServiceInfoItem;
	import com.android.loganalysis.item.DmesgStageInfoItem;
	import com.android.loganalysis.item.DmesgModuleInfoItem;

	import com.google.common.annotations.VisibleForTesting;

	import java.io.BufferedReader;
	import java.io.IOException;
	import java.util.List;
	import java.util.Map;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;


	/**
	* Parse the dmesg logs. </p>
	*/
	public class DmesgParser implements IParser {

	private static final String SERVICENAME = "SERVICENAME";
	private static final String TIMESTAMP = "TIMESTAMP";
	private static final String STAGE = "STAGE";
	private static final String ACTION = "ACTION";
	private static final String SOURCE = "SOURCE";
	private static final String DURATION = "DURATION";
	private static final String UEVENTD = "ueventd";
	private static final String INIT = "init";
	private static final String WAIT_PROPERTY = "Wait for property ";
	private static final String TOTAL_MODULE = "TOTAL_MODULE";

	// Matches: [ 14.822691] init:
	private static final String SERVICE_PREFIX = String.format("^\\[\\s+(?<%s>.*)\\] init:\\s+",
	TIMESTAMP);
	// Matches: [ 3.791635] ueventd:
	private static final String UEVENTD_PREFIX = String.format("^\\[\\s+(?<%s>.*)\\] ueventd:\\s+",
	TIMESTAMP);

	// Matches: starting service 'ueventd'...
	private static final String START_SERVICE_SUFFIX = String.format("starting service "
	+ "\\'(?<%s>.*)\\'...", SERVICENAME);
	// Matches: Service 'ueventd' (pid 439) exited with status 0
	private static final String EXIT_SERVICE_SUFFIX = String.format("Service \\'(?<%s>.*)\\'\\s+"
	+ "\\((?<PID>.)\\) exited with status 0.", SERVICENAME);

	private static final Pattern START_SERVICE = Pattern.compile(
	String.format("%s%s", SERVICE_PREFIX, START_SERVICE_SUFFIX));
	private static final Pattern EXIT_SERVICE = Pattern.compile(
	String.format("%s%s", SERVICE_PREFIX, EXIT_SERVICE_SUFFIX));

	// Matches: init first stage started!
	// Matches: init second stage started!
	private static final String START_STAGE_PREFIX = String.format("init (?<%s>.*) stage started!",
	STAGE);

	// Matches: [ 13.647997] init: init first stage started!
	private static final Pattern START_STAGE = Pattern.compile(
	String.format("%s%s", SERVICE_PREFIX, START_STAGE_PREFIX));

	// Matches: init: processing action (early-init) from (/init.rc:14)
	private static final String START_PROCESSING_ACTION_PREFIX =
	String.format("processing action \\((?<%s>[^)])\\)( from \\((?<%s>.)\\)\|.*)$",
	ACTION, SOURCE);

	// Matches: init: processing action (early-init) from (/init.rc:14)
	private static final Pattern START_PROCESSING_ACTION =
	Pattern.compile(String.format("%s%s", SERVICE_PREFIX, START_PROCESSING_ACTION_PREFIX));

	// Matches: [ 1.175984] [ T1] init: Loaded 198 kernel modules took 808 ms
	private static final Pattern MODULES_INFO =
	Pattern.compile(
	String.format(
	"%sLoaded (?<count>\\d+) kernel modules took (?<%s>\\d+) ms.*$",
	SERVICE_PREFIX, DURATION));

	// Matches: [ 0.503853] [ T1] init: Loading module /lib/modules/exynos_dit.ko with args ''
	private static final Pattern MODULE_LOADING =
	Pattern.compile(
	String.format(
	"%sLoading module \\S+\\/(?<koname>\\S+)\\.ko with args.*",
	SERVICE_PREFIX));

	// Matches: [ 0.503803] [ T1] init: Loaded kernel module /lib/modules/boot_device_spi.ko
	private static final Pattern MODULE_LOADED =
	Pattern.compile(
	String.format(
	"%sLoaded kernel module \\S+\\/(?<koname>\\S+)\\.ko", SERVICE_PREFIX));

	// Matches: [ 3.791635] ueventd: Coldboot took 0.695055 seconds
	private static final String STAGE_SUFFIX= String.format(
	"(?<%s>.)\\s+took\\s+(?<%s>.)\\s+seconds$", STAGE, DURATION);
	private static final Pattern UEVENTD_STAGE_INFO = Pattern.compile(
	String.format("%s%s", UEVENTD_PREFIX, STAGE_SUFFIX));

	private static final String PROPERTY_SUFFIX =
	String.format("Wait for property\\s(?<%s>.)\\s+took\\s+(?<%s>.)ms$", STAGE, DURATION);
	// Matches [ 7.270487] init: Wait for property 'apexd.status=ready' took 230ms
	private static final Pattern WAIT_FOR_PROPERTY_INFO = Pattern.compile(
	String.format("%s%s", SERVICE_PREFIX, PROPERTY_SUFFIX));

	private DmesgItem mDmesgItem = new DmesgItem();

	/**
	* {@inheritDoc}
	*/
	@Override
	public DmesgItem parse(List<String> lines) {
	for (String line : lines) {
	parse(line);
	}

	return mDmesgItem;
	}

	/**
	* Parse the kernel log till EOF to retrieve the duration of the service calls, start times of
	* different boot stages and actions taken. Besides, while parsing these informations are stored
	* in the intermediate {@link DmesgServiceInfoItem}, {@link DmesgStageInfoItem} and
	* {@link DmesgActionInfoItem} objects
	*
	* @param input dmesg log
	* @throws IOException
	*/
	public DmesgItem parseInfo(BufferedReader bufferedLog) throws IOException {
	String line;
	while ((line = bufferedLog.readLine()) != null) {
	parse(line);
	}

	return mDmesgItem;
	}

	/**
	* <p>
	* Parse single line of the dmesg log to retrieve the duration of the service calls or start
	* times of different boot stages or start times of actions taken based on the info contained in
	* the line.
	* </p>
	* <p>
	* Besides, while parsing these informations are stored in the intermediate
	* {@link DmesgServiceInfoItem}, {@link DmesgStageInfoItem} and {@link DmesgActionInfoItem}
	* objects
	* </p>
	*
	* @param line individual line of the dmesg log
	*/
	private void parse(String line) {

	if (parseServiceInfo(line)) {
	return;
	}
	if (parseStageInfo(line)) {
	return;
	}
	if (parseActionInfo(line)) {
	return;
	}
	if (parseModuleInfo(line)) {
	return;
	}
	}

	/**
	* Parse init services {@code start time} and {@code end time} from each {@code line} of dmesg
	* log and store the {@code duration} it took to complete the service if the end time stamp is
	* available in {@link DmesgServiceInfoItem}.
	*
	* @param individual line of the dmesg log
	* @return {@code true}, if the {@code line} indicates start or end of a service,
	* {@code false}, otherwise
	*/
	@VisibleForTesting
	boolean parseServiceInfo(String line) {
	Matcher match = null;
	if ((match = matches(START_SERVICE, line)) != null) {
	DmesgServiceInfoItem serviceItem = new DmesgServiceInfoItem();
	serviceItem.setServiceName(match.group(SERVICENAME));
	serviceItem.setStartTime((long) (Double.parseDouble(
	match.group(TIMESTAMP)) * 1000));
	getServiceInfoItems().put(match.group(SERVICENAME), serviceItem);
	return true;
	} else if ((match = matches(EXIT_SERVICE, line)) != null) {
	if (getServiceInfoItems().containsKey(match.group(SERVICENAME))) {
	DmesgServiceInfoItem serviceItem = getServiceInfoItems().get(
	match.group(SERVICENAME));
	serviceItem.setEndTime((long) (Double.parseDouble(
	match.group(TIMESTAMP)) * 1000));
	}
	return true;
	}
	return false;
	}

	/**
	* Parse init stages log from each {@code line} of dmesg log and
	* store the stage name, start time and duration if available in a
	* {@link DmesgStageInfoItem} object
	*
	* @param individual line of the dmesg log
	* @return {@code true}, if the {@code line} indicates start of a boot stage,
	* {@code false}, otherwise
	*/
	@VisibleForTesting
	boolean parseStageInfo(String line) {
	Matcher match = null;
	if ((match = matches(START_STAGE, line)) != null) {
	DmesgStageInfoItem stageInfoItem = new DmesgStageInfoItem();
	stageInfoItem.setStageName(match.group(STAGE));
	stageInfoItem.setStartTime((long) (Double.parseDouble(
	match.group(TIMESTAMP)) * 1000));
	mDmesgItem.addStageInfoItem(stageInfoItem);
	return true;
	}
	if((match = matches(UEVENTD_STAGE_INFO, line)) != null) {
	DmesgStageInfoItem stageInfoItem = new DmesgStageInfoItem();
	stageInfoItem.setStageName(String.format("%s_%s", UEVENTD, match.group(STAGE)));
	stageInfoItem.setDuration((long) (Double.parseDouble(
	match.group(DURATION)) * 1000));
	mDmesgItem.addStageInfoItem(stageInfoItem);
	return true;
	}
	if((match = matches(WAIT_FOR_PROPERTY_INFO, line)) != null) {
	DmesgStageInfoItem stageInfoItem = new DmesgStageInfoItem();
	stageInfoItem.setStageName(
	String.format("%s_%s%s", INIT, WAIT_PROPERTY, match.group(STAGE)));
	stageInfoItem.setDuration((long) Double.parseDouble(match.group(DURATION)));
	mDmesgItem.addStageInfoItem(stageInfoItem);
	return true;
	}

	return false;
	}

	/**
	* Parse action from each {@code line} of dmesg log and store the action name and start time
	* in {@link DmesgActionInfoItem} object
	*
	* @param individual {@code line} of the dmesg log
	* @return {@code true}, if {@code line} indicates starting of processing of action
	* {@code false}, otherwise
	*/
	@VisibleForTesting
	boolean parseActionInfo(String line) {
	Matcher match = null;
	if ((match = matches(START_PROCESSING_ACTION, line)) != null) {
	DmesgActionInfoItem actionInfoItem = new DmesgActionInfoItem();
	if (match.group(SOURCE) != null) {
	actionInfoItem.setSourceName(match.group(SOURCE));
	}
	actionInfoItem.setActionName(match.group(ACTION));
	actionInfoItem.setStartTime((long) (Double.parseDouble(
	match.group(TIMESTAMP)) * 1000));
	mDmesgItem.addActionInfoItem(actionInfoItem);
	return true;
	}
	return false;
	}

	/**
	* Parse modules from each {@code line} of dmesg log and store the module name and loading time
	* in {@link DmesgModuleInfoItem} object
	*
	* @param individual {@code line} of the dmesg log
	* @return {@code true}, if {@code line} indicates start, end of a module loading or the summary
	* {@code false}, otherwise
	*/
	@VisibleForTesting
	boolean parseModuleInfo(String line) {
	Matcher match = null;
	if ((match = matches(MODULES_INFO, line)) != null) {
	DmesgModuleInfoItem moduleInfoItem = new DmesgModuleInfoItem();
	moduleInfoItem.setModuleName(TOTAL_MODULE);
	moduleInfoItem.setModuleDuration((long) Double.parseDouble(match.group(DURATION)));
	moduleInfoItem.setModuleCount(match.group("count"));
	mDmesgItem.addModuleInfoItem(TOTAL_MODULE, moduleInfoItem);
	return true;
	}

	if ((match = matches(MODULE_LOADING, line)) != null) {
	DmesgModuleInfoItem moduleInfoItem = new DmesgModuleInfoItem();
	moduleInfoItem.setModuleName(match.group("koname"));
	moduleInfoItem.setStartTime((long) (Double.parseDouble(match.group(TIMESTAMP)) * 1000));
	mDmesgItem.addModuleInfoItem(match.group("koname"), moduleInfoItem);
	return true;
	} else if ((match = matches(MODULE_LOADED, line)) != null) {
	if (getModuleInfoItems().containsKey(match.group("koname"))) {
	DmesgModuleInfoItem moduleInfoItem =
	getModuleInfoItems().get(match.group("koname"));
	moduleInfoItem.setEndTime(
	(long) (Double.parseDouble(match.group(TIMESTAMP)) * 1000));
	}
	return true;
	}
	return false;
	}

	/**
	* Checks whether {@code line} matches the given {@link Pattern}.
	*
	* @return The resulting {@link Matcher} obtained by matching the {@code line} against
	* {@code pattern}, or null if the {@code line} does not match.
	*/
	private static Matcher matches(Pattern pattern, String line) {
	Matcher ret = pattern.matcher(line);
	return ret.matches() ? ret : null;
	}

	public Map<String, DmesgServiceInfoItem> getServiceInfoItems() {
	return mDmesgItem.getServiceInfoItems();
	}

	public void setServiceInfoItems(Map<String, DmesgServiceInfoItem> serviceInfoItems) {
	for(String key : serviceInfoItems.keySet()) {
	mDmesgItem.addServiceInfoItem(key, serviceInfoItems.get(key));
	}
	}

	public List<DmesgStageInfoItem> getStageInfoItems() {
	return mDmesgItem.getStageInfoItems();
	}

	public List<DmesgActionInfoItem> getActionInfoItems() {
	return mDmesgItem.getActionInfoItems();
	}

	public Map<String, DmesgModuleInfoItem> getModuleInfoItems() {
	return mDmesgItem.getModuleInfoItems();
	}
	}